/*
 * task.c
 *
 *  Created on: 2023-4-20
 *      Author: xukaiming
 */
#include "task.h"
#include "task_header.h"

#include "perf_counter.h"
#include "stdio.h"

typedef struct mytask
{
	uint8_t   	cActive;            // >0:活动,1:初始化后立即启动
	uint8_t   	cTaskMode;          // 任务工作方式
	uint16_t    cType;              // 任务类型  
	int32_t   	lLastTime;
	int32_t   	lPeriod;            // 活动周期,uint=1mS
	char    	(*TaskProc)(struct pt* pt1);  	// 任务处理子程序
    struct pt   pt1;    
}TASK_DATA,*PTASK_DATA;

enum TIMER_MODE
{
	TIMER_MODE_TIMER = 0,
	TIMER_MODE_ONCEROUTINE,
	TIMER_MODE_CYCROUTINE
};
// define timer data struct
typedef struct mytimer
{
	uint8_t   	cUse;
	int8_t		*TimerID;
	uint8_t   	cMode;                  // timer work mode
	uint8_t		reserve1;
    
	int32_t		lPeriod;                // timer period, unit=10ms.
	int32_t		lLastTime;              // timer count for reload
    void    	(*routine)(void *   Param1);        // user's timer routine
    void 		*Param1;
}TIMER_DATA,*PTIMER_DATA;


// function prototype
static char TaskTimer(struct pt *pt1); 
void Task_SysTick_Handler(void);


static TASK_DATA TaskDb[]={ 
    {1, TASK_MODE_PERIOD,	TASK_ID(TaskTimer),   	10L,  10L,		TaskTimer,{0}} ,  
    #include "task_container.h"
};

static TIMER_DATA TimerData[MAX_TIMER];
static uint32_t TMP1msCount = 0; //1ms到标志，控制多任务处理的时间隔为1ms



//空闲时执行操作
__attribute__((weak))
void idle(void)
{ 
    
}

//循环执行任务列表,时间到了执行任务
void TaskProc(void)
{
	uint32_t i = 0;
	while(1)
	{
		if(!TMP1msCount)  //保证1ms扫描一次
		{
			idle();
		}
		else
		{
			for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
			{
				if(!TaskDb[i].cActive)
					continue;

				TaskDb[i].lLastTime-=TMP1msCount;
				if(TaskDb[i].lLastTime<=0)
				{
					TaskDb[i].lLastTime += TaskDb[i].lPeriod;
					if(TaskDb[i].TaskProc!=NULL)
						TaskDb[i].TaskProc(&TaskDb[i].pt1);                                 //执行任务
				}
			}
			TMP1msCount = 0;
		}
	}
}

//回调定时器 在指定时间后单次或者多次执行某回调函数
static char TaskTimer(struct pt *pt1 )
{
    TIMER_DATA *pt;
    unsigned char i;

    pt=&TimerData[0];                                         // pointer to the first timer
    for(i=0;i<MAX_TIMER;i++,pt++)
    {
        if(!pt->cUse)
            continue;
        if((--(pt->lLastTime))<=0)
        {
            switch(pt->cMode)
            {
                case TIMER_MODE_TIMER:                      // timer only
                     pt->cUse=0;
                    break;
                case TIMER_MODE_CYCROUTINE:                   // cyclely routine
                     pt->lLastTime+=pt->lPeriod;
                     pt->routine(pt->Param1);                          // start user's routine
                    break;
                case TIMER_MODE_ONCEROUTINE:                // timer routine once
                     pt->cUse=0;                            //防止在routine里stoptimer后启动timer造成错误停止
                     pt->routine(pt->Param1);               // start user routine
                     break;
                default:
                    pt->cUse=0;
                    break;
            }
        }
    }
    UNUSED_PARAM(pt1);
    return 0;
}

//Counter
volatile AL_STATIC uint64_t AllTickCount = 0;
void Task_SysTick_Handler(void)
{
    AllTickCount++;
	TMP1msCount++;
}
 

//Start State Machine
void InitTask(void)
{ 
    #if(EnEventRecorder)
    Init_EventRecorder();
    #else
    SerialInit();
    #endif
    SetSYSTickCallBack(Task_SysTick_Handler);
    InitLEDPort();
    InitSysTick(1000);
    init_cycle_counter(true);
    printf("Task Start\r\n");
     
}

/**********************************************************************************************************/
int16_t ActiveTask(uint16_t cTaskType, int32_t lPeriod)
{
    int16_t result = -1;
    unsigned int i;

    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            if(TaskDb[i].cActive==0)
            {
                TaskDb[i].cActive=1;
                TaskDb[i].lPeriod=lPeriod;
                TaskDb[i].lLastTime=lPeriod;
            }
            result = 0;
            break;
            
        }
    }
    return result;
}
//
int16_t ActiveTaskNow(uint16_t cTaskType, int32_t lPeriod)
{
    int16_t result = -1;
    unsigned int i;

    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            if(TaskDb[i].cActive==0)
            {
                TaskDb[i].cActive=1;
                TaskDb[i].lPeriod=lPeriod;
                TaskDb[i].lLastTime=0;
            }
            result = 0;
            break;
        }
    }
    return result;
}

int16_t SetTaskLastTime(uint16_t cTaskType,int32_t lLastTime)
{
    int16_t result = -1;
    unsigned int i; 
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {  
            result =(int16_t) i;
            TaskDb[i].lLastTime=lLastTime; 
            break;
        }
    }
    return result;
}
/***********************************************************************************************************/
int16_t SuspendTask(uint16_t cTaskType)
{
    int16_t result = -1;
    uint32_t i;
    for(  i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            result = (int16_t)i;
            TaskDb[i].cActive=0;
            break;
        }
    }
    return result;
}
/*********************************************************************************************************
	FUNCTION:   StartTimer
	PURPOSE:    start a timer ok then return timer number ; =-1 failed;
**********************************************************************************************************/
int8_t StartTimer(uint8_t cMode,int32_t lPeriod,void (* routine)(void *   Param1),void *   Param1)
{
    int8_t timerID = -1;
    timerID = StartTimer2(NULL,cMode,lPeriod,routine,Param1);
    return timerID;
}
    

int8_t StartTimer2(int8_t *TimerID,uint8_t cMode,int32_t lPeriod,void (* routine)(void *   Param1),void *   Param1)
{
    int8_t  i;
    TIMER_DATA *pt;

    pt=&TimerData[0];
    for(i=0;i<MAX_TIMER;i++,pt++)
    {
        if(!pt->cUse)
        {
            switch(cMode)
            {
                case TIMER_MODE_TIMER:              // timer only
                case TIMER_MODE_ONCEROUTINE:        // timely routine
                case TIMER_MODE_CYCROUTINE:         // cyclely routine
                    break;
                default:
                    pt->cUse = 0;
                    return -1;                      // error
            }
            pt->lPeriod     = lPeriod;              // set timer period
            pt->lLastTime   = lPeriod;	    		// get current system time as start timer
            pt->routine     = routine;              // user timer's routine
            pt->cMode       = cMode;                // timer's work mode
            pt->cUse        = 1;
            pt->Param1      = Param1;
            pt->TimerID     = TimerID;
            if(TimerID!=NULL)
            {
                *TimerID = i;
            }
            return (i);                             // return timer number
        }
    } 
    #ifdef _DEBUG
    printf("定时器资源不足,申请不成功\n");
		while(1);
    #endif
		
    return (-1);                                    // no timer available
}
/**********************************************************************************************************
	FUNCTION:   StopTimer
	PURPOSE:    stop timer count
***********************************************************************************************************/
int8_t StopTimer ( int8_t * pcTimerNumber )
{
    if(*pcTimerNumber>=MAX_TIMER || *pcTimerNumber==-1)
        return -1;                            // timer number error

    TimerData[*pcTimerNumber].cUse=0;
    *pcTimerNumber = -1;

    return 0;
}
/***********************************************************************************************************
	FUNCTION:   StopAllTimer
	PURPOSE:    stop all timer count
************************************************************************************************************/
void StopAllTimer(void)
{
    unsigned char i;
    for(i=0;i<MAX_TIMER;i++)
    {
        TimerData[i].cUse=0;
    }
}