os.c

基于16位单片机的符合osek标准的操作系统

  {
    OSEKOS_COV(17);
    if(OSEKOStermregie == 0){
      OSEKOStaskStatus[OSEKOStidact] ^= (RUNNING^READY);
      OSEKOS_COV(20);
    }
    OSEKOSneuregie = 0;  
    OSEKOSAsmDispatch(OSEKOShighPrio);
  }
  else 
  {
    OSEKOS_COV(21);
    OSEKOSrunprio = PMAX;
    for(p=PMAX ; (p>0) && (OSEKOSpliste[p] >= ATMAX); --p){
      OSEKOS_COV(22);
    }
    if(p==0&&(OSEKOSpliste[0] >= ATMAX))
    {
      TaskType lastTask;
      OSEKOS_COV(23);
      OSEKOSkernel = 1;
      lastTask = OSEKOStidact;
      OSEKOStidact = INVALID_TASK;
      OSEKOS_COV(26);
      while(1)
      {
        OSEKOS_COV(27);
        /* HALT must be possible with locked interrupts,
        if interrupts are open a race contition may
        occur here!
        That means the CPU HALT instruction must be left
        when an interrupt is pending or gets pending.
        In that case the interrupt handler is called
        directly after the OSEKOSEnable() below.
        */
        OSEKOSArchIdle(); 
        OSEKOSEnable();
        /* This is the idle loop. Interrupts must be enabled here.
        * If this is not the case something must have gone wrong.
        * Most probably the Disable/EnableAllInterrupts() or the 
        * Suspend/Resume(OS|All)Interrupts() functions were used
        * incorrectly.
        */
        OSEKOSPossibleInterrupt();
        p = PMAX; 
        OSEKOSDisable();
        for(; (p>0) && (OSEKOSpliste[p] >= ATMAX ); --p){
          OSEKOS_COV(28);
        }
        if ((p!=0) || (OSEKOSpliste[0] < ATMAX)){
          OSEKOS_COV(29);
          break;
        }
      }
      OSEKOStidact = lastTask;
      OSEKOSkernel = 0;
      OSEKOSneuregie = 0;
      OSEKOShighPrio = p;
      OSEKOS_COV(32);
      OSEKOSAsmDispatch(p);
    }
    else
    {
      OSEKOS_COV(35);
      OSEKOShighPrio = p;
      OSEKOSneuregie = 0;  
      OSEKOS_COV(38);
      if(OSEKOSpliste[p] != OSEKOStidact || OSEKOStermregie != 0)
      {
        OSEKOS_COV(39);
        if(OSEKOStermregie == 0){
          OSEKOS_COV(42);
          OSEKOStaskStatus[OSEKOStidact] ^= (RUNNING^READY);
        }
        OSEKOSAsmDispatch(p);
      }
      else{
        OSEKOSrunprio = p; 
        OSEKOS_COV(45);
      }
    }
  }
  OSEKOS_COV(46);
}
StatusType OSEKOSReturn(StatusType s)
{  
  OSEKOS_COV(57);
  OSEKOSEnable();
  return s;
}
void OSEKOSShutdownOS(register StatusType s)
{  
  OSEKOS_COV(59);
  OSEKOSDisable();
# ifdef INCLUDE_OSEKTIME
  {
    extern volatile char ttOSEKOSRunning;
    ttOSEKOSRunning=0;
  }
# endif 
  while(1);
}
#define TskAnker (OSEKOStaskTKette[TMAX]) 
StatusType OSEKOSActivateTask(register TaskType tid)
{  register OSEKOSPrioType pid;
  register TaskStateType lastState;
  OSEKOS_COV(61);
  lastState = OSEKOStaskStatus[tid];
  OSEKOS_COV(62);
  pid = OSEKOStaskPrio[tid];
  OSEKOS_COV(63);
  if((OSEKOStaskStatus[tid]&TSTATBITS) != SUSPENDED)
  {
    OSEKOS_COV(64);
    OSEKOS_COV(69);
    return(E_OS_LIMIT);
  }
  else
  {
    OSEKOS_COV(70);
    OSEKOStaskStatus[tid] ^= ((READY^SUSPENDED)|SETSTART);
  }
  {
    OSEKOS_COV(75);
    rtact = OSEKOSpliste[pid];  
    if( (lastState&(READY | RUNNING)) || rtact < ATMAX )
    {
      register OSEK_U8 p;
      OSEKOS_COV(76);
      while(OSEKOStaskTKette[rtact] < ATMAX){
        rtact = OSEKOStaskTKette[rtact];
        OSEKOS_COV(77);
      }
      {  
        OSEKOS_COV(81);
        OSEKOStaskTKette[rtact] = tid;
        OSEKOStaskTKette[tid] = ATMAX;
      }
    }
    else
    {  
      OSEKOS_COV(85);
      OSEKOSpliste[pid] = tid;
      if(pid > OSEKOSrunprio) 
      {
        OSEKOS_COV(86);
        OSEKOSSETneuregie(1);
        if ((pid) > OSEKOShighPrio){
          OSEKOShighPrio = pid;
          OSEKOS_COV(87);
        }
      }
    }
  }
  OSEKOS_COV(94);
  return(E_OK);
}
void OSEKOSTerminateTask(TaskType tact,TaskType tid)
{  
  OSEKOS_COV(95);
  OSEKOS_COV(103);
  OSEKOSpliste[OSEKOSrunprio] = OSEKOStaskTKette[tact];
  OSEKOStaskTKette[tact] = ATMAX;
  OSEKOStaskStatus[tact] ^= (RUNNING^SUSPENDED);
  tact = tid;
  if(tact < (TMAX+1)){
    OSEKOS_COV(105);
    OSEKOSActivateTask(tact);
  }
  OSEKOStermregie = OSEK_TASK_TERMINATION; 
}
StatusType OSEKOSGetResource(register ResourceType rid)
{
  OSEKOS_COV(153);
  if((OSEKOSresPrio[rid] < OSEKOStaskPrio[OSEKOStidact]) || 
  (OSEKOSresTaskPrio[rid] != OSEKOS_INVALID_PRIO)){    
    OSEKOS_COV(154);
    return(E_OS_ACCESS);
  }
  OSEKOS_COV(155);
  OSEKOS_COV(156);
  OSEKOS_COV(157);
  ++OSEKOStaskResCounter[OSEKOStidact];
  OSEKOSresLIFOindex++;     
  OSEKOSresLIFO[OSEKOSresLIFOindex]=rid;		
  OSEKOSresTaskPrio[rid] = OSEKOSrunprio;
  rid = OSEKOSresPrio[rid];
  if(rid > OSEKOSrunprio)
  {  
    OSEKOS_COV(158);
    OSEKOS_COV(159);
    OSEKOS_COV(161);
    OSEKOSpliste[OSEKOSrunprio] = OSEKOStaskTKette[OSEKOStidact];
    OSEKOStaskTKette[OSEKOStidact] = OSEKOSpliste[rid];
    OSEKOSpliste[OSEKOSrunprio = rid] = OSEKOStidact;
  }
  OSEKOS_COV(163);
  OSEKOSSETneuregie(2);
  OSEKOS_COV(164);
  return(E_OK);
}
StatusType OSEKOSReleaseResource(register ResourceType rid)
{
  register OSEKOSPrioType p;
  OSEKOS_COV(190);
  if(OSEKOSresLIFO[OSEKOSresLIFOindex]!=rid){	
    OSEKOS_COV(191);
    return(E_OS_NOFUNC);
  }
  if(((rid = OSEKOSresTaskPrio[p = rid]) == OSEKOS_INVALID_PRIO)){  
    OSEKOS_COV(192);
    return(E_OS_NOFUNC);
  }
  if((OSEKOSresPrio[p] < OSEKOStaskPrio[OSEKOStidact])){  
    OSEKOS_COV(193);
    return(E_OS_ACCESS);
  }
  --OSEKOStaskResCounter[OSEKOStidact];
  OSEKOSresTaskPrio[p] = OSEKOS_INVALID_PRIO;  
  OSEKOSresLIFOindex--;			
  if(rid < OSEKOSrunprio)
  {  
    OSEKOS_COV(195);
    OSEKOS_COV(196);
    OSEKOS_COV(198);
    OSEKOSpliste[OSEKOSrunprio] = OSEKOStaskTKette[OSEKOStidact];
    OSEKOStaskTKette[OSEKOStidact] = OSEKOSpliste[rid];
    OSEKOSpliste[rid] = OSEKOStidact;
    OSEKOSrunprio = rid;
    OSEKOSSETneuregie(2);
  }
  OSEKOS_COV(200);
  return(E_OK);
}
StatusType OSEKOSSetAbsAlarm(AlarmType a, TickType b, TickType c)
{
  OSEKOS_COV(202);
  OSEKOSDisable();
  if (OSEKOSca_kette[a]!=a)
  {
    OSEKOS_COV(206);
    OSEKOSEnable();
    return (E_OS_STATE);
  }
  if (b>=OSEKOSc_atic[OSEKOSa_counter[a]])
  {
    OSEKOS_COV(207);
    b-=OSEKOSc_atic[OSEKOSa_counter[a]];
  }
  else 
  {
    OSEKOS_COV(208);
    b+=OSEKOSc_maxtick[0]-OSEKOSc_atic[OSEKOSa_counter[a]]+1;
  }
  OSEKOSSetAlarm(a,b,c);
  OSEKOSEnable();
  return E_OK;
}
void OSEKOSSetAlarm(AlarmType aid,TickType OSEKOStmpIWert,TickType OSEKOStmpZWert)
{
  OSEKOS_COV(212);
  OSEKOS_COV(213);
  aprev = (AlarmType)AMAX_STD;
  if(OSEKOStmpIWert==0){
    OSEKOStmpIWert=OSEKOSc_maxtick[0]+1;
    OSEKOS_COV(214);
  }
  while((anext = OSEKOSca_kette[aprev]) < AMAX_STD)
  {  
    OSEKOS_COV(217);
    if(OSEKOSa_startw[anext] > OSEKOStmpIWert)
    {  
      OSEKOS_COV(218);
      OSEKOSa_startw[anext] -= OSEKOStmpIWert;
      break;
    }
    OSEKOStmpIWert -= OSEKOSa_startw[anext];
    aprev = anext;
  }
  OSEKOS_COV(219);
  OSEKOSca_kette[aid] = anext;
  OSEKOSca_kette[aprev] = aid;
  OSEKOSa_startw[aid] = OSEKOStmpIWert;
  OSEKOSa_zykw[aid] = OSEKOStmpZWert;
}
TickType OSEKOSGetAlarm(register AlarmType aid)
{  
  TickType OSEKOStmpIWert = 0;
  OSEKOS_COV(220);
  if(OSEKOSca_kette[aid] != aid)
  {  
    OSEKOS_COV(221);
    OSEKOS_COV(222);
    aprev = OSEKOSca_kette[AMAX_STD];
    OSEKOS_COV(224);
    for( ; ; aprev = OSEKOSca_kette[aprev])
    {  
      OSEKOS_COV(225);
      OSEKOStmpIWert += OSEKOSa_startw[aprev];
      if(aprev == aid){
        OSEKOS_COV(226);
        break;
      }
    }
    OSEKOS_COV(227);
  }
  return(OSEKOStmpIWert);
}
StatusType OSEKOSCancelAlarm(register AlarmType aid)
{  
  OSEKOS_COV(228);
  if(OSEKOSca_kette[aid] == aid){
    OSEKOS_COV(229);
    return(E_OS_NOFUNC);  
  }
  OSEKOS_COV(230);
  for(
  aprev = (AlarmType)AMAX_STD;
  (anext = OSEKOSca_kette[aprev]) != aid; aprev = anext)
  OSEKOS_COV(231);
  if((anext = OSEKOSca_kette[aid]) < AMAX_STD){
    OSEKOS_COV(232);
    OSEKOSa_startw[anext] += OSEKOSa_startw[aid];
  }
  OSEKOSca_kette[aprev] = anext;
  OSEKOSca_kette[aid] = aid;
  return(E_OK);
}
void OSEKOSAdvCntr(void)
{  
  register AlarmType aid;
  register TickType OSEKOStmpIWert;
  OSEKOS_COV(248);
  do
  {
    OSEKOS_COV(249);
    aid = OSEKOSca_kette[AMAX_STD];
    { 
      OSEKOS_COV(261);
      OSEKOS_COV(267);
      OSEKOSActivateTask(OSEKOSa_task[aid]);
    }
    OSEKOS_COV(268);
    OSEKOSca_kette[AMAX_STD] = OSEKOSca_kette[aid];
    OSEKOSca_kette[aid] = aid;
    if(OSEKOSa_zykw[aid] != 0)
    {
      OSEKOS_COV(270);
      OSEKOStmpIWert = OSEKOSa_zykw[aid];
      OSEKOS_COV(271);
      aprev = (AlarmType)AMAX_STD;
      while((anext = OSEKOSca_kette[aprev]) < AMAX_STD)
      {  
        OSEKOS_COV(273);
        if(OSEKOSa_startw[anext] > OSEKOStmpIWert)
        {  
          OSEKOS_COV(274);
          OSEKOSa_startw[anext] -= OSEKOStmpIWert;
          break;
        }
        OSEKOStmpIWert -= OSEKOSa_startw[anext];
        aprev = anext;
      }
      OSEKOS_COV(275);
      OSEKOSca_kette[aid] = anext;
      OSEKOSca_kette[aprev] = aid;
      OSEKOSa_startw[aid] = OSEKOStmpIWert;
    }
    OSEKOSEnable();
    OSEKOSDisable();
  }
  while(OSEKOSa_startw[OSEKOSca_kette[AMAX_STD]]==0);
  OSEKOS_COV(276);
}
# ifdef INCLUDE_RealOSEKFunctions
StatusType ActivateTask(TaskType A) { return ___ActivateTask(A); }
StatusType TerminateTask(void){ return ___TerminateTask();}
StatusType ChainTask(TaskType A) { return ___ChainTask(A);}
StatusType GetTaskState(TaskType A,TaskStateRefType B) {return ___GetTaskState(A,B);}
StatusType GetTaskID(TaskRefType A) {return ___GetTaskID(A);}
StatusType Schedule(void) { return ___Schedule();}
StatusType GetResource(ResourceType A) {return ___GetResource(A);}
StatusType ReleaseResource(ResourceType A) {return ___ReleaseResource(A);}
StatusType SetEvent(TaskType A,EventMaskType B) {return ___SetEvent(A,B);}
StatusType ClearEvent(EventMaskType A) { return ___ClearEvent(A);}
StatusType WaitEvent(EventMaskType A) {return ___WaitEvent(A);}
StatusType GetEvent(TaskType A,EventMaskRefType B) {return ___GetEvent(A,B);}
StatusType GetAlarm(AlarmType A, TickRefType B) {return ___GetAlarm(A,B);}
StatusType GetAlarmBase(AlarmType A,AlarmBaseRefType B) {return ___GetAlarmBase(A,B);}
StatusType SetRelAlarm(AlarmType A,TickType B,TickType C) {return ___SetRelAlarm(A,B,C);}
StatusType SetAbsAlarm(AlarmType A,TickType B,TickType C) {return ___SetAbsAlarm(A,B,C);}
StatusType CancelAlarm(AlarmType A) {return ___CancelAlarm(A);}
StatusType AdvCntr(CounterType A)    {return ___AdvCntr(A);}
StatusType IAdvCntr(CounterType A)   {return ___IAdvCntr(A);}
void SuspendOSInterrupts(void) {___SuspendOSInterrupts();}
void ResumeOSInterrupts(void)  {___ResumeOSInterrupts();}
void SuspendAllInterrupts(void){___SuspendAllInterrupts();}
void ResumeAllInterrupts(void) {___ResumeAllInterrupts();}
void DisableAllInterrupts(void){___DisableAllInterrupts();}
void EnableAllInterrupts(void) {___EnableAllInterrupts();}
# endif
#define __SET_INDEX(A)  (((OSEKOSinintr==0)&&(OSEKOStidact<TMAX))?(A=OSEKOStidact):(A=TMAX))
# ifdef INCLUDE_RealOSEKFunctions 
AppModeType GetActiveApplicationMode(void)
{
  return OSEKOSapplicationMode;
}
void main(void);
void OSEKOSUserMain(void);
void StartOS(AppModeType a)
{
  OSEKOSapplicationMode = a;
  main();
}
# endif 
# if (defined(__HIWARE__))
# if (defined(__BANKED__))
# pragma CODE_SEG NON_BANKED 
# pragma CONST_SEG CONST_NON_BANKED 
# endif 
# endif 
extern void OSEKOSSystem(void);
unsigned char OSEKOSneuregie = 0;
unsigned char OSEKOSinintr = 0;
OSEKOSSaveType  OSEKOSisrInterruptedTaskStackPointer;
const unsigned short * OSEKOSisrStackPointer = (const unsigned short *) (&OSEKOSstacks.interrupt_stack[OSEKOS_STARTOF_ISRSTACK]);
unsigned char OSEKOSoldCCR = 0;