ucos多任务单串口打印遇到的问题

dmzy

目前正在学习ucos，使用的代码版本为ucos 2.92，现在使用多任务单串口打印的时候，发现容易丢字符的现象，即使使用互斥信号量依旧存在该问题，话不多说，上代码给大家看看

main函数代码

1. int main(void)
   
2. {
   
3.         CPU_INT08U  err;
   
4. 
   
5.         Bsp_Init();
   
6.        
   
7.         OSInit();                                                   /* Initialize "uC/OS-II, The Real-Time Kernel"              */
   
8.         OSMutexCreate(3, &err);
   
9. 
   
10.         OSTaskCreateExt(LED1TaskStart,                               /* Create the start task                                    */
    
11.                                         (void *)0,
    
12.                                         (OS_STK *)&LED1TaskStartStk[TASK_START_STK_SIZE - 1],
    
13.                                         LED1_TASK_START_PRIO,
    
14.                                         LED1_TASK_START_PRIO,
    
15.                                         (OS_STK *)&LED1TaskStartStk[0],
    
16.                                         TASK_START_STK_SIZE,
    
17.                                         (void *)0,
    
18.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
19. 
    
20.         OSTaskNameSet(LED1_TASK_START_PRIO, "LED1 Task", &err);
    
21. 
    
22.         OSTaskCreateExt(LED2TaskStart,                               /* Create the start task                                    */
    
23.                                         (void *)0,
    
24.                                         (OS_STK *)&LED2TaskStartStk[TASK_START_STK_SIZE - 1],
    
25.                                         LED2_TASK_START_PRIO,
    
26.                                         LED2_TASK_START_PRIO,
    
27.                                         (OS_STK *)&LED2TaskStartStk[0],
    
28.                                         TASK_START_STK_SIZE,
    
29.                                         (void *)0,
    
30.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
31. 
    
32.         OSTaskNameSet(LED2_TASK_START_PRIO, "LED2 Task", &err);
    
33. 
    
34.         OSTaskCreateExt(LED3TaskStart,                               /* Create the start task                                    */
    
35.                                         (void *)0,
    
36.                                         (OS_STK *)&LED3TaskStartStk[TASK_START_STK_SIZE - 1],
    
37.                                         LED3_TASK_START_PRIO,
    
38.                                         LED3_TASK_START_PRIO,
    
39.                                         (OS_STK *)&LED3TaskStartStk[0],
    
40.                                         TASK_START_STK_SIZE,
    
41.                                         (void *)0,
    
42.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
43. 
    
44.         OSTaskNameSet(LED3_TASK_START_PRIO, "LED3 Task", &err);
    
45. 
    
46.         OSTaskCreateExt(LED4TaskStart,                               /* Create the start task                                    */
    
47.                                         (void *)0,
    
48.                                         (OS_STK *)&LED4TaskStartStk[TASK_START_STK_SIZE - 1],
    
49.                                         LED4_TASK_START_PRIO,
    
50.                                         LED4_TASK_START_PRIO,
    
51.                                         (OS_STK *)&LED4TaskStartStk[0],
    
52.                                         TASK_START_STK_SIZE,
    
53.                                         (void *)0,
    
54.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
55. 
    
56.         OSTaskNameSet(LED4_TASK_START_PRIO, "LED4 Task", &err);
    
57. 
    
58.         OSTaskCreateExt(LED5TaskStart,                               /* Create the start task                                    */
    
59.                                         (void *)0,
    
60.                                         (OS_STK *)&LED5TaskStartStk[TASK_START_STK_SIZE - 1],
    
61.                                         LED5_TASK_START_PRIO,
    
62.                                         LED5_TASK_START_PRIO,
    
63.                                         (OS_STK *)&LED5TaskStartStk[0],
    
64.                                         TASK_START_STK_SIZE,
    
65.                                         (void *)0,
    
66.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
67. 
    
68.         OSTaskNameSet(LED5_TASK_START_PRIO, "LED5 Task", &err);
    
69. 
    
70.         OSTaskCreateExt(LED6TaskStart,                               /* Create the start task                                    */
    
71.                                         (void *)0,
    
72.                                         (OS_STK *)&LED6TaskStartStk[TASK_START_STK_SIZE - 1],
    
73.                                         LED6_TASK_START_PRIO,
    
74.                                         LED6_TASK_START_PRIO,
    
75.                                         (OS_STK *)&LED6TaskStartStk[0],
    
76.                                         TASK_START_STK_SIZE,
    
77.                                         (void *)0,
    
78.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
79. 
    
80.         OSTaskNameSet(LED6_TASK_START_PRIO, "LED6 Task", &err);
    
81. 
    
82.         OSTaskCreateExt(LED7TaskStart,                               /* Create the start task                                    */
    
83.                                         (void *)0,
    
84.                                         (OS_STK *)&LED7TaskStartStk[TASK_START_STK_SIZE - 1],
    
85.                                         LED7_TASK_START_PRIO,
    
86.                                         LED7_TASK_START_PRIO,
    
87.                                         (OS_STK *)&LED7TaskStartStk[0],
    
88.                                         TASK_START_STK_SIZE,
    
89.                                         (void *)0,
    
90.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    
91. 
    
92.         OSTaskNameSet(LED7_TASK_START_PRIO, "LED7 Task", &err);
    
93. 
    
94.         OSTaskCreateExt(LED8TaskStart,                               /* Create the start task                                    */
    
95.                                         (void *)0,
    
96.                                         (OS_STK *)&LED8TaskStartStk[TASK_START_STK_SIZE - 1],
    
97.                                         LED8_TASK_START_PRIO,
    
98.                                         LED8_TASK_START_PRIO,
    
99.                                         (OS_STK *)&LED8TaskStartStk[0],
    
100.                                         TASK_START_STK_SIZE,
     
101.                                         (void *)0,
     
102.                                         OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
     
103. 
     
104.         OSTaskNameSet(LED8_TASK_START_PRIO, "LED8 Task", &err);
     
105. 
     
106.         OSStart();
     
107. }
     

复制代码

任务代码

1. static void LED1TaskStart(void * p_arg)
   
2. {
   
3.         INT8U err;
   
4.         (void)p_arg;
   
5. 
   
6.         while (1)
   
7.         {                                          /* Task body, always written as an infinite loop.           */
   
8.                 BSP_LED_Toggle(0);
   
9.                 OSMutexPend(ResourceMutex, 0, &err);
   
10.                 UsartPrintf(USART1, "LED1TaskStart\n");
    
11.                 OSMutexPost(ResourceMutex);
    
12.                 OSTimeDlyHMSM(0, 0, 1, 0);
    
13.         }
    
14. }
    
15. 
    
16. static void LED2TaskStart(void * p_arg)
    
17. {
    
18.         INT8U err;
    
19.         (void)p_arg;
    
20. 
    
21.         while (1)
    
22.         {                                          /* Task body, always written as an infinite loop.           */
    
23.                 BSP_LED_Toggle(1);
    
24.                 OSMutexPend(ResourceMutex, 0, &err);
    
25.                 UsartPrintf(USART1, "LED2TaskStart\n");
    
26.                 OSMutexPost(ResourceMutex);
    
27.                 OSTimeDlyHMSM(0, 0, 2, 0);
    
28.         }
    
29. }
    
30. 
    
31. static void LED3TaskStart(void * p_arg)
    
32. {
    
33.         INT8U err;
    
34.         (void)p_arg;
    
35. 
    
36.         while (1)
    
37.         {                                          /* Task body, always written as an infinite loop.           */
    
38.                 BSP_LED_Toggle(2);
    
39.                 OSMutexPend(ResourceMutex, 0, &err);
    
40.                 UsartPrintf(USART1, "LED3TaskStart\n");
    
41.                 OSMutexPost(ResourceMutex);
    
42.                 OSTimeDlyHMSM(0, 0, 3, 0);
    
43.         }
    
44. }
    
45. 
    
46. static void LED4TaskStart(void * p_arg)
    
47. {
    
48.         INT8U err;
    
49.         (void)p_arg;
    
50. 
    
51.         while (1)
    
52.         {                                          /* Task body, always written as an infinite loop.           */
    
53.                 BSP_LED_Toggle(3);
    
54.                 OSMutexPend(ResourceMutex, 0, &err);
    
55.                 UsartPrintf(USART1, "LED4TaskStart\n");
    
56.                 OSMutexPost(ResourceMutex);
    
57.                 OSTimeDlyHMSM(0, 0, 4, 0);
    
58.         }
    
59. }
    
60. 
    
61. static void LED5TaskStart(void * p_arg)
    
62. {
    
63.         INT8U err;
    
64.         (void)p_arg;
    
65. 
    
66.         while (1)
    
67.         {                                          /* Task body, always written as an infinite loop.           */
    
68.                 BSP_LED_Toggle(4);
    
69.                 OSMutexPend(ResourceMutex, 0, &err);
    
70.                 UsartPrintf(USART1, "LED5TaskStart\n");
    
71.                 OSMutexPost(ResourceMutex);
    
72.                 OSTimeDlyHMSM(0, 0, 5, 0);
    
73.         }
    
74. }
    
75. 
    
76. static void LED6TaskStart(void * p_arg)
    
77. {
    
78.         INT8U err;
    
79.         (void)p_arg;
    
80. 
    
81.         while (1)
    
82.         {                                          /* Task body, always written as an infinite loop.           */
    
83.                 BSP_LED_Toggle(5);
    
84.                 OSMutexPend(ResourceMutex, 0, &err);
    
85.                 UsartPrintf(USART1, "LED6TaskStart\n");
    
86.                 OSMutexPost(ResourceMutex);
    
87.                 OSTimeDlyHMSM(0, 0, 6, 0);
    
88.         }
    
89. }
    
90. 
    
91. static void LED7TaskStart(void * p_arg)
    
92. {
    
93.         INT8U err;
    
94.         (void)p_arg;
    
95. 
    
96.         while (1)
    
97.         {                                          /* Task body, always written as an infinite loop.           */
    
98.                 BSP_LED_Toggle(6);
    
99.                 OSMutexPend(ResourceMutex, 0, &err);
    
100.                 UsartPrintf(USART1, "LED7TaskStart\n");
     
101.                 OSMutexPost(ResourceMutex);
     
102.                 OSTimeDlyHMSM(0, 0, 7, 0);
     
103.         }
     
104. }
     
105. 
     
106. static void LED8TaskStart(void * p_arg)
     
107. {
     
108.         INT8U err;
     
109.         (void)p_arg;
     
110. 
     
111.         while (1)
     
112.         {                                          /* Task body, always written as an infinite loop.           */
     
113.                 BSP_LED_Toggle(8);
     
114.                 OSMutexPend(ResourceMutex, 0, &err);
     
115.                 UsartPrintf(USART1, "LED8TaskStart\n");
     
116.                 OSMutexPost(ResourceMutex);
     
117.                 OSTimeDlyHMSM(0, 0, 8, 0);
     
118.         }
     
119. }

复制代码

打印函数

1. void UsartPrintf(USART_TypeDef * USARTx, const char * fmt, ...)
   
2. {
   
3.         va_list args;
   
4. 
   
5.         char printf_buffer[256];
   
6.         char * ptr = printf_buffer;
   
7. 
   
8.         va_start(args, fmt);
   
9. 
   
10.         vsprintf(printf_buffer, fmt, args);
    
11. 
    
12.         va_end(args);
    
13. /**查询发送************************************************************************/
    
14.         while (*ptr != '\0')
    
15.         {
    
16.                 USART_SendData(USARTx, *(ptr++));
    
17.                 while (!(USARTx->SR & USART_FLAG_TXE));
    
18.         }
    
19. }
    

复制代码

我的疑问如下：
1、我加入了互斥型信号量，为何打印任务仍然被打断了；
2、字符为何丢失，有什么方法可以解决；
请各位高手指点迷津............

dmzy

附上软件代码，以供大家测试。

w282529350

任务堆栈给大点试试呢

没用过ucos，不知道UsartPrintf里的那个256的数组是不是在任务堆栈里申请

security

逻辑没有错，退一步说，就算被抢占，也不应该丢失字符。
出现此情况有两种可能：
一是， PC 端的串口软件有 bug。
二是，你的栈溢出了。

你的栈太小了。

1. #define  TASK_START_STK_SIZE                    216
   

复制代码

再看看 UsartPrintf 函数里面，看看那个 printf_buffer 的 size。
正确的做法是：将 printf_buffer  定义为 static 类型吧，减少对宿主 thread 栈的依赖。

dmzy

security 发表于 2017-2-23 09:51
逻辑没有错，退一步说，就算被抢占，也不应该丢失字符。
出现此情况有两种可能：
一是， PC 端的串口软件有 ...

您好，感谢您的回复。我将TASK_START_STK_SIZE设置为416，并且将printf_buffer  定义为 static 类型后，问题依旧存在。还恳请指点一下。

w282529350

w282529350 发表于 2017-2-23 09:13
任务堆栈给大点试试呢

没用过ucos，不知道UsartPrintf里的那个256的数组是不是在任务堆栈里申请 ...

还有一个错误，你创建的信号量返回值没有给变量

security

dmzy 发表于 2017-2-23 12:05
您好，感谢您的回复。我将TASK_START_STK_SIZE设置为416，并且将printf_buffer  定义为 static 类型后， ...

那你就要检查下互斥量是否有效，
你有初始化 ResourceMutex 吗？往这边看看。

hswkcg

我感觉不是栈的问题，我曾看到过这样的问题，串口打印输出乱码，原因是printf函数打印输出时，被别的任务抢占，而抢占任务也用到了printf，最后解决是将打印输出放在临界段里面，或者加任务锁。你可以这么试一下，看看管不管用，只是个猜测。

dmzy

w282529350 发表于 2017-2-23 13:54
还有一个错误，你创建的信号量返回值没有给变量

我检查了下，的确是的，改成如下代码，经测试过后就没有问题了。感谢指点，错误太低级了.........

1. ResourceMutex = OSMutexCreate(10, &err);

复制代码

dmzy

security 发表于 2017-2-23 13:59
那你就要检查下互斥量是否有效，
你有初始化 ResourceMutex 吗？往这边看看。 ...

问题是互斥变量忘记初始化了，改成如下就好了，测试没问题，谢谢指点。

1. ResourceMutex = OSMutexCreate(10, &err);

复制代码