#include "task.h"  
 
#include "task_type.h"  
#include "cfg/task_cfg.h"   
#include "string.h"

#ifdef __cplusplus
extern "C" {
#endif

    

 
 
AL_STATIC XDATA   TASK_DATA TaskDb[]={ 
    {1, TASK_MODE_PERIOD,	TASK_ID(TaskTimer),  TASK_NAME(TaskTimer), 	100L,     1L,		TaskTimer, 0 } ,     //  TASK_NAME(TaskTimer), 
    #include "cfg/task_container.h"
}; 
 
 
 

AL_STATIC XDATA  TIMER_DATA TimerData[MAX_TIMER];
AL_STATIC IDATA  volatile uint8_t TMP1msCount = 0;   
AL_STATIC IDATA  volatile uint32_t AllTickCount = 0;
 
   
 



void TaskFunc (void)
{ 
    ////////////////////////////////////////
    uint8_t ret        = 0;
    uint8_t j          = 0; 
    uint8_t size       = sizeof(TaskDb)/sizeof(TaskDb[0]); 
    
    _nop_();     
    
    InitTaskStack();  //计算堆栈用的
    
    for(j=0;j<size;j++)
    {
        if(!TaskDb[j].cActive) 
            continue;  
        
        
        TaskDb[j].lLastTime-=TMP1msCount;
        if(TaskDb[j].lLastTime<=0)
        {
            TaskDb[j].lLastTime += TaskDb[j].lPeriod;
            if(TaskDb[j].cMode==TASK_MODE_ONCE)
                TaskDb[j].cActive = 0;  
            
            if(TaskDb[j].TaskProc!=NULL)
            {      
                taskProc func = TaskDb[j].TaskProc;
                #if(TASK_WITH_PT)
                struct pt* pt2 = &(TaskDb[j].pt1);
                _nop_();      
                ret = func(pt2);       
                #else 
                _nop_();     
                func();    
                #endif 
                _nop_(); 
            } 
             
        }
        _nop_();
    } 
    TMP1msCount = 0;  
} 

void TaskProc (void)    
{
#if(TASK_OVERLAY_CHECK)
    uint32_t dummy_stack[2] = {0};  ////指针函数就是个垃圾,overlay计算不正确 不过这个可以用来计算堆栈
    uint8_t depth = 0;
    uint8_t size = 0;
    for(  depth=0;depth<sizeof(dummy_stack)/sizeof(uint32_t);depth++)
    {
        dummy_stack[depth] = 0xDEADBEEF;
        //如果这个变量被涂改,说明InitTaskStack有任务函数没有加入
    } 
#endif    
    _nop_();
	while(1)
	{
		if(!TMP1msCount)  
		{
			Idle();
		}
		else
		{
            TaskFunc();
            _nop_();
        }
        
#if(TASK_OVERLAY_CHECK)
        for(  depth=0;depth<sizeof(dummy_stack)/sizeof(uint32_t);depth++)
        {
            if(dummy_stack[depth]!= 0xDEADBEEF)
            {
                //如果这个变量被涂改,说明InitTaskStack有任务函数没有加入
                while(1)
                {
                    _nop_();
                }
            }
        } 
#endif
        
    }
}



int8_t SetTaskLastTime(int8_t cTaskID,int32_t lLastTime)
{
    int16_t result = -1;
    unsigned int i; 
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {  
            result =(int16_t) i;
            TaskDb[i].lLastTime=lLastTime; 
            break;
        }
    }
    return result;
}


void ActiveTaskNow(int8_t cTaskID, int32_t lPeriod)
{
    unsigned int i;

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



int8_t ActiveTask(int8_t cTaskID, int32_t lPeriod) 
{    
    int8_t result = -1;
    unsigned int i;

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

int8_t SuspendTask(int8_t cTaskID)
{   
    int16_t result = -1;
    uint32_t i;
    for(  i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cTaskID==cTaskID)
        {
            result = (int16_t)i;
            TaskDb[i].cActive=0;
            break;
        }
    }
    return result;
}


int8_t StartTimer2(int8_t *TimerID,int8_t cMode,uint32_t lPeriod,void (* routine)(void *   Param1),void *   Param1) 
{ 
    int8_t id = StartTimer(cMode,lPeriod,routine,Param1);
    TimerData[id].TimerID = TimerID;
    *TimerID = id;
    return id; 
}

//TASK_PROT
/*********************************************************************************************************
    FUNCTION:   StartTimer
    PURPOSE:    start a timer ok then return timer number ; =-1 failed;
**********************************************************************************************************/
int8_t StartTimer(int8_t cMode,int32_t lPeriod,void (* routine)(void *   Param1),void *   Param1)
{
    unsigned char   i;
    xdata TIMER_DATA *ptimer;

    ptimer=&TimerData[0];
    for(i=0;i<MAX_TIMER;i++)
    {
        if(!ptimer[i].cUse)
        {
            switch(cMode)
            {
                case TIMER_MODE_TIMER:              // timer only
                case TIMER_MODE_ONCEROUTINE:        // timely routine
                case TIMER_MODE_CYCROUTINE:         // cyclely routine
                    break;
                default:
                    ptimer[i].cUse = 0;
                    return -1;                      // error
            }
            ptimer[i].lPeriod     = lPeriod;              // set timer period
            ptimer[i].lLastTime   = lPeriod;                // get current system time as start timer
            ptimer[i].routine     = routine;              // user timer's routine
            ptimer[i].cMode       = cMode;                // timer's work mode
            ptimer[i].cUse        = 1;
            ptimer[i].Param1      = Param1;
            return (i);                             // return timer number
        }
    }
    //if(i== MAX_TIMER);
    #ifdef _DEBUG
    printf("timer id not found!");
    #endif
    return (-1);                                    // no timer available
}
/**********************************************************************************************************
    FUNCTION:   StopTimer
    PURPOSE:    stop timer count
***********************************************************************************************************/
int8_t StopTimer ( signed char * pcTimerNumber )
{
    int8_t index = * pcTimerNumber;
    if(index>=MAX_TIMER || index==-1)
        return -1;                            // timer number error

    TimerData[index].cUse=0;
    if(TimerData[index].TimerID!=NULL)
    {
        *TimerData[index].TimerID = -1;
        TimerData[index].TimerID = NULL;
    }
    *pcTimerNumber = -1;

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

 
// The callback timer executes a callback function one or more times after a specified time


#if TASK_WITH_PT 
PT_THREAD(TaskTimer(struct pt *pt1 ))
#else 
PT_THREAD(TaskTimer(void))  
#endif  
{         
    unsigned char i;
    TIMER_DATA *pTimer; 
#if(TIMER_OVERLAY_CHECK)
    uint32_t dummy_stack[2] = {0};  ////指针函数就是个垃圾,overlay计算不正确 不过这个可以用来计算堆栈
    uint8_t depth = 0;
    uint8_t size = 0;
    for(  depth=0;depth<sizeof(dummy_stack)/sizeof(uint32_t);depth++)
    {
        dummy_stack[depth] = 0xDEADBEEF;
        //如果这个变量被涂改,说明InitTaskStack有任务函数没有加入
    } 
    InitTimerStack();
#endif    
    _nop_();          
    pTimer=&TimerData[0];                                         // pointer to the first timer
    for(i=0;i<MAX_TIMER;i++)
    {
        if(!pTimer[i].cUse)
            continue; 
        if((--(pTimer[i].lLastTime))<=0)
        {
            switch(pTimer[i].cMode)
            {
                case TIMER_MODE_TIMER:                      // timer only
                     pTimer[i].cUse=0; 
                     if(pTimer[i].TimerID!=NULL)
                        *pTimer[i].TimerID = -1;
                    break; 
                case TIMER_MODE_ONCEROUTINE:                // timer routine once
                     pTimer[i].cUse=0;                            //prevents the start of timer after stoptimer in the routine from causing an error stop. 
                     if(pTimer[i].TimerID!=NULL)
                        *pTimer[i].TimerID = -1;
                case TIMER_MODE_CYCROUTINE:                   // cyclely routine
                     pTimer[i].lLastTime+=pTimer[i].lPeriod;
                     if(pTimer[i].routine!=NULL)
                        pTimer[i].routine(pTimer[i].Param1);                          // start user's routine
                    break;
                default:
                    pTimer[i].cUse=0;
                    break;
            }
        }
    }    
#if(TIMER_OVERLAY_CHECK)
    for(  depth=0;depth<sizeof(dummy_stack)/sizeof(uint32_t);depth++)
    {
        if(dummy_stack[depth]!= 0xDEADBEEF)
        {
            //如果这个变量被涂改,说明InitTaskStack有任务函数没有加入
            while(1)
            {
                _nop_();
            }
        }
    } 
#endif
    
    UNUSED(pt1);
    return 0;
}

void Task_SysTick_Handler(void)
{
    AllTickCount++;
    TMP1msCount++;
}

uint32_t  get_system_ms(void)
{
    return AllTickCount;
}    


void ResetTimer(void)
{
    TMP1msCount = 0;
}

#ifdef __cplusplus
}
#endif