#include "task.h"    

//任务数据库 
TASK_DATA TaskDb[10]={                                        
    {1, TASK_MODE_PERIOD,   1L,       1L,   TASK_TIMER,0,   TaskTimer},  
   // {1, TASK_MODE_PERIOD, 250L,  250L,    TASK_BLINK, TaskBlink},    
};

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

char HW_VER[20] ="1.0";    
char SW_VER[20] ="1.0";
RCC_TypeDef myRCC __at(RCC_BASE);
void Init_task_timer(void)
{
} 

///////////////////////////////////////////////////////////////////////////////////////////////////////////
/**********************************************************************************************************
    任务调度,在主循环中调用。
    由于是模拟多任务，所以要求每个任务的处理时间尽可能短。
***********************************************************************************************************/

void idle(void) 
{     
               
}                        

void TaskProc(void)
{       
    uint32_t i;
    if(!gc1ms)  //保证1ms扫描一次
    {
        idle();
    }    
    else
    {
        if(TMP1msCount>0)
        {
            for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
            {
                TaskDb[i].lLastTime-=TMP1msCount;
            }
        }
        gc1ms=0;
        TMP1msCount = 0;            
        for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
        {
            if(!TaskDb[i].cActive)
                continue;
            if(TaskDb[i].TaskProc1==NULL)
                break;
            
            if(--TaskDb[i].lLastTime<=0)
            {
                TaskDb[i].lLastTime += TaskDb[i].lPeriod;
                TaskDb[i].TaskProc1(&TaskDb[i].pParam);                                 //执行任务
            }
        } 
    }  
}

 

void AddTask(uint8_t cTaskType,uint8_t TaskMode,char (*TaskProcDef)(struct  pt  *p),struct  pt pParam ,uint32_t lPeriod) 
{ 
    unsigned int i;
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if((TaskDb[i].cType==cTaskType)||(TaskDb[i].cType==0))
        {
            TaskDb[i].cActive=1;  
            TaskDb[i].cType=cTaskType;
            TaskDb[i].cTaskMode=TaskMode;
            TaskDb[i].pParam=pParam;
            TaskDb[i].lPeriod=lPeriod;
            TaskDb[i].lLastTime=lPeriod; 
            TaskDb[i].TaskProc1=TaskProcDef; 
            break; 
        }
    } 
}
//Task Function 
void ActiveTask(uint8_t cTaskType, uint32_t lPeriod)
{

    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;
            }
            break;
        }
    } 
}


int32_t GetTaskLastTime(uint8_t cTaskType )
{
    unsigned int i; 
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {  
            return TaskDb[i].lLastTime ;  
        }
    }
    return -1L;
}

char bTaskIsActived(uint8_t cTaskType)
{ 
    unsigned int i; 
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            if(TaskDb[i].cActive==0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    } 
    return false;
}


void SuspendTask(uint8_t cTaskType)
{

    unsigned int i;
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            TaskDb[i].cActive=0;
            break;
        }
    }
    
}
//Timer Function  
int8_t StartTimer(int8_t *cTimerID,uint8_t cMode,uint32_t lPeriod,void (* routine)(const void * Param1),void * Param1)
{ 
    unsigned int   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->cTimerID    = cTimerID;
            *cTimerID       = i;
            return (i);                             // return timer number
        }
    }
    
    #ifdef _DEBUG
    if(i== MAX_TIMER)
        printf("定时器资源不足,申请不成功");
    #endif      
    
    *cTimerID       = -1;
    return (-1);                                    // no timer available
    
}

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;
    
    
}
    


void StopAllTimer(void)
{  
    unsigned int i;
    for(i=0;i<MAX_TIMER;i++)
    {
        TimerData[i].cUse=0;
    }       
}


char  TaskTimer(struct pt *pParam)
{
    TIMER_DATA *ppt;
    unsigned int i;

    ppt=&TimerData[0];                                         // pointer to the first timer
    for(i=0;i<MAX_TIMER;i++,ppt++)
    {
        if(!ppt->cUse)
            continue;
        if((--(ppt->lLastTime))<=0)
        {
            switch(ppt->cMode)
            {
                case TIMER_MODE_TIMER:                      // timer only
                     ppt->cUse=0;
                    break;
                case TIMER_MODE_CYCROUTINE:                   // cyclely routine
                     ppt->lLastTime+=ppt->lPeriod;
                     ppt->routine(ppt->Param1);                          // start user's routine
                    break;
                case TIMER_MODE_ONCEROUTINE:                // timer routine once
                     *ppt->cTimerID = -1;
                     ppt->cUse=0;
                     ppt->routine(ppt->Param1);             // start user routine
                    break;
                default:
                    ppt->cUse=0;
                    break;
            }
        }
    }
    return 0;
}


//////////////////////////////////////////////////////////////////////////////////////////////////////
//    定时器中断服务程序,定时器0中断1次/10mS.
//////////////////////////////////////////////////////////////////////////////////////////////////////


uint32_t TickCount=0  ;
volatile unsigned  char i = 0;
void SysTick_Handler(void)
{
    if(gc1ms==1)
    {
        TMP1msCount++;
    }    
    gc1ms=1;    
    TickCount++; 
}

void Delay(unsigned long delayCnt)
{
    while(delayCnt--)
    {
        __nop();
    }
}