NB_APP_Code/src/AppTaskMain.c

/****************************************************************************
 *
 * Copy right:   Qx.CJ
 * File name:    MainTask.c
 * Description:  主要负责：1.工作模式转换2.定时器定时3.定时保存运行数据4.异常状态重启
 * History:      2021-07-05
 * Version:      V3.0
 ****************************************************************************/
#include "AppTaskMain.h"

static StaticTask_t           gProcess_Main_Task_t;
static UINT8                  gProcess_Main_TaskStack[PROC_MAIN_TASK_STACK_SIZE];
static osThreadId_t           MainTaskId = NULL;
static process_Main 		    gProcess_Main_Task;
#define PROC_MAIN_STATE_SWITCH(a)  (gProcess_Main_Task = a)
#define PROC_APP_STATE_SWITCH(a)  (gProcess_app = a)
static volatile BOOL WorkTimerEnd = FALSE;
static volatile BOOL SleepTimerEnd = FALSE;
void monitor_timer_callback(TimerHandle_t xTimer);
void work_timer_callback(TimerHandle_t xTimer);
void sleep_timer_callback(TimerHandle_t xTimer);

static void appBeforeHib(void *pdata, slpManLpState state);
static void appAfterHib(void *pdata, slpManLpState state);
static void appBeforeSlp1(void *pdata, slpManLpState state);
static void appAfterSlp1(void *pdata, slpManLpState state);
static void appBeforeSlp2(void *pdata, slpManLpState state);
static void appAfterSlp2(void *pdata, slpManLpState state);

UINT8 MainSlpHandler          = 0xff;//主线程睡眠句柄
static void MainTask(void* arg)
{
    UINT8 PadInterrupt_clrCounter = 0;
    TimerHandle_t monitor_timer = NULL;
    TimerHandle_t work_timer = NULL;
    TimerHandle_t sleep_timer = NULL;
    monitor_timer = xTimerCreate("monitor_timer", 100 / portTICK_RATE_MS, pdTRUE, NULL, monitor_timer_callback);
    work_timer    = xTimerCreate("work_timer", WORK_TIME*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, work_timer_callback);
    sleep_timer   = xTimerCreate("sleep_timer", SLEEP_TIME*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, sleep_timer_callback);
    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
    slpManSetPmuSleepMode(true,SLP_HIB_STATE,false);
    slpManApplyPlatVoteHandle("MainSlp",&MainSlpHandler);
    slpManPlatVoteDisableSleep(MainSlpHandler, SLP_SLP1_STATE);//禁用SLEEP1休眠
    UINT32 inParam = 0xAABBCCDD;
    slpManRegisterUsrdefinedBackupCb(appBeforeHib,&inParam,SLPMAN_HIBERNATE_STATE);
    slpManRegisterUsrdefinedRestoreCb(appAfterHib,NULL,SLPMAN_HIBERNATE_STATE);
    slpManRegisterUsrdefinedBackupCb(appBeforeSlp1,NULL,SLPMAN_SLEEP1_STATE);
    slpManRegisterUsrdefinedRestoreCb(appAfterSlp1,NULL,SLPMAN_SLEEP1_STATE);
    slpManRegisterUsrdefinedBackupCb(appBeforeSlp2,NULL,SLPMAN_SLEEP2_STATE);
    slpManRegisterUsrdefinedRestoreCb(appAfterSlp2,NULL,SLPMAN_SLEEP2_STATE);
    slpManWakeSrc_e Wakeup_source;
    Wakeup_source =  slpManGetWakeupSrc();//获取唤醒源
    //配置文件及运行数据加载
    if(Error_Mutex == NULL)
    {
        Error_Mutex = osMutexNew(NULL);
    }
    LoadAppConfig();
    
    if(Wakeup_source ==0)
    {
        AppDataInfo.appDataModify = TRUE;
        AppDataInfo.SysReStartCount = AppDataInfo.SysReStartCount + 1;
    }
    xTimerStart(monitor_timer, 0);
    UINT8 Temp = 0;
    while(true)
    {
        switch(gProcess_Main_Task)
        {
            case PROCESS_STATE_IDLE:
            {
                LoadAppData();
                PROC_APP_STATE_SWITCH(IDLE);
                xTimerStart(work_timer, 0);
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_WORK);
                break;
            }
            case PROCESS_STATE_WORK:
            {
                osDelay(100);
                PROC_APP_STATE_SWITCH(WORK);
                //状态转换延时
                if(TimeCounter%10==0)
                {
                    BattWorkDelayFunc(battWorkState);
                    #ifdef USING_PRINTF1
                        printf("[%d]-%d-%d,%d,%d \n",__LINE__,TimeCounter,socd_pct_battSoc,fastChargeTemp,normalChargeTemp);
                    #endif
                    if(TimeCounter%(10*60)==0)
                    {
                        BattLockFunc();
                    }
                    if(AppDataInfo.appDataModify)
                    {
                        SaveAppData();
                    }
                }
                if(WorkTimerEnd==TRUE)//从工作转换为监听的条件,定时器结束
                {
                    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_LISTEN);
                    xTimerStop(work_timer,0);
                    xTimerStart(sleep_timer, 0);
                    WorkTimerEnd = FALSE;
                    NVIC_EnableIRQ(PadWakeup1_IRQn);
                    PadInterrupt = 0x00;
                    break;
                }
                if((BMS_Fota_update_flag!=FALSE)||(TCPWorkState!=0x00)||(BattWorkStateDelay!=BATT_IDLE_SYM)||(PadInterrupt!=0x00))
                {
                    xTimerReset(work_timer,0);
                }
                if(TcpErrorcount>=10 &&PadInterrupt==0x00)
                {
                    AppDataInfo.appDataModify = true;
                    AppDataInfo.SysReStartCount = AppDataInfo.SysReStartCount +1;
                    if(AppDataInfo.SysReStartCount>=0xfffe)
                    {
                        AppDataInfo.SysReStartCount = 0;
                    }
                    if(AppDataInfo.appDataModify)
                    {
                        SaveAppData();
                    }
                    if(BcuDataInfo.appDataModify)
                    {
                        SaveBcuData();
                    }
                    appSetCFUN(0);
                    osDelay(1000);
                    EC_SystemReset();
                }
				if(BcuDataInfo.appDataModify)//BCU数据实时保存
                {
                    SaveBcuData();
                }
                break;
            }
            case PROCESS_STATE_LISTEN:
            {
                PROC_APP_STATE_SWITCH(LISTEN);
                if(getbit(PadInterrupt,1)==0x01)
                {
                    clrbit(PadInterrupt,1);
                    osDelay(10);
                    PadInterrupt_clrCounter = PadInterrupt_clrCounter + 1;
                    Temp = PadInterrupt;
                }
                else if(getbit(PadInterrupt,1)==0x00 && PadInterrupt!=0x00)
                {
                    PadInterrupt_clrCounter = PadInterrupt_clrCounter + 3;
                }
                else
                {
                    osDelay(100);
                }
                if(AppDataInfo.appDataModify)
                {
                    SaveAppData();
                }
                if(BcuDataInfo.appDataModify)
                {
                    SaveBcuData();
                }
                #ifdef USING_PRINTF1
                    printf("[%d]%x - %x - %x - %x\n",__LINE__,SleepTimerEnd,BMS_Fota_update_flag,TCPWorkState,PadInterrupt);
                #endif
                if((SleepTimerEnd)||(TCPWorkState==1)||(PadInterrupt_clrCounter>=3))//从监听转换为工作的条件
                {
                    #ifdef USING_PRINTF1
                        printf("[%d]-%x",__LINE__,battWorkState);
                        printf("[%d]%x - %x - %x - %x - %x-%d\n",__LINE__,WorkTimerEnd,BMS_Fota_update_flag,TCPWorkState,BattWorkStateDelay,Temp,PadInterrupt_clrCounter);
                    #endif
                    #ifdef DEBUGLOG
                        Debug_printf("WORK:%d,%d\n",PadInterrupt_clrCounter,PadInterrupt);
                    #endif
                    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                    xTimerStop(sleep_timer,0);
                    SleepTimerEnd = FALSE;
                    PadInterrupt = 0x00;
                    PadInterrupt_clrCounter = 0;
                    NVIC_DisableIRQ(PadWakeup1_IRQn);
                    break;
                }
                if(NB_Fota_update_flag)
                {
                    if(AppDataInfo.appDataModify)
                    {
                        SaveAppData();
                    }
                    if(BcuDataInfo.appDataModify)
                    {
                        SaveBcuData();
                    }
                    appSetCFUN(0);
                    osDelay(1000);
                    EC_SystemReset();
                }
                break;
            }
            default:
            {
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                break;
            }
        }
    }
}
void monitor_timer_callback(TimerHandle_t xTimer)
{
    TimeCounter++;
    if(TimeCounter>0xFFFFFFF0)
    {
        TimeCounter=0;
    }
}
void work_timer_callback(TimerHandle_t xTimer)
{
    #ifdef USING_PRINTF
        printf("work_timer_callback\n");
    #endif
    WorkTimerEnd = true;
}
void sleep_timer_callback(TimerHandle_t xTimer)
{
    #ifdef USING_PRINTF
        printf("sleep_timer_callback\n");
    #endif
    SleepTimerEnd = true;
}
void AppTaskMainInit(void *arg)
{
    #ifndef USING_PRINTF
    if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_LOG_CONTROL) != 0)
    {
        HAL_UART_RecvFlowControl(false);
    }
    #endif
    osThreadAttr_t task_attr;
    memset(&task_attr,0,sizeof(task_attr));
    memset(gProcess_Main_TaskStack, 0xA5, PROC_MAIN_TASK_STACK_SIZE);
    task_attr.name = "Main_Task";
    task_attr.stack_mem = gProcess_Main_TaskStack;
    task_attr.stack_size = PROC_MAIN_TASK_STACK_SIZE;
    task_attr.priority = osPriorityNormal;
    task_attr.cb_mem = &gProcess_Main_Task_t;
    task_attr.cb_size = sizeof(StaticTask_t);
    MainTaskId = osThreadNew(MainTask, NULL, &task_attr);

}
void AppTaskMainDeInit(void *arg)
{
    osThreadTerminate(MainTaskId);
    MainTaskId = NULL;
}
//睡眠进出函数区
static void appBeforeHib(void *pdata, slpManLpState state)
{
    uint32_t *p_param = (uint32_t *)pdata;

    #ifdef USING_PRINTF
        printf("Before Hibernate:%d \n",state);
    #endif
	slpManAONIOLatchEn(AonIOLatch_Enable);

}
static void appAfterHib(void *pdata, slpManLpState state)
{
    #ifdef USING_PRINTF
        printf("Try Hibernate Failed:%d \n",state);
    #endif
}
static void appBeforeSlp1(void *pdata, slpManLpState state)
{
    #ifdef USING_PRINTF
        printf("Before Sleep1:%d \n",state);
    #endif
	slpManAONIOLatchEn(AonIOLatch_Enable);
}
static void appAfterSlp1(void *pdata, slpManLpState state)
{
    #ifdef USING_PRINTF
        printf("After Sleep1:%d \n",state);
    #endif
}
static void appBeforeSlp2(void *pdata, slpManLpState state)
{
    #ifdef USING_PRINTF
        printf("before sleep2:%d \n",state);
    #endif
	slpManAONIOLatchEn(AonIOLatch_Enable);
}
static void appAfterSlp2(void *pdata, slpManLpState state)
{
    #ifdef USING_PRINTF
        printf("sleep2 failed:%d \n",state);
    #endif
}