rtx430.c

MSP430单片机的实时多任务操作系统c源代码

/*************************************************************************************/
/** Author:linger                                                                   **/
/** Email:[e-mail]                                                          **/
/** This file is part of the 'RTX-430' Real-Time Operating System Source Package    **/
/*************************************************************************************/
/**                                                                                 **/
/** 千万注意：                                                                      **/
/**              在中断程序开始处一定要调用 " RTX_TS|=RTX_TS_DELAY; " 这一语句      **/
/**                                                                                 **/
/*************************************************************************************/

#include  <msp430x14x.h>

#define  TIMESHARING        5        /* 每个任务的最大运行时间       */
#define  RTX_STACKFREE      40       /* 当前任务的最小堆栈空间       */
#define  RTX_MAXTASKN       10       /* 最大任务数                   */
#define  INT_CLOCK          10000    /* 每个定时中断的时钟数         */
#define  RAMBOTTOM          0x300    /* 最大 RAM 数                  */
#define  RAMTOP             0x9FF    /* 最大 RAM 数                  */

#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         /* 进入中断处理程序后，要将 RTX_TS 中的该位置为 1 */

unsigned int    STKP[RTX_MAXTASKN];   /* 指向前一任务堆栈的尾地址 */
unsigned char   RTX_RobinTime;        /* 每个任务最长的运行周期 */
unsigned char   TASK_Current;         /* 当前运行的任务号 */
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 转去错误处理程序 */

     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)     /* 没有任务切换 */
        {
            restore_sr();
            return;
        }

      if(STATE[TASK_Current].time!=RTX_RobinTime) /* 没有任务切换 */
        {
            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;