NB_APP_Code/src/MainTask.c

/****************************************************************************
 *
 * Copy right:   Qx.
 * File name:    MainTask.c
 * Description:  APP任务调取和异常处理
 * History:      2021-03-05
 * PS：主线程里面关闭了网络为了测试睡眠和唤醒
 ****************************************************************************/
#include "bsp.h"
#include "bsp_custom.h"
#include "osasys.h"
#include "ostask.h"
#include "queue.h"
#include "ps_event_callback.h"
#include "cmisim.h"
#include "cmimm.h"
#include "cmips.h"
#include "sockets.h"
#include "psifevent.h"
#include "ps_lib_api.h"
#include "lwip/netdb.h"
//#include <cis_def.h>
#include "debug_log.h"
#include "slpman_ec616.h"
#include "plat_config.h"
#include "ec_tcpip_api.h"
#include "hal_module_adapter.h"
#include "timers.h"
#include "app.h"
#include "MainTask.h"
#include "TcpTask.h"
#include "Fota.h"
extern volatile bool Fota_update_flag;
CHAR BattSN[BATT_SN_LEN] = "GYTEST00000000003";//SN仍在测试
//全局变量
UINT32 Timer_count;//每100ms加1
volatile bool Sleep_flag = false;//睡眠标志位
extern UINT32 TcpService;
AppNVMDataType AppNVMData;

//主线程堆栈声明区
static StaticTask_t           gProcess_Main_Task_t;
static UINT8                  gProcess_Main_TaskStack[PROC_MAIN_TASK_STACK_SIZE];
static osThreadId_t           MainTaskId = NULL;
uint8_t MainSlpHandler          = 0xff;//主线程睡眠句柄
uint8_t deepslpTimerID          = DEEPSLP_TIMER_ID7;//睡眠定时器ID
volatile bool Work_timer_end = false;
static process_Main 		    gProcess_Main_Task;
#define PROC_MAIN_STATE_SWITCH(a)  (gProcess_Main_Task = a)

//函数声明区
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);
void montior_timer_callback(TimerHandle_t xTimer);
void work_timer_callback(TimerHandle_t xTimer);

static void setDefaultAppDataValue(void);
void appLoadConfig(void);
void appSaveConfig(void);
static void appGetNVMSavedData(void);
void appSaveNVMData(void);


AppConfigHeader    AppConfigHr;   //4 bytes


//主线程任务区
static void MainTask(void* arg)
{
    int32_t inParam = 0xAABBCCDD;
    slpManSetPmuSleepMode(true,SLP_HIB_STATE,false);
    slpManApplyPlatVoteHandle("MainSlp",&MainSlpHandler);
    slpManPlatVoteDisableSleep(MainSlpHandler, SLP_SLP1_STATE);
    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);
    slpManSlpState_t slpstate = slpManGetLastSlpState(); 

    TimerHandle_t montior_timer = NULL;
    TimerHandle_t work_timer = NULL;
    slpManWakeSrc_e Wakeup_source;

	appGetNVMSavedData();
    #ifdef USING_PRINTF
    UINT8 *pReadAppConfig;
    UINT32 readCount;
    //AppConfigHeader    AppConfigHr;
    OSAFILE file;
    file = OsaFopen(APP_CONFIG_FILE_NAME,"rb");
    OsaFseek(file, 0, SEEK_SET);
    pReadAppConfig  = OsaAllocZeroMemory(AppConfigHr.fileBodySize+4);    
    readCount = OsaFread(pReadAppConfig, AppConfigHr.fileBodySize+4, 1, file);
    printf("AppConfigHr.fileBodySize+4 = %d\n",AppConfigHr.fileBodySize+4);
    printf("readCount = %d\n",readCount);
    printf("the config data = \n");
    for (int i ;i<AppConfigHr.fileBodySize+4;i++)
        printf("%d ",*(pReadAppConfig+i));
    printf("\n");
    #endif
    if(AppNVMData.AppSwVersion!=APPSWVERSION)
    {
        AppNVMData.HwVersion = HWVERSION;
        AppNVMData.BLSwVersion = BLSWVERSION;
        AppNVMData.DrvSwVersion = DRVSWVERSION;
        AppNVMData.AppSwVersion = APPSWVERSION;
        AppNVMData.appDataModify=TRUE;
    }


	
    montior_timer = xTimerCreate("montior_timer", 100 / portTICK_RATE_MS, pdTRUE, NULL, montior_timer_callback);
    work_timer = xTimerCreate("work_timer", AppNVMData.wakeupWorkTime*60*1000 / portTICK_RATE_MS, pdTRUE, NULL, work_timer_callback);

	
	
    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
    while(true)
    {
        switch(gProcess_Main_Task)
        {
            case PROCESS_STATE_IDLE:
            {
                Timer_count = 0;
                xTimerStart(montior_timer, 0);
                xTimerStart(work_timer, 0);
                Sleep_flag = false;
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_WORK);
                break;
            }
            case PROCESS_STATE_WORK:
            {
                osDelay(1000);
                if(Work_timer_end)
                {
                    #ifdef USING_PRINTF
                    printf("Main Task,Work_timer_end!\n");
                    #endif
                    xTimerStop(montior_timer, 0);
                    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_SLEEP);
                }
                if(TcpService!=0x00)
                {
                    xTimerReset(work_timer,0);
                }
                break;
            }
            case PROCESS_STATE_SLEEP:
            {
                Sleep_flag = true;
                if(AppNVMData.appDataModify)
                {
                    appSaveNVMData();
                }
                osDelay(5000);
                if(Fota_update_flag)
                {
                    appSetCFUN(0);
                    osDelay(1000);
                    EC_SystemReset();
                }
                xTimerStop(work_timer, 0);
                slpManSlpState_t State;
                uint8_t cnt;
                if(slpManCheckVoteState(MainSlpHandler, &State, &cnt)==RET_TRUE)
                {
                    #ifdef USING_PRINTF
                        printf("[%d]We Can Check Vote Main State, state=%d, cnt=%d\r\n",__LINE__,State,cnt);
                    #endif						
                }
                slpManPlatVoteForceEnableSleep(MainSlpHandler, SLP_SLP1_STATE);
                if(slpManCheckVoteState(MainSlpHandler, &State, &cnt)==RET_TRUE)
                {
                    #ifdef USING_PRINTF
                        printf("[%d]We Can Check Vote Main State Again, state=%d, cnt=%d\r\n",__LINE__,State,cnt);
                    #endif					
                }
                #ifdef USING_PRINTF
                    printf("[%d]Waiting sleep\r\n",__LINE__);
                #endif
                FaultDisplay(LED_TURN_ON);
                slpManSlpState_t slpstate = slpManPlatGetSlpState();
                #ifdef USING_PRINTF
                    printf("which slpstate can go now :%d \n",slpstate);
                #endif
                slpManDeepSlpTimerStart(deepslpTimerID, AppNVMData.sleepTime*1000*60);
                while(1)
                {
                    osDelay(20*60*1000/portTICK_PERIOD_MS);
                    break;
                }
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                break;
            }
            default:
            {
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                break;
            }
        }
    }
}
void MainTaskInit(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 MainTaskDeInit(void *arg)
{
    osThreadTerminate(MainTaskId);
    MainTaskId = NULL;
}
//定时器回调函数区
void montior_timer_callback(TimerHandle_t xTimer)
{
    Timer_count++;
    if(Timer_count>100000*100)
    {
        Timer_count=0;
    }
}
void work_timer_callback(TimerHandle_t xTimer)
{
    Work_timer_end = true;
    #ifdef USING_PRINTF
        printf("Hello work Timer!\n");
    #endif
}

//睡眠进出函数区
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
}


static void appGetNVMSavedData(void)
{
    appLoadConfig();

/*	IH_appChargEndWorkTime = AppNVMData.chargEndWorkTime;
	IH_appWakeupWorkTime=AppNVMData.wakeupWorkTime;
	IH_appSleepTime = AppNVMData.sleepTime;
	IH_isBattLocked = AppNVMData.isBattLocked;
	MEMCPY(&BattSN, AppNVMData.battSN, BATT_SN_LEN);	
*/
}

void appSaveNVMData(void)
{
/*
	AppNVMData.chargEndWorkTime = OH_appChargEndWorkTime;
    AppNVMData.wakeupWorkTime = OH_appWakeupWorkTime;
    AppNVMData.sleepTime = OH_appSleepTime ;
    AppNVMData.isBattLocked = OH_isBattLocked;    
	MEMCPY( AppNVMData.battSN, &BattSN, BATT_SN_LEN);
	*/
	appSaveConfig();
}

static void appSaveConfig(void)
{
    OSAFILE fp = PNULL;
    UINT32  writeCount = 0;
    AppConfigHeader    AppConfigHr;   //4 bytes

    /*
     * open the NVM file
    */
    fp = OsaFopen(APP_CONFIG_FILE_NAME, "wb");   //read & write
    if(OsaFseek(fp, 0, SEEK_SET) != 0)
	{
        #ifdef USING_PRINTF
				printf("Seek file failed [%d] \r\n",__LINE__);
	    #endif
	    OsaFclose(fp);
        return;
	}
    if (fp == PNULL)
    {
	   #ifdef USING_PRINTF
			printf(" NVM, can't open/create NVM: 'qxappconfig.nvm', save NVM failed\n");
		#endif
        return;
    }

    /*
     * write the header
    */
    AppConfigHr.fileBodySize   = sizeof(AppNVMData);
    AppConfigHr.version	= 	APP_CONFIG_FILE_LATEST_VERSION;    
    AppConfigHr.checkSum       = OsaCalcCrcValue((UINT8 *)&AppNVMData, sizeof(AppNVMData));

    writeCount = OsaFwrite(&AppConfigHr, sizeof(AppConfigHeader), 1, fp);
    if (writeCount != 1)
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppConfigSave_2, P_ERROR, 0,
        //           " NVM: 'qxappconfig.nvm', write the file header failed");
	#ifdef USING_PRINTF
				printf(" NVM: 'qxappconfig.nvm', write the file header failed\n");
	#endif

        OsaFclose(fp);
        return;
    }

    /*
     * write the file body
    */
    AppNVMData.appDataModify = FALSE;
    writeCount = OsaFwrite(&AppNVMData, sizeof(AppNVMData), 1, fp);
    if (writeCount != 1)
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppConfigSave_3, P_ERROR, 0,
        //           " NVM: 'qxappconfig.nvm', write the file body failed");
        #ifdef USING_PRINTF
					printf(" NVM: 'qxappconfig.nvm', write the file body failed\n");
		#endif
    }
    OsaFclose(fp);
    return;
}


void appLoadConfig(void)
{
    OSAFILE fp = PNULL;
    UINT32  readCount = 0;
    //AppConfigHeader    AppConfigHr;   //4 bytes
    UINT8   crcCheck = 0;
    BOOL    needAdjust = FALSE;
    void    *pReadAppConfig = (void *)&AppNVMData;
    /*
     * open the NVM file
    */
    fp = OsaFopen(APP_CONFIG_FILE_NAME, "rb");   //read only
    
    if (fp == PNULL)
    {
	#ifdef USING_PRINTF
		printf(" NVM, can't open NVM: 'qxappConfig.nvm', use the defult value\n");
	#endif
        setDefaultAppDataValue();
        appSaveConfig();
        return;
    }
    /*
     * read the file header
    */
    readCount = OsaFread(&AppConfigHr, sizeof(AppConfigHeader), 1, fp);
    
    if (readCount != 1)
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_header_e_1, P_ERROR, 1,
        //            "NVM: 'qxappconfig.nvm', can't read header, return: %d, use the defult value", readCount);

	#ifdef USING_PRINTF
				printf("NVM: 'qxappconfig.nvm', can't read header, return: %d, use the defult value \n");
	#endif

        OsaFclose(fp);
        setDefaultAppDataValue();
        appSaveConfig();

        return;
    }

    if (AppConfigHr.version != APP_CONFIG_FILE_LATEST_VERSION)
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_ver_w_1, P_ERROR, 2,
        //            "NVM: 'qxappconfig.nvm', version: %d not latest: %d, try to adapt",
        //            AppConfigHr.version, MID_WARE_NVM_FILE_LATEST_VERSION);

		#ifdef USING_PRINTF
				printf("NVM: 'qxappconfig.nvm', version: %d not latest: %d, try to adapt\n",
						AppConfigHr.version, MID_WARE_NVM_FILE_LATEST_VERSION);
		#endif
        if (AppConfigHr.fileBodySize > 1024)   //in fact this NVM size should limited in 1KB
        {
            //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_ver_e_1, P_ERROR, 2,
            //            "NVM: 'qxappconfig.nvm', version: %d, NVM body size: %d > 1024, not right, use the default value",
             //           AppConfigHr.version, AppConfigHr.fileBodySize);
			#ifdef USING_PRINTF
				printf("NVM: 'qxappconfig.nvm', version: %d, NVM body size: %d > 1024, not right, use the default value",
                       AppConfigHr.version, AppConfigHr.fileBodySize);
			#endif
            OsaFclose(fp);
            setDefaultAppDataValue();
            appSaveConfig();

            return;
        }

        /*
         * As need to do adaption, can't read the old NVM into "mwNvmConfig", here we allocate a new buffer to store it
        */
        pReadAppConfig  = OsaAllocZeroMemory(AppConfigHr.fileBodySize);

        if (pReadAppConfig == PNULL)
        {
            //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_buff_e_1, P_ERROR, 2,
            //            "NVM: 'qxappconfig.nvm', version: %d, can not allo memsize: %d, use the default value",
            //            AppConfigHr.version, AppConfigHr.fileBodySize);
			#ifdef USING_PRINTF
				printf("NVM: 'qxappconfig.nvm', version: %d, can not allo memsize: %d, use the default value",
                        AppConfigHr.version, AppConfigHr.fileBodySize);
			#endif
            OsaFclose(fp);
            setDefaultAppDataValue();
            appSaveConfig();

            return;
        }		
        needAdjust = TRUE;
    }
    else if (AppConfigHr.fileBodySize != sizeof(AppNVMData))  //file version is the same, but NVM file size not right
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_2, P_ERROR, 2,
        //            "MW NVM: 'midwareconfig.nvm', file body size not right: (%u/%u), use the defult value",
        //            AppConfigHr.fileBodySize, sizeof(AppNVMData));
		#ifdef USING_PRINTF
				printf("MW NVM: 'midwareconfig.nvm', file body size not right: (%u/%u), use the defult value",
        		            AppConfigHr.fileBodySize, sizeof(AppNVMData));
		#endif
		
        OsaFclose(fp);

        setDefaultAppDataValue();
        appSaveConfig();

        return;
    }

    /*
     * read the file body
    */
    
    readCount = OsaFread(pReadAppConfig, AppConfigHr.fileBodySize, 1, fp);
    crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, AppConfigHr.fileBodySize);
	
    if (readCount != 1 ||
        crcCheck != AppConfigHr.checkSum)
    {
        //ECOMM_TRACE(UNILOG_PLA_MIDWARE, AppLoadNvmConfig_3, P_ERROR, 2,
        //            "NVM: 'qxappconfig.nvm', can't read body, or body not right, (%u/%u), use the defult value",
        //            crcCheck, AppConfigHr.checkSum);
		#ifdef USING_PRINTF
			printf(" NVM: 'qxappconfig.nvm', can't read body, or body not right, (%u/%u), use the defult value\n ",
						crcCheck, AppConfigHr.checkSum);
		#endif
        OsaFclose(fp);
        setDefaultAppDataValue();
        appSaveConfig();

        if (needAdjust)
        {
            OsaFreeMemory(&pReadAppConfig);
        }
        return;
    }

#if 1
    if (needAdjust)
    {
        OsaFclose(fp);
        setDefaultAppDataValue();
        appSaveConfig();

        /* free memory */
        OsaFreeMemory(&pReadAppConfig);
    }
#endif

#if 0 
	int i=0;

	printf("AppConfigHeader:\n");
	printf("%d,%d,%d\n",AppConfigHr.fileBodySize,AppConfigHr.version,AppConfigHr.checkSum);
	printf("AppConfigFileBody:\n");
	printf("%d,%d,%d\n",AppNVMData.chargEndWorkTime,AppNVMData.wakeupWorkTime,AppNVMData.sleepTime);
	printf("\n");
#endif
    return;
}


//if the AppNVMData.version(read form nvm) != APP_CONFIG_FILE_LATEST_VERSION, it will setDefaultAppDataValue()
//so if you want to modify the default value, please modify the APP_CONFIG_FILE_LATEST_VERSION (in MainTask.h) meanwhile, so that will be store to the nvm file
static void setDefaultAppDataValue(void)
{
    UINT8  i = 0;
    memset(&AppNVMData, 0x00, sizeof(AppNVMDataType));
	for(i=0;i<BATT_SN_LEN;i++)
	{
		AppNVMData.battSN[i] = BattSN[i];  //the defult sn is "0000..0000"(17 bytes ASCII)
	}
	AppNVMData.isBattLocked = false;
	AppNVMData.chargEndWorkTime = 30;  //30 min
	AppNVMData.wakeupWorkTime = 15;	//2min
	AppNVMData.sleepTime = 5;			//5min
    AppNVMData.HwVersion = HWVERSION;
    AppNVMData.BLSwVersion = BLSWVERSION;
    AppNVMData.DrvSwVersion = DRVSWVERSION;
    AppNVMData.AppSwVersion = APPSWVERSION;
    return;
}