NB_APP_Code/src/AppTaskMain.c

/*
 * @Author       : ChenJie
 * @Date         : 2021-10-14 09:27:15
 * @Version      : V3.0
 * @LastEditors  : ChenJie
 * @LastEditTime : 2021-11-04 14:14:26
 * @Description  : 主要负责：1.工作模式转换2.定时器定时3.定时保存运行数据4.异常状态重启
 * @FilePath     : \PLAT\project\ec616_0h00\apps\qx_app\src\AppTaskMain.c
 */
#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);
    while (true)
    {
        switch (gProcess_Main_Task)
        {
        case PROCESS_STATE_IDLE:
        {
            LoadAppData();
            LoadBcuData();
            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 (WorkTimerEnd == TRUE) //从工作转换为监听的条件,定时器结束
            {
                xTimerStop(work_timer, 0);
                xTimerStart(sleep_timer, 0);
                WorkTimerEnd = FALSE;
                NVIC_EnableIRQ(PadWakeup1_IRQn);
                PadInterrupt = 0x00;
                UartInterruptcount = 0;
                PadInterrupt_clrCounter = 0;
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_LISTEN);
                break;
            }
            if ((BMS_Fota_update_flag != FALSE) || (TCPWorkState != 0x00) || (BattWorkStateDelay != BATT_IDLE_SYM) || (battWorkState != BATT_IDLE_SYM) || (PadInterrupt != 0x00))
            {
                xTimerReset(work_timer, 0);
            }
            if ((TcpErrorcount >= 10 && getbit(PadInterrupt, 0) == 0x00 && battWorkState != BATT_CHARGE_SYM) || (NB_Fota_update_flag == TRUE))
            {
                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();
            }
            if (AppDataInfo.appDataModify)
            {
                SaveAppData();
            }
            break;
        }
        case PROCESS_STATE_LISTEN:
        {
            PROC_APP_STATE_SWITCH(LISTEN);
            if (UartInterruptcount > 1)
            {
                if (UartInterruptcount > 10)
                {
                    UartInterruptcount = 0;
                }
                else
                {
                    PadInterrupt_clrCounter = PadInterrupt_clrCounter + 1;
                }
            }
            else if ((getbit(PadInterrupt, 1) == 0x00 && PadInterrupt != 0x00))
            {
                PadInterrupt_clrCounter = PadInterrupt_clrCounter + 1;
            }
            else
            {
                osDelay(100);
            }
            if (AppDataInfo.appDataModify)
            {
                SaveAppData();
            }
            if (BcuDataInfo.appDataModify)
            {
                SaveBcuData();
            }
            if ((SleepTimerEnd) || (TCPWorkState == 1) || (PadInterrupt_clrCounter >= 1)) //从监听转换为工作的条件
            {
#ifdef USING_PRINTF1
                printf("WORK:%d,%d,%d\n", PadInterrupt_clrCounter, PadInterrupt, UartInterruptcount);
#endif
#ifdef DEBUGLOG
                Debug_printf("WORK:%d,%d,%d\n", PadInterrupt_clrCounter, PadInterrupt, UartInterruptcount);
#endif
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                xTimerStop(sleep_timer, 0);
                SleepTimerEnd = FALSE;
                PadInterrupt = 0x00;
                NVIC_DisableIRQ(PadWakeup1_IRQn);
                break;
            }
            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
}