/**************************************************************************** * * Copy right: 2020-, Copyrigths of QIXIANG TECH Ltd. * File name: app.c 睡眠测试 * Description: QX app source file * History: Rev1.0 2020-10-16 * Athuor: chenjie * ****************************************************************************/ //include #include "bsp.h" #include "bsp_custom.h" #include "osasys.h" #include "ostask.h" #include "queue.h" #include "ps_event_callback.h" #include "app.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 #include "debug_log.h" #include "slpman_ec616.h" #include "plat_config.h" //define // app task static stack and control block #define PROC_TASK_STACK_SIZE (1024) uint8_t process0SlpHandler = 0xff; uint8_t process1SlpHandler = 0xfe; uint8_t process2SlpHandler = 0xfd; uint8_t deepslpTimerID = 0; typedef enum { PROCESS0_STATE_IDLE = 0, PROCESS0_STATE_WORK, PROCESS0_STATE_SLEEP }process0SM; typedef enum { PROCESS1_STATE_IDLE = 0, PROCESS1_STATE_WORK, PROCESS1_STATE_SLEEP }process1SM; typedef enum { PROCESS2_STATE_IDLE = 0, PROCESS2_STATE_WORK, PROCESS2_STATE_SLEEP }process2SM; static StaticTask_t gProcessTask0; static UINT8 gProcessTaskStack0[PROC_TASK_STACK_SIZE]; static StaticTask_t gProcessTask1; static UINT8 gProcessTaskStack1[PROC_TASK_STACK_SIZE]; static StaticTask_t gProcessTask2; static UINT8 gProcessTaskStack2[PROC_TASK_STACK_SIZE]; process0SM gProc0State = PROCESS0_STATE_IDLE; process1SM gProc1State = PROCESS1_STATE_IDLE; process2SM gProc2State = PROCESS2_STATE_IDLE; #define PROC0_STATE_SWITCH(a) (gProc0State = a) #define PROC1_STATE_SWITCH(a) (gProc1State = a) #define PROC2_STATE_SWITCH(a) (gProc2State = a) static void appBeforeHib(void *pdata, slpManLpState state) { uint32_t *p_param = (uint32_t *)pdata; ECOMM_TRACE(UNILOG_PLA_APP, appBeforeHib_1, P_SIG, 1, "Before Hibernate = %x",*p_param); } static void appAfterHib(void *pdata, slpManLpState state) { ECOMM_TRACE(UNILOG_PLA_APP, appAfterHib_1, P_SIG, 0, "Try Hibernate Failed, Interrupt Pending. Only sleep failed this function will excute"); } static void appBeforeSlp1(void *pdata, slpManLpState state) { ECOMM_TRACE(UNILOG_PLA_APP, appBeforeSlp1_1, P_SIG, 0, "Before Sleep1"); } static void appAfterSlp1(void *pdata, slpManLpState state) { ECOMM_TRACE(UNILOG_PLA_APP, appAfterSlp1_1, P_SIG, 0, "After Sleep1, no matter sleep success or not this function will excute"); } static void appBeforeSlp2(void *pdata, slpManLpState state) { ECOMM_TRACE(UNILOG_PLA_APP, appBeforeSlp2_1, P_SIG, 0, "Before Sleep2"); } static void appAfterSlp2(void *pdata, slpManLpState state) { ECOMM_TRACE(UNILOG_PLA_APP, appAfterSlp2_1, P_SIG, 0, "Sleep2 Failed, Interrupt Pending. Only sleep failed this function will excute"); } static void process0AppTask(void* arg) { NetSocDisplay(0,LED_TURN_OFF); NetSocDisplay(1,LED_TURN_OFF); NetSocDisplay(2,LED_TURN_OFF); NetSocDisplay(3,LED_TURN_OFF); NetSocDisplay(4,LED_TURN_OFF); uint32_t inParam = 0xAABBCCDD; uint32_t cnt; slpManSetPmuSleepMode(true,SLP_HIB_STATE,false); //slpManApplyPlatVoteHandle("process0slp",&process0SlpHandler); 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(); UINT8 Can_index = 0; UINT8 Uart_index = 0; uint8_t sleep_index = 0; PROC0_STATE_SWITCH(PROCESS0_STATE_IDLE); while(1) { switch(gProc0State) { case PROCESS0_STATE_IDLE: { PROC0_STATE_SWITCH(PROCESS0_STATE_WORK); break; } case PROCESS0_STATE_WORK: { NetSocDisplay(0,LED_TURN_ON); osDelay(10);//10ms Can_index++; Uart_index++; if (Uart_index >10)//Uart 100ms 调用一次 { PROC2_STATE_SWITCH(PROCESS2_STATE_WORK); Uart_index = 0; } if (Can_index >=100)//Can 1000ms 调用一次 { PROC1_STATE_SWITCH(PROCESS1_STATE_WORK); Can_index = 0; } if (sleep_index>5000) { sleep_index =0; PROC0_STATE_SWITCH(PROCESS0_STATE_SLEEP); } break; } case PROCESS0_STATE_SLEEP: { slpManSlpState_t State; uint8_t cnt; //slpManPlatVoteEnableSleep(process0SlpHandler, SLP_HIB_STATE); // cancel the prohibition of sleep2 //slpManDeepSlpTimerStart(deepslpTimerID, 60000); // create a 30s timer, DeepSleep Timer is always oneshoot while(1) // now app can enter hib, but ps and phy maybe not, so wait here { osDelay(3000); } } } } } static void process1AppTask(void* arg) { PROC1_STATE_SWITCH(PROCESS1_STATE_IDLE); //slpManApplyPlatVoteHandle("process1slp",&process1SlpHandler); NVIC_EnableIRQ(PadWakeup0_IRQn); while(1) { switch(gProc1State) { case PROCESS1_STATE_IDLE: { break; } case PROCESS1_STATE_WORK: { NetSocDisplay(1,LED_TURN_ON); osDelay(10000); PROC1_STATE_SWITCH(PROCESS1_STATE_SLEEP); break; } case PROCESS1_STATE_SLEEP: { //slpManPlatVoteDisableSleep(process1SlpHandler, SLP_SLP2_STATE); break; } } } } static void process2AppTask(void* arg) { PROC2_STATE_SWITCH(PROCESS2_STATE_IDLE); //slpManApplyPlatVoteHandle("process2slp",&process2SlpHandler); NVIC_EnableIRQ(PadWakeup0_IRQn); while(1) { switch(gProc2State) { case PROCESS2_STATE_IDLE: { break; } case PROCESS2_STATE_WORK: { NetSocDisplay(2,LED_TURN_ON); osDelay(20000); PROC2_STATE_SWITCH(PROCESS2_STATE_SLEEP); break; } case PROCESS2_STATE_SLEEP: { //slpManPlatVoteDisableSleep(process2SlpHandler, SLP_SLP2_STATE); break; } } } } /** \fn process0Init(void) \brief process0Init function. \return */ void process0Init(void) { osThreadAttr_t task_attr; #ifndef USING_PRINTF if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_LOG_CONTROL) != 0) { HAL_UART_RecvFlowControl(false); } #endif memset(&task_attr,0,sizeof(task_attr)); memset(gProcessTaskStack0, 0xA5,PROC_TASK_STACK_SIZE); task_attr.name = "Process0AppTask"; task_attr.stack_mem = gProcessTaskStack0; task_attr.stack_size = PROC_TASK_STACK_SIZE; task_attr.priority = osPriorityNormal;//osPriorityBelowNormal; task_attr.cb_mem = &gProcessTask0;//task control block task_attr.cb_size = sizeof(StaticTask_t);//size of task control block osThreadNew(process0AppTask, NULL, &task_attr); } /** \fn process1Init(void) \brief process1Init function. \return */ void process1Init(void) { osThreadAttr_t task_attr; #ifndef USING_PRINTF if(BSP_GetPlatConfigItemValue(PLAT_CONFIG_ITEM_LOG_CONTROL) != 0) { HAL_UART_RecvFlowControl(false); } #endif memset(&task_attr,0,sizeof(task_attr)); memset(gProcessTaskStack1, 0xA5,PROC_TASK_STACK_SIZE); task_attr.name = "Process1AppTask"; task_attr.stack_mem = gProcessTaskStack1; task_attr.stack_size = PROC_TASK_STACK_SIZE; task_attr.priority = osPriorityNormal;//osPriorityBelowNormal; task_attr.cb_mem = &gProcessTask1;//task control block task_attr.cb_size = sizeof(StaticTask_t);//size of task control block osThreadNew(process1AppTask, NULL, &task_attr); } /** \fn process2Init(void) \brief process2Init function. \return */ void process2Init(void) { osThreadAttr_t task_attr; memset(&task_attr,0,sizeof(task_attr)); memset(gProcessTaskStack2, 0xA5,PROC_TASK_STACK_SIZE); task_attr.name = "Process2AppTask"; task_attr.stack_mem = gProcessTaskStack2; task_attr.stack_size = PROC_TASK_STACK_SIZE; task_attr.priority = osPriorityNormal;//osPriorityBelowNormal; task_attr.cb_mem = &gProcessTask2;//task control block task_attr.cb_size = sizeof(StaticTask_t);//size of task control block osThreadNew(process2AppTask, NULL, &task_attr); } /** \fn appInit(void) \brief appInit function. \return */ void appInit(void *arg) { process0Init(); process1Init(); process2Init(); } /** \fn int main_entry(void) \brief main entry function. \return */ void main_entry(void) { BSP_CommonInit(); osKernelInitialize(); registerAppEntry(appInit, NULL); if (osKernelGetState() == osKernelReady) { osKernelStart(); } while(1); }