/*************************************************************************************/
/** Author:linger                                                                   **/
/** Email:ling_re@sina.com                                                          **/
/** This file is part of the 'RTX-430' Real-Time Operating System Source Package    **/
/*************************************************************************************/
/**                                                                                 **/
/** 千萬注意：                                                                      **/
/**              在中斷程序開始處一定要調(diào)用 " RTX_TS|=RTX_TS_DELAY; " 這一語句      **/
/**                                                                                 **/
/*************************************************************************************/

#include  <msp430x14x.h>

#define  TIMESHARING        5        /* 每個任務(wù)的最大運(yùn)行時(shí)間       */
#define  RTX_STACKFREE      40       /* 當(dāng)前任務(wù)的最小堆棧空間       */
#define  RTX_MAXTASKN       10       /* 最大任務(wù)數(shù)                   */
#define  INT_CLOCK          10000    /* 每個定時(shí)中斷的時(shí)鐘數(shù)         */
#define  RAMBOTTOM          0x300    /* 最大 RAM 數(shù)                  */
#define  RAMTOP             0x9FF    /* 最大 RAM 數(shù)                  */

#define  RTX_TIMESHARING    (0 - TIMESHARING)
#define  RTX_CLOCK          INT_CLOCK
#define  RTX_RAMBOTTOM      RAMBOTTOM/2*2               
#define  RTX_RAMTOP         RAMTOP/2*2              

#define  K_SIG              1
#define  K_TMO              2
#define  SIG_EVENT          4
#define  TMO_EVENT          8
#define  K_READY            16
#define  K_ACTIVE           32
#define  K_ROBIN            64
#define  K_IVL              128

#define  B_WAITSIG          0
#define  B_WAITTIM          1
#define  B_SIGNAL           2
#define  B_TIMEOUT          3
#define  B_READY            4
#define  B_ACTIVE           5
#define  B_ROBIN            6
#define  B_INTERVAL         7

#define  RTX_TS_REQ         1
#define  RTX_TS_DELAY       2         /* 進(jìn)入中斷處理程序后，要將 RTX_TS 中的該位置為 1 */

unsigned int    STKP[RTX_MAXTASKN];   /* 指向前一任務(wù)堆棧的尾地址 */
unsigned char   RTX_RobinTime;        /* 每個任務(wù)最長的運(yùn)行周期 */
unsigned char   TASK_Current;         /* 當(dāng)前運(yùn)行的任務(wù)號 */
unsigned char   RTX_TS;
unsigned int    RTX_SP;

unsigned int    SAVE_SR;
unsigned int    SAVE_PC;

struct
{
   char  time;
   char  st;
}
STATE[RTX_MAXTASKN];

void timer0_comm(void);
void clear_watchdog(void);
void os_system_init(void);
unsigned char task_switch(void);
unsigned char os_system_start(void);
unsigned char os_delete_task(unsigned char task_no);
unsigned char os_send_signal(unsigned char task_no);
unsigned char isr_send_signal(unsigned char task_no);
unsigned char os_clear_signal(unsigned char task_no);
unsigned char os_wait(unsigned type, unsigned timeout);
unsigned char os_create_task(unsigned int proc_name, unsigned char task_no);

extern int  getsp(void);              // Get Stack Pointer
extern void putsp(int sp_value);      // Get Stack Pointer

extern void save_pop(void);
extern void save_push(void);
extern void restore_sr(void);

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

interrupt [TIMERA0_VECTOR] void WD( void )
{
    unsigned int *i,*j;
    
    clear_watchdog();
    
    i=(unsigned int *)getsp();
    j=i-1;
    putsp((unsigned int)j);
    
    *j=*i;
    j++;
    i++;
    
    *j=*i;
    j++;
    i++;
    
    *j=*i;
    j++;
    i++;
    
    *j=*i;
    j++;
    i++;

    *j=*i;
    j++;
    i++;
    
    *j=*i;
    j++;
    i++;
        
    SAVE_SR=*i;
    *j=*i;
    *i=(unsigned int)timer0_comm;
}


void timer0_comm(void)
{  
     unsigned char i;
     unsigned char stack_free;

//Clear_watchdog:     
     clear_watchdog();
     
//Update_Timer0:
     CCR0+=RTX_CLOCK;

//Chcec_Stack:   /* 堆棧檢查，如果剩余堆棧 <  RTX_STACKFREE 轉(zhuǎn)去錯誤處理程序 */

     stack_free=TASK_Current==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[TASK_Current+1];

     stack_free=getsp()-stack_free;

     if(stack_free<RTX_STACKFREE)
       {
           _DINT();
           while(1)
           {
              /* ************此處加入堆棧溢出處理程序*************** */
           };
       }


//Update_Check_Task_Timers:

      for(i=0;i<RTX_MAXTASKN;i++)
         {
             STATE[i].time--;
             _DINT();
             if((STATE[i].st&K_TMO)&&(STATE[i].time==0))STATE[i].st|=K_READY+TMO_EVENT;
             _EINT();
         }

//Check_Round_Robin_TimeOut:

      if(RTX_TIMESHARING==0)     /* 沒有任務(wù)切換 */
        {
            restore_sr();
            return;
        }

      if(STATE[TASK_Current].time!=RTX_RobinTime) /* 沒有任務(wù)切換 */
        {
            restore_sr();
            return;
        }

      if(RTX_TS&RTX_TS_DELAY)
        {
           RTX_TS|=RTX_TS_REQ;
           restore_sr();
           return;
        }

     save_push();
     
     _DINT();
     STATE[TASK_Current].st|=K_ROBIN;
     _EINT();

     task_switch();
}



unsigned char task_switch(void)
{
     unsigned char i;
     unsigned int *j,*p1,*p2;

     clear_watchdog();
     
     RTX_SP=getsp();
     p1=(unsigned int *)(RTX_SP+8);
     p2=p1-1;
       
     for(i=0;i<4;i++)
        {      
           *p1=*p2;
           p1--;
           p2--;
        }
   
     RTX_SP+=2;
     putsp(RTX_SP);
     j=(unsigned int *)RTX_SP;
       
     RTX_TS|=RTX_TS_DELAY;

     i=TASK_Current;


     while(1)
     {
        if ((++i)==(RTX_MAXTASKN))i=0;
        if (STATE[i].st&K_READY)break;
     }
     
     while(TASK_Current<i)
     {
        TASK_Current++;
        
        p1=(unsigned int *)STKP[TASK_Current];
        p2=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_RAMBOTTOM : STKP[TASK_Current+1]);

        STKP[TASK_Current]=RTX_SP;
        
        while(p1!=p2)
        {
           RTX_SP-=2;
           putsp(RTX_SP);
           j--;
           p1--;
           *j=*p1;
        }
     }

     while(TASK_Current>i)
     {
        p1=(unsigned int *)(TASK_Current==RTX_MAXTASKN ? RTX_SP : STKP[TASK_Current+1]);
        p2=(unsigned int *)STKP[TASK_Current];
        
        while(j!=p2)
        {
           *p1=*j;
           p1++;
           j++;
           RTX_SP+=2;
           putsp(RTX_SP);
        }
        STKP[TASK_Current] = (unsigned int)p1;

        TASK_Current--;
     }

     RTX_RobinTime = STATE[TASK_Current].time + RTX_TIMESHARING;
     
     _DINT();
     
     if(STATE[TASK_Current].st & K_ROBIN)
       {
          _EINT();
          RTX_TS&=~RTX_TS_DELAY;
          RTX_TS&=~RTX_TS_REQ;
          
          save_pop();
          
          return(0x00);
       }

     if((STATE[TASK_Current].st & K_SIG) && (STATE[TASK_Current].st & SIG_EVENT))
       {
          STATE[TASK_Current].st&=0xf0;
          _EINT();
          RTX_TS&=~RTX_TS_DELAY;
          RTX_TS&=~RTX_TS_REQ;
          return(SIG_EVENT);
       }

     if((STATE[TASK_Current].st & K_TMO) && (STATE[TASK_Current].st & TMO_EVENT))
       {
          STATE[TASK_Current].st&=0xf4;
          _EINT();
          RTX_TS&=~RTX_TS_DELAY;
          RTX_TS&=~RTX_TS_REQ;
          return(TMO_EVENT);
       }

     _EINT();
     RTX_TS&=~RTX_TS_DELAY;
     RTX_TS&=~RTX_TS_REQ;
     return(0x00);
}

unsigned char os_wait(unsigned type, unsigned timeout)
{
   unsigned char st = 0;
   
   clear_watchdog();

   if(type==0)
     {
        _DINT();
        STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);
        _EINT();
        return (st);
     }

   TACTL&=~MC1;           

   if(type&K_IVL)
     {
        STATE[TASK_Current].time+=timeout;
        if(!C)
          {
             st = TMO_EVENT;
             _DINT();
             STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);
             _EINT();
             TACTL|=MC1;           
             return (st);
          }
        _DINT();
        STATE[TASK_Current].st |= K_TMO;
        _EINT();
      }

    if(type&K_TMO)
      {
         if(timeout==0)
           {
              st = TMO_EVENT;
              _DINT();
              STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);
              _EINT();
              TACTL|=MC1;           
              return (st);
           }
         STATE[TASK_Current].time = timeout;

         _DINT();
         STATE[TASK_Current].st |= K_TMO;
         _EINT();
      }

    if(type&K_SIG)
      {
         if(STATE[TASK_Current].st&SIG_EVENT)
           {
              st=SIG_EVENT;
              _DINT();
              STATE[TASK_Current].st &= ~ (st | K_SIG | K_TMO);
              _EINT();
              TACTL|=MC1;           
              return (st);
           }
         _DINT();
         STATE[TASK_Current].st |= K_SIG;
         _EINT();
    }

    _DINT();
    STATE[TASK_Current].st &= ~K_READY;
    _EINT();
    
    TACTL|=MC1;