[BSP]Update STM32F10xHAL bsp to RTT 3.0.0

With USB Device Drivers

bsp/stm32f10x_HAL/.config

+#
+# Automatically generated file; DO NOT EDIT.
+# RT-Thread Configuration
+#
+
+#
+# RT-Thread Kernel
+#
+CONFIG_RT_NAME_MAX=8
+CONFIG_RT_ALIGN_SIZE=4
+# CONFIG_RT_THREAD_PRIORITY_8 is not set
+CONFIG_RT_THREAD_PRIORITY_32=y
+# CONFIG_RT_THREAD_PRIORITY_256 is not set
+CONFIG_RT_THREAD_PRIORITY_MAX=32
+CONFIG_RT_TICK_PER_SECOND=100
+CONFIG_RT_DEBUG=y
+CONFIG_RT_USING_OVERFLOW_CHECK=y
+CONFIG_RT_DEBUG_INIT=0
+CONFIG_RT_DEBUG_THREAD=0
+CONFIG_RT_USING_HOOK=y
+CONFIG_IDLE_THREAD_STACK_SIZE=256
+# CONFIG_RT_USING_TIMER_SOFT is not set
+
+#
+# Inter-Thread communication
+#
+CONFIG_RT_USING_SEMAPHORE=y
+CONFIG_RT_USING_MUTEX=y
+CONFIG_RT_USING_EVENT=y
+CONFIG_RT_USING_MAILBOX=y
+CONFIG_RT_USING_MESSAGEQUEUE=y
+# CONFIG_RT_USING_SIGNALS is not set
+
+#
+# Memory Management
+#
+CONFIG_RT_USING_MEMPOOL=y
+CONFIG_RT_USING_MEMHEAP=y
+# CONFIG_RT_USING_NOHEAP is not set
+CONFIG_RT_USING_SMALL_MEM=y
+# CONFIG_RT_USING_SLAB is not set
+# CONFIG_RT_USING_MEMHEAP_AS_HEAP is not set
+CONFIG_RT_USING_HEAP=y
+
+#
+# Kernel Device Object
+#
+CONFIG_RT_USING_DEVICE=y
+# CONFIG_RT_USING_INTERRUPT_INFO is not set
+CONFIG_RT_USING_CONSOLE=y
+CONFIG_RT_CONSOLEBUF_SIZE=128
+CONFIG_RT_CONSOLE_DEVICE_NAME="uart2"
+# CONFIG_RT_USING_MODULE is not set
+
+#
+# RT-Thread Components
+#
+CONFIG_RT_USING_COMPONENTS_INIT=y
+CONFIG_RT_USING_USER_MAIN=y
+
+#
+# C++ features
+#
+# CONFIG_RT_USING_CPLUSPLUS is not set
+
+#
+# Command shell
+#
+CONFIG_RT_USING_FINSH=y
+CONFIG_FINSH_USING_HISTORY=y
+CONFIG_FINSH_USING_SYMTAB=y
+CONFIG_FINSH_USING_DESCRIPTION=y
+CONFIG_FINSH_THREAD_PRIORITY=20
+CONFIG_FINSH_THREAD_STACK_SIZE=4096
+CONFIG_FINSH_CMD_SIZE=80
+# CONFIG_FINSH_USING_AUTH is not set
+CONFIG_FINSH_USING_MSH=y
+CONFIG_FINSH_USING_MSH_DEFAULT=y
+CONFIG_FINSH_USING_MSH_ONLY=y
+
+#
+# Device virtual file system
+#
+# CONFIG_RT_USING_DFS is not set
+
+#
+# Device Drivers
+#
+CONFIG_RT_USING_DEVICE_IPC=y
+CONFIG_RT_USING_SERIAL=y
+# CONFIG_RT_USING_CAN is not set
+# CONFIG_RT_USING_HWTIMER is not set
+# CONFIG_RT_USING_I2C is not set
+CONFIG_RT_USING_PIN=y
+# CONFIG_RT_USING_MTD_NOR is not set
+# CONFIG_RT_USING_MTD_NAND is not set
+# CONFIG_RT_USING_RTC is not set
+# CONFIG_RT_USING_SDIO is not set
+# CONFIG_RT_USING_SPI is not set
+# CONFIG_RT_USING_WDT is not set
+# CONFIG_RT_USING_USB_HOST is not set
+# CONFIG_RT_USING_USB_DEVICE is not set
+
+#
+# POSIX layer and C standard library
+#
+# CONFIG_RT_USING_LIBC is not set
+# CONFIG_RT_USING_PTHREADS is not set
+
+#
+# Network stack
+#
+
+#
+# light weight TCP/IP stack
+#
+# CONFIG_RT_USING_LWIP is not set
+
+#
+# Modbus master and slave stack
+#
+# CONFIG_RT_USING_MODBUS is not set
+
+#
+# RT-Thread UI Engine
+#
+# CONFIG_RT_USING_GUIENGINE is not set
+
+#
+# VBUS(Virtual Software BUS)
+#
+# CONFIG_RT_USING_VBUS is not set
+
+#
+# RT-Thread online packages
+#
+
+#
+# system packages
+#
+# CONFIG_PKG_USING_PARTITION is not set
+# CONFIG_PKG_USING_SQLITE is not set
+
+#
+# IoT - internet of things
+#
+# CONFIG_PKG_USING_CJSON is not set
+# CONFIG_PKG_USING_PAHOMQTT is not set
+# CONFIG_PKG_USING_WEBCLIENT is not set
+# CONFIG_PKG_USING_MONGOOSE is not set
+# CONFIG_PKG_USING_WEBTERMINAL is not set
+
+#
+# security packages
+#
+# CONFIG_PKG_USING_MBEDTLS is not set
+
+#
+# language packages
+#
+# CONFIG_PKG_USING_JERRYSCRIPT is not set
+
+#
+# multimedia packages
+#
+
+#
+# tools packages
+#
+# CONFIG_PKG_USING_CMBACKTRACE is not set
+# CONFIG_PKG_USING_EASYLOGGER is not set
+
+#
+# miscellaneous packages
+#
+# CONFIG_PKG_USING_HELLO is not set
+
+#
+# BSP_SPECIAL CONFIG
+#
+CONFIG_STM32F10X_PIN_NUMBERS=64
+# CONFIG_RT_USING_UART1 is not set
+CONFIG_RT_USING_UART2=y
+# CONFIG_RT_USING_UART3 is not set

bsp/stm32f10x_HAL/KConfig

+mainmenu "RT-Thread Configuration"
+
+config $BSP_DIR
+    string
+    option env="BSP_ROOT"
+    default "."
+
+config $RTT_DIR
+    string
+    option env="RTT_ROOT"
+    default "../.."
+
+config $PKGS_DIR
+    string
+    option env="PKGS_ROOT"
+    default "packages"
+
+source "$RTT_DIR/KConfig"
+source "$PKGS_DIR/KConfig"
+
+
+if RT_USING_PIN
+
+    config STM32F10X_PIN_NUMBERS
+        int "number of stm32 pin numbers"
+        default 64
+
+endif
+
+if RT_USING_SERIAL
+
+    config RT_USING_UART1
+        bool "Using uart1"
+        default y    
+
+    config RT_USING_UART2
+        bool "Using uart2"
+        default n    
+
+    config RT_USING_UART3
+        bool "Using uart3"
+        default n   
+
+endif
+
+if RT_USING_SPI
+    config RT_USING_SPI1
+        bool "Using spi1"
+        default y
+    config RT_USING_SPI2
+        bool "Using spi2"
+        default n
+endif
+
+
+
+
+    
+    
\ No newline at end of file

bsp/stm32f10x_HAL/applications/SConscript

@@ -2,16 +2,8 @@ Import('RTT_ROOT')
 Import('rtconfig')
 from building import *
 
-cwd = os.path.join(str(Dir('#')), 'applications')
-
-src = Split("""
-application.c
-startup.c
-""")
-
-if GetDepend('RT_USING_CAN'):
-    src += ['canapp.c']
-
+cwd = GetCurrentDir()
+src = Glob('*.c')
 CPPPATH = [cwd, str(Dir('#'))]
 
 group = DefineGroup('Applications', src, depend = [''], CPPPATH = CPPPATH)

bsp/stm32f10x_HAL/applications/application.c

-/*
- * File      : application.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Development Team
- *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://www.rt-thread.org/license/LICENSE
- *
- * Change Logs:
- * Date           Author       Notes
- * 2009-01-05     Bernard      the first version
- * 2013-07-12     aozima       update for auto initial.
- */
-
-/**
- * @addtogroup STM32
- */
-/*@{*/
-
-#include <board.h>
-#include <rtthread.h>
-
-#ifdef RT_USING_COMPONENTS_INIT
-#include <components.h>
-#endif /* RT_USING_COMPONENTS_INIT */
-
-#ifdef RT_USING_DFS
-/* dfs filesystem:ELM filesystem init */
-#include <dfs_elm.h>
-/* dfs Filesystem APIs */
-#include <dfs_fs.h>
-#include <dfs_posix.h>
-extern int dfs_init(void);
-#endif
-
-//ALIGN(RT_ALIGN_SIZE)
-
-void rt_init_thread_entry(void *parameter)
-{
-
-/* Filesystem Initialization */
-#ifdef RT_USING_SPI
-    stm32_hw_spi_init();
-#endif
-
-#if defined(RT_USING_DFS) && defined(RT_USING_DFS_ELMFAT)
-    dfs_init();
-    elm_init();
-    /* mount sd card fat partition 1 as root directory */
-    if (dfs_mount("flash0", "/", "elm", 0, 0) == 0)
-    {
-        rt_kprintf("File System initialized!\n");
-    }
-    else
-		{
-			rt_kprintf("File System initialzation failed!\n");
-			dfs_mkfs("elm","flash0");
-			HAL_NVIC_SystemReset();
-		}
-        
-#endif /* RT_USING_DFS */
-}
-
-int rt_application_init(void)
-{
-    rt_thread_t init_thread;
-
-//    rt_err_t result;
-
-#if (RT_THREAD_PRIORITY_MAX == 32)
-    init_thread = rt_thread_create("init",
-                                   rt_init_thread_entry, RT_NULL,
-                                   1024, 8, 20);
-#else
-    init_thread = rt_thread_create("init",
-                                   rt_init_thread_entry, RT_NULL,
-                                   1024, 80, 20);
-#endif
-
-    if (init_thread != RT_NULL)
-        rt_thread_startup(init_thread);
-
-    return 0;
-}
-
-/*@}*/

bsp/stm32f10x_HAL/applications/main.c

+/*
+ * File      : main.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2009, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2015-07-29     Arda.Fu      first implementation
+ */
+#include <rtthread.h>
+
+int main(void)
+{
+  /* user app entry */
+  return 0;
+}

bsp/stm32f10x_HAL/applications/startup.c

-/*
- * File      : startup.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, RT-Thread Develop Team
- *
- * The license and distribution terms for this file may be
- * found in the file LICENSE in this distribution or at
- * http://openlab.rt-thread.com/license/LICENSE
- *
- * Change Logs:
- * Date           Author       Notes
- * 2006-08-31     Bernard      first implementation
- */
-
-#include <rthw.h>
-#include <rtthread.h>
-
-#include "board.h"
-#ifdef RT_USING_FINSH
-#include "shell.h"
-#endif
-/**
- * @addtogroup STM32
- */
-
-/*@{*/
-
-extern int  rt_application_init(void);
-
-#ifdef __CC_ARM
-extern int Image$$RW_IRAM1$$ZI$$Limit;
-#elif __ICCARM__
-#pragma section="HEAP"
-#else
-extern int __bss_end;
-#endif
-
-/*******************************************************************************
-* Function Name  : assert_failed
-* Description    : Reports the name of the source file and the source line number
-*                  where the assert error has occurred.
-* Input          : - file: pointer to the source file name
-*                  - line: assert error line source number
-* Output         : None
-* Return         : None
-*******************************************************************************/
-void assert_failed(rt_uint8_t * file, rt_uint32_t line)
-{
-    rt_kprintf("\n\r Wrong parameter value detected on\r\n");
-    rt_kprintf("       file  %s\r\n", file);
-    rt_kprintf("       line  %d\r\n", line);
-
-    while (1) ;
-}
-
-/**
- * This function will startup RT-Thread RTOS.
- */
-void rtthread_startup(void)
-{
-    /* init board */
-    rt_hw_board_init();
-
-    /* show version */
-    rt_show_version();
-
-#ifdef RT_USING_HEAP
-#if STM32_EXT_SRAM
-    rt_system_heap_init((void*)STM32_EXT_SRAM_BEGIN, (void*)STM32_EXT_SRAM_END);
-#else
-#ifdef __CC_ARM
-    rt_system_heap_init((void*)&Image$$RW_IRAM1$$ZI$$Limit, (void*)STM32_SRAM_END);
-#elif __ICCARM__
-    rt_system_heap_init(__segment_end("HEAP"), (void*)STM32_SRAM_END);
-#else
-    /* init memory system */
-    rt_system_heap_init((void*)&__bss_end, (void*)STM32_SRAM_END);
-#endif
-#endif  /* STM32_EXT_SRAM */
-#endif /* RT_USING_HEAP */
-
-    /* init scheduler system */
-    rt_system_scheduler_init();
-
-    /* initialize timer */
-    rt_system_timer_init();
-
-    /* init timer thread */
-    rt_system_timer_thread_init();
-
-    /* init application */
-    rt_application_init();
-#ifdef RT_USING_FINSH
-    finsh_system_init();
-    finsh_set_device(RT_CONSOLE_DEVICE_NAME);
-#endif
-    /* init idle thread */
-    rt_thread_idle_init();
-
-    /* start scheduler */
-    rt_system_scheduler_start();
-
-    /* never reach here */
-    return ;
-}
-
-int main(void)
-{
-    /* disable interrupt first */
-    rt_hw_interrupt_disable();
-
-    /* startup RT-Thread RTOS */
-    rtthread_startup();
-
-    return 0;
-}
-
-/*@}*/

bsp/stm32f10x_HAL/drivers/SConscript

@@ -2,7 +2,7 @@ Import('RTT_ROOT')
 Import('rtconfig')
 from building import *
 
-cwd     = os.path.join(str(Dir('#')), 'drivers')
+cwd = GetCurrentDir()
 
 # add the general drivers.
 src = Split("""
@@ -11,11 +11,14 @@ stm32f1xx_it.c
 """)
 
 if GetDepend(['RT_USING_PIN']):
-    src += ['gpio.c']
+    src += ['drv_gpio.c']
 if GetDepend(['RT_USING_SERIAL']):
-    src += ['usart.c']
+    src += ['drv_usart.c']
 if GetDepend(['RT_USING_SPI']):
-    src += ['stm32_spi.c']
+    src += ['drv_spi.c']
+if GetDepend(['RT_USING_USB_DEVICE']):
+    src += ['drv_usb.c']
+
 
     
 CPPPATH = [cwd]

bsp/stm32f10x_HAL/drivers/board.c

@@ -11,6 +11,7 @@
  * Date           Author       Notes
  * 2009-01-05     Bernard      first implementation
  * 2017-10-20     ZYH          emmm...setup for HAL Libraries
+ * 2017-11-15     ZYH            update to 3.0.0
  */
 
 #include <rthw.h>
@@ -27,65 +28,64 @@
 void HAL_MspInit(void)
 {
 
-  HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
-
-  /* System interrupt init*/
-  __HAL_RCC_AFIO_CLK_ENABLE();
-  /* MemoryManagement_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(MemoryManagement_IRQn, 0, 0);
-  /* BusFault_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(BusFault_IRQn, 0, 0);
-  /* UsageFault_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(UsageFault_IRQn, 0, 0);
-  /* SVCall_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(SVCall_IRQn, 0, 0);
-  /* DebugMonitor_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(DebugMonitor_IRQn, 0, 0);
-  /* PendSV_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(PendSV_IRQn, 15, 0);
-  /* SysTick_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
-
-  /**DISABLE: JTAG-DP Disabled and SW-DP Disabled 
-    */
-  __HAL_AFIO_REMAP_SWJ_NOJTAG();
+    HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4);
+
+    /* System interrupt init*/
+    __HAL_RCC_AFIO_CLK_ENABLE();
+    /* MemoryManagement_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(MemoryManagement_IRQn, 0, 0);
+    /* BusFault_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(BusFault_IRQn, 0, 0);
+    /* UsageFault_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(UsageFault_IRQn, 0, 0);
+    /* SVCall_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(SVCall_IRQn, 0, 0);
+    /* DebugMonitor_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(DebugMonitor_IRQn, 0, 0);
+    /* PendSV_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(PendSV_IRQn, 15, 0);
+    /* SysTick_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
+
+    /**DISABLE: JTAG-DP Disabled and SW-DP Disabled**/
+    __HAL_AFIO_REMAP_SWJ_NOJTAG();
 }
 void SystemClock_Config(void)
 {
 
-  RCC_OscInitTypeDef RCC_OscInitStruct;
-  RCC_ClkInitTypeDef RCC_ClkInitStruct;
-
-  /**Initializes the CPU, AHB and APB busses clocks 
-    */
-  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
-  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
-  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
-  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
-  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
-  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
-  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
-  RT_ASSERT(HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK);
-  /**Initializes the CPU, AHB and APB busses clocks 
-    */
-  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
-  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
-  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
-  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
-  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
-
-  RT_ASSERT(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) == HAL_OK);
-
-  /**Configure the Systick interrupt time 
-    */
-  HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
-
-  /**Configure the Systick 
-    */
-  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
-
-  /* SysTick_IRQn interrupt configuration */
-  HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
+    RCC_OscInitTypeDef RCC_OscInitStruct;
+    RCC_ClkInitTypeDef RCC_ClkInitStruct;
+
+    /**Initializes the CPU, AHB and APB busses clocks
+      */
+    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
+    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
+    RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
+    RCC_OscInitStruct.HSIState = RCC_HSI_ON;
+    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
+    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
+    RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
+    RT_ASSERT(HAL_RCC_OscConfig(&RCC_OscInitStruct) == HAL_OK);
+    /**Initializes the CPU, AHB and APB busses clocks
+      */
+    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
+    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
+    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
+    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
+    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
+
+    RT_ASSERT(HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) == HAL_OK);
+
+    /**Configure the Systick interrupt time
+      */
+    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / RT_TICK_PER_SECOND);
+
+    /**Configure the Systick
+      */
+    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
+
+    /* SysTick_IRQn interrupt configuration */
+    HAL_NVIC_SetPriority(SysTick_IRQn, 15, 0);
 }
 
 
@@ -95,14 +95,14 @@ void SystemClock_Config(void)
  */
 void SysTick_Handler(void)
 {
-  /* enter interrupt */
-  rt_interrupt_enter();
+    /* enter interrupt */
+    rt_interrupt_enter();
 
-  HAL_IncTick();
-  rt_tick_increase();
+    HAL_IncTick();
+    rt_tick_increase();
 
-  /* leave interrupt */
-  rt_interrupt_leave();
+    /* leave interrupt */
+    rt_interrupt_leave();
 }
 
 /**
@@ -110,16 +110,18 @@ void SysTick_Handler(void)
  */
 void rt_hw_board_init(void)
 {
-  HAL_Init();
-  SystemClock_Config();
-#ifdef RT_USING_SERIAL
-  rt_hw_usart_init();
+    HAL_Init();
+    SystemClock_Config();
+#ifdef RT_USING_HEAP
+    rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);
 #endif
-#ifdef RT_USING_PIN
-  rt_hw_pin_init();
+
+#ifdef RT_USING_COMPONENTS_INIT
+    rt_components_board_init();
 #endif
+
 #ifdef RT_USING_CONSOLE
-  rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
+    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
 #endif
 
 }

bsp/stm32f10x_HAL/drivers/board.h

@@ -18,15 +18,6 @@
 #define __BOARD_H__
 
 #include "stm32f1xx_hal.h"
-#ifdef RT_USING_SERIAL
-#include "usart.h"
-#endif
-#ifdef RT_USING_PIN
-#include "gpio.h"
-#endif
-#ifdef RT_USING_SPI
-#include "stm32_spi.h"
-#endif
 /* board configuration */
 
 /* whether use board external SRAM memory */
@@ -45,8 +36,17 @@
 //	<i>Default: 64
 #define STM32_SRAM_SIZE 20
 #define STM32_SRAM_END (0x20000000 + STM32_SRAM_SIZE * 1024)
-
-// <<< Use Configuration Wizard in Context Menu >>>
+#ifdef __CC_ARM
+extern int Image$$RW_IRAM1$$ZI$$Limit;
+#define HEAP_BEGIN  ((void *)&Image$$RW_IRAM1$$ZI$$Limit)
+#elif __ICCARM__
+#pragma section="HEAP"
+#define HEAP_BEGIN  (__segment_end("HEAP"))
+#else
+extern int __bss_end;
+#define HEAP_BEGIN  ((void *)&__bss_end)
+#endif
+#define HEAP_END    STM32_SRAM_END
 
 void rt_hw_board_init(void);
 

bsp/stm32f10x_HAL/drivers/gpio.h → bsp/stm32f10x_HAL/drivers/drv_gpio.h

 /*
- * File      : gpio.h
+ * File      : drv_gpio.h
  * This file is part of RT-Thread RTOS
  * COPYRIGHT (C) 2015, RT-Thread Development Team
  *
@@ -10,6 +10,7 @@
  * Change Logs:
  * Date           Author       Notes
  * 2015-01-05     Bernard      the first version
+ * 2017-11-35     ZYH            update to 3.0.0
  */
 #ifndef GPIO_H__
 #define GPIO_H__

bsp/stm32f10x_HAL/drivers/stm32_spi.c → bsp/stm32f10x_HAL/drivers/drv_spi.c

 /*
- * File      : gpio.c
+ * File      : dev_gpio.c
  * This file is part of RT-Thread RTOS
  * COPYRIGHT (C) 2015, RT-Thread Development Team
  *
@@ -10,15 +10,15 @@
  * Change Logs:
  * Date           Author            Notes
  * 2017-10-20     ZYH            the first version
+ * 2017-11-35     ZYH            update to 3.0.0
  */
 
 #include <board.h>
-#include "spi_flash_w25qxx.h"
-#define SPIRXEVENT 0x01
-#define SPITXEVENT 0x02
-
+#include <drv_spi.h>
 #ifdef RT_USING_SPI
 
+#define SPIRXEVENT 0x01
+#define SPITXEVENT 0x02
 #define SPITIMEOUT 2
 #define SPICRCEN 0
 
@@ -90,41 +90,41 @@ static rt_err_t stm32_spi_init(SPI_TypeDef *spix, struct rt_spi_configuration *c
     }
     else
     {
-			hspi.Init.NSS = SPI_NSS_SOFT;
+        hspi.Init.NSS = SPI_NSS_SOFT;
 //        hspi.Init.NSS = SPI_NSS_HARD_OUTPUT;
     }
-    if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/2)
+    if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 2)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/4)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 4)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/8)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 8)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/16)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 16)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/32)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 32)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/64)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 64)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
     }
-    else if(cfg->max_hz >= HAL_RCC_GetPCLK2Freq()/128)
+    else if (cfg->max_hz >= HAL_RCC_GetPCLK2Freq() / 128)
     {
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
     }
     else
     {
-            /*  min prescaler 256 */
-            hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
+        /*  min prescaler 256 */
+        hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
     }
     if (cfg->mode & RT_SPI_MSB)
     {
@@ -137,7 +137,7 @@ static rt_err_t stm32_spi_init(SPI_TypeDef *spix, struct rt_spi_configuration *c
     hspi.Init.TIMode = SPI_TIMODE_DISABLE;
     hspi.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
     hspi.Init.CRCPolynomial = 7;
-		hspi.State = HAL_SPI_STATE_RESET;
+    hspi.State = HAL_SPI_STATE_RESET;
     if (HAL_SPI_Init(&hspi) != HAL_OK)
     {
         return RT_EIO;
@@ -201,7 +201,7 @@ static rt_uint32_t spixfer(struct rt_spi_device *device, struct rt_spi_message *
     RT_ASSERT(device != RT_NULL);
     RT_ASSERT(device->bus != RT_NULL);
     RT_ASSERT(device->bus->parent.user_data != RT_NULL);
-    struct stm32_spi * hspi = (struct stm32_spi *)device->bus->parent.user_data;
+    struct stm32_spi *hspi = (struct stm32_spi *)device->bus->parent.user_data;
     struct stm32_hw_spi_cs *cs = device->parent.user_data;
 
     if (message->cs_take)
@@ -240,153 +240,143 @@ static rt_uint32_t spixfer(struct rt_spi_device *device, struct rt_spi_message *
 
 
 rt_err_t spi_configure(struct rt_spi_device *device,
-    struct rt_spi_configuration *configuration)
+                       struct rt_spi_configuration *configuration)
 {
-    struct stm32_spi * hspi = (struct stm32_spi *)device->bus->parent.user_data;
+    struct stm32_spi *hspi = (struct stm32_spi *)device->bus->parent.user_data;
     hspi->cfg = configuration;
     return stm32_spi_init(hspi->Instance, configuration);
 }
 
 const struct rt_spi_ops stm_spi_ops =
 {
-        .configure = spi_configure,
-        .xfer = spixfer,
+    .configure = spi_configure,
+    .xfer = spixfer,
 };
 
-
-int stm32_spi_register_bus(SPI_TypeDef * SPIx,const char * name)
+struct rt_spi_bus _spi_bus1, _spi_bus2;
+struct stm32_spi _spi1, _spi2;
+int stm32_spi_register_bus(SPI_TypeDef *SPIx, const char *name)
 {
-    struct rt_spi_bus * spi_bus = (struct rt_spi_bus *)rt_malloc(sizeof(struct rt_spi_bus));
-    RT_ASSERT(spi_bus != RT_NULL);
-    struct stm32_spi * spi = (struct stm32_spi *)rt_malloc(sizeof(struct stm32_spi));
-    RT_ASSERT(spi != RT_NULL);
+    struct rt_spi_bus *spi_bus;
+    struct stm32_spi *spi;
+    if (SPIx == SPI1)
+    {
+        spi_bus = &_spi_bus1;
+        spi = &_spi1;
+    }
+    else if (SPIx == SPI2)
+    {
+        spi_bus = &_spi_bus2;
+        spi = &_spi2;
+    }
+    else
+    {
+        return -1;
+    }
     spi->Instance = SPIx;
     spi_bus->parent.user_data = spi;
     return rt_spi_bus_register(spi_bus, name, &stm_spi_ops);
 }
 
-rt_err_t stm32_spi_bus_attach_device(rt_uint32_t pin,const char * bus_name,const char * device_name)
+rt_err_t stm32_spi_bus_attach_device(rt_uint32_t pin, const char *bus_name, const char *device_name)
 {
-    struct rt_spi_device * spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device));
+    struct rt_spi_device *spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device));
     RT_ASSERT(spi_device != RT_NULL);
-    struct stm32_hw_spi_cs * cs_pin = (struct stm32_hw_spi_cs *)rt_malloc(sizeof(struct stm32_hw_spi_cs));
+    struct stm32_hw_spi_cs *cs_pin = (struct stm32_hw_spi_cs *)rt_malloc(sizeof(struct stm32_hw_spi_cs));
     RT_ASSERT(cs_pin != RT_NULL);
     cs_pin->pin = pin;
-    rt_pin_mode(pin,PIN_MODE_OUTPUT);
+    rt_pin_mode(pin, PIN_MODE_OUTPUT);
     rt_pin_write(pin, 1);
     return rt_spi_bus_attach_device(spi_device, device_name, bus_name, (void *)cs_pin);
 }
 
 int stm32_hw_spi_init(void)
 {
-    stm32_spi_register_bus(SPI2,"spi2");
-    stm32_spi_bus_attach_device(33,"spi2","cs_b12");
-    return w25qxx_init("flash0","cs_b12");
+    int result = 0;
+#ifdef RT_USING_SPI1
+    result = stm32_spi_register_bus(SPI1, "spi1");
+#endif
+#ifdef RT_USING_SPI2
+    result = stm32_spi_register_bus(SPI2, "spi2");
+#endif
+    return result;
 }
 INIT_BOARD_EXPORT(stm32_hw_spi_init);
 
-void HAL_SPI_MspInit(SPI_HandleTypeDef* spiHandle)
+void HAL_SPI_MspInit(SPI_HandleTypeDef *spiHandle)
 {
 
-  GPIO_InitTypeDef GPIO_InitStruct;
-  if(spiHandle->Instance==SPI1)
-  {
-  /* USER CODE BEGIN SPI1_MspInit 0 */
-
-  /* USER CODE END SPI1_MspInit 0 */
-    /* SPI1 clock enable */
-    __HAL_RCC_SPI1_CLK_ENABLE();
-    __HAL_RCC_GPIOA_CLK_ENABLE();
-    /**SPI1 GPIO Configuration    
-    PA5     ------> SPI1_SCK
-    PA6     ------> SPI1_MISO
-    PA7     ------> SPI1_MOSI 
-    */
-    GPIO_InitStruct.Pin = GPIO_PIN_5|GPIO_PIN_7;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-    GPIO_InitStruct.Pin = GPIO_PIN_6;
-    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-    GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-  /* USER CODE BEGIN SPI1_MspInit 1 */
-
-  /* USER CODE END SPI1_MspInit 1 */
-  }
-  else if(spiHandle->Instance==SPI2)
-  {
-  /* USER CODE BEGIN SPI2_MspInit 0 */
-
-  /* USER CODE END SPI2_MspInit 0 */
-    /* SPI2 clock enable */
-    __HAL_RCC_SPI2_CLK_ENABLE();
-    __HAL_RCC_GPIOB_CLK_ENABLE();
-    /**SPI2 GPIO Configuration    
-    PB13     ------> SPI2_SCK
-    PB14     ------> SPI2_MISO
-    PB15     ------> SPI2_MOSI 
-    */
-    GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_15;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-
-    GPIO_InitStruct.Pin = GPIO_PIN_14;
-    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-    GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-
-  /* USER CODE BEGIN SPI2_MspInit 1 */
-
-  /* USER CODE END SPI2_MspInit 1 */
-  }
+    GPIO_InitTypeDef GPIO_InitStruct;
+    if (spiHandle->Instance == SPI1)
+    {
+        /* SPI1 clock enable */
+        __HAL_RCC_SPI1_CLK_ENABLE();
+        __HAL_RCC_GPIOA_CLK_ENABLE();
+        /**SPI1 GPIO Configuration
+        PA5     ------> SPI1_SCK
+        PA6     ------> SPI1_MISO
+        PA7     ------> SPI1_MOSI
+        */
+        GPIO_InitStruct.Pin = GPIO_PIN_5 | GPIO_PIN_7;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+        GPIO_InitStruct.Pin = GPIO_PIN_6;
+        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+    }
+    else if (spiHandle->Instance == SPI2)
+    {
+        /* SPI2 clock enable */
+        __HAL_RCC_SPI2_CLK_ENABLE();
+        __HAL_RCC_GPIOB_CLK_ENABLE();
+        /**SPI2 GPIO Configuration
+        PB13     ------> SPI2_SCK
+        PB14     ------> SPI2_MISO
+        PB15     ------> SPI2_MOSI
+        */
+        GPIO_InitStruct.Pin = GPIO_PIN_13 | GPIO_PIN_15;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+        GPIO_InitStruct.Pin = GPIO_PIN_14;
+        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+    }
 }
 
-void HAL_SPI_MspDeInit(SPI_HandleTypeDef* spiHandle)
+void HAL_SPI_MspDeInit(SPI_HandleTypeDef *spiHandle)
 {
 
-  if(spiHandle->Instance==SPI1)
-  {
-  /* USER CODE BEGIN SPI1_MspDeInit 0 */
-
-  /* USER CODE END SPI1_MspDeInit 0 */
-    /* Peripheral clock disable */
-    __HAL_RCC_SPI1_CLK_DISABLE();
-  
-    /**SPI1 GPIO Configuration    
-    PA5     ------> SPI1_SCK
-    PA6     ------> SPI1_MISO
-    PA7     ------> SPI1_MOSI 
-    */
-    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5|GPIO_PIN_6|GPIO_PIN_7);
-
-  /* USER CODE BEGIN SPI1_MspDeInit 1 */
-
-  /* USER CODE END SPI1_MspDeInit 1 */
-  }
-  else if(spiHandle->Instance==SPI2)
-  {
-  /* USER CODE BEGIN SPI2_MspDeInit 0 */
-
-  /* USER CODE END SPI2_MspDeInit 0 */
-    /* Peripheral clock disable */
-    __HAL_RCC_SPI2_CLK_DISABLE();
-  
-    /**SPI2 GPIO Configuration    
-    PB13     ------> SPI2_SCK
-    PB14     ------> SPI2_MISO
-    PB15     ------> SPI2_MOSI 
-    */
-    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15);
-
-  /* USER CODE BEGIN SPI2_MspDeInit 1 */
-
-  /* USER CODE END SPI2_MspDeInit 1 */
-  }
-} 
+    if (spiHandle->Instance == SPI1)
+    {
+        /* Peripheral clock disable */
+        __HAL_RCC_SPI1_CLK_DISABLE();
+
+        /**SPI1 GPIO Configuration
+        PA5     ------> SPI1_SCK
+        PA6     ------> SPI1_MISO
+        PA7     ------> SPI1_MOSI
+        */
+        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
+    }
+    else if (spiHandle->Instance == SPI2)
+    {
+        /* Peripheral clock disable */
+        __HAL_RCC_SPI2_CLK_DISABLE();
+
+        /**SPI2 GPIO Configuration
+        PB13     ------> SPI2_SCK
+        PB14     ------> SPI2_MISO
+        PB15     ------> SPI2_MOSI
+        */
+        HAL_GPIO_DeInit(GPIOB, GPIO_PIN_13 | GPIO_PIN_14 | GPIO_PIN_15);
+    }
+}
 #endif /*RT_USING_SPI*/
 
 

bsp/stm32f10x_HAL/drivers/usart.c → bsp/stm32f10x_HAL/drivers/drv_usart.c

 /*
- * File      : usart.c
+ * File      : drv_usart.c
  * This file is part of RT-Thread RTOS
  * COPYRIGHT (C) 2006-2013, RT-Thread Development Team
  *
@@ -17,10 +17,11 @@
  * 2017-01-19     aubr.cool    add interrupt Tx mode
  * 2017-04-13     aubr.cool    correct Rx parity err
  * 2017-10-20     ZYH          porting to HAL Libraries(with out DMA)
+ * 2017-11-15     ZYH          update to 3.0.0
  */
 #include "board.h"
 #include <rtdevice.h>
-
+#include <drv_usart.h>
 
 
 /* STM32 uart driver */
@@ -33,68 +34,68 @@ struct stm32_uart
 static rt_err_t stm32_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
 {
     struct stm32_uart *uart;
-    
-      RT_ASSERT(serial != RT_NULL);
-      RT_ASSERT(cfg != RT_NULL);
-    
-      uart = (struct stm32_uart *)serial->parent.user_data;
-    
-      uart->huart.Init.BaudRate   = cfg->baud_rate;
-      uart->huart.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
-      uart->huart.Init.Mode       = UART_MODE_TX_RX;
-      uart->huart.Init.OverSampling = UART_OVERSAMPLING_16;
-    
-      switch (cfg->data_bits)
-      {
-      case DATA_BITS_8:
-          uart->huart.Init.WordLength = UART_WORDLENGTH_8B;
-          break;
-      case DATA_BITS_9:
-          uart->huart.Init.WordLength = UART_WORDLENGTH_9B;
-          break;
-      default:
-          uart->huart.Init.WordLength = UART_WORDLENGTH_8B;
-          break;
-      }
-      switch (cfg->stop_bits)
-      {
-      case STOP_BITS_1:
-          uart->huart.Init.StopBits   = UART_STOPBITS_1;
-          break;
-      case STOP_BITS_2:
-          uart->huart.Init.StopBits   = UART_STOPBITS_2;
-          break;
-      default:
-          uart->huart.Init.StopBits   = UART_STOPBITS_1;
-          break;
-      }
-      switch (cfg->parity)
-      {
-      case PARITY_NONE:
-          uart->huart.Init.Parity     = UART_PARITY_NONE;
-          break;
-      case PARITY_ODD:
-          uart->huart.Init.Parity     = UART_PARITY_ODD;
-          break;
-      case PARITY_EVEN:
-          uart->huart.Init.Parity     = UART_PARITY_EVEN;
-          break;
-      default:
-          uart->huart.Init.Parity     = UART_PARITY_NONE;
-          break;
-      }
-    
-      if (HAL_UART_Init(&uart->huart) != HAL_OK)
-      {
-          return RT_ERROR;
-      }
-    
-      return RT_EOK;
+
+    RT_ASSERT(serial != RT_NULL);
+    RT_ASSERT(cfg != RT_NULL);
+
+    uart = (struct stm32_uart *)serial->parent.user_data;
+
+    uart->huart.Init.BaudRate   = cfg->baud_rate;
+    uart->huart.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
+    uart->huart.Init.Mode       = UART_MODE_TX_RX;
+    uart->huart.Init.OverSampling = UART_OVERSAMPLING_16;
+
+    switch (cfg->data_bits)
+    {
+    case DATA_BITS_8:
+        uart->huart.Init.WordLength = UART_WORDLENGTH_8B;
+        break;
+    case DATA_BITS_9:
+        uart->huart.Init.WordLength = UART_WORDLENGTH_9B;
+        break;
+    default:
+        uart->huart.Init.WordLength = UART_WORDLENGTH_8B;
+        break;
+    }
+    switch (cfg->stop_bits)
+    {
+    case STOP_BITS_1:
+        uart->huart.Init.StopBits   = UART_STOPBITS_1;
+        break;
+    case STOP_BITS_2:
+        uart->huart.Init.StopBits   = UART_STOPBITS_2;
+        break;
+    default:
+        uart->huart.Init.StopBits   = UART_STOPBITS_1;
+        break;
+    }
+    switch (cfg->parity)
+    {
+    case PARITY_NONE:
+        uart->huart.Init.Parity     = UART_PARITY_NONE;
+        break;
+    case PARITY_ODD:
+        uart->huart.Init.Parity     = UART_PARITY_ODD;
+        break;
+    case PARITY_EVEN:
+        uart->huart.Init.Parity     = UART_PARITY_EVEN;
+        break;
+    default:
+        uart->huart.Init.Parity     = UART_PARITY_NONE;
+        break;
+    }
+
+    if (HAL_UART_Init(&uart->huart) != HAL_OK)
+    {
+        return RT_ERROR;
+    }
+
+    return RT_EOK;
 }
 
 static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *arg)
 {
-    struct stm32_uart* uart;
+    struct stm32_uart *uart;
 //    rt_uint32_t ctrl_arg = (rt_uint32_t)(arg);
 
     RT_ASSERT(serial != RT_NULL);
@@ -102,14 +103,14 @@ static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *ar
 
     switch (cmd)
     {
-        /* disable interrupt */
+    /* disable interrupt */
     case RT_DEVICE_CTRL_CLR_INT:
         /* disable rx irq */
         NVIC_DisableIRQ(uart->irq);
         /* disable interrupt */
         __HAL_UART_DISABLE_IT(&uart->huart, USART_IT_RXNE);
         break;
-        /* enable interrupt */
+    /* enable interrupt */
     case RT_DEVICE_CTRL_SET_INT:
         /* enable rx irq */
         NVIC_EnableIRQ(uart->irq);
@@ -122,11 +123,11 @@ static rt_err_t stm32_control(struct rt_serial_device *serial, int cmd, void *ar
 
 static int stm32_putc(struct rt_serial_device *serial, char c)
 {
-    struct stm32_uart* uart;
+    struct stm32_uart *uart;
 
     RT_ASSERT(serial != RT_NULL);
     uart = (struct stm32_uart *)serial->parent.user_data;
-    while(__HAL_UART_GET_FLAG(&uart->huart,UART_FLAG_TXE) == RESET);
+    while (__HAL_UART_GET_FLAG(&uart->huart, UART_FLAG_TXE) == RESET);
     uart->huart.Instance->DR = c;
     return 1;
 }
@@ -134,11 +135,11 @@ static int stm32_putc(struct rt_serial_device *serial, char c)
 static int stm32_getc(struct rt_serial_device *serial)
 {
     int ch;
-    struct stm32_uart* uart;
+    struct stm32_uart *uart;
     RT_ASSERT(serial != RT_NULL);
     uart = (struct stm32_uart *)serial->parent.user_data;
     ch = -1;
-    if (__HAL_UART_GET_FLAG(&uart->huart,UART_FLAG_RXNE) != RESET)
+    if (__HAL_UART_GET_FLAG(&uart->huart, UART_FLAG_RXNE) != RESET)
     {
         ch = uart->huart.Instance->DR & 0xff;
     }
@@ -151,15 +152,16 @@ static int stm32_getc(struct rt_serial_device *serial)
  *
  * @param serial serial device
  */
-static void uart_isr(struct rt_serial_device *serial) {
+static void uart_isr(struct rt_serial_device *serial)
+{
     struct stm32_uart *uart = (struct stm32_uart *) serial->parent.user_data;
 
     RT_ASSERT(uart != RT_NULL);
 
-    if((__HAL_UART_GET_FLAG(&uart->huart, UART_FLAG_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->huart,UART_IT_RXNE) != RESET))
+    if ((__HAL_UART_GET_FLAG(&uart->huart, UART_FLAG_RXNE) != RESET) && (__HAL_UART_GET_IT_SOURCE(&uart->huart, UART_IT_RXNE) != RESET))
     {
         rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
-        __HAL_UART_CLEAR_FLAG(&uart->huart,UART_FLAG_RXNE);
+        __HAL_UART_CLEAR_FLAG(&uart->huart, UART_FLAG_RXNE);
     }
 }
 
@@ -234,14 +236,14 @@ void USART3_IRQHandler(void)
 }
 #endif /* RT_USING_UART2 */
 
-static void MX_USART_UART_Init(UART_HandleTypeDef* uartHandle);
+static void MX_USART_UART_Init(UART_HandleTypeDef *uartHandle);
 
-void rt_hw_usart_init(void)
+int rt_hw_usart_init(void)
 {
-    struct stm32_uart* uart;
+    struct stm32_uart *uart;
     struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
-	__HAL_RCC_GPIOD_CLK_ENABLE();
-  __HAL_RCC_GPIOA_CLK_ENABLE();
+    __HAL_RCC_GPIOD_CLK_ENABLE();
+    __HAL_RCC_GPIOA_CLK_ENABLE();
 #if defined(RT_USING_UART1)
     uart = &uart1;
     config.baud_rate = BAUD_RATE_115200;
@@ -255,33 +257,34 @@ void rt_hw_usart_init(void)
 #endif /* RT_USING_UART1 */
 
 #if defined(RT_USING_UART2)
-uart = &uart2;
-config.baud_rate = BAUD_RATE_115200;
-serial2.ops    = &stm32_uart_ops;
-serial2.config = config;
-MX_USART_UART_Init(&uart->huart);
-/* register UART1 device */
-rt_hw_serial_register(&serial2, "uart2",
-                      RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX ,
-                      uart);
+    uart = &uart2;
+    config.baud_rate = BAUD_RATE_115200;
+    serial2.ops    = &stm32_uart_ops;
+    serial2.config = config;
+    MX_USART_UART_Init(&uart->huart);
+    /* register UART1 device */
+    rt_hw_serial_register(&serial2, "uart2",
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX ,
+                          uart);
 #endif /* RT_USING_UART1 */
 
 #if defined(RT_USING_UART3)
-uart = &uart3;
-config.baud_rate = BAUD_RATE_115200;
-serial3.ops    = &stm32_uart_ops;
-serial3.config = config;
-MX_USART_UART_Init(&uart->huart);
-/* register UART1 device */
-rt_hw_serial_register(&serial3, "uart3",
-                      RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX ,
-                      uart);
+    uart = &uart3;
+    config.baud_rate = BAUD_RATE_115200;
+    serial3.ops    = &stm32_uart_ops;
+    serial3.config = config;
+    MX_USART_UART_Init(&uart->huart);
+    /* register UART1 device */
+    rt_hw_serial_register(&serial3, "uart3",
+                          RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX ,
+                          uart);
 #endif /* RT_USING_UART1 */
-
+    return 0;
 }
+INIT_BOARD_EXPORT(rt_hw_usart_init);
 
 
-static void MX_USART_UART_Init(UART_HandleTypeDef* uartHandle)
+static void MX_USART_UART_Init(UART_HandleTypeDef *uartHandle)
 {
     uartHandle->Init.BaudRate = 115200;
     uartHandle->Init.WordLength = UART_WORDLENGTH_8B;
@@ -296,163 +299,163 @@ static void MX_USART_UART_Init(UART_HandleTypeDef* uartHandle)
 /* USART2 init function */
 
 
-void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
+void HAL_UART_MspInit(UART_HandleTypeDef *uartHandle)
 {
 
-  GPIO_InitTypeDef GPIO_InitStruct;
-  if(uartHandle->Instance==USART1)
-  {
-  /* USER CODE BEGIN USART1_MspInit 0 */
-
-  /* USER CODE END USART1_MspInit 0 */
-    /* USART1 clock enable */
-    __HAL_RCC_USART1_CLK_ENABLE();
-  
-    /**USART1 GPIO Configuration    
-    PA9     ------> USART1_TX
-    PA10     ------> USART1_RX 
-    */
-    GPIO_InitStruct.Pin = GPIO_PIN_9;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-    GPIO_InitStruct.Pin = GPIO_PIN_10;
-    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-    GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-    /* USART1 interrupt Init */
-    HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
-    HAL_NVIC_EnableIRQ(USART1_IRQn);
-  /* USER CODE BEGIN USART1_MspInit 1 */
-
-  /* USER CODE END USART1_MspInit 1 */
-  }
-  else if(uartHandle->Instance==USART2)
-  {
-  /* USER CODE BEGIN USART2_MspInit 0 */
-
-  /* USER CODE END USART2_MspInit 0 */
-    /* USART2 clock enable */
-    __HAL_RCC_USART2_CLK_ENABLE();
-  
-    /**USART2 GPIO Configuration    
-    PA2     ------> USART2_TX
-    PA3     ------> USART2_RX 
-    */
-    GPIO_InitStruct.Pin = GPIO_PIN_2;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-    GPIO_InitStruct.Pin = GPIO_PIN_3;
-    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-    GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
-
-    /* USART2 interrupt Init */
-    HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
-    HAL_NVIC_EnableIRQ(USART2_IRQn);
-  /* USER CODE BEGIN USART2_MspInit 1 */
-
-  /* USER CODE END USART2_MspInit 1 */
-  }
-  else if(uartHandle->Instance==USART3)
-  {
-  /* USER CODE BEGIN USART3_MspInit 0 */
-
-  /* USER CODE END USART3_MspInit 0 */
-    /* USART3 clock enable */
-    __HAL_RCC_USART3_CLK_ENABLE();
-  
-    /**USART3 GPIO Configuration    
-    PB10     ------> USART3_TX
-    PB11     ------> USART3_RX 
-    */
-    GPIO_InitStruct.Pin = GPIO_PIN_10;
-    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
-    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
-    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-
-    GPIO_InitStruct.Pin = GPIO_PIN_11;
-    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
-    GPIO_InitStruct.Pull = GPIO_NOPULL;
-    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
-
-    /* USART3 interrupt Init */
-    HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
-    HAL_NVIC_EnableIRQ(USART3_IRQn);
-  /* USER CODE BEGIN USART3_MspInit 1 */
-
-  /* USER CODE END USART3_MspInit 1 */
-  }
+    GPIO_InitTypeDef GPIO_InitStruct;
+    if (uartHandle->Instance == USART1)
+    {
+        /* USER CODE BEGIN USART1_MspInit 0 */
+
+        /* USER CODE END USART1_MspInit 0 */
+        /* USART1 clock enable */
+        __HAL_RCC_USART1_CLK_ENABLE();
+
+        /**USART1 GPIO Configuration
+        PA9     ------> USART1_TX
+        PA10     ------> USART1_RX
+        */
+        GPIO_InitStruct.Pin = GPIO_PIN_9;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+        GPIO_InitStruct.Pin = GPIO_PIN_10;
+        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+        /* USART1 interrupt Init */
+        HAL_NVIC_SetPriority(USART1_IRQn, 5, 0);
+        HAL_NVIC_EnableIRQ(USART1_IRQn);
+        /* USER CODE BEGIN USART1_MspInit 1 */
+
+        /* USER CODE END USART1_MspInit 1 */
+    }
+    else if (uartHandle->Instance == USART2)
+    {
+        /* USER CODE BEGIN USART2_MspInit 0 */
+
+        /* USER CODE END USART2_MspInit 0 */
+        /* USART2 clock enable */
+        __HAL_RCC_USART2_CLK_ENABLE();
+
+        /**USART2 GPIO Configuration
+        PA2     ------> USART2_TX
+        PA3     ------> USART2_RX
+        */
+        GPIO_InitStruct.Pin = GPIO_PIN_2;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+        GPIO_InitStruct.Pin = GPIO_PIN_3;
+        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+
+        /* USART2 interrupt Init */
+        HAL_NVIC_SetPriority(USART2_IRQn, 5, 0);
+        HAL_NVIC_EnableIRQ(USART2_IRQn);
+        /* USER CODE BEGIN USART2_MspInit 1 */
+
+        /* USER CODE END USART2_MspInit 1 */
+    }
+    else if (uartHandle->Instance == USART3)
+    {
+        /* USER CODE BEGIN USART3_MspInit 0 */
+
+        /* USER CODE END USART3_MspInit 0 */
+        /* USART3 clock enable */
+        __HAL_RCC_USART3_CLK_ENABLE();
+
+        /**USART3 GPIO Configuration
+        PB10     ------> USART3_TX
+        PB11     ------> USART3_RX
+        */
+        GPIO_InitStruct.Pin = GPIO_PIN_10;
+        GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+        GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
+        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+        GPIO_InitStruct.Pin = GPIO_PIN_11;
+        GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+        GPIO_InitStruct.Pull = GPIO_NOPULL;
+        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
+
+        /* USART3 interrupt Init */
+        HAL_NVIC_SetPriority(USART3_IRQn, 5, 0);
+        HAL_NVIC_EnableIRQ(USART3_IRQn);
+        /* USER CODE BEGIN USART3_MspInit 1 */
+
+        /* USER CODE END USART3_MspInit 1 */
+    }
 }
 
-void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
+void HAL_UART_MspDeInit(UART_HandleTypeDef *uartHandle)
 {
 
-  if(uartHandle->Instance==USART1)
-  {
-  /* USER CODE BEGIN USART1_MspDeInit 0 */
-
-  /* USER CODE END USART1_MspDeInit 0 */
-    /* Peripheral clock disable */
-    __HAL_RCC_USART1_CLK_DISABLE();
-  
-    /**USART1 GPIO Configuration    
-    PA9     ------> USART1_TX
-    PA10     ------> USART1_RX 
-    */
-    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);
-
-    /* USART1 interrupt Deinit */
-    HAL_NVIC_DisableIRQ(USART1_IRQn);
-  /* USER CODE BEGIN USART1_MspDeInit 1 */
-
-  /* USER CODE END USART1_MspDeInit 1 */
-  }
-  else if(uartHandle->Instance==USART2)
-  {
-  /* USER CODE BEGIN USART2_MspDeInit 0 */
-
-  /* USER CODE END USART2_MspDeInit 0 */
-    /* Peripheral clock disable */
-    __HAL_RCC_USART2_CLK_DISABLE();
-  
-    /**USART2 GPIO Configuration    
-    PA2     ------> USART2_TX
-    PA3     ------> USART2_RX 
-    */
-    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2|GPIO_PIN_3);
-
-    /* USART2 interrupt Deinit */
-    HAL_NVIC_DisableIRQ(USART2_IRQn);
-  /* USER CODE BEGIN USART2_MspDeInit 1 */
-
-  /* USER CODE END USART2_MspDeInit 1 */
-  }
-  else if(uartHandle->Instance==USART3)
-  {
-  /* USER CODE BEGIN USART3_MspDeInit 0 */
-
-  /* USER CODE END USART3_MspDeInit 0 */
-    /* Peripheral clock disable */
-    __HAL_RCC_USART3_CLK_DISABLE();
-  
-    /**USART3 GPIO Configuration    
-    PB10     ------> USART3_TX
-    PB11     ------> USART3_RX 
-    */
-    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11);
-
-    /* USART3 interrupt Deinit */
-    HAL_NVIC_DisableIRQ(USART3_IRQn);
-  /* USER CODE BEGIN USART3_MspDeInit 1 */
-
-  /* USER CODE END USART3_MspDeInit 1 */
-  }
-} 
+    if (uartHandle->Instance == USART1)
+    {
+        /* USER CODE BEGIN USART1_MspDeInit 0 */
+
+        /* USER CODE END USART1_MspDeInit 0 */
+        /* Peripheral clock disable */
+        __HAL_RCC_USART1_CLK_DISABLE();
+
+        /**USART1 GPIO Configuration
+        PA9     ------> USART1_TX
+        PA10     ------> USART1_RX
+        */
+        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9 | GPIO_PIN_10);
+
+        /* USART1 interrupt Deinit */
+        HAL_NVIC_DisableIRQ(USART1_IRQn);
+        /* USER CODE BEGIN USART1_MspDeInit 1 */
+
+        /* USER CODE END USART1_MspDeInit 1 */
+    }
+    else if (uartHandle->Instance == USART2)
+    {
+        /* USER CODE BEGIN USART2_MspDeInit 0 */
+
+        /* USER CODE END USART2_MspDeInit 0 */
+        /* Peripheral clock disable */
+        __HAL_RCC_USART2_CLK_DISABLE();
+
+        /**USART2 GPIO Configuration
+        PA2     ------> USART2_TX
+        PA3     ------> USART2_RX
+        */
+        HAL_GPIO_DeInit(GPIOA, GPIO_PIN_2 | GPIO_PIN_3);
+
+        /* USART2 interrupt Deinit */
+        HAL_NVIC_DisableIRQ(USART2_IRQn);
+        /* USER CODE BEGIN USART2_MspDeInit 1 */
+
+        /* USER CODE END USART2_MspDeInit 1 */
+    }
+    else if (uartHandle->Instance == USART3)
+    {
+        /* USER CODE BEGIN USART3_MspDeInit 0 */
+
+        /* USER CODE END USART3_MspDeInit 0 */
+        /* Peripheral clock disable */
+        __HAL_RCC_USART3_CLK_DISABLE();
+
+        /**USART3 GPIO Configuration
+        PB10     ------> USART3_TX
+        PB11     ------> USART3_RX
+        */
+        HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10 | GPIO_PIN_11);
+
+        /* USART3 interrupt Deinit */
+        HAL_NVIC_DisableIRQ(USART3_IRQn);
+        /* USER CODE BEGIN USART3_MspDeInit 1 */
+
+        /* USER CODE END USART3_MspDeInit 1 */
+    }
+}
 
 
 

bsp/stm32f10x_HAL/drivers/usart.h → bsp/stm32f10x_HAL/drivers/drv_usart.h

@@ -17,6 +17,6 @@
 
 #include <rthw.h>
 #include <rtthread.h>
-void rt_hw_usart_init(void);
+int rt_hw_usart_init(void);
 
 #endif

bsp/stm32f10x_HAL/drivers/drv_usb.c

+/*
+ * File      : drv_usb.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2015, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author            Notes
+ * 2017-10-30     ZYH            the first version
+ * 2017-11-15     ZYH          update to 3.0.0
+ */
+#include "drv_usb.h"
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "board.h"
+
+#define USB_DISCONNECT_PIN                  30		//PA9
+
+static PCD_HandleTypeDef _stm_pcd;
+static struct udcd _stm_udc;
+static struct ep_id _ep_pool[] =
+{
+    {0x0,  USB_EP_ATTR_CONTROL,     USB_DIR_INOUT,  64, ID_ASSIGNED  },
+    {0x1,  USB_EP_ATTR_BULK,        USB_DIR_IN,     64, ID_UNASSIGNED},
+    {0x1,  USB_EP_ATTR_BULK,        USB_DIR_OUT,    64, ID_UNASSIGNED},
+    {0x2,  USB_EP_ATTR_INT,         USB_DIR_OUT,    64, ID_UNASSIGNED},
+    {0x2,  USB_EP_ATTR_INT,         USB_DIR_IN,     64, ID_UNASSIGNED},
+    {0xFF, USB_EP_ATTR_TYPE_MASK,   USB_DIR_MASK,   0,  ID_ASSIGNED  },
+};
+
+void USB_LP_CAN1_RX0_IRQHandler(void)
+{
+    rt_interrupt_enter();
+
+    HAL_PCD_IRQHandler(&_stm_pcd);
+
+    rt_interrupt_leave();
+}
+
+void HAL_PCD_ResetCallback(PCD_HandleTypeDef *pcd)
+{
+    /* open ep0 OUT and IN */
+    HAL_PCD_EP_Open(pcd, 0x00, 0x40, EP_TYPE_CTRL);
+    HAL_PCD_EP_Open(pcd, 0x80, 0x40, EP_TYPE_CTRL);
+    rt_usbd_reset_handler(&_stm_udc);
+}
+
+void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
+{
+    rt_usbd_ep0_setup_handler(&_stm_udc, (struct urequest*)hpcd->Setup);
+}
+
+
+void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+    if (epnum == 0)
+    {
+        rt_usbd_ep0_in_handler(&_stm_udc);
+    }
+    else
+    {
+        rt_usbd_ep_in_handler(&_stm_udc, 0x80|epnum,hpcd->IN_ep[epnum].xfer_count);
+    }
+}
+
+void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
+{
+    rt_usbd_connect_handler(&_stm_udc);
+}
+
+void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
+{
+//  rt_usbd_sof_handler(&_stm_udc);
+}
+
+void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
+{
+    rt_usbd_disconnect_handler(&_stm_udc);
+}
+
+void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+    if (epnum != 0)
+    {
+        rt_usbd_ep_out_handler(&_stm_udc, epnum, hpcd->OUT_ep[epnum].xfer_count);
+    }
+    else
+    {
+        rt_usbd_ep0_out_handler(&_stm_udc,hpcd->OUT_ep[0].xfer_count);
+    }
+}
+
+
+void HAL_PCDEx_SetConnectionState(PCD_HandleTypeDef *hpcd, uint8_t state)
+{
+    if(state == 1)
+    {
+        rt_pin_write(USB_DISCONNECT_PIN,PIN_HIGH);
+    }
+    else
+    {
+        rt_pin_write(USB_DISCONNECT_PIN,PIN_LOW);
+    }  
+}
+
+void HAL_PCD_MspInit(PCD_HandleTypeDef* pcdHandle)
+{
+    if(pcdHandle->Instance==USB)
+    {
+        __HAL_RCC_GPIOA_CLK_ENABLE();
+        rt_pin_mode(USB_DISCONNECT_PIN,PIN_MODE_OUTPUT);
+        rt_pin_write(USB_DISCONNECT_PIN,PIN_LOW);
+        /* Peripheral clock enable */
+        __HAL_RCC_USB_CLK_ENABLE();
+
+        /* Peripheral interrupt init */
+        HAL_NVIC_SetPriority(USB_LP_CAN1_RX0_IRQn, 5, 0);
+        HAL_NVIC_EnableIRQ(USB_LP_CAN1_RX0_IRQn);
+    }
+}
+
+void HAL_PCD_MspDeInit(PCD_HandleTypeDef* pcdHandle)
+{
+    if(pcdHandle->Instance==USB)
+    {
+        /* Peripheral clock disable */
+        __HAL_RCC_USB_CLK_DISABLE();
+
+        /* Peripheral interrupt Deinit*/
+        HAL_NVIC_DisableIRQ(USB_LP_CAN1_RX0_IRQn);
+    }
+}
+
+static rt_err_t _ep_set_stall(rt_uint8_t address)
+{
+    HAL_PCD_EP_SetStall(&_stm_pcd, address);
+    return RT_EOK;
+}
+
+static rt_err_t _ep_clear_stall(rt_uint8_t address)
+{
+    HAL_PCD_EP_ClrStall(&_stm_pcd, address);  
+    return RT_EOK;
+}
+
+static rt_err_t _set_address(rt_uint8_t address)
+{
+    HAL_PCD_SetAddress(&_stm_pcd, address);
+    return RT_EOK;
+}
+
+static rt_err_t _set_config(rt_uint8_t address)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _ep_enable(uep_t ep)
+{
+    RT_ASSERT(ep != RT_NULL);
+    RT_ASSERT(ep->ep_desc != RT_NULL);
+    HAL_PCD_EP_Open(&_stm_pcd, ep->ep_desc->bEndpointAddress,
+                    ep->ep_desc->wMaxPacketSize, ep->ep_desc->bmAttributes);
+
+    return RT_EOK;
+}
+
+static rt_err_t _ep_disable(uep_t ep)
+{
+    RT_ASSERT(ep != RT_NULL);
+    RT_ASSERT(ep->ep_desc != RT_NULL);
+    HAL_PCD_EP_Close(&_stm_pcd, ep->ep_desc->bEndpointAddress);
+    return RT_EOK;
+}
+
+static rt_size_t _ep_read(rt_uint8_t address, void *buffer)
+{
+    rt_size_t size = 0;
+    RT_ASSERT(buffer != RT_NULL);
+    return size;
+}
+
+static rt_size_t _ep_read_prepare(rt_uint8_t address, void *buffer, rt_size_t size)
+{
+    HAL_PCD_EP_Receive(&_stm_pcd, address, buffer, size);
+    return size;
+}
+
+static rt_size_t _ep_write(rt_uint8_t address, void *buffer, rt_size_t size)
+{
+    HAL_PCD_EP_Transmit(&_stm_pcd, address, buffer, size);
+    return size;
+}
+
+static rt_err_t _ep0_send_status(void)
+{	
+    HAL_PCD_EP_Transmit(&_stm_pcd, 0x00, NULL, 0);
+    return RT_EOK;
+}
+
+static rt_err_t _suspend(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _wakeup(void)
+{
+    return RT_EOK;
+}
+
+static rt_err_t _init(rt_device_t device)
+{
+    PCD_HandleTypeDef *pcd;
+
+    /* Set LL Driver parameters */
+    pcd = (PCD_HandleTypeDef*)device->user_data;
+
+    pcd->Instance = USB;
+    pcd->Init.dev_endpoints = 8;
+    pcd->Init.speed = PCD_SPEED_FULL;
+    pcd->Init.ep0_mps = DEP0CTL_MPS_8;
+    pcd->Init.low_power_enable = DISABLE;
+    pcd->Init.lpm_enable = DISABLE;
+    pcd->Init.battery_charging_enable = DISABLE;
+
+    /* Initialize LL Driver */
+    HAL_PCD_Init(pcd);
+  
+    HAL_PCDEx_PMAConfig(pcd , 0x00 , PCD_SNG_BUF, 0x18);
+    HAL_PCDEx_PMAConfig(pcd , 0x80 , PCD_SNG_BUF, 0x58);
+    HAL_PCDEx_PMAConfig(pcd , 0x81 , PCD_SNG_BUF, 0x98);    
+    HAL_PCDEx_PMAConfig(pcd , 0x01 , PCD_SNG_BUF, 0x118);
+    HAL_PCDEx_PMAConfig(pcd , 0x82 , PCD_SNG_BUF, 0xD8);   
+    HAL_PCDEx_PMAConfig(pcd , 0x02 , PCD_SNG_BUF, 0x158);
+    HAL_PCD_Start(pcd);
+
+    return RT_EOK;
+}
+
+const static struct udcd_ops _udc_ops =
+{
+    _set_address,
+    _set_config,
+    _ep_set_stall,
+    _ep_clear_stall,
+    _ep_enable,
+    _ep_disable,
+    _ep_read_prepare,
+    _ep_read,
+    _ep_write,
+    _ep0_send_status,
+    _suspend,
+    _wakeup,
+};
+
+
+int stm_usbd_register(void)
+{
+    rt_memset((void *)&_stm_udc, 0, sizeof(struct udcd));
+
+    _stm_udc.parent.type = RT_Device_Class_USBDevice;
+    _stm_udc.parent.init = _init;
+    _stm_udc.parent.user_data = &_stm_pcd;
+    _stm_udc.ops = &_udc_ops;
+    /* Register endpoint infomation */
+    _stm_udc.ep_pool = _ep_pool;
+    _stm_udc.ep0.id = &_ep_pool[0];
+
+    rt_device_register((rt_device_t)&_stm_udc, "usbd", 0);
+    rt_usb_device_init();
+    return 0;
+}
+INIT_DEVICE_EXPORT(stm_usbd_register);
+ 

bsp/stm32f10x_HAL/drivers/drv_usb.h

+/*
+ * File      : drv_usb.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2015, RT-Thread Development Team
+ *
+ * The license and distribution terms for this file may be
+ * found in the file LICENSE in this distribution or at
+ * http://www.rt-thread.org/license/LICENSE
+ *
+ * Change Logs:
+ * Date           Author            Notes
+ * 2017-10-30     ZYH            the first version
+ */
+#ifndef __STM32_USB_H__
+#define __STM32_USB_H__
+#include <rtthread.h>
+
+int stm_usbd_register(void);
+
+#endif

bsp/stm32f10x_HAL/drivers/stm32f1xx_hal_conf.h

@@ -55,18 +55,17 @@
 /**
   * @brief This is the list of modules to be used in the HAL driver 
   */
-// defined in rtconfig.h
-// #define HAL_MODULE_ENABLED
+#define HAL_MODULE_ENABLED
 // #define HAL_ADC_MODULE_ENABLED
 // #define HAL_CAN_MODULE_ENABLED
 // #define HAL_CEC_MODULE_ENABLED
-// #define HAL_CORTEX_MODULE_ENABLED
+#define HAL_CORTEX_MODULE_ENABLED
 // #define HAL_CRC_MODULE_ENABLED
 // #define HAL_DAC_MODULE_ENABLED
-// #define HAL_DMA_MODULE_ENABLED
+#define HAL_DMA_MODULE_ENABLED
 // #define HAL_ETH_MODULE_ENABLED
-// #define HAL_FLASH_MODULE_ENABLED
-// #define HAL_GPIO_MODULE_ENABLED
+#define HAL_FLASH_MODULE_ENABLED
+#define HAL_GPIO_MODULE_ENABLED
 // #define HAL_HCD_MODULE_ENABLED
 // #define HAL_I2C_MODULE_ENABLED
 // #define HAL_I2S_MODULE_ENABLED
@@ -75,17 +74,24 @@
 // #define HAL_NAND_MODULE_ENABLED
 // #define HAL_NOR_MODULE_ENABLED
 // #define HAL_PCCARD_MODULE_ENABLED
-// #define HAL_PCD_MODULE_ENABLED
-// #define HAL_PWR_MODULE_ENABLED
-// #define HAL_RCC_MODULE_ENABLED
+#ifdef RT_USING_USB_DEVICE
+  #define HAL_PCD_MODULE_ENABLED
+#endif
+#define HAL_PWR_MODULE_ENABLED
+#define HAL_RCC_MODULE_ENABLED
 // #define HAL_RTC_MODULE_ENABLED
 // #define HAL_SD_MODULE_ENABLED
 // #define HAL_SMARTCARD_MODULE_ENABLED
-// #define HAL_SPI_MODULE_ENABLED
+#ifdef RT_USING_SPI
+  #define HAL_SPI_MODULE_ENABLED
+#endif
 // #define HAL_SRAM_MODULE_ENABLED
-// #define HAL_TIM_MODULE_ENABLED
-// #define HAL_UART_MODULE_ENABLED
-// #define HAL_USART_MODULE_ENABLED
+#define HAL_TIM_MODULE_ENABLED
+#ifdef RT_USING_SERIAL
+  #define HAL_UART_MODULE_ENABLED
+  #define HAL_USART_MODULE_ENABLED
+#endif
+
 // #define HAL_WWDG_MODULE_ENABLED
 // #define HAL_MMC_MODULE_ENABLED
 

bsp/stm32f10x_HAL/drivers/stm32f1xx_it.c

@@ -42,7 +42,7 @@
 /* External variables --------------------------------------------------------*/
 
 /******************************************************************************/
-/*            Cortex-M3 Processor Interruption and Exception Handlers         */ 
+/*            Cortex-M3 Processor Interruption and Exception Handlers         */
 /******************************************************************************/
 
 /**
@@ -50,12 +50,12 @@
 */
 void NMI_Handler(void)
 {
-  /* USER CODE BEGIN NonMaskableInt_IRQn 0 */
+    /* USER CODE BEGIN NonMaskableInt_IRQn 0 */
 
-  /* USER CODE END NonMaskableInt_IRQn 0 */
-  /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
+    /* USER CODE END NonMaskableInt_IRQn 0 */
+    /* USER CODE BEGIN NonMaskableInt_IRQn 1 */
 
-  /* USER CODE END NonMaskableInt_IRQn 1 */
+    /* USER CODE END NonMaskableInt_IRQn 1 */
 }
 
 
@@ -65,15 +65,15 @@ void NMI_Handler(void)
 */
 void MemManage_Handler(void)
 {
-  /* USER CODE BEGIN MemoryManagement_IRQn 0 */
+    /* USER CODE BEGIN MemoryManagement_IRQn 0 */
 
-  /* USER CODE END MemoryManagement_IRQn 0 */
-  while (1)
-  {
-  }
-  /* USER CODE BEGIN MemoryManagement_IRQn 1 */
+    /* USER CODE END MemoryManagement_IRQn 0 */
+    while (1)
+    {
+    }
+    /* USER CODE BEGIN MemoryManagement_IRQn 1 */
 
-  /* USER CODE END MemoryManagement_IRQn 1 */
+    /* USER CODE END MemoryManagement_IRQn 1 */
 }
 
 /**
@@ -81,15 +81,15 @@ void MemManage_Handler(void)
 */
 void BusFault_Handler(void)
 {
-  /* USER CODE BEGIN BusFault_IRQn 0 */
+    /* USER CODE BEGIN BusFault_IRQn 0 */
 
-  /* USER CODE END BusFault_IRQn 0 */
-  while (1)
-  {
-  }
-  /* USER CODE BEGIN BusFault_IRQn 1 */
+    /* USER CODE END BusFault_IRQn 0 */
+    while (1)
+    {
+    }
+    /* USER CODE BEGIN BusFault_IRQn 1 */
 
-  /* USER CODE END BusFault_IRQn 1 */
+    /* USER CODE END BusFault_IRQn 1 */
 }
 
 /**
@@ -97,15 +97,15 @@ void BusFault_Handler(void)
 */
 void UsageFault_Handler(void)
 {
-  /* USER CODE BEGIN UsageFault_IRQn 0 */
+    /* USER CODE BEGIN UsageFault_IRQn 0 */
 
-  /* USER CODE END UsageFault_IRQn 0 */
-  while (1)
-  {
-  }
-  /* USER CODE BEGIN UsageFault_IRQn 1 */
+    /* USER CODE END UsageFault_IRQn 0 */
+    while (1)
+    {
+    }
+    /* USER CODE BEGIN UsageFault_IRQn 1 */
 
-  /* USER CODE END UsageFault_IRQn 1 */
+    /* USER CODE END UsageFault_IRQn 1 */
 }
 
 /**
@@ -113,12 +113,12 @@ void UsageFault_Handler(void)
 */
 void DebugMon_Handler(void)
 {
-  /* USER CODE BEGIN DebugMonitor_IRQn 0 */
+    /* USER CODE BEGIN DebugMonitor_IRQn 0 */
 
-  /* USER CODE END DebugMonitor_IRQn 0 */
-  /* USER CODE BEGIN DebugMonitor_IRQn 1 */
+    /* USER CODE END DebugMonitor_IRQn 0 */
+    /* USER CODE BEGIN DebugMonitor_IRQn 1 */
 
-  /* USER CODE END DebugMonitor_IRQn 1 */
+    /* USER CODE END DebugMonitor_IRQn 1 */
 }
 
 /**

bsp/stm32f10x_HAL/rtconfig.h

-/* RT-Thread config file */
-#ifndef __RTTHREAD_CFG_H__
-#define __RTTHREAD_CFG_H__
+#ifndef RT_CONFIG_H__
+#define RT_CONFIG_H__
 
-/* RT_NAME_MAX*/
-#define RT_NAME_MAX	8
+/* Automatically generated file; DO NOT EDIT. */
+/* RT-Thread Configuration */
 
-/* RT_ALIGN_SIZE*/
-#define RT_ALIGN_SIZE	4
+/* RT-Thread Kernel */
 
-/* PRIORITY_MAX */
-#define RT_THREAD_PRIORITY_MAX	32
-
-/* Tick per Second */
-#define RT_TICK_PER_SECOND	100
-
-/* SECTION: RT_DEBUG */
-/* Thread Debug */
+#define RT_NAME_MAX 8
+#define RT_ALIGN_SIZE 4
+/* RT_THREAD_PRIORITY_8 is not set */
+#define RT_THREAD_PRIORITY_32
+/* RT_THREAD_PRIORITY_256 is not set */
+#define RT_THREAD_PRIORITY_MAX 32
+#define RT_TICK_PER_SECOND 100
 #define RT_DEBUG
-#define RT_THREAD_DEBUG
-
 #define RT_USING_OVERFLOW_CHECK
-
-/* Using Hook */
+#define RT_DEBUG_INIT 0
+#define RT_DEBUG_THREAD 0
 #define RT_USING_HOOK
+#define IDLE_THREAD_STACK_SIZE 256
+/* RT_USING_TIMER_SOFT is not set */
 
-/* Using Software Timer */
-/* #define RT_USING_TIMER_SOFT */
-#define RT_TIMER_THREAD_PRIO		4
-#define RT_TIMER_THREAD_STACK_SIZE	512
-#define RT_TIMER_TICK_PER_SECOND	10
+/* Inter-Thread communication */
 
-/* SECTION: IPC */
-/* Using Semaphore*/
 #define RT_USING_SEMAPHORE
-
-/* Using Mutex */
 #define RT_USING_MUTEX
-
-/* Using Event */
 #define RT_USING_EVENT
-
-/* Using MailBox */
 #define RT_USING_MAILBOX
-
-/* Using Message Queue */
 #define RT_USING_MESSAGEQUEUE
+/* RT_USING_SIGNALS is not set */
 
-/* SECTION: Memory Management */
-/* Using Memory Pool Management*/
-#define RT_USING_MEMPOOL
-
-/* Using Dynamic Heap Management */
-#define RT_USING_HEAP
+/* Memory Management */
 
-/* Using Small MM */
+#define RT_USING_MEMPOOL
+#define RT_USING_MEMHEAP
+/* RT_USING_NOHEAP is not set */
 #define RT_USING_SMALL_MEM
+/* RT_USING_SLAB is not set */
+/* RT_USING_MEMHEAP_AS_HEAP is not set */
+#define RT_USING_HEAP
 
-// <bool name="RT_USING_COMPONENTS_INIT" description="Using RT-Thread components initialization" default="true" />
-//#define RT_USING_COMPONENTS_INIT
+/* Kernel Device Object */
 
-/* SECTION: Device System */
-/* Using Device System */
 #define RT_USING_DEVICE
-// <bool name="RT_USING_DEVICE_IPC" description="Using device communication" default="true" />
-#define RT_USING_DEVICE_IPC
+/* RT_USING_INTERRUPT_INFO is not set */
+#define RT_USING_CONSOLE
+#define RT_CONSOLEBUF_SIZE 128
+#define RT_CONSOLE_DEVICE_NAME "uart2"
+/* RT_USING_MODULE is not set */
 
+/* RT-Thread Components */
 
+#define RT_USING_COMPONENTS_INIT
+#define RT_USING_USER_MAIN
 
-/* SECTION: device filesystem */
-//#define RT_USING_DFS 
-
-#define RT_USING_DFS_ELMFAT
-/* Reentrancy (thread safe) of the FatFs module.  */
-#define RT_DFS_ELM_REENTRANT
-/* Number of volumes (logical drives) to be used. */
-#define RT_DFS_ELM_DRIVES			1
-/* #define RT_DFS_ELM_USE_LFN			1 */
-/* #define RT_DFS_ELM_CODE_PAGE			936 */
-#define RT_DFS_ELM_MAX_LFN			255
-/* Maximum sector size to be handled. */
-#define RT_DFS_ELM_MAX_SECTOR_SIZE  4096
-
-/* the max number of mounted filesystem */
-#define DFS_FILESYSTEMS_MAX			1
-/* the max number of opened files 		*/
-#define DFS_FD_MAX					4
-
-/* SECTION: lwip, a lighwight TCP/IP protocol stack */
-/* #define RT_USING_LWIP */
-/* LwIP uses RT-Thread Memory Management */
-#define RT_LWIP_USING_RT_MEM
-/* Enable ICMP protocol*/
-#define RT_LWIP_ICMP
-/* Enable UDP protocol*/
-#define RT_LWIP_UDP
-/* Enable TCP protocol*/
-#define RT_LWIP_TCP
-/* Enable DNS */
-#define RT_LWIP_DNS
-
-/* the number of simulatenously active TCP connections*/
-#define RT_LWIP_TCP_PCB_NUM	5
-
-/* Using DHCP */
-/* #define RT_LWIP_DHCP */
-
-/* ip address of target*/
-#define RT_LWIP_IPADDR0	192
-#define RT_LWIP_IPADDR1	168
-#define RT_LWIP_IPADDR2	1
-#define RT_LWIP_IPADDR3	30
-
-/* gateway address of target*/
-#define RT_LWIP_GWADDR0	192
-#define RT_LWIP_GWADDR1	168
-#define RT_LWIP_GWADDR2	1
-#define RT_LWIP_GWADDR3	1
-
-/* mask address of target*/
-#define RT_LWIP_MSKADDR0	255
-#define RT_LWIP_MSKADDR1	255
-#define RT_LWIP_MSKADDR2	255
-#define RT_LWIP_MSKADDR3	0
-
-/* tcp thread options */
-#define RT_LWIP_TCPTHREAD_PRIORITY		12
-#define RT_LWIP_TCPTHREAD_MBOX_SIZE		10
-#define RT_LWIP_TCPTHREAD_STACKSIZE		1024
-
-/* ethernet if thread options */
-#define RT_LWIP_ETHTHREAD_PRIORITY		15
-#define RT_LWIP_ETHTHREAD_MBOX_SIZE		10
-#define RT_LWIP_ETHTHREAD_STACKSIZE		512
-
-/* TCP sender buffer space */
-#define RT_LWIP_TCP_SND_BUF	8192
-/* TCP receive window. */
-#define RT_LWIP_TCP_WND		8192
-
-/* image support */
-/* #define RTGUI_IMAGE_XPM */
-/* #define RTGUI_IMAGE_BMP */
-
-// <bool name="RT_USING_CMSIS_OS" description="Using CMSIS OS API" default="true" />
-// #define RT_USING_CMSIS_OS
-// <bool name="RT_USING_RTT_CMSIS" description="Using CMSIS in RTT" default="true" />
-#define RT_USING_RTT_CMSIS
-// <bool name="RT_USING_BSP_CMSIS" description="Using CMSIS in BSP" default="true" />
-// #define RT_USING_BSP_CMSIS
-
-/* nanopb support */
-/* #define RT_USING_NANOPB */
-
-#define RT_USING_CPU_FFS
-
-#define HAL_MODULE_ENABLED
-// #define HAL_ADC_MODULE_ENABLED
-// #define HAL_CAN_MODULE_ENABLED
-// #define HAL_CEC_MODULE_ENABLED
-#define HAL_CORTEX_MODULE_ENABLED
-// #define HAL_CRC_MODULE_ENABLED
-// #define HAL_DAC_MODULE_ENABLED
-#define HAL_DMA_MODULE_ENABLED
-// #define HAL_ETH_MODULE_ENABLED
-#define HAL_FLASH_MODULE_ENABLED
-#define HAL_GPIO_MODULE_ENABLED
-// #define HAL_HCD_MODULE_ENABLED
-// #define HAL_I2C_MODULE_ENABLED
-// #define HAL_I2S_MODULE_ENABLED
-// #define HAL_IRDA_MODULE_ENABLED
-// #define HAL_IWDG_MODULE_ENABLED
-// #define HAL_NAND_MODULE_ENABLED
-// #define HAL_NOR_MODULE_ENABLED
-// #define HAL_PCCARD_MODULE_ENABLED
-#define HAL_PCD_MODULE_ENABLED
-#define HAL_PWR_MODULE_ENABLED
-#define HAL_RCC_MODULE_ENABLED
-// #define HAL_RTC_MODULE_ENABLED
-// #define HAL_SD_MODULE_ENABLED
-// #define HAL_SMARTCARD_MODULE_ENABLED
-#define HAL_SPI_MODULE_ENABLED
-// #define HAL_SRAM_MODULE_ENABLED
-#define HAL_TIM_MODULE_ENABLED
-#define HAL_UART_MODULE_ENABLED
-#define HAL_USART_MODULE_ENABLED
-// #define HAL_WWDG_MODULE_ENABLED
-// #define HAL_MMC_MODULE_ENABLED
+/* C++ features */
 
+/* RT_USING_CPLUSPLUS is not set */
 
-#define RT_USING_SERIAL
+/* Command shell */
+
+#define RT_USING_FINSH
+#define FINSH_USING_HISTORY
+#define FINSH_USING_SYMTAB
+#define FINSH_USING_DESCRIPTION
+#define FINSH_THREAD_PRIORITY 20
+#define FINSH_THREAD_STACK_SIZE 4096
+#define FINSH_CMD_SIZE 80
+/* FINSH_USING_AUTH is not set */
+#define FINSH_USING_MSH
+#define FINSH_USING_MSH_DEFAULT
+#define FINSH_USING_MSH_ONLY
+
+/* Device virtual file system */
 
+/* RT_USING_DFS is not set */
+
+/* Device Drivers */
+
+#define RT_USING_DEVICE_IPC
+#define RT_USING_SERIAL
+/* RT_USING_CAN is not set */
+/* RT_USING_HWTIMER is not set */
+/* RT_USING_I2C is not set */
 #define RT_USING_PIN
+/* RT_USING_MTD_NOR is not set */
+/* RT_USING_MTD_NAND is not set */
+/* RT_USING_RTC is not set */
+/* RT_USING_SDIO is not set */
+/* RT_USING_SPI is not set */
+/* RT_USING_WDT is not set */
+/* RT_USING_USB_HOST is not set */
+/* RT_USING_USB_DEVICE is not set */
 
-#define RT_USING_UART1
+/* POSIX layer and C standard library */
 
-#define RT_CONSOLE_DEVICE_NAME	    "uart1"
-/* SECTION: Console options */
-#define RT_USING_CONSOLE
-/* the buffer size of console*/
-#define RT_CONSOLEBUF_SIZE	        128
-// <string name="RT_CONSOLE_DEVICE_NAME" description="The device name for console" default="uart1" />
+/* RT_USING_LIBC is not set */
+/* RT_USING_PTHREADS is not set */
 
+/* Network stack */
 
-/* SECTION: finsh, a C-Express shell */
-#define RT_USING_FINSH
+/* light weight TCP/IP stack */
 
-//#define FINSH_USING_MSH
-/* Using symbol table */
-#define FINSH_USING_SYMTAB
+/* RT_USING_LWIP is not set */
 
-#define FINSH_USING_DESCRIPTION
+/* Modbus master and slave stack */
+
+/* RT_USING_MODBUS is not set */
+
+/* RT-Thread UI Engine */
+
+/* RT_USING_GUIENGINE is not set */
+
+/* VBUS(Virtual Software BUS) */
+
+/* RT_USING_VBUS is not set */
+
+/* RT-Thread online packages */
+
+/* system packages */
+
+/* PKG_USING_PARTITION is not set */
+/* PKG_USING_SQLITE is not set */
+
+/* IoT - internet of things */
+
+/* PKG_USING_CJSON is not set */
+/* PKG_USING_PAHOMQTT is not set */
+/* PKG_USING_WEBCLIENT is not set */
+/* PKG_USING_MONGOOSE is not set */
+/* PKG_USING_WEBTERMINAL is not set */
+
+/* security packages */
+
+/* PKG_USING_MBEDTLS is not set */
+
+/* language packages */
+
+/* PKG_USING_JERRYSCRIPT is not set */
+
+/* multimedia packages */
+
+/* tools packages */
+
+/* PKG_USING_CMBACKTRACE is not set */
+/* PKG_USING_EASYLOGGER is not set */
+
+/* miscellaneous packages */
 
-//#define RT_USING_SPI
+/* PKG_USING_HELLO is not set */
 
-#define SPI_USE_DMA
+/* BSP_SPECIAL CONFIG */
 
-#define RT_USING_W25QXX
+#define STM32F10X_PIN_NUMBERS 64
+/* RT_USING_UART1 is not set */
+#define RT_USING_UART2
+/* RT_USING_UART3 is not set */
 
 #endif