eRTK.h File Reference

#include <avr/io.h>
#include <stddef.h>
#include <util/atomic.h>
#include <avr/interrupt.h>

Include dependency graph for eRTK.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	t_eRTK_tcb

Macros
#define	VANZTASK   6
#define	F_CPU   16000000ul
#define	eRTKHZ   1000
#define	TIMERPREDIV   64ul
#define	TIMERPRELOAD   ( F_CPU/( TIMERPREDIV*eRTKHZ ) )
#define	ERTKDEBUG
#define	eRTK_STARTUP_MS   0
#define	eRTK_MAX_OVERLOAD   0
#define	ERTK_STACKSIZE   256
#define	IDLELED
#define	sbi(port, nr)   (port|=_BV(nr))
#define	cbi(port, nr)   (port&=~_BV(nr))
#define	oIDLE(a)   { ( a ) ? sbi( PORTE, PE2 ) : cbi( PORTE, PE2 ); sbi( DDRE, PE2 ); }
#define	oIDLEfast(a)   { ( a ) ? sbi( PORTE, PE2 ) : cbi( PORTE, PE2 ); }

Enumerations
enum	tsys {   SYS_NOTASK, SYS_NULLPTR, SYS_NULLTIMER, SYS_OVERLOAD,   SYS_VERIFY, SYS_UNKNOWN }

Functions
void	deadbeef (tsys reason)
void	__attribute__ ((naked)) eRTK_scheduler(void)
uint8_t	eRTK_GetTimer8 (void)
uint16_t	eRTK_GetTimer16 (void)
uint8_t	eRTK_GetTid (void)
void	eRTK_SetReady (uint8_t tid)
void	eRTK_SetSuspended (uint8_t tid)
void	eRTK_WaitUntil (uint8_t then)
void	eRTK_Sleep_ms (uint16_t ms)
void	eRTK_get_sema (uint8_t semaid)
void	eRTK_wefet (uint8_t timeout)
void	eRTK_init (void)
void	eRTK_timer_init (void)
void	eRTK_go (void)

Variables
const t_eRTK_tcb	rom_tcb [VANZTASK]

Macro Definition Documentation

#define cbi	(		port,
			nr
	)		(port&=~_BV(nr))

Definition at line 38 of file eRTK.h.

#define eRTK_MAX_OVERLOAD   0

Definition at line 30 of file eRTK.h.

#define ERTK_STACKSIZE   256

Definition at line 32 of file eRTK.h.

#define eRTK_STARTUP_MS   0

Definition at line 29 of file eRTK.h.

#define ERTKDEBUG

Definition at line 27 of file eRTK.h.

#define eRTKHZ   1000

Definition at line 19 of file eRTK.h.

#define F_CPU   16000000ul

Definition at line 17 of file eRTK.h.

#define IDLELED

Definition at line 34 of file eRTK.h.

#define oIDLE

(

a

)

{ ( a ) ? sbi( PORTE, PE2 ) : cbi( PORTE, PE2 ); sbi( DDRE, PE2 ); }

Definition at line 41 of file eRTK.h.

#define oIDLEfast

(

a

)

{ ( a ) ? sbi( PORTE, PE2 ) : cbi( PORTE, PE2 ); }

Definition at line 42 of file eRTK.h.

#define sbi	(		port,
			nr
	)		(port|=_BV(nr))

Definition at line 37 of file eRTK.h.

#define TIMERPREDIV   64ul

Definition at line 20 of file eRTK.h.

#define TIMERPRELOAD   ( F_CPU/( TIMERPREDIV*eRTKHZ ) )

Definition at line 21 of file eRTK.h.

#define VANZTASK   6

Definition at line 15 of file eRTK.h.

Enumeration Type Documentation

enum tsys

Enumerator
SYS_NOTASK
SYS_NULLPTR
SYS_NULLTIMER
SYS_OVERLOAD
SYS_VERIFY
SYS_UNKNOWN

Definition at line 50 of file eRTK.h.

{ SYS_NOTASK, SYS_NULLPTR, SYS_NULLTIMER, SYS_OVERLOAD, SYS_VERIFY, SYS_UNKNOWN } tsys; 

Function Documentation

void __attribute__

(

(naked)

)

Definition at line 115 of file eRTK.c.

                                                    { /* start der hoechstprioren ready task, notfalls idle */
  push();
  stackptr[akttask]=pp_stack;
  //
  if( pTaskRdy ) { //da muss natuerlich immer was drinstehen ;)
    //do round robin bei mehreren mit gleicher prio
    s_tcd *p=pTaskRdy;
    while( p->tid != akttask ) {
      p=p->pnext; //finde aktuelle task
      if( !p ) break;
     }
    if( p ) { //task stand noch in der ready liste
      //teste pri des nachfolgers
      if( p->pnext!=NULL ) { //wenn es nachfolger gibt
        if( p->prio == p->pnext->prio ) { //schalte weiter wenn nachfolger prio genauso ist
          akttask=p->pnext->tid;
         }
        else {
          akttask=pTaskRdy->tid;
         }
       }
      else { //sonst nimm den ersten in der liste, der muss per definition die gleiche prio haben da wir bei kleineren prios gar nicht suchen !
        akttask=pTaskRdy->tid;
       }
     }
    else akttask=pTaskRdy->tid; //nimm das erstbeste aus der ready liste ;)
   }
  else deadbeef( SYS_NOTASK );
  //
  pp_stack=stackptr[akttask];
  pop();
  sei();
  asm volatile ( "ret" );
 }

Here is the call graph for this function:

void deadbeef

(

tsys

reason

)

Here is the caller graph for this function:

void eRTK_get_sema

(

uint8_t

semaid

)

Definition at line 309 of file eRTK.c.

                                     { /* Warten bis Semaphore frei ist und danach besetzen */
  if( semaid>=ANZSEMA ) deadbeef( SYS_UNKNOWN );
  while( xch( &sema[semaid], 1 ) ) { /* >0 = sema blockiert */
    sei();
    eRTK_wefet( 1 );
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

uint8_t eRTK_GetTid

(

void

)

Definition at line 233 of file eRTK.c.

                            { //holen der eigenen task id
  return akttask;
 }

Here is the caller graph for this function:

uint16_t eRTK_GetTimer16

(

void

)

Definition at line 461 of file eRTK.c.

                                 { //wenn 256ms nicht reichen
  register uint16_t val;
  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {     
    val=eRTK_m_timer.timer16;
   }
  return val;
 }

uint8_t eRTK_GetTimer8

(

void

)

Definition at line 457 of file eRTK.c.

                               { //256ms bis overflow
  return eRTK_m_timer.timer8[0];
 }

Here is the caller graph for this function:

void eRTK_go

(

void

)

Definition at line 151 of file eRTK.c.

                     { /* start der hoechstprioren ready task, notfalls idle */
  if( pTaskRdy ) akttask=pTaskRdy->tid;
  else deadbeef( SYS_NOTASK );
  //
  eRTK_up=1;
  pp_stack=stackptr[akttask];
  pop();
  asm volatile( "ret" );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void eRTK_init

(

void

)

Definition at line 371 of file eRTK.c.

                       { /* Initialisierung der Daten des Echtzeitsystems */
  uint8_t n, prio, index;
  uint8_t task;
  //
  for( n=0; n<VANZTASK+1; n++ ) {
    tcd[n].pnext=NULL; /* verkettung der tcd's in unsortiertem grundzustand */
    tcd[n].pbefore=NULL;
    tcd[n].tid=n;
    tcd[n].prio=n ? rom_tcb[n-1].prio : 0; //idle task ist immer da mit pri 0
    tcd[n].timer=0;
    //die parameter merken zum debuggen
#ifdef ERTK_DEBUG
    tcd[n].param0= n ? 0 : rom_tcb[n-1].param0;
    tcd[n].param1= n ? 0 : rom_tcb[n-1].param1;
#endif
   }
  //einsetzen der idle task, die muss immer da sein !
  pTaskRdy=( s_tcd * )&tcd[0];
  pTaskRdy->pnext=NULL;
  pTaskRdy->pbefore=NULL;
  /* einsortieren der tasks mit verkettung nach absteigender prioritaet */
  char hit[VANZTASK+1];
  memset( hit, 0, sizeof hit );
  for( task=1; task<VANZTASK+1; task++ ) {
    prio=0;
    index=0;
    for( n=1; n<VANZTASK+1; n++ ) { //hoechstpriore ready und noch nicht verkettete task finden
      if( tcd[n].prio>=prio && !hit[n] ) { /* prio>prio und noch nicht in liste */
        prio=tcd[n].prio;
        index=n;
       }
     }
    eRTK_SetReady( index ); //pTaskReady -> tcdx -> txdy -> 0
    hit[index]=1;
   }
  //
  for( n=0; n<VANZTASK+1; n++ ) { /* SP der Tasks auf jeweiliges Stackende setzen */
    for( uint16_t f=0; f<ERTK_STACKSIZE/4; f++ ) memcpy( stack[n]+4*f, "\xde\xad\xbe\xef", 4 );
    //memcpy( &stack[n][214], "0123456789abcdef0123456789ABCDEF", 32 );
    /* startadressen und parameter auf den stack */
    stack[n][ERTK_STACKSIZE-9]=0; //r1=0
    //
    union {
      uint32_t ui32;
      uint8_t ui8[4];
      void ( *task )( uint16_t param0, void *param1 );
      void ( *tvoid )( void );
      void ( *tbeef )( tsys );
     } taddr;
    memset( &taddr, 0, sizeof taddr );
    taddr.tbeef=deadbeef;
    stack[n][ERTK_STACKSIZE-1]=taddr.ui8[0];
    stack[n][ERTK_STACKSIZE-2]=taddr.ui8[1];
    stack[n][ERTK_STACKSIZE-3]=taddr.ui8[2];
    if( n ) taddr.task=rom_tcb[n-1].task;
    else taddr.tvoid=eRTK_Idle;
    stack[n][ERTK_STACKSIZE-4]=taddr.ui8[0];
    stack[n][ERTK_STACKSIZE-5]=taddr.ui8[1];
    stack[n][ERTK_STACKSIZE-6]=taddr.ui8[2];
    //
    //                      hi  lo         hi  lo
    //zwei parameter in p0=r25:r24 und p1=r23:r22
    if( n ) {
      stack[n][ERTK_STACKSIZE-32]=rom_tcb[n-1].param0&0xff;
      stack[n][ERTK_STACKSIZE-33]=rom_tcb[n-1].param0>>8;
      stack[n][ERTK_STACKSIZE-30]=( uint16_t )( rom_tcb[n-1].param1 )&0xff;
      stack[n][ERTK_STACKSIZE-31]=( uint16_t )( rom_tcb[n-1].param1 )>>8;
     }
    //
    stackptr[n]=&stack[n][ERTK_STACKSIZE-40];
   }
  sema_init();
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void eRTK_SetReady

(

uint8_t

tid

)

Definition at line 238 of file eRTK.c.

                                  {
  if( !tid ) deadbeef( SYS_NULLPTR ); //idle task ist immer ready
  if( tcd[tid].pnext || tcd[tid].pbefore ) deadbeef( SYS_VERIFY ); //war gar nicht suspendiert
  //
  s_tcd *pthis=pTaskRdy;
  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
    tcd[tid].timer=0; //timer loeschen damit er nicht spaeter nochmal startet
    do { //pthis->hoechstprioren tcd oder idle
      if( tcd[tid].prio > pthis->prio || pthis->pnext==NULL ) { //neuer eintrag hat hoehere prio oder es gibt keinen nachfolger
        insertat( pthis, &tcd[tid] );
        break;
       }
     } while( ( pthis=pthis->pnext ) );
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void eRTK_SetSuspended

(

uint8_t

tid

)

Definition at line 255 of file eRTK.c.

                                      { //tcd[tid] aus der ready list austragen
  if( !tid ) deadbeef( SYS_NULLPTR ); //idle task darf nicht suspendiert werden
  if( !tcd[tid].pbefore && !tcd[tid].pnext ) deadbeef( SYS_VERIFY ); //war nicht in ready list
  s_tcd *pthis=pTaskRdy;
  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
    do {
      if( pthis->tid==tid ) {
        removeat( pthis );
        break;
       }
     } while( ( pthis=pthis->pnext ) );
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void eRTK_Sleep_ms

(

uint16_t

ms

)

Definition at line 280 of file eRTK.c.

                                  {
  while( ms ) {
    if( ms>255 ) { 
      eRTK_wefet( 255 ); 
      ms-=255; 
     }
    else {
      eRTK_wefet( ms );
      ms=0;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void eRTK_timer_init

(

void

)

Definition at line 515 of file eRTK.c.

                             {
#if defined (__AVR_ATmega2560__)
  timer0_init();
#elif defined (__AVR_ATxmega128A1U__)
#endif
 }

Here is the caller graph for this function:

void eRTK_WaitUntil

(

uint8_t

then

)

Definition at line 469 of file eRTK.c.

                                    {
  eRTK_wefet( then-eRTK_GetTimer8() );
 }

Here is the call graph for this function:

void eRTK_wefet

(

uint8_t

timeout

)

Definition at line 269 of file eRTK.c.

                                   {
  if( timeout ) { //sonst klinkt sich die task in einem wait_until() fuer immer aus
    ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) { //14+2=16 cycles pro loop -> 16MHz -> 1000 inc/ms
      if( tcd[akttask].timer ) deadbeef( SYS_UNKNOWN );
      tcd[akttask].timer=timeout;
      eRTK_SetSuspended( akttask );
      eRTK_scheduler();
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

const t_eRTK_tcb rom_tcb[VANZTASK]

Definition at line 90 of file main.c.