如果您是完全按照《如何将移植ucos到STM32F103开发板上-1》来新建的工程的话，那很遗憾，你要重新建立一个工程，因为，在那篇文章的步骤1中，我们选中了GPIO，但是没有选中USART，所以要新建一个工程，只是也要把USART选中


BSP.c文件中增加对串口的初始化及中断的初始化：

1. 
   
2. void NVIC_Configuration(void)
   
3. {
   
4.   //EXTI_InitTypeDef EXTI_InitStructure;
   
5.   NVIC_InitTypeDef NVIC_InitStructure;
   
6.   
   
7.   /* Configure the NVIC Preemption Priority Bits */  
   
8.   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
   
9. 
   
10.   NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
11.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    
12.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
13.   NVIC_Init(&NVIC_InitStructure);
    
14. }
    
15. 
    
16. void USART_Config(USART_TypeDef* USARTx,u32 baud){
    
17.   USART_InitTypeDef USART_InitStructure;
    
18.   GPIO_InitTypeDef GPIO_InitStructure;
    
19. 
    
20.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
21.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);       
    
22.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
    
23.   
    
24.   //usart_init----------------------------------------------------
    
25.   /* Configure USART1 Rx (PA.10) as input floating */
    
26.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    
27.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
28.   GPIO_Init(GPIOA, &GPIO_InitStructure);                                         
    
29.   
    
30.   /* Configure USART1 Tx (PA.09) as alternate function push-pull */
    
31.   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    
32.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
33.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    
34.   GPIO_Init(GPIOA, &GPIO_InitStructure);
    
35.   
    
36.   
    
37.   USART_InitStructure.USART_BaudRate =baud;
    
38.   USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
39.   USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
40.   USART_InitStructure.USART_Parity = USART_Parity_No;
    
41.   USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    
42.   USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    
43. 
    
44.   /* Configure USART1 */
    
45.   USART_Init(USARTx, &USART_InitStructure);
    
46. 
    
47.   /* Enable USART1 Receive and Transmit interrupts */
    
48.   USART_ITConfig(USARTx, USART_IT_RXNE, ENABLE);
    
49.   //USART_ITConfig(USARTx, USART_IT_TXE, ENABLE);
    
50. 
    
51.   
    
52.   /* Enable the USART1 */
    
53.   USART_Cmd(USARTx, ENABLE);       
    
54. 
    
55.   //USART_ClearFlag(USARTx, USART_FLAG_TXE);
    
56. }
    
57. 
    
58. void BSP_Init(void)
    
59. {
    
60.   /* System Clocks Configuration --72M*/
    
61.   RCC_Configuration();   
    
62.   GPIO_Configuration();
    
63. 
    
64.   NVIC_Configuration();
    
65.   USART_Config(USART1,115200);
    
66. }
    

复制代码

APP目录下新建USART.c文件，添加如下代码：

1. #include <usart.h>
   
2. 
   
3. void USART_OUT(USART_TypeDef* USARTx, uint8_t *Data,...){
   
4.         const char *s;
   
5.         int d;
   
6. 
   
7.         char buf[16];
   
8.         va_list ap;
   
9.         va_start(ap, Data);
   
10. 
    
11.         while(*Data!=0){
    
12.                 if(*Data==0x5c){
    
13.                         switch (*++Data){
    
14.                                 case 'r':
    
15.                                         USART_SendData(USARTx, 0x0d);
    
16. 
    
17.                                         Data++;
    
18.                                         break;
    
19.                                 case 'n':
    
20.                                         USART_SendData(USARTx, 0x0a);       
    
21.                                         Data++;
    
22.                                         break;
    
23. 
    
24.                                 default:
    
25.                                         Data++;
    
26.                                         break;
    
27.                         }
    
28.                 }else if(*Data=='%'){
    
29.                         switch (*++Data){
    
30.                                 case 's':
    
31.                                         s = va_arg(ap, const char *);
    
32.                                         for ( ; *s; s++) {
    
33.                                                 USART_SendData(USARTx,*s);
    
34.                                                 while(USART_GetFlagStatus(USARTx, USART_FLAG_TC)==RESET);
    
35.                                         }
    
36.                                         Data++;
    
37.                                         break;
    
38.                                 case 'd':
    
39.                                         d = va_arg(ap, int);
    
40.                                         itoa(d, buf, 10);
    
41.                                         for (s = buf; *s; s++) {
    
42.                                                 USART_SendData(USARTx,*s);
    
43.                                                 while(USART_GetFlagStatus(USARTx, USART_FLAG_TC)==RESET);
    
44.                                         }
    
45.                                         Data++;
    
46.                                         break;
    
47.                                 default:
    
48.                                         Data++;
    
49.                                         break;
    
50.                         }                 
    
51.                 }else{
    
52.                         USART_SendData(USARTx, *Data++);
    
53.                 }
    
54.                 while(USART_GetFlagStatus(USARTx, USART_FLAG_TC)==RESET);
    
55.         }
    
56. }
    
57. 
    
58. char *itoa(int value, char *string, int radix)
    
59. {
    
60.         int     i, d;
    
61.         int     flag = 0;
    
62.         char    *ptr = string;
    
63. 
    
64.         /* This implementation only works for decimal numbers. */
    
65.         if (radix != 10)
    
66.         {
    
67.                 *ptr = 0;
    
68.                 return string;
    
69.         }
    
70. 
    
71.         if (!value)
    
72.         {
    
73.                 *ptr++ = 0x30;
    
74.                 *ptr = 0;
    
75.                 return string;
    
76.         }
    
77. 
    
78.         /* if this is a negative value insert the minus sign. */
    
79.         if (value < 0)
    
80.         {
    
81.                 *ptr++ = '-';
    
82.                 /* Make the value positive. */
    
83.                 value *= -1;
    
84.         }
    
85.         for (i = 10000; i > 0; i /= 10)
    
86.         {
    
87.                 d = value / i;
    
88. 
    
89.                 if (d || flag)
    
90.                 {
    
91.                         *ptr++ = (char)(d + 0x30);
    
92.                         value -= (d * i);
    
93.                         flag = 1;
    
94.                 }
    
95.         }
    
96. 
    
97.         /* Null terminate the string. */
    
98.         *ptr = 0;
    
99. 
    
100.         return string;
     
101. 
     
102. } /* NCL_Itoa */
     
103. 
     
104. int SendChar (int ch)  {                /* Write character to Serial Port     */
     
105.   USART_SendData(USART1, (unsigned char) ch);
     
106.   while (!(USART1->SR & USART_FLAG_TXE));
     
107.         if(ch=='\r')
     
108.                 SendChar('\n');
     
109.   return (ch);
     
110. }
     
111. 
     

复制代码

新建usart.h文件：

1. <pre name="code" class="html">#ifndef __USART_H__
   
2. #define __USART_H__
   
3. 
   
4. #include <includes.h>
   
5. 
   
6. void USART_OUT(USART_TypeDef* USARTx, uint8_t *Data,...);
   
7. char *itoa(int value, char *string, int radix);
   
8. int SendChar (int ch);
   
9. 
   
10. #endif
    

复制代码

stm32f10x_it.c文件中添加串口中断处理：

1. void USART1_IRQHandler(void)
   
2. {
   
3.         unsigned int i;
   
4.         unsigned char msg[50];
   
5.         OS_CPU_SR  cpu_sr;
   
6. 
   
7.         OS_ENTER_CRITICAL();
   
8.         OSIntNesting++;
   
9. 
   
10.         OS_EXIT_CRITICAL();
    
11. 
    
12.         //OSTimeTick();
    
13. 
    
14.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    
15.         {       
    
16.                 if(RxCounter1>20)
    
17.                         RxCounter1=1;
    
18. 
    
19.                 // Read one byte from the receive data register
    
20.                 msg[RxCounter1++]= USART_ReceiveData(USART1);
    
21.                 SendChar(msg[RxCounter1-1]);
    
22. 
    
23.                 if(msg[RxCounter1-1]=='L')
    
24.                 {
    
25.                         msg[0]='L'; RxCounter1=1;
    
26.                 }else if(msg[RxCounter1-1]=='F')
    
27.                 {
    
28.                         for(i=0; i< RxCounter1; i++){
    
29.                                 TxBuffer1[i]        =msg[i];
    
30.                         }
    
31.                         TxBuffer1[RxCounter1]=0;
    
32.                         RxCounter1=0;
    
33.                         //OSSemPost(Com1_SEM);           
    
34.                         OSMboxPost(Com1_MBOX,(void *)&msg);                            
    
35.                 }
    
36.         }
    
37.         if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET)
    
38.         {
    
39.                 USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
    
40.         }       
    
41.         OSIntExit();
    
42. }
    

复制代码

APP.c文件中新建消息邮箱处理函数：

1. 
   
2. static  void Task_Com1(void *p_arg){
   
3.         INT8U err;       
   
4.         unsigned char * msg;
   
5.         (void)p_arg;                                            
   
6.         while(1){
   
7.                 msg=(unsigned char *)OSMboxPend(Com1_MBOX,0,&err);
   
8.                 if(msg[0]=='L'&&msg[1]=='1'){
   
9.                         milsec1=atoi(&msg[3]);
   
10.                         USART_OUT(USART1,"\r\n");
    
11.                         USART_OUT(USART1,"LED1: %d ms delay",milsec1);
    
12.                         USART_OUT(USART1,"\r\n");
    
13.                 }else if(msg[0]=='L'&&msg[1]=='2'){
    
14.                         milsec2=atoi(&msg[3]);
    
15.                         USART_OUT(USART1,"\r\n");
    
16.                         USART_OUT(USART1,"LED2: %d ms delay",milsec2);
    
17.                         USART_OUT(USART1,"\r\n");
    
18.                 }
    
19.         }
    
20. }
    

复制代码

并添加该任务：

1. OSTaskCreateExt(Task_Com1,(void *)0,(OS_STK *)&Task_Com1Stk[Task_Com1_STK_SIZE-1],
   
2.                 Task_Com1_PRIO,Task_Com1_PRIO,(OS_STK *)&Task_Com1Stk[0],
   
3.                 Task_Com1_STK_SIZE,(void *)0,OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR);
   

复制代码

新建一个头文件globals.h：

1. #ifdef GLOBALS
   
2. #define EXT
   
3. #else
   
4. #define EXT extern
   
5. #endif
   
6. 
   
7. 
   
8. EXT unsigned char TxBuffer1[400];
   
9. 
   
10. EXT unsigned char TxBuffer2[];
    
11. EXT unsigned char RxBuffer1[400];
    
12. EXT unsigned char RxBuffer2[];
    
13. EXT unsigned char TxCounter1;
    
14. EXT unsigned int TxCounter2;
    
15. EXT volatile unsigned int RxCounter1;
    
16. EXT volatile unsigned int RxCounter2;
    
17. 
    
18. EXT volatile unsigned char rec_f,tx_flag;
    
19. EXT volatile unsigned long Rec_Len;       
    
20. EXT volatile unsigned  int  milsec1,milsec2,milsec3;
    

复制代码

将 globals.h 文件 include 到 APP.c 和 stm32f10x_it.c 中，注意，在APP.c文件 中应该先define GLOBALS，即

1. #define GLOBALS
   
2. 
   
3. #include <globals.h>

复制代码

APP.c文件中添加全局变量：

1. OS_EVENT* Com1_MBOX;

复制代码

stm32f10x_it.c 中也添加该变量：

1. extern OS_EVENT* Com1_MBOX;

复制代码