如题，程序中有一个CAN总线发送任务（任务名为vCanTxTask），优先级最高（设置的10），通过读取发送队列中的数据，将数据发送至CAN总线。读取方式为调用xQueueReceive，设置了阻塞时间（1000ms）；其他任务调用vCanTx()函数将数据发送至CAN发送队列，vCanTx函数中通过__get_CONTROL()返回值判断该函数是否处于中断模式，从而调用xQueueSend或xQueueSendFromISR函数；


测试时程序只是周期性发送1个TPDO和CANOpen心跳，周期均是3s。
测试时发现刚开始都很正常的运行，但是过了几十分钟（有时几个小时）就不再发送CAN帧了，调试后发现以下信息：
1、查询CAN控制器的各个寄存器，发现CAN控制器并没有任何错误产生。
2、在vCanTxTask中多处设置断点，发现程序不再运行该任务，但是其他任务都很正常的运行。
3、在另一个任务中查询vCanTxTask任务状态，其状态始终处于eReady就绪状态，且堆栈也没有溢出。
4、其他任务发送数据至CAN发送队列的结果均是入队失败，推测应该队列已经满了，vCanTxTask没有运行所以一直没有数据出队。
综上现象，现在很疑惑为什么任务明明就绪了却一直没有被调度运行？且该任务优先级是最高的，希望各位坛友能帮助分析下，不胜感激！
下面分别为vCanTxTask任务函数，vCanTx函数的原码，以及另一个任务vBoardLedTask（用于查询vCanTxTask状态）

1. /*****************************************************************
   
2. * 函数名称 ： vCanTxTask
   
3. * 功    能 ： 将CAN发送队列中的数据发送至CAN总线
   
4. * 参    数 ： 无
   
5. * 返 回 值 ： 无
   
6. ******************************************************************/
   
7. void vCanTxTask(void *pvPara)
   
8. {
   
9.         static CanTxFrameTypeDef can_tx;
   
10.         static uint32_t uxHighWaterMarkCan;
    
11.     static uint32_t txerr;
    
12.     BaseType_t r;
    
13.     uint8_t txcnt=0;
    
14.     eTaskState TaskState;
    
15.    
    
16.         while (1)
    
17.         {
    
18. 
    
19.         DEBUG_PRINTF(" CAN Transmit Task Start! \r\n");
    
20.         r = xQueueReceive(CanTxQueue, &can_tx, pdMS_TO_TICKS(1000));
    
21.         DEBUG_PRINTF(" CAN Transmit Task Wait End! \r\n");
    
22.         if ( r )
    
23.         {
    
24.             DEBUG_PRINTF(" CAN Transmit Bsp Strat!  \r\n");
    
25.             txcnt = vBspCanTx1(&can_tx);   
    
26.             if(txcnt>=64)
    
27.             {
    
28.                 xQueueReset(CanTxQueue);
    
29.                 DEBUG_PRINTF(" CAN Retransmit Cnt>64 \r\n\r\n");
    
30.             }
    
31.             else
    
32.             {
    
33.                 DEBUG_PRINTF(" CAN Transmit OK! \r\n\r\n");
    
34.             }
    
35.         }
    
36.         //vCanErrorProcess();
    
37.         TaskState=eTaskGetState(CanTxTaskHandle);
    
38.         switch((int)TaskState)
    
39.         {
    
40.             case eRunning:
    
41.                 DEBUG_PRINTF(" CANTxTask State ==  eRunning \r\n");
    
42.                 break;
    
43.             case eReady:
    
44.                 DEBUG_PRINTF(" CANTxTask State ==  eReady \r\n");
    
45.                 break;
    
46.             case eSuspended:
    
47.                 DEBUG_PRINTF(" CANTxTask State ==  eSuspended \r\n");
    
48.                 break;
    
49.             case eDeleted:
    
50.                 DEBUG_PRINTF(" CANTxTask State ==  eDeleted \r\n");
    
51.                 break;
    
52.             case eInvalid:
    
53.                 DEBUG_PRINTF(" CANTxTask State ==  eInvalid \r\n");
    
54.                 break;
    
55.         }
    
56.                 uxHighWaterMarkCan = uxTaskGetStackHighWaterMark(CanTxTaskHandle);
    
57.         
    
58.         //vTaskDelay(pdMS_TO_TICKS(CAN_TASK_PERIOD_MS));
    
59. 
    
60.                 (void)uxHighWaterMarkCan;
    
61.         }
    
62. }

复制代码

1. /*****************************************************************
   
2. * 函数名称 ： vCanTx
   
3. * 功    能 ： 将发送帧写入CAN发送队列
   
4. * 参    数 ： ptx-CAN发送帧
   
5. * 返 回 值 ： 无
   
6. ******************************************************************/
   
7. extern struct sExtRunType sExtRun;
   
8. void vCanTx(CanTxFrameTypeDef *ptx)
   
9. {
   
10.     BaseType_t r;
    
11.     BaseType_t xHigherPriorityTaskWoken;
    
12.     CanRxFrameTypeDef rx;
    
13. 
    
14.     if(sExtRun.eExtMode!=eNoConnect)
    
15.     {
    
16.         rx.RXHeader.IDE = ptx->TxHeader.IDE;
    
17.         rx.RXHeader.ExtId = ptx->TxHeader.ExtId;
    
18.         rx.RXHeader.StdId = ptx->TxHeader.StdId;
    
19.         rx.RXHeader.DLC = ptx->TxHeader.DLC;
    
20.         rx.RXHeader.RTR =  ptx->TxHeader.RTR;
    
21.         for(uint8_t i=0;i<ptx->TxHeader.DLC;i++)
    
22.             rx.Data[i] = ptx->Data[i];
    
23.         
    
24.     }
    
25. 
    
26.     /* 判断是否在执行中断 */
    
27.     if(0 == __get_CONTROL())
    
28.     {
    
29.         r = xQueueSendFromISR(CanTxQueue, ptx, &xHigherPriorityTaskWoken);
    
30.         if(sExtRun.eExtMode!=eNoConnect && sExtRun.ExtCanRxQueue!=NULL)
    
31.             r = xQueueSendFromISR(sExtRun.ExtCanRxQueue, &rx, &xHigherPriorityTaskWoken);
    
32.         portEND_SWITCHING_ISR(xHigherPriorityTaskWoken);
    
33.     }
    
34.     else
    
35.     {
    
36.         r = xQueueSend(CanTxQueue, ptx, pdMS_TO_TICKS(4));//等待时间不能太长，以免影响20ms周期的读取
    
37.         if(sExtRun.eExtMode!=eNoConnect && sExtRun.ExtCanRxQueue!=NULL)
    
38.             r = xQueueSend(sExtRun.ExtCanRxQueue, &rx, pdMS_TO_TICKS(4));
    
39.     }
    
40. 
    
41.         if ( r )
    
42.         {
    
43.         }
    
44.     else
    
45.     {
    
46.         DEBUG_PRINTF("Send CanTxQueue Failed ! return=%d\r\n",r);
    
47.     }
    
48. }
    

复制代码

1. void vBoardLedTask(void*para)
   
2. {
   
3.    
   
4.     static eTaskState CanTaskState;
   
5.    
   
6.     while(1)
   
7.     {
   
8.         CanTaskState=eTaskGetState(CanTxTaskHandle);
   
9.         switch((int)CanTaskState)
   
10.         {
    
11.             case eRunning:
    
12.                 DEBUG_PRINTF(" CANTxTask State ==  eRunning \r\n");
    
13.                 break;
    
14.             case eReady:
    
15.                 DEBUG_PRINTF(" CANTxTask State ==  eReady \r\n");
    
16.                 break;
    
17.             case eSuspended:
    
18.                 DEBUG_PRINTF(" CANTxTask State ==  eSuspended \r\n");
    
19.                 break;
    
20.             case eDeleted:
    
21.                 DEBUG_PRINTF(" CANTxTask State ==  eDeleted \r\n");
    
22.                 break;
    
23.             case eInvalid:
    
24.                 DEBUG_PRINTF(" CANTxTask State ==  eInvalid \r\n");
    
25.                 break;
    
26.             case eBlocked:
    
27.                 DEBUG_PRINTF(" CANTxTask State ==  eBlocked \r\n");
    
28.                 break;
    
29.         }
    
30.         
    
31.         if(hcan1.ErrorCode == HAL_CAN_ERROR_NONE)
    
32.         {
    
33.             io_pin_write(PIN_LED_TST,0);
    
34.             vTaskDelay(pdMS_TO_TICKS(10));
    
35.             io_pin_write(PIN_LED_TST,1);
    
36.         }
    
37.         else
    
38.         {
    
39.             io_pin_write(PIN_LED_TST,0);
    
40.             vTaskDelay(pdMS_TO_TICKS(300));
    
41.             io_pin_write(PIN_LED_TST,1);
    
42.             HAL_CAN_ResetError(&hcan1);            
    
43.         }
    
44.         
    
45.         
    
46.         
    
47.         vTaskDelay( pdMS_TO_TICKS(LED_TASK_PERIOD_MS) );
    
48.     }
    
49.    
    
50. }

复制代码

如果最高优先级任务是Ready状态，应该会立即执行。按描述，可能任务优先级被改了，导致一直不能执行.调试一下看

遇到同样的情况，请问解决了吗？

bfl111 发表于 2020-6-24 15:26
遇到同样的情况，请问解决了吗？

解决了，是有个定时器中断优先级高于FreeRTOS管理的优先级，而在这个定时器中断中调用了FreeRTOS的API函数。

题主，我也遇到了这个问题，这么说的话，是不是要把定时器的优先级降低？