os_task.c

采用C++改写的uCOS-II,目标系统为MSP430系列CPU。

#ifndef  OS_MASTER_FILE
#include "linos.h"
#endif

/*
*******************************************************************************
*                                     任务产生函数                            *
*******************************************************************************
*/
INT8U OSTaskCreate (void (*task)(void *pd),void *p_arg,OS_STK *ptos,INT8U prio)
{
#if OS_CRITICAL_METHOD == 3
  OS_CPU_SR  cpu_sr;
#endif
  OS_STK    *psp;
  INT8U      err;


#if OS_ARG_CHK_EN > 0 //任务产生优先级检查
  if(prio>OS_LOWEST_PRIO)
  {
    return (OS_PRIO_INVALID);
  }
#endif

  OS_ENTER_CRITICAL(); //中断保护
  
  if(OSTCBPrioTbl[prio]==(OS_TCB *)0) //如果优先级表为空产生任务,否则返回一个错误
  {
    OSTCBPrioTbl[prio] = (OS_TCB *)1; //首先占据空表
                                        
    OS_EXIT_CRITICAL(); //退出中断保护
    
    psp = (OS_STK *)OSTaskStkInit(task, p_arg, ptos, 0);     //初始化任务堆栈
    err = OS_TCBInit(prio,psp); //系统TCB初始化
    if(err == OS_NO_ERR)
    {
      OS_ENTER_CRITICAL();
      OSTaskCtr++;    
      OS_EXIT_CRITICAL();
    
      if (OSRunning == TRUE)  //如果系统已经运行,产生任务时进行调度
      {
        OS_Sched();
      }
    }
    else
    {
      OS_ENTER_CRITICAL();
      OSTCBPrioTbl[prio] = (OS_TCB *)0; //产生任务不成功,释放优先级表
      OS_EXIT_CRITICAL();
    }
    return (err);
  }

  OS_EXIT_CRITICAL();
  return (OS_PRIO_EXIST);
}

/*
*******************************************************************************
*                                任务优先级改变函数                           *
*******************************************************************************
*/
#if OS_TASK_CHANGE_PRIO_EN > 0
INT8U  OSTaskChangePrio (INT8U oldprio, INT8U newprio)
{
#if OS_CRITICAL_METHOD == 3
  OS_CPU_SR    cpu_sr;
#endif
  OS_TCB      *ptcb;
  INT8U        x;
  INT8U        y;
  INT8U        bitx;
  INT8U        bity;
  INT8U        y_old;

#if OS_ARG_CHK_EN > 0  //任务改变优先级检查
  if(oldprio>=OS_LOWEST_PRIO)
  {
   if(oldprio != OS_PRIO_SELF)
   {
      return (OS_PRIO_INVALID);
    }
  }
  if(newprio >= OS_LOWEST_PRIO)
  {
    return (OS_PRIO_INVALID);
  }
#endif

  OS_ENTER_CRITICAL();

  if(OSTCBPrioTbl[newprio] != (OS_TCB *)0) //如果新优先级已经存在,返回错误代码
  {
    OS_EXIT_CRITICAL();
    return (OS_PRIO_EXIST);
  }
   
  if(oldprio == OS_PRIO_SELF)
  {
    oldprio = OSTCBCur->OSTCBPrio; //得到当前优先级
  }
  
  ptcb = OSTCBPrioTbl[oldprio];
  if(ptcb == (OS_TCB *)0) //如果老的优先级任务不存在,返回错误代码
  {
    OS_EXIT_CRITICAL();
     return (OS_PRIO_ERR);
  }
                                         
  y    = newprio >> 3;
  bity = OSMapTbl[y];
  x    = newprio & 0x07;
  bitx = OSMapTbl[x];

  OSTCBPrioTbl[oldprio] = (OS_TCB *)0; //释放老的优先级连表
  OSTCBPrioTbl[newprio] = ptcb;        //设置新的优先级连表
  y_old                 = ptcb->OSTCBY;
  if((OSRdyTbl[y_old] & ptcb->OSTCBBitX) != 0x00) //清除老优先级任务就绪状态
 	{
    OSRdyTbl[y_old] &= ~ptcb->OSTCBBitX;
    if(OSRdyTbl[y_old] == 0x00) //如果老优先级就绪,没有别的任务就绪,清除老优先级就绪组
   	{
      OSRdyGrp &= ~ptcb->OSTCBBitY;
    }
    OSRdyGrp    |= bity; //设置新优先级任务就绪
    OSRdyTbl[y] |= bitx;
  }

  ptcb->OSTCBPrio = newprio; //设置新优先级相关变量
  ptcb->OSTCBY    = y;
  ptcb->OSTCBX    = x;
  ptcb->OSTCBBitY = bity;
  ptcb->OSTCBBitX = bitx;

  OS_EXIT_CRITICAL();
  OS_Sched();
  return (OS_NO_ERR);
}
#endif

/*
*******************************************************************************
*                                任务挂起/恢复函数                            *
*******************************************************************************
*/
#if OS_TASK_SUSPEND_EN > 0
INT8U  OSTaskSuspend (INT8U prio)
{
#if OS_CRITICAL_METHOD == 3
  OS_CPU_SR  cpu_sr;
#endif
  BOOLEAN    self;
  OS_TCB    *ptcb;
  INT8U      y;

#if OS_ARG_CHK_EN > 0  //任务改变优先级检查
  if(prio == OS_IDLE_PRIO)  //不允许挂起空闲任务
  {
    return (OS_TASK_SUSPEND_IDLE);
  }
  if(prio >= OS_LOWEST_PRIO)
  {
    if (prio != OS_PRIO_SELF)
    {
      return (OS_PRIO_INVALID);
    }
  }
#endif
  
  OS_ENTER_CRITICAL();
  if(prio == OS_PRIO_SELF)
  {
    prio = OSTCBCur->OSTCBPrio;
    self = TRUE;
  }
  else if(prio == OSTCBCur->OSTCBPrio)
  {
    self = TRUE;
  }
  else
  {
    self = FALSE;
  }
  
  ptcb = OSTCBPrioTbl[prio];
  if(ptcb == (OS_TCB *)0) //如果为空任务,返回一个错误
  {
    OS_EXIT_CRITICAL();
    return (OS_TASK_SUSPEND_PRIO);
  }
  y            = ptcb->OSTCBY;
  OSRdyTbl[y] &= ~ptcb->OSTCBBitX; //使任务推出就绪状态
  if(OSRdyTbl[y] == 0x00) //如果就绪组中无其他任务,清除就绪组
  { 
    OSRdyGrp &= ~ptcb->OSTCBBitY;
  }
  ptcb->OSTCBStat |= OS_STAT_SUSPEND; //设置任务状态为挂起状态
  OS_EXIT_CRITICAL();
  if(self == TRUE) //如果为自我挂起,则进行调度
  {
    OS_Sched();
  }
  return (OS_NO_ERR);
}

INT8U  OSTaskResume (INT8U prio)
{
#if OS_CRITICAL_METHOD == 3
  OS_CPU_SR  cpu_sr;
#endif
  OS_TCB    *ptcb;

#if OS_ARG_CHK_EN > 0  //任务改变优先级检查
  if(prio >= OS_LOWEST_PRIO)
  {
    return (OS_PRIO_INVALID);
  }
#endif
  
  OS_ENTER_CRITICAL();
  ptcb = OSTCBPrioTbl[prio];
  if(ptcb == (OS_TCB *)0)
  {
    OS_EXIT_CRITICAL();
    return (OS_TASK_RESUME_PRIO);
  }
  if((ptcb->OSTCBStat & OS_STAT_SUSPEND) != OS_STAT_RDY)
  {
    ptcb->OSTCBStat &= ~OS_STAT_SUSPEND;
    if(ptcb->OSTCBStat == OS_STAT_RDY)
    {                      
      if(ptcb->OSTCBDly  == 0) //检查任务延时
      {
        OSRdyGrp               |= ptcb->OSTCBBitY;
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        OS_EXIT_CRITICAL();
        OS_Sched();
      }
      else
      {
        OS_EXIT_CRITICAL();
      }//if(ptcb->OSTCBDly..
    }
    else
    {
      OS_EXIT_CRITICAL();
    }//if(ptcb->OSTCBStat...
    return (OS_NO_ERR);
  }//if((ptcb->OSTCBStat...
  OS_EXIT_CRITICAL();
  return (OS_TASK_NOT_SUSPENDED);
}

#endif