Free-RTOS系统跑着跑着就死机了

yinhanxue

Free-RTOS系统跑着跑着就死机了，定时中断的状态灯还在正常闪烁，说明没有完全死机，像是系统down在哪里出不来了。同样的功能代码，裸机跑就没事。代码贴在这里，请帮忙分析：

//任务优先级
#define START_TASK_PRIO                1
//任务堆栈大小       
#define START_STK_SIZE                 128  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

//任务优先级（定时监测）
#define Task01_TASK_PRIO                9                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task01_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task01Task_Handler;
//任务函数
void Task01_task(void *pvParameters);

//任务优先级（网口-USART2数据）
#define Task02_TASK_PRIO                8                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task02_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task02Task_Handler;
//任务函数
void Task02_task(void *pvParameters);

//任务优先级（喂狗）
#define Task03_TASK_PRIO                7                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task03_STK_SIZE                 128  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task03Task_Handler;
//任务函数
void Task03_task(void *pvParameters);

//任务优先级（USB-USART1数据）
#define Task04_TASK_PRIO                6                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task04_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task04Task_Handler;
//任务函数
void Task04_task(void *pvParameters);

//任务优先级（RS232-USART4数据）
#define Task05_TASK_PRIO                5                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task05_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task05Task_Handler;
//任务函数
void Task05_task(void *pvParameters);

//任务优先级（RS485-USART5数据）
#define Task06_TASK_PRIO                4                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task06_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task06Task_Handler;
//任务函数
void Task06_task(void *pvParameters);

//任务优先级（4GCAT1-USART3数据）
#define Task07_TASK_PRIO                3                //FreeRTOS共有32个优先级等级（0~31,数值越大，优先级越高）——Chain2022-07-20       
//任务堆栈大小       
#define Task07_STK_SIZE                 512  //增大堆栈大小——Chain2022-08-05
//任务句柄
TaskHandle_t Task07Task_Handler;
//任务函数
void Task07_task(void *pvParameters);



int main(void)
{
        IWDG_Init(6,625);                                                                                       //独立看门狗 时间4s
        NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);                //设置系统中断优先级分组4         
        delay_init();                                                                                                                                            //延时函数初始化         
        init_board();                                                                                                                                                        //初始化GPIO及串口       
        TIM3_Int_Init(20-1,7200-1);                //初始化定时器3，定时器周期2ms
        TIM5_Int_Init(200-1,7200-1);                //初始化定时器5，定时器周期20ms

         Init_SendArray();
        //创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
}

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    //创建Task01任务（定时监测）
    xTaskCreate((TaskFunction_t )Task01_task,            
                (const char*    )"Task01_task",          
                (uint16_t       )Task01_STK_SIZE,
                (void*          )NULL,                               
                (UBaseType_t    )Task01_TASK_PRIO,       
                (TaskHandle_t*  )&Task01Task_Handler);   
    //创建Task02任务（网口-USART2数据）
    xTaskCreate((TaskFunction_t )Task02_task,     
                (const char*    )"Task02_task",   
                (uint16_t       )Task02_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task02_TASK_PRIO,
                (TaskHandle_t*  )&Task02Task_Handler);  
                //创建Task03任务（喂狗）
    xTaskCreate((TaskFunction_t )Task03_task,     
                (const char*    )"Task03_task",   
                (uint16_t       )Task03_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task03_TASK_PRIO,
                (TaskHandle_t*  )&Task03Task_Handler);   
                //创建Task04任务（USB-USART1数据）
    xTaskCreate((TaskFunction_t )Task04_task,     
                (const char*    )"Task04_task",   
                (uint16_t       )Task04_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task04_TASK_PRIO,
                (TaskHandle_t*  )&Task04Task_Handler);  
                //创建Task05任务（RS232-USART4数据）
    xTaskCreate((TaskFunction_t )Task05_task,     
                (const char*    )"Task05_task",   
                (uint16_t       )Task05_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task05_TASK_PRIO,
                (TaskHandle_t*  )&Task05Task_Handler);  
                //创建Task06任务（RS485-USART5数据）
    xTaskCreate((TaskFunction_t )Task06_task,     
                (const char*    )"Task06_task",   
                (uint16_t       )Task06_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task06_TASK_PRIO,
                (TaskHandle_t*  )&Task06Task_Handler);  
                //创建Task07任务（4GCAT1-USART3数据）
    xTaskCreate((TaskFunction_t )Task07_task,     
                (const char*    )"Task07_task",   
                (uint16_t       )Task07_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )Task07_TASK_PRIO,
                (TaskHandle_t*  )&Task07Task_Handler);                                                                 
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}

//Task01任务函数（定时监测）
void Task01_task(void *pvParameters)
{
       
                while(1)
    {
//                                taskENTER_CRITICAL();           //进入临界区
//        taskEXIT_CRITICAL();            //退出临界区
                       
//      ScanInputSignal();                //放到定时器3中断中去做检测       
                        ScanACSignal();
                        SendCRC16();
                        StudyLightSignal();
                       
                        if(clearUart1_flag == 1)
                        {
                                clearUart1_flag = 0;      //进来清标志
                                OvertimeReceiveUart1();                //串口接收超时了，清除接收缓存区及计数
                        }
                        if(clearUart2_flag == 1)
                        {
                                clearUart2_flag = 0;      //进来清标志
                                OvertimeReceiveUart2();                //串口接收超时了，清除接收缓存区及计数
                        }                       
                        if(clearUart4_flag == 1)
                        {
                                clearUart4_flag = 0;      //进来清标志
                                OvertimeReceiveUart4();                //串口接收超时了，清除接收缓存区及计数
                        }
                        if(clearUart5_flag == 1)
                        {
                                clearUart5_flag = 0;      //进来清标志
                                OvertimeReceiveUart5();                //串口接收超时了，清除接收缓存区及计数
                        }
                                               
                        vTaskDelay(5);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
    }
}   

//Task02任务函数（网口-USART2数据）
void Task02_task(void *pvParameters)
{
        int i;
    while(1)
    {
                       
                        if(TerminalSendCMD_Usart2 == 1)
                        {                       
                                        for(i=0;i<129;i++)
                                        {
                                                USART2_Send_Byte(SendUchar[i]);
                                        }               
                        }               
                        vTaskDelay(1000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

//Task03任务函数（喂狗）
void Task03_task(void *pvParameters)
{
    while(1)
    {
                        IWDG_Feed();                                      //定时喂狗                               
                        vTaskDelay(3000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

//Task04任务函数（USB-USART1数据）
void Task04_task(void *pvParameters)
{
        int i;
    while(1)
    {
                        if(TerminalSendCMD_Usart1 == 1)
                        {                       
                                        for(i=0;i<129;i++)
                                        {
                                                USART1_Send_Byte(SendUchar[i]);
                                        }               
                        }               
                        vTaskDelay(1000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

//Task05任务函数（RS232-USART4数据）
void Task05_task(void *pvParameters)
{
        int i;
    while(1)
    {
                        if(TerminalSendCMD_Usart4 == 1)
                        {                       
                                        for(i=0;i<129;i++)
                                        {
                                                USART4_Send_Byte(SendUchar[i]);
                                        }               
                        }               
                        vTaskDelay(1000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

//Task06任务函数（RS485-USART5数据）
void Task06_task(void *pvParameters)
{
        int i;
    while(1)
    {
                        if(TerminalSendCMD_Usart5 == 1)
                        {               
                                        C1_485=1;//使能RS485发送
                                        for(i=0;i<129;i++)
                                        {
                                                USART5_Send_Byte(SendUchar[i]);
                                        }       
                                        C1_485=0;//失能RS485发送
                        }               
                        vTaskDelay(1000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

//Task07任务函数（4GCAT1-USART3数据）
void Task07_task(void *pvParameters)
{
    while(1)
    {
                        vTaskDelay(3000);//使用vTaskDelay和vTaskDelayUntil延时函数，这样在延时过程中，本任务处于阻塞，而有时间执行其它任务。Chain2022-07-20
                }
}

huanan

帮顶           

xiaoxiaoren

帮顶