/*********************************************************************************************************
    FILE:       TASK.C

*********************************************************************************************************/

#include "task.h"
#include "modbus.h"
#include "ctrl.h"    
#include "DAC.H" 
#include "test.h"      
//global variable
//任务数据库
TASK_DATA TaskDb[]={                                                                
        {1, TASK_MODE_PERIOD, 10L,          10L,            TASK_TIMER,                 TaskTimer} ,        
        {1, TASK_MODE_PERIOD, 2L,           2L,             TASK_COMM_TIMER,            TaskCommTimer},    
       // {1, TASK_MODE_PERIOD, 10L,          10L,            TASK_CMD,                   TaskParsaCmd}, 
        {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_BEEP,                  TaskBeep},
        {1, TASK_MODE_PERIOD, 100L,         100L,           TASK_BLINK,                 TaskBlinLed},
        {1, TASK_MODE_PERIOD, 40L,          40L,            TASK_MANUAL_CTRL,           TaskManualMovePos},
        {1, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_INTGAL_FREQ,           TaskIntFreq},
        {0, TASK_MODE_PERIOD, 2000L,        2000L,          TASK_FUZZY,                 TaskFuzzy},
        {0, TASK_MODE_PERIOD, 2000L,        2000L,          TASK_RESET,                 TaskReset},
        {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_TEST,                  TaskTest},
        {0, TASK_MODE_PERIOD, 5L,           5L,             TASK_DJ,                    TaskDJ},         
        {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_STOPMOTOR,             TaskStopMotor}, 
        {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_STOP_SAMPLEPOS,        TaskStopSamplePos}  ,   
        {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_STOP_SAMPLEPOS2,        TaskStopSamplePos2}     ,
         {0, TASK_MODE_PERIOD, 1000L,        1000L,          TASK_STOP_ENCODE_POS,        TaskStopSampleEncodePos}     
        };

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


const char LeapDays[14]={0,31,29,31,30,31,30,31,31,30,31,30,31,31};
const char NormDays[14]={0,31,28,31,30,31,30,31,31,30,31,30,31,31};
///////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <absacc.h>        
//input Port

volatile unsigned long PD2_I    __at (BITBAND((int)&(GPIOD->IDR),2));
volatile unsigned long PD3_I    __at (BITBAND((int)&(GPIOD->IDR),3));
volatile unsigned long PD4_I    __at (BITBAND((int)&(GPIOD->IDR),4));
volatile unsigned long PD5_I    __at (BITBAND((int)&(GPIOD->IDR),5));
volatile unsigned long PD6_I    __at (BITBAND((int)&(GPIOD->IDR),6));
volatile unsigned long PD7_I    __at (BITBAND((int)&(GPIOD->IDR),7)); 

volatile unsigned long PF0_I        __at (BITBAND((int)&(GPIOF->IDR),0));
volatile unsigned long PF1_I        __at (BITBAND((int)&(GPIOF->IDR),1));
volatile unsigned long PF2_I        __at (BITBAND((int)&(GPIOF->IDR),2));
volatile unsigned long PF3_I        __at (BITBAND((int)&(GPIOF->IDR),3));
volatile unsigned long PF4_I        __at (BITBAND((int)&(GPIOF->IDR),4));  
volatile unsigned long PF5_I        __at (BITBAND((int)&(GPIOF->IDR),5));  
//Output port
unsigned long PA0_O    __at (BITBAND((int)&(GPIOA->ODR),0));    
unsigned long PA1_O    __at (BITBAND((int)&(GPIOA->ODR),1));
unsigned long PA4_O    __at (BITBAND((int)&(GPIOA->ODR),4));    
unsigned long PA5_O    __at (BITBAND((int)&(GPIOA->ODR),5));    
unsigned long PA7_O    __at (BITBAND((int)&(GPIOA->ODR),7));    
unsigned long PA12_O    __at (BITBAND((int)&(GPIOA->ODR),12));              

unsigned long PB0_O        __at (BITBAND((int)&(GPIOB->ODR),0));
unsigned long PB1_O        __at (BITBAND((int)&(GPIOB->ODR),1));     

unsigned long PC0_O        __at (BITBAND((int)&(GPIOC->ODR),0));
unsigned long PC1_O        __at (BITBAND((int)&(GPIOC->ODR),1));
unsigned long PC2_O        __at (BITBAND((int)&(GPIOC->ODR),2));
unsigned long PC3_O        __at (BITBAND((int)&(GPIOC->ODR),3));   
unsigned long PC4_O        __at (BITBAND((int)&(GPIOC->ODR),4));
unsigned long PC5_O        __at (BITBAND((int)&(GPIOC->ODR),5));   
 
unsigned long PC8_I        __at (BITBAND((int)&(GPIOC->IDR),8));   

unsigned long PC13_O       __at (BITBAND((int)&(GPIOC->ODR),13)); 

unsigned long PD0_O        __at (BITBAND((int)&(GPIOD->ODR),0));  
unsigned long PD1_O        __at (BITBAND((int)&(GPIOD->ODR),1));   
unsigned long PD2_O        __at (BITBAND((int)&(GPIOD->ODR),2));  
unsigned long PD3_O        __at (BITBAND((int)&(GPIOD->ODR),3));  
unsigned long PD4_O        __at (BITBAND((int)&(GPIOD->ODR),4));  
unsigned long PD5_O        __at (BITBAND((int)&(GPIOD->ODR),5));  
unsigned long PD6_O        __at (BITBAND((int)&(GPIOD->ODR),6));  
unsigned long PD7_O        __at (BITBAND((int)&(GPIOD->ODR),7));  



unsigned long PE0_O     __at (BITBAND((int)&(GPIOE->ODR),0));
unsigned long PE15_O    __at (BITBAND((int)&(GPIOE->ODR),15));

 
///////////////////////////////////////////////////////////////////////////////////////////////////////////
/**********************************************************************************************************
    任务调度,在主循环中调用。
    由于是模拟多任务，所以要求每个任务的处理时间尽可能短。
***********************************************************************************************************/
void idle(void) 
{
    //__asm("WFI");   
	IdleRoutine();
}     

void TaskProc(void)
{
    unsigned char 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].lLastTime<=0)
            {
                TaskDb[i].lLastTime += TaskDb[i].lPeriod;
                TaskDb[i].TaskProc();                                 //执行任务
            }
        }
    }
}
/**********************************************************************************************************/
void ActiveTask(UCHAR cTaskType, ULONG 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;
        }
    }
}
/***********************************************************************************************************/
void SuspendTask(UCHAR cTaskType)
{
    unsigned int i;
    for(i=0;i<sizeof(TaskDb)/sizeof(TaskDb[0]);i++)
    {
        if(TaskDb[i].cType==cTaskType)
        {
            TaskDb[i].cActive=0;
            break;
        }
    }
}
/*********************************************************************************************************
    FUNCTION:   StartTimer
    PURPOSE:    start a timer ok then return timer number ; =-1 failed;
**********************************************************************************************************/
SCHAR StartTimer(UCHAR cMode,ULONG lPeriod,void (* routine)(void *   Param1),void *   Param1)
{
    unsigned char   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;
            return (i);                             // return timer number
        }
    }
    //if(i== MAX_TIMER);
    #ifdef _DEBUG
    printf("定时器资源不足,申请不成功");
    #endif
    return (-1);                                    // no timer available
}
/**********************************************************************************************************
    FUNCTION:   StopTimer
    PURPOSE:    stop timer count
***********************************************************************************************************/
signed char StopTimer ( signed char * 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;
    }
}
/**********************************************************************************************************
    FUNCTION:   TaskTimer
    PURPOSE:    timer service routine.
***********************************************************************************************************/
void TaskTimer(void)
{
    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;
                     pt->routine(pt->Param1);                         // start user routine
                    break;
                default:
                    pt->cUse=0;
                    break;
            }
        }
    }
}

/**********************************************************************************************************
    定时器中断服务程序,定时器0中断1次/10mS.
***********************************************************************************************************/
 
void SysTick_Handler(void)
{
    if(gc1ms==1)
    {
        TMP1msCount++;
    }              
    gc1ms=1;                       
}
 


 

void Init_task_timer(void )
{   
//  SysTick_SetReload(9000);             
//  SysTick_ITConfig(ENABLE);             
}

 

void TaskBlinLed(void)
{ 
    static unsigned char count =0;            
    count=(++count)%10;    
    PB0_O = count>0?1:0;     
    GetInput();
    GetOutPut();
}

/*******************************************************/
//
//maketime    2000-1-1 00:00:00=0
/*******************************************************/
time_t MakeTime(TIME *ptm)
{
    int days, year, month;
    time_t t=0;

    if(ptm->iYear>=2000)    /* if after Jan 1, 2000 */
    {
        for(days=0,year=2000;year<ptm->iYear;year++)
        {
            if((year%4==0 && year%100!=0)||(year%400==0))
                days+=366;
            else
                days+=365;
        }

        for(month=1;month<ptm->cMon;month++)
        {
            if(((ptm->iYear%4==0) && (ptm->iYear%100!=0))||(ptm->iYear%400==0))
                days+=LeapDays[month];
            else
                days+=NormDays[month];
        }

        days+=(ptm->cDay-1);
        t=days*86400L+ptm->cHour*3600L+ptm->cMin*60L+ptm->cSec;
    }
    return t;
}
/***********************************************/
//localtime, time_t 0=2000-1-1 00:00:00
/***********************************************/
void LocalTime(TIME *t,time_t *tSec)
{
    unsigned long days,year,month,hour,min,sec;

    days=(*tSec/86400L);
    hour=(*tSec%86400L)/3600;
    min=(*tSec%3600L)/60;
    sec=*tSec%60L;

    year=2000;
    while(days>=(((year%4==0 && year%100!=0)||(year%400==0)) ? 366:365))  //if
    {
        days-=(((year%4==0 && year%100!=0)||(year%400==0)) ? 366:365);
        year++;
    }
    month=1;
    while(days>=((year%4==0) ? LeapDays[month]:NormDays[month]))
    {
        days-=(((year%4==0 && year%100!=0)||(year%400==0)) ? LeapDays[month]:NormDays[month]);
        month++;
    }
    days++;

    t->iYear=year;
    t->cMon=(char)(month);
    t->cDay=(char)(days);
    t->cSec=(char)(sec);
    t->cMin=(char)(min);
    t->cHour=(char)(hour);
}                
 
void InitPLL(void)
{
/*
    uint32_t u32clock;
    // SYSCLK =>12Mhz      

                              
    //Init PLL   
                                    
    SYSCLK->PLLCON.PLL_SRC = E_SYS_EXTERNAL_12M; //PLL时钟源选择12M晶体
    
  
    SYSCLK->PLLCON.IN_DV    = 2;
    SYSCLK->PLLCON.OUT_DV   = 0;      
    SYSCLK->PLLCON.FB_DV    = 7;   
    SYSCLK->PLLCON.PD = 0;    
    SYSCLK->PLLCON.BP = 0;         
    SYSCLK->PLLCON.OE = 0;                 //启动PLL模式   

    //DrvSYS_SelectPLLSource(E_SYS_EXTERNAL_12M); // 选择12MHz为PLL输入  
    //DrvSYS_Open(27000000)   ;      
    //
    u32clock = DrvSYS_GetPLLClockFreq ( );    
    Delay(10000);             
    DrvSYS_SelectHCLKSource (2);   // Change HCLK clock source to be PLL  
    while(DrvSYS_GetClockSwitchStatus ()!=0);   // Get clock switch flag   
    u32clock = DrvSYS_GetHCLKFreq ( );   // Get current HCLK clock        
    Delay(2);
    */
}

void Delay(UINT delayCnt)
{
    while(delayCnt--)
    {
        __NOP();
        __NOP();
    }
}