NB_APP_Code/app_1_2.c

/****************************************************************************
 *
 * 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 <cis_def.h>
#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     = 0xff;
uint8_t process2SlpHandler     = 0xff;
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;
    uint32_t sleep_index = 0;
    NVIC_EnableIRQ(PXIC_Timer0_IRQn);
    PROC0_STATE_SWITCH(PROCESS0_STATE_IDLE);
    while(1)
    {
        switch(gProc0State)
        {
            case PROCESS0_STATE_IDLE:
            {   
                slpManPlatVoteDisableSleep(process0SlpHandler, SLP_SLP2_STATE); 
                PROC0_STATE_SWITCH(PROCESS0_STATE_WORK);
                break;
            }
            case PROCESS0_STATE_WORK:
            {
                NetSocDisplay(0,LED_TURN_ON);
                osDelay(10);//10ms
                Can_index++;
                Uart_index++;
                sleep_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 >=1000)
                {
                    PROC0_STATE_SWITCH(PROCESS0_STATE_SLEEP);
                    PROC1_STATE_SWITCH(PROCESS1_STATE_SLEEP);
                    PROC2_STATE_SWITCH(PROCESS2_STATE_SLEEP);
                    sleep_index = 0;
                }
                break;
                
            }
            case PROCESS0_STATE_SLEEP:
            {

                slpManSlpState_t State;
                uint8_t cnt;
                slpManPlatVoteEnableSleep(process0SlpHandler,SLP_SLP2_STATE);
                slpManPlatVoteDisableSleep(process0SlpHandler, SLP_HIB_STATE); 
                slpManDeepSlpTimerStart(deepslpTimerID, 10000); // create a 10s timer, DeepSleep Timer is always oneshoot
                while(1)                // now app can enter hib, but ps and phy maybe not, so wait here
                {
                    NetSocDisplay(0,LED_TURN_OFF);
                    osDelay(3000);
                }
            }
        }
    }
}
static void process1AppTask(void* arg)
{
	PROC1_STATE_SWITCH(PROCESS1_STATE_IDLE);
    NVIC_EnableIRQ(PadWakeup1_IRQn);
    slpManApplyPlatVoteHandle("process1slp",&process1SlpHandler);
    while(1)
    {
        switch(gProc1State)
        {
            case PROCESS1_STATE_IDLE:
            {
                slpManPlatVoteDisableSleep(process1SlpHandler, SLP_SLP2_STATE); 
                break;
            }
            case PROCESS1_STATE_WORK:
            {
                NetSocDisplay(1,LED_TURN_ON);
                break;
            }
            case PROCESS1_STATE_SLEEP:
            {   
                slpManPlatVoteEnableSleep(process1SlpHandler, SLP_SLP2_STATE); 
                slpManPlatVoteDisableSleep(process1SlpHandler, SLP_HIB_STATE);   
                while(1)
                {
                    osDelay(3000);
                }                              
                break;
            }
        }
    }
}
static void process2AppTask(void* arg)
{
	PROC2_STATE_SWITCH(PROCESS2_STATE_IDLE);
    NVIC_EnableIRQ(PadWakeup1_IRQn);
    slpManApplyPlatVoteHandle("process2slp",&process2SlpHandler);
    while(1)
    {
        switch(gProc2State)
        {
            case PROCESS2_STATE_IDLE:
            {   
                slpManPlatVoteDisableSleep(process2SlpHandler, SLP_SLP2_STATE);
                break;
            }
            case PROCESS2_STATE_WORK:
            {
                NetSocDisplay(2,LED_TURN_ON);
                break;
            }
            case PROCESS2_STATE_SLEEP:
            {
                slpManPlatVoteEnableSleep(process2SlpHandler, SLP_SLP2_STATE);  
                slpManPlatVoteDisableSleep(process2SlpHandler, SLP_HIB_STATE);  
                while(1)
                {
                    osDelay(3000);
                }                     
                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);
}