搭建基于 STM32 和 rt-thread 的开发平台

   1: /* board.h */

   2: #ifndef __BOARD_H__

   3: #define __BOARD_H__

   4:  

   5: #define STM32_EXT_SRAM          0

   6: //    <o>Begin Address of External SRAM

   7: //        <i>Default: 0x68000000

   8: #define STM32_EXT_SRAM_BEGIN    0x68000000 /* the begining address of external SRAM */

   9: //    <o>End Address of External SRAM

  10: //        <i>Default: 0x68080000

  11: #define STM32_EXT_SRAM_END      0x68080000 /* the end address of external SRAM */

  12: // </e>

  13:  

  14: // <o> Internal SRAM memory size[Kbytes] <8-64>

  15: //    <i>Default: 64

  16: #define STM32_SRAM_SIZE         20

  17: #define STM32_SRAM_END          (0x20000000 + STM32_SRAM_SIZE * 1024)

  18:  

  19: void board_initiate();

  20:  

  21: /* LED */

  22: #define USING_LED1

  23: #define led1_periph_clock       RCC_APB2Periph_GPIOC

  24: #define led1_port               GPIOC

  25: #define led1_pin                (GPIO_Pin_13)

  26:  

  27: #endif

   1: /* board.c */

   2: #include <rthw.h>

   3: #include <rtthread.h>

   4:  

   5: #include <stm32f10x.h>

   6: #include "board.h"

   7: #include "usart.h"

   8:  

   9: void board_initiate(){

  10:     SystemInit();

  11:     SysTick_Config( SystemCoreClock / RT_TICK_PER_SECOND );

  12:  

  13:     rt_hw_usart_init();

  14:     rt_console_set_device(RT_CONSOLE_DEVICE_NAME);

  15: }

  16:  

  17: void SysTick_Handler(void)

  18: {

  19:     rt_interrupt_enter();

  20:     rt_tick_increase();

  21:     rt_interrupt_leave();

  22: }

   1: /* led.h */

   2: #ifndef __LED_H__

   3: #define __LED_H__

   4:  

   5: #include <stdint.h>

   6:  

   7: void led_initiate(void);

   8: void led_on(uint8_t led);

   9: void led_off(uint8_t led);

  10:  

  11: #endif

   1: /* led.c */

   2: #include <stm32f10x.h>

   3: #include "led.h"

   4: #include <board.h>

   5:  

   6: void led_initiate(void)

   7: {

   8:     GPIO_InitTypeDef GPIO_InitStructure;

   9:     GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_Out_PP;

  10:     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  11:  

  12: #ifdef USING_LED1

  13:     RCC_APB2PeriphClockCmd(led1_periph_clock,ENABLE);

  14:     GPIO_InitStructure.GPIO_Pin   = led1_pin;

  15:     GPIO_Init(led1_port, &GPIO_InitStructure);

  16: #endif

  17: }

  18:  

  19: void led_on(uint8_t n)

  20: {

  21: #ifdef USING_LED1

  22:     if(n!=0)return;

  23:     GPIO_SetBits(led1_port, led1_pin);

  24: #endif

  25: }

  26: void led_off(uint8_t n)

  27: {

  28: #ifdef USING_LED1

  29:     if(n!=0)return;

  30:     GPIO_ResetBits(led1_port, led1_pin);

  31: #endif

  32: }

   1: /* app.h */

   2: #ifndef __APP_H__

   3: #define __APP_H__

   4:  

   5: int app_initiate(void);

   6:  

   7: #endif /* __APP_H__ */

   1: /* app.c */

   2: #include <rthw.h>

   3: #include <rtthread.h>

   4:  

   5: #include "app.h"

   6: #include "led.h"

   7:  

   8: #ifdef  RT_USING_COMPONENTS_INIT

   9: #include <components.h>

  10: #endif  /* RT_USING_COMPONENTS_INIT */

  11:  

  12: static rt_uint8_t led_stack[256];

  13: static struct rt_thread led_thread;

  14: static void led_thread_entry(void* parameter)

  15: {

  16:     led_initiate();

  17:     while (1)

  18:     {

  19:         led_on(0);

  20:         rt_thread_delay( RT_TICK_PER_SECOND/2 );

  21:         led_off(0);

  22:         rt_thread_delay( RT_TICK_PER_SECOND/2 );

  23:  

  24:     }

  25: }

  26:  

  27: int app_initiate(void)

  28: {

  29:     rt_err_t result;

  30:     /* init led thread */

  31:     result = rt_thread_init(&led_thread,

  32:             "led",

  33:             led_thread_entry,

  34:             RT_NULL,

  35:             (rt_uint8_t*)&led_stack[0],

  36:             sizeof(led_stack),

  37:             20,

  38:             5);

  39:     if (result == RT_EOK)

  40:     {

  41:         rt_thread_startup(&led_thread);

  42:     }

  43:  

  44: #ifdef RT_USING_COMPONENTS_INIT

  45:     /* initialization RT-Thread Components */

  46:     rt_components_init();

  47: #endif

  48:  

  49:     return 0;

  50: }

   1: /* main.c */

   2: #include <rthw.h>

   3: #include <rtthread.h>

   4: #ifdef __CC_ARM

   5: extern int Image$$RW_IRAM1$$ZI$$Limit;

   6: #elif __ICCARM__

   7: #pragma section="HEAP"

   8: #else

   9: extern int __bss_end;

  10: #endif

  11:  

  12: #include <stdint.h>

  13: #include "board.h"

  14: #include "app.h"

  15:  

  16: int main()

  17: {

  18:     board_initiate();

  19: #ifdef RT_USING_HEAP

  20: #if STM32_EXT_SRAM

  21:     rt_system_heap_init((void*)STM32_EXT_SRAM_BEGIN, (void*)STM32_EXT_SRAM_END);

  22: #else

  23: #ifdef __CC_ARM

  24:     rt_system_heap_init((void*)&Image$$RW_IRAM1$$ZI$$Limit, (void*)STM32_SRAM_END);

  25: #elif __ICCARM__

  26:     rt_system_heap_init(__segment_end("HEAP"), (void*)STM32_SRAM_END);

  27: #else

  28:     /* init memory system */

  29:     rt_system_heap_init((void*)&__bss_end, (void*)STM32_SRAM_END);

  30: #endif

  31: #endif  /* STM32_EXT_SRAM */

  32: #endif /* RT_USING_HEAP */

  33:     /* init scheduler system */

  34:     rt_system_scheduler_init();

  35:     /* initialize timer */

  36:     rt_system_timer_init();

  37:     /* init timer thread */

  38:     rt_system_timer_thread_init();

  39:     /* init application */

  40:     app_initiate();

  41:     /* init idle thread */

  42:     rt_thread_idle_init();

  43:     /* start scheduler */

  44:     rt_system_scheduler_start();

  45:     /* never reach here */

  46:     return 0;

  47: }

  48:  

  49: void assert_failed(uint8_t* file, uint32_t line)

  50: {

  51:     while (1) ;

  52: }