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"
#include "UartTask.h"
#include "sensor.h"
#include "Signal.h"
extern UINT8 	UDSSwitch;
extern volatile bool NB_Fota_update_flag;
extern volatile bool BMS_Fota_update_flag;
CHAR defaultBattSN[BATT_SN_LEN] = "RLTEST00000000001";//未进行下线检测的默认SN
//全局变量
UINT32 Timer_count;//每100ms加1
volatile BOOL Sleep_flag = false;//睡眠标志位
extern UINT32 TcpService;
extern UINT8 BattChrgEndFlag;
extern UINT8 Aoi1Event;
extern UINT8 Aoi2Event;
AppConfigHeader   AppConfigHr;   //4 bytes
AppNVMDataType AppNVMData;
AppDataHeader AppDataHr;
AppDataBody AppDataInfo;


//主线程堆栈声明区
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
static volatile bool Work_timer_end = false;
static process_Main 		    gProcess_Main_Task;
#define PROC_MAIN_STATE_SWITCH(a)  (gProcess_Main_Task = a)

extern void GsensorInit(void);
extern void GsensorI2CHandler(ARM_I2C_SignalEvent_t cb_event);
extern void GsensorI2CCallback(UINT32 event);
//函数声明区
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);
void BattWorkStateDelayFunc(UINT8 battWorkCurrentState);
INT8 rentalEndDetectFunc(void);
void BattLockFunc(void);
static void setDefaultAppDataValue(void);
void appLoadConfig(void);
void appSaveConfig(void);
static void appGetNVMSavedData(void);
void appSaveNVMData(void);
void RecoveyTheData(void);
static void setDefaultAppDataInfo(void);
static void LoadAppDataInfo(void);
static void appSaveDataInfo(void);
//主线程任务区
static void MainTask(void* arg)
{
    if(Error_Mutex == NULL)
    {
        Error_Mutex = osMutexNew(NULL);
    }
    GsensorI2CHandler(GsensorI2CCallback);
    GsensorInit();
    

    int32_t inParam = 0xAABBCCDD;
    UINT32  param;
    UINT32 adcValue;
    UINT8  Adcindex=0;
    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;
    Wakeup_source =  slpManGetWakeupSrc();//获取唤醒源
    #ifdef USING_PRINTF1
        printf("Wakeup_source:%d \n",Wakeup_source);
    #endif
    #ifdef DEBUGLOG
    Debug_printf("Wkp-%d \n",Wakeup_source);
    #endif
	appGetNVMSavedData();
    LoadAppDataInfo();
    #ifdef USING_PRINTF1
    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
    #ifdef USING_PRINTF1
    UINT8 *pReadAppData;
    UINT32 readCount;
    //AppConfigHeader    AppConfigHr;
    OSAFILE file;
    file = OsaFopen(APP_DATAINFO_FILE_NAME,"rb");
    OsaFseek(file, 0, SEEK_SET);
    pReadAppData  = OsaAllocZeroMemory(AppDataHr.fileBodySize+3);    
    readCount = OsaFread(pReadAppData, AppDataHr.fileBodySize+3, 1, file);
    printf("AppDataHr.fileBodySize+3 = %d\n",AppDataHr.fileBodySize+3);
    printf("readCount = %d\n",readCount);
    printf("the data = ");
    for (int i=0 ;i<AppDataHr.fileBodySize+3;i++)
        printf("%x(%d) ",*(pReadAppData+i),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);

	/***calibrate the ADC Collect***/
	AdcSendReq(ADC_REQ_BITMAP_VBAT_CALI,&param,1,ADC_GET_RESULT_TIMOUT);						
	AdcSendReq(ADC_REQ_BITMAP_INRES_CALI,&param,1,ADC_GET_RESULT_TIMOUT);
	
	NetSocDisplay(LED_SOC_0,LED_TURN_OFF);
	NetSocDisplay(LED_SOC_1,LED_TURN_OFF);
	NetSocDisplay(LED_SOC_2,LED_TURN_OFF);
	NetSocDisplay(LED_SOC_3,LED_TURN_OFF);
	FaultDisplay(LED_TURN_OFF);
    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(100);
                if(Error_count>=5 && CanMsgFlag==0x00 && UDSSwitch==0 &&BMS_Fota_update_flag==FALSE)
                {
                    AppDataInfo.appDataModify = true;
                    AppDataInfo.SysReStart = AppDataInfo.SysReStart +1;
                    if(AppDataInfo.SysReStart>=0xfffe)
                    {
                        AppDataInfo.SysReStart = 0;
                    }
                    if(AppNVMData.appDataModify)
                    {
                        appSaveNVMData();
                    }
                    if(AppDataInfo.appDataModify)
                    {
                        appSaveDataInfo();
                    }
                    #ifdef DEBUGLOG
                        Debug_printf("404\n");
                    #endif
                    appSetCFUN(0);
                    osDelay(1000);
                    EC_SystemReset();
                }
                if(Timer_count%10==0)
                {
                    BattWorkStateDelayFunc(battWorkState);
                    if( BattWorkStateDelay ==0x02)
                    {
                        BattChrgEndFlag=TRUE;
                    }
                    if(AppDataInfo.ErrorMsg != 0)
                    {
                        if(osOK==osMutexAcquire(Error_Mutex, 100))
                        {
                            UINT8 ErrorNumTemp = AppDataInfo.ErrorMsg;
                            PutErrorNum((UINT16 *)ErrorNum,ErrorNumLen,ErrorNumTemp);
                        }
                        osMutexRelease(Error_Mutex);
                    }
                    if(Timer_count%(10*60)==0)
                    {
                        BattLockFunc();
                    }
                }
                if(Work_timer_end)
                {
                    xTimerStop(montior_timer, 0);
                    PROC_MAIN_STATE_SWITCH(PROCESS_STATE_SLEEP);
                    break;
                }
                else
                {   
                    switch (Adcindex)
                    {
                        case FAST_CHARGE_TEMP:
                         NB_ADC_Get(&adcValue,FAST_CHARGE_TEMP);
                         fastChargeTemp = LookUpRTtable(adcValue);
                        break;
                        case NORMAL_CHARGE_TEMP:
                            NB_ADC_Get(&adcValue,NORMAL_CHARGE_TEMP);
                            normalChargeTemp = LookUpRTtable(adcValue);
                        break;
                        case OTHER_TEMP_1:
                            NB_ADC_Get(&adcValue,OTHER_TEMP_1);
                            heatTemp1 = LookUpRTtable(adcValue);                      
                        break;
                        case OTHER_TEMP_2:
                            NB_ADC_Get(&adcValue,OTHER_TEMP_2);
                            heatTemp2 = LookUpRTtable(adcValue);                       
                        break;
                        case  VBAT:
                            NB_ADC_Get(&adcValue,VBAT);                        
                            Adcindex = 0;
                        break;
                        default:
                            Adcindex=0;
                            break;
                    }
                    Adcindex++;   
                }
                #ifdef USING_PRINTF1
                    printf("TcpService:%d,UDSSwitch:%d,BMS_Fota_update_flag:%d,battWorkState:%d,Can_Msg_Enble:%d\r\n",TcpService,UDSSwitch,BMS_Fota_update_flag,battWorkState,Can_Msg_Enble);
                #endif	
                if(TcpService!=0x00||UDSSwitch==1||BMS_Fota_update_flag||battWorkState!=0||CanMsgFlag==0x01||chargerConnectState==0x01)
                {
                    xTimerReset(work_timer,0);
                }
                if(BattChrgEndFlag)
                {
                    xTimerChangePeriod(work_timer,AppNVMData.chargEndWorkTime*60*1000 / portTICK_RATE_MS,0);
                    xTimerReset(work_timer,0);
                }
                break;
            }
            case PROCESS_STATE_SLEEP:
            {
                Sleep_flag = true;
                if((minCellVol<2800 && minCellVol>0)||(maxCellVol<3000 && maxCellVol>0))
                {
                    AppNVMData.appDataModify = TRUE;
                    AppNVMData.sleepTime = 60;
                }
                else if((minCellVol>4000&&minCellVol<6000) && AppNVMData.sleepTime==60)
                {
                    AppNVMData.appDataModify = TRUE;
                    AppNVMData.sleepTime = 10;
                }
                if(AppNVMData.appDataModify)
                {
                    appSaveNVMData();
                }
                if(AppDataInfo.appDataModify)
                {
                    appSaveDataInfo();
                }
                if(NB_Fota_update_flag)
                {
                    appSetCFUN(0);
                    osDelay(1000);
                    EC_SystemReset();
                }
                osDelay(1*1000);
                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
                #ifdef DEBUGLOG
                    Debug_printf("slp-%d,%d\n",slpstate,AppDataInfo.SysReStart);
                #endif
                slpManDeepSlpTimerStart(deepslpTimerID, AppNVMData.sleepTime*1000*60);
                UINT8 sleeptime_count=0;
                RxInterprut = 0;
                Aoi1Event=0;
                Aoi2Event=0;
                while(1)
                {
                    if(!slpManDeepSlpTimerIsRunning(deepslpTimerID))
					    slpManDeepSlpTimerDel(deepslpTimerID);
				    slpManDeepSlpTimerStart(deepslpTimerID, AppNVMData.sleepTime*1000*60);
                    osDelay(1*60*1000/portTICK_PERIOD_MS);
                    sleeptime_count++;
                    #ifdef USING_PRINTF
                        printf("sleeptime_count :%d \n",sleeptime_count);
                    #endif
                    if(sleeptime_count>10||RxInterprut==1||Aoi1Event==1||Aoi2Event==1)
                    {
                        #ifdef DEBUGLOG
                            Debug_printf("405\n");
                        #endif
                        appSetCFUN(0);
                        osDelay(1000);
                        EC_SystemReset();
                    }
                }
                break;
            }
            default:
            {
                PROC_MAIN_STATE_SWITCH(PROCESS_STATE_IDLE);
                #ifdef USING_PRINTF
                    printf("default!\n");
                #endif
                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)
{
    #ifdef USING_PRINTF1
        if (Timer_count%50==0)
        {
            printf("Main Task,Batt_Cell_Num:%d,%d!\n",BATT_CELL_VOL_NUM,Timer_count);
        }
    #endif
    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();
}

void appSaveNVMData(void)
{
	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;
    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);
    UINT8 readtimes=0;
    while (readCount != 1 && readtimes<=5 )
    {
        //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
        readtimes++;
        readCount = OsaFread(&AppConfigHr, sizeof(AppConfigHeader), 1, fp);
        osDelay(10);
    }
    if(readtimes>5)
    {
        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, sizeof(AppNVMData));
	readtimes = 0;
    //while (readtimes<=5 && crcCheck != AppConfigHr.checkSum)
    while (readtimes<=5 && readCount != 1)
    {
        readtimes++;
        readCount = OsaFread(pReadAppConfig, AppConfigHr.fileBodySize, 1, fp);
        crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, sizeof(AppNVMData));
    }
    if (readtimes>5)
    {
        //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 0
        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
    OsaFclose(fp);
    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] = defaultBattSN[i];  //the defult sn is "0000..0000"(17 bytes ASCII)
	}
	AppNVMData.isBattLocked = false;
	AppNVMData.chargEndWorkTime = 30;  //30 min
	AppNVMData.wakeupWorkTime = 2;	//2min
	AppNVMData.sleepTime = 5;			//5min
    AppNVMData.HwVersion = HWVERSION;
    AppNVMData.BLSwVersion = BLSWVERSION;
    AppNVMData.DrvSwVersion = DRVSWVERSION;
    AppNVMData.AppSwVersion = APPSWVERSION;
    AppNVMData.EOLState = EOLSTATE; //未进行下线配置，北京电池测试默认进行下线测试
    return;
}

static void appSaveDataInfo(void)
{
    OSAFILE fp = PNULL;
    UINT32  writeCount = 0;
    fp = OsaFopen(APP_DATAINFO_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;
    }
    AppDataHr.fileBodySize   = sizeof(AppDataInfo); 
    AppDataHr.checkSum       = OsaCalcCrcValue((UINT8 *)&AppDataInfo, sizeof(AppDataInfo));
    #ifdef USING_PRINTF
		printf(" AppDataHr.fileBodySize:%x\n",AppDataHr.fileBodySize);
	#endif
    writeCount = OsaFwrite(&AppDataHr, sizeof(AppDataHr), 1, fp);
    if (writeCount != 1)
    {
        #ifdef USING_PRINTF
                    printf(" NVM: 'qxappconfig.nvm', write the file header failed\n");
        #endif
        OsaFclose(fp);
        return;
    }
    AppDataInfo.appDataModify = FALSE;
    writeCount = OsaFwrite(&AppDataInfo, sizeof(AppDataInfo), 1, fp);
    if (writeCount != 1)
    {
        #ifdef USING_PRINTF
			printf(" NVM: 'qxappconfig.nvm', write the file body failed\n");
		#endif
    }
    OsaFclose(fp);
    return;
}

static void LoadAppDataInfo(void)
{
    OSAFILE fp = PNULL;
    UINT32  readCount = 0;
    UINT8   crcCheck = 0;
    void    *pReadAppConfig = (void *)&AppDataInfo;
    fp = OsaFopen(APP_DATAINFO_FILE_NAME, "rb");   //read only
    if (fp == PNULL)
    {
        #ifdef USING_PRINTF
            printf(" NVM, can't open NVM: 'qxappData.nvm', use the defult value\n");
        #endif
        setDefaultAppDataInfo();
        appSaveDataInfo();
        return;
    }

    readCount = OsaFread(&AppDataHr, sizeof(AppDataHr), 1, fp);
    UINT8 readtimes=0;
    while (readCount != 1 && readtimes<=5 )
    {
        readtimes++;
        readCount = OsaFread(&AppDataHr, sizeof(AppDataHr), 1, fp);
        osDelay(10);
    }
    if(readtimes>5)
    {
        OsaFclose(fp);
        setDefaultAppDataInfo();
        appSaveDataInfo();
        return;
    }
    if(AppDataHr.fileBodySize==sizeof(AppDataInfo))//结构体数据没变动，可直接读出
    {
        readCount = OsaFread(pReadAppConfig, AppDataHr.fileBodySize, 1, fp);
        //crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, sizeof(AppNVMData));
        readtimes = 0;
        while (readtimes<=5 && readCount != 1)
        {
            readtimes++;
            readCount = OsaFread(pReadAppConfig, AppConfigHr.fileBodySize, 1, fp);
            //crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, sizeof(AppNVMData));
        }
    }
    else
    {
        setDefaultAppDataInfo();
        readCount = OsaFread(pReadAppConfig, AppDataHr.fileBodySize, 1, fp);
        //crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, sizeof(AppNVMData));
        readtimes = 0;
        while (readtimes<=5 && readCount != 1)
        {
            readtimes++;
            readCount = OsaFread(pReadAppConfig, AppConfigHr.fileBodySize, 1, fp);
            //crcCheck = OsaCalcCrcValue((UINT8 *)pReadAppConfig, sizeof(AppNVMData));
        }
        appSaveDataInfo();
        #ifdef USING_PRINTF
            printf(" Struct update\n");
        #endif
    }
    OsaFclose(fp);
    return;
}
void RecoveyTheData(void)
{
    setDefaultAppDataInfo();
    appSaveDataInfo();
}
//无法找到文件时的第一次启动，后续不会启动此函数
static void setDefaultAppDataInfo(void)
{
    memset(&AppDataInfo, 0x00, sizeof(AppDataInfo));
    AppDataInfo.appDataModify = false;
    AppDataInfo.BmsChrgInfoSendFreq = 5;
    AppDataInfo.BmsDisChrgInfoSendFreq = 30;
    AppDataInfo.GpsChrgInfoSendFreq = 30;
    AppDataInfo.GpsDisChrgInfoSendFreq = 5;
    AppDataInfo.BattCurrentNegFlag = 1;
    AppDataInfo.CumulativeCapacity = 0;
    AppDataInfo.AccMileage = 0;
    AppDataInfo.SysReStart = 0;
    AppDataInfo.RelayControl = 0;
    AppDataInfo.userLock = 0;
    AppDataInfo.rentalLock = 0;
    AppDataInfo.ErrorMsg = 0;
    AppDataInfo.rentaltype = 0;
    memset(AppDataInfo.ExpiryTimeArray, 0x00, sizeof(AppDataInfo.ExpiryTimeArray));
    return;
}
void BattWorkStateDelayFunc(UINT8 battWorkCurrentState)
{
    static UINT8 workDelayCounter;
    if(battWorkCurrentState==BATT_DISCHARGE_SYM)//从 充电或者静置 转放电 3s延时
	{
		workDelayCounter++;
		if(workDelayCounter>=3)
		{
			workDelayCounter=0;
			BattWorkStateDelay = battWorkCurrentState;
		}
	}
	else if(battWorkCurrentState==BATT_CHARGE_SYM)//从 放电或者静置 转充电30s延时
	{
		workDelayCounter++;
		if(workDelayCounter>=30)
		{
			workDelayCounter=0;
			BattWorkStateDelay = battWorkCurrentState;
		}
	}
	else
	{
		BattWorkStateDelay = battWorkCurrentState;
		workDelayCounter = 0;
	}
}
INT8 rentalEndDetectFunc(void)
{
	OsaUtcTimeTValue TimeStracture;
	UTC8TimeType UTC8Time,ExpiryTime;
	UINT16 year;
    UINT8 month,day,hour,minute,sec;
	appGetSystemTimeUtcSync(&TimeStracture);
    year=(TimeStracture.UTCtimer1&0xffff0000)>>16;
    month=(TimeStracture.UTCtimer1&0xff00)>>8;
    day=TimeStracture.UTCtimer1&0xff;
    hour=(TimeStracture.UTCtimer2&0xff000000)>>24;
    minute=(TimeStracture.UTCtimer2&0xff0000)>>16;
    sec=(TimeStracture.UTCtimer2&0xff00)>>8;
    UTCToBeijing((UTC8TimeType *)&UTC8Time,year,month,day,hour,minute,sec);	
	if(UTC8Time.year>2000)
	{
		#ifdef USING_PRINTF
            printf("retal Jug:%d %d %d %d,%d %d %d %d\n",UTC8Time.year,UTC8Time.month,UTC8Time.day,UTC8Time.hour,AppDataInfo.ExpiryTimeArray[0],AppDataInfo.ExpiryTimeArray[1],AppDataInfo.ExpiryTimeArray[2],AppDataInfo.ExpiryTimeArray[3]);
        #endif
        if(((UTC8Time.year - 0x07D0) & 0xFF)==AppDataInfo.ExpiryTimeArray[0])//年份相等判定月份
        {
            if(UTC8Time.month==AppDataInfo.ExpiryTimeArray[1])//月份相等判定日期
            {
                if(UTC8Time.day==AppDataInfo.ExpiryTimeArray[2])//日期相等判定小时
                {
                    // if(UTC8Time.hour<=AppDataInfo.ExpiryTimeArray[3])//小时相等不锁定，小时超出锁定
                    // {
                    //     return 0;
                    // }
                    // else
                    // {
                    //     return 1;
                    // }
                    return 0;
                }
                else if(UTC8Time.day>AppDataInfo.ExpiryTimeArray[2])
                {
                    return 1;
                }
                else if(UTC8Time.day<AppDataInfo.ExpiryTimeArray[2])
                {
                    return 0;
                }
            }
            else if(UTC8Time.month>AppDataInfo.ExpiryTimeArray[1])//实际月份大于终止月份
            {
                return 1;
            }
            else if(UTC8Time.month<AppDataInfo.ExpiryTimeArray[1])//实际月份小于终止月份
            {
                return 0;
            }
        }
        else if(((UTC8Time.year - 0x07D0) & 0xFF)>AppDataInfo.ExpiryTimeArray[0])//实际年份大于终止年份
        {
            return 1;
        }
        else if(((UTC8Time.year - 0x07D0) & 0xFF)<AppDataInfo.ExpiryTimeArray[0])//年比较,实际年份小于终止年份
        {
            return 0;
        }
	}
    else
    {
        return -1;//没有获取到时间返回
    }

}
void BattLockFunc(void)
{
    if(AppDataInfo.rentaltype==0)//测试模式
    {
        ;
    }
    else if (AppDataInfo.rentaltype==1)//零售模式
    {
        if(AppDataInfo.rentalLock==TRUE)
        {
            AppDataInfo.userLock = FALSE;
            AppDataInfo.rentalLock=FALSE;
            AppDataInfo.appDataModify=TRUE; 
        }
    }
    else if(AppDataInfo.rentaltype==2)// 租赁模式
    {
        INT8 ret = -1;
        ret = rentalEndDetectFunc();
        if(ret==1 && AppDataInfo.rentalLock==FALSE)//租期判定是否超期函数
        {
            #ifdef USING_PRINTF
                printf("retal lock,%d\n",ret);
            #endif
            AppDataInfo.rentalLock=TRUE;
            AppDataInfo.appDataModify=TRUE;
        }
        else if(ret==0 && AppDataInfo.rentalLock==TRUE)
        {
            #ifdef USING_PRINTF
                printf("retal unlock,%d\n",ret);
            #endif
            AppDataInfo.rentalLock=FALSE;
            AppDataInfo.appDataModify=TRUE;
            AppDataInfo.userLock = FALSE;
        }
    }

    if(AppDataInfo.rentalLock==FALSE&&AppDataInfo.userLock==FALSE)
    {
        AppNVMData.isBattLocked = FALSE;
        AppNVMData.appDataModify = TRUE;
    }
    else if(AppDataInfo.rentalLock==TRUE||AppDataInfo.userLock==TRUE)
    {
        AppNVMData.isBattLocked = TRUE;
        AppNVMData.appDataModify = TRUE;
    }   

    return;
}