eRTK
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
Data Structures | Macros | Typedefs | Functions | Variables
eRTK.c File Reference
#include <avr/io.h>
#include <avr/interrupt.h>
#include <string.h>
#include <stdio.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
#include "eRTK.h"
#include "adc.h"
Include dependency graph for eRTK.c:

Go to the source code of this file.

Data Structures

struct  s_tcd
 

Macros

#define push()
 
#define pop()
 
#define ANZSEMA   10
 

Typedefs

typedef struct s_tcd s_tcd
 

Functions

uint8_t stack[VANZTASK+1][ERTK_STACKSIZE] __attribute__ ((aligned(256)))
 
void __attribute__ ((optimize("O2")))
 
 __attribute__ ((noinline))
 
void __attribute__ ((naked))
 
void eRTK_go (void)
 
uint8_t eRTK_GetTid (void)
 
void eRTK_SetReady (uint8_t tid)
 
void eRTK_SetSuspended (uint8_t tid)
 
void eRTK_wefet (uint8_t timeout)
 
void eRTK_Sleep_ms (uint16_t ms)
 
void eRTK_get_sema (uint8_t semaid)
 
void eRTK_free_sema (uint8_t semaid)
 
void sema_init (void)
 
void eRTK_init (void)
 
uint8_t eRTK_GetTimer8 (void)
 
uint16_t eRTK_GetTimer16 (void)
 
void eRTK_WaitUntil (uint8_t then)
 
__inline__ void __attribute__ ((always_inline))
 
void eRTK_timer_init (void)
 

Variables

void * stackptr [VANZTASK+1]
 
volatile uint8_t akttask
 
s_tcd tcd [VANZTASK+1]
 
s_tcd * pTaskRdy
 
volatile uint8_t eRTK_up
 
volatile uint16_t eRTK_perfcount
 
volatile uint16_t eRTK_perfcounter [256]
 
volatile uint8_t eRTK_iperf
 
volatile uint16_t eRTK_ticks
 
volatile uint8_t eRTK_cnt_overload
 
void * pp_stack
 
push r0 npush r1 npush r2
npush r3 npush r4 npush r5
npush r6 npush r7 npush r8
npush r9 npush r10 npush r11
npush r12 npush r13 npush r14
npush r15 npush r16 npush r17
npush r18 npush r19 npush r20
npush r21 npush r22 npush r23
npush r24 npush r25 npush r26
npush r27 npush r28 npush r29
npush r30 npush r31 n in 		r0
 
push r0 npush r1 npush r2
npush r3 npush r4 npush r5
npush r6 npush r7 npush r8
npush r9 npush r10 npush r11
npush r12 npush r13 npush r14
npush r15 npush r16 npush r17
npush r18 npush r19 npush r20
npush r21 npush r22 npush r23
npush r24 npush r25 npush r26
npush r27 npush r28 npush r29
npush r30 npush r31 n in
__SP_L__ n sts r0 n in
__SP_H__ n sts r0 		n
 
union {
   volatile uint8_t   timer8 [2]
 
   volatile uint16_t   timer16
 
} eRTK_m_timer
 

Macro Definition Documentation

#define ANZSEMA   10

Definition at line 294 of file eRTK.c.

#define pop ( )
Value:
{ \
asm volatile ( \
"lds r0, pp_stack \n" \
"out __SP_L__, r0 \n" \
"lds r0, pp_stack+1\n" \
"out __SP_H__, r0\n" \
/*pop r31..sreg*/ \
"pop r31\npop r30\npop r29\npop r28\npop r27\npop r26\npop r25\npop r24\npop r23\npop r22\npop r21\npop r20\npop r19\npop r18\npop r17\npop r16\npop r15\npop r14\npop r13\npop r12\npop r11\npop r10\npop r9\npop r8\npop r7\npop r6\npop r5\npop r4\npop r3\npop r2\npop r1\npop r0\n" \
"out __SREG__, r0\n" \
"pop r0\n"/*pop r0*/ \
"sei\n" \
); \
}

Definition at line 101 of file eRTK.c.

#define push ( )
Value:
{ \
asm volatile ( \
"push r0\n"/*push r0*/ \
"in r0, __SREG__\n" \
"cli\n" /*push sreg, push r1..r31 */\

Definition at line 87 of file eRTK.c.

Typedef Documentation

typedef struct s_tcd s_tcd

Function Documentation

uint8_t stack [VANZTASK+1][ERTK_STACKSIZE] __attribute__ ( (aligned(256))  )
void __attribute__ ( (optimize("O2"))  )

Definition at line 59 of file eRTK.c.

59  {
60 #ifdef ERTKDEBUG
61  while( 1 ) { //14+2=16 cycles pro loop -> 16MHz -> 1000 inc/ms
62  cli(); //cli=1clock
63  ++eRTK_perfcount; //lds,lds,adiw,sts,sts=5x2clocks
64  sei(); //sei=1clock
65  oIDLEfast( 1 ); //2 cycles fuer 2xnop oder ein output bit setzen
66  } //rjmp=2clocks
67 #else
68  while( 1 ) {
69  set_sleep_mode( SLEEP_MODE_IDLE );
70  sleep_enable();
71  sei();
72  oIDLE( 1 );
73  sleep_cpu();
74  sleep_disable();
75  }
76 #endif
77  }
eRTK_perfcount
volatile uint16_t eRTK_perfcount
Definition: eRTK.c:53
oIDLEfast
#define oIDLEfast(a)
Definition: eRTK.h:42
oIDLE
#define oIDLE(a)
Definition: eRTK.h:41
__attribute__ ( (noinline)  )

Definition at line 80 of file eRTK.c.

80  {
81  while( 1 );
82  }
void __attribute__ ( (naked)  )

Definition at line 115 of file eRTK.c.

115  { /* start der hoechstprioren ready task, notfalls idle */
116  push();
117  stackptr[akttask]=pp_stack;
118  //
119  if( pTaskRdy ) { //da muss natuerlich immer was drinstehen ;)
120  //do round robin bei mehreren mit gleicher prio
121  s_tcd *p=pTaskRdy;
122  while( p->tid != akttask ) {
123  p=p->pnext; //finde aktuelle task
124  if( !p ) break;
125  }
126  if( p ) { //task stand noch in der ready liste
127  //teste pri des nachfolgers
128  if( p->pnext!=NULL ) { //wenn es nachfolger gibt
129  if( p->prio == p->pnext->prio ) { //schalte weiter wenn nachfolger prio genauso ist
130  akttask=p->pnext->tid;
131  }
132  else {
133  akttask=pTaskRdy->tid;
134  }
135  }
136  else { //sonst nimm den ersten in der liste, der muss per definition die gleiche prio haben da wir bei kleineren prios gar nicht suchen !
137  akttask=pTaskRdy->tid;
138  }
139  }
140  else akttask=pTaskRdy->tid; //nimm das erstbeste aus der ready liste ;)
141  }
142  else deadbeef( SYS_NOTASK );
143  //
144  pp_stack=stackptr[akttask];
145  pop();
146  sei();
147  asm volatile ( "ret" );
148  }
s_tcd::tid
uint8_t tid
Definition: eRTK.c:30
s_tcd
Definition: eRTK.c:27
pTaskRdy
s_tcd * pTaskRdy
Definition: eRTK.c:40
s_tcd::pnext
struct s_tcd * pnext
Definition: eRTK.c:28
pp_stack
void * pp_stack
Definition: eRTK.c:85
deadbeef
void deadbeef(tsys reason)
akttask
volatile uint8_t akttask
Definition: eRTK.c:24
stackptr
void * stackptr[VANZTASK+1]
Definition: eRTK.c:22
push
#define push()
Definition: eRTK.c:87
s_tcd::prio
uint8_t prio
Definition: eRTK.c:31
pop
#define pop()
Definition: eRTK.c:101

Here is the call graph for this function:

__inline__ void __attribute__ ( (always_inline)  )

Definition at line 474 of file eRTK.c.

474  { //damit im irq alle register gesichert werden
475  oIDLE( 0 );
476  if( eRTK_ticks<65535u ) ++eRTK_ticks;
477  ++eRTK_m_timer.timer16;
478  s_tcd *p=tcd;
479  //timer service
480  for( uint8_t n=0; n<VANZTASK+1; n++ ) {
481  if( p->timer ) {
482  if( !--p->timer ) {
483  eRTK_SetReady( p->tid );
484  }
485  }
486  ++p;
487  }
488  if( eRTK_up && eRTK_ticks>eRTK_STARTUP_MS ) { //solange geben wir dem system zum hochlauf
489  eRTK_perfcounter[ ( eRTK_iperf++ )/*&0x0f*/ ]=eRTK_perfcount;
490  if( eRTK_perfcount<1 ) {
491  ++eRTK_cnt_overload;
492  if( eRTK_MAX_OVERLOAD && eRTK_cnt_overload>eRTK_MAX_OVERLOAD ) deadbeef( SYS_OVERLOAD );
493  }
494  else eRTK_cnt_overload=0;
495  eRTK_perfcount=0;
496  }
497  if( eRTK_up ) eRTK_scheduler();
498  }
eRTK_MAX_OVERLOAD
#define eRTK_MAX_OVERLOAD
Definition: eRTK.h:30
n
push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in __SP_H__ n sts r0 n
Definition: eRTK.c:93
tcd
s_tcd tcd[VANZTASK+1]
Definition: eRTK.c:38
s_tcd::tid
uint8_t tid
Definition: eRTK.c:30
eRTK_iperf
volatile uint8_t eRTK_iperf
Definition: eRTK.c:55
s_tcd
Definition: eRTK.c:27
eRTK_ticks
volatile uint16_t eRTK_ticks
Definition: eRTK.c:56
eRTK_perfcount
volatile uint16_t eRTK_perfcount
Definition: eRTK.c:53
VANZTASK
#define VANZTASK
Definition: eRTK.h:15
eRTK_STARTUP_MS
#define eRTK_STARTUP_MS
Definition: eRTK.h:29
oIDLE
#define oIDLE(a)
Definition: eRTK.h:41
eRTK_cnt_overload
volatile uint8_t eRTK_cnt_overload
Definition: eRTK.c:57
eRTK_up
volatile uint8_t eRTK_up
Definition: eRTK.c:52
eRTK_SetReady
void eRTK_SetReady(uint8_t tid)
Definition: eRTK.c:238
deadbeef
void deadbeef(tsys reason)
s_tcd::timer
uint8_t timer
Definition: eRTK.c:32
eRTK_m_timer
union @0 eRTK_m_timer
eRTK_perfcounter
volatile uint16_t eRTK_perfcounter[256]
Definition: eRTK.c:54

Here is the call graph for this function:

void eRTK_free_sema ( uint8_t  semaid)

Definition at line 317 of file eRTK.c.

317  {
318  if( semaid>=ANZSEMA ) deadbeef( SYS_UNKNOWN );
319  xch( &sema[semaid], 0 ) ;
320  }
ANZSEMA
#define ANZSEMA
Definition: eRTK.c:294
deadbeef
void deadbeef(tsys reason)

Here is the call graph for this function:

void eRTK_get_sema ( uint8_t  semaid)

Definition at line 309 of file eRTK.c.

309  { /* Warten bis Semaphore frei ist und danach besetzen */
310  if( semaid>=ANZSEMA ) deadbeef( SYS_UNKNOWN );
311  while( xch( &sema[semaid], 1 ) ) { /* >0 = sema blockiert */
312  sei();
313  eRTK_wefet( 1 );
314  }
315  }
ANZSEMA
#define ANZSEMA
Definition: eRTK.c:294
eRTK_wefet
void eRTK_wefet(uint8_t timeout)
Definition: eRTK.c:269
deadbeef
void deadbeef(tsys reason)

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.

233  { //holen der eigenen task id
234  return akttask;
235  }
akttask
volatile uint8_t akttask
Definition: eRTK.c:24

Here is the caller graph for this function:

uint16_t eRTK_GetTimer16 ( void  )

Definition at line 461 of file eRTK.c.

461  { //wenn 256ms nicht reichen
462  register uint16_t val;
463  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
464  val=eRTK_m_timer.timer16;
465  }
466  return val;
467  }
eRTK_m_timer
union @0 eRTK_m_timer
uint8_t eRTK_GetTimer8 ( void  )

Definition at line 457 of file eRTK.c.

457  { //256ms bis overflow
458  return eRTK_m_timer.timer8[0];
459  }
eRTK_m_timer
union @0 eRTK_m_timer

Here is the caller graph for this function:

void eRTK_go ( void  )

Definition at line 151 of file eRTK.c.

151  { /* start der hoechstprioren ready task, notfalls idle */
152  if( pTaskRdy ) akttask=pTaskRdy->tid;
153  else deadbeef( SYS_NOTASK );
154  //
155  eRTK_up=1;
156  pp_stack=stackptr[akttask];
157  pop();
158  asm volatile( "ret" );
159  }
s_tcd::tid
uint8_t tid
Definition: eRTK.c:30
pTaskRdy
s_tcd * pTaskRdy
Definition: eRTK.c:40
pp_stack
void * pp_stack
Definition: eRTK.c:85
eRTK_up
volatile uint8_t eRTK_up
Definition: eRTK.c:52
deadbeef
void deadbeef(tsys reason)
akttask
volatile uint8_t akttask
Definition: eRTK.c:24
stackptr
void * stackptr[VANZTASK+1]
Definition: eRTK.c:22
pop
#define pop()
Definition: eRTK.c:101

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.

371  { /* Initialisierung der Daten des Echtzeitsystems */
372  uint8_t n, prio, index;
373  uint8_t task;
374  //
375  for( n=0; n<VANZTASK+1; n++ ) {
376  tcd[n].pnext=NULL; /* verkettung der tcd's in unsortiertem grundzustand */
377  tcd[n].pbefore=NULL;
378  tcd[n].tid=n;
379  tcd[n].prio=n ? rom_tcb[n-1].prio : 0; //idle task ist immer da mit pri 0
380  tcd[n].timer=0;
381  //die parameter merken zum debuggen
382 #ifdef ERTK_DEBUG
383  tcd[n].param0= n ? 0 : rom_tcb[n-1].param0;
384  tcd[n].param1= n ? 0 : rom_tcb[n-1].param1;
385 #endif
386  }
387  //einsetzen der idle task, die muss immer da sein !
388  pTaskRdy=( s_tcd * )&tcd[0];
389  pTaskRdy->pnext=NULL;
390  pTaskRdy->pbefore=NULL;
391  /* einsortieren der tasks mit verkettung nach absteigender prioritaet */
392  char hit[VANZTASK+1];
393  memset( hit, 0, sizeof hit );
394  for( task=1; task<VANZTASK+1; task++ ) {
395  prio=0;
396  index=0;
397  for( n=1; n<VANZTASK+1; n++ ) { //hoechstpriore ready und noch nicht verkettete task finden
398  if( tcd[n].prio>=prio && !hit[n] ) { /* prio>prio und noch nicht in liste */
399  prio=tcd[n].prio;
400  index=n;
401  }
402  }
403  eRTK_SetReady( index ); //pTaskReady -> tcdx -> txdy -> 0
404  hit[index]=1;
405  }
406  //
407  for( n=0; n<VANZTASK+1; n++ ) { /* SP der Tasks auf jeweiliges Stackende setzen */
408  for( uint16_t f=0; f<ERTK_STACKSIZE/4; f++ ) memcpy( stack[n]+4*f, "\xde\xad\xbe\xef", 4 );
409  //memcpy( &stack[n][214], "0123456789abcdef0123456789ABCDEF", 32 );
410  /* startadressen und parameter auf den stack */
411  stack[n][ERTK_STACKSIZE-9]=0; //r1=0
412  //
413  union {
414  uint32_t ui32;
415  uint8_t ui8[4];
416  void ( *task )( uint16_t param0, void *param1 );
417  void ( *tvoid )( void );
418  void ( *tbeef )( tsys );
419  } taddr;
420  memset( &taddr, 0, sizeof taddr );
421  taddr.tbeef=deadbeef;
422  stack[n][ERTK_STACKSIZE-1]=taddr.ui8[0];
423  stack[n][ERTK_STACKSIZE-2]=taddr.ui8[1];
424  stack[n][ERTK_STACKSIZE-3]=taddr.ui8[2];
425  if( n ) taddr.task=rom_tcb[n-1].task;
426  else taddr.tvoid=eRTK_Idle;
427  stack[n][ERTK_STACKSIZE-4]=taddr.ui8[0];
428  stack[n][ERTK_STACKSIZE-5]=taddr.ui8[1];
429  stack[n][ERTK_STACKSIZE-6]=taddr.ui8[2];
430  //
431  // hi lo hi lo
432  //zwei parameter in p0=r25:r24 und p1=r23:r22
433  if( n ) {
434  stack[n][ERTK_STACKSIZE-32]=rom_tcb[n-1].param0&0xff;
435  stack[n][ERTK_STACKSIZE-33]=rom_tcb[n-1].param0>>8;
436  stack[n][ERTK_STACKSIZE-30]=( uint16_t )( rom_tcb[n-1].param1 )&0xff;
437  stack[n][ERTK_STACKSIZE-31]=( uint16_t )( rom_tcb[n-1].param1 )>>8;
438  }
439  //
440  stackptr[n]=&stack[n][ERTK_STACKSIZE-40];
441  }
442  sema_init();
443  }
n
push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in __SP_H__ n sts r0 n
Definition: eRTK.c:93
tcd
s_tcd tcd[VANZTASK+1]
Definition: eRTK.c:38
s_tcd::tid
uint8_t tid
Definition: eRTK.c:30
s_tcd
Definition: eRTK.c:27
ERTK_STACKSIZE
#define ERTK_STACKSIZE
Definition: eRTK.h:32
sema_init
void sema_init(void)
Definition: eRTK.c:322
pTaskRdy
s_tcd * pTaskRdy
Definition: eRTK.c:40
t_eRTK_tcb::task
void(* task)(uint16_t param0, void *param1)
Definition: eRTK.h:68
VANZTASK
#define VANZTASK
Definition: eRTK.h:15
s_tcd::pnext
struct s_tcd * pnext
Definition: eRTK.c:28
t_eRTK_tcb::prio
uint8_t prio
Definition: eRTK.h:69
s_tcd::pbefore
struct s_tcd * pbefore
Definition: eRTK.c:29
eRTK_SetReady
void eRTK_SetReady(uint8_t tid)
Definition: eRTK.c:238
deadbeef
void deadbeef(tsys reason)
s_tcd::timer
uint8_t timer
Definition: eRTK.c:32
t_eRTK_tcb::param1
void * param1
Definition: eRTK.h:71
rom_tcb
const t_eRTK_tcb rom_tcb[VANZTASK]
Definition: main.c:90
stackptr
void * stackptr[VANZTASK+1]
Definition: eRTK.c:22
tsys
tsys
Definition: eRTK.h:50
s_tcd::prio
uint8_t prio
Definition: eRTK.c:31
t_eRTK_tcb::param0
uint16_t param0
Definition: eRTK.h:70

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.

238  {
239  if( !tid ) deadbeef( SYS_NULLPTR ); //idle task ist immer ready
240  if( tcd[tid].pnext || tcd[tid].pbefore ) deadbeef( SYS_VERIFY ); //war gar nicht suspendiert
241  //
242  s_tcd *pthis=pTaskRdy;
243  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
244  tcd[tid].timer=0; //timer loeschen damit er nicht spaeter nochmal startet
245  do { //pthis->hoechstprioren tcd oder idle
246  if( tcd[tid].prio > pthis->prio || pthis->pnext==NULL ) { //neuer eintrag hat hoehere prio oder es gibt keinen nachfolger
247  insertat( pthis, &tcd[tid] );
248  break;
249  }
250  } while( ( pthis=pthis->pnext ) );
251  }
252  }
tcd
s_tcd tcd[VANZTASK+1]
Definition: eRTK.c:38
s_tcd
Definition: eRTK.c:27
pTaskRdy
s_tcd * pTaskRdy
Definition: eRTK.c:40
s_tcd::pnext
struct s_tcd * pnext
Definition: eRTK.c:28
deadbeef
void deadbeef(tsys reason)
s_tcd::timer
uint8_t timer
Definition: eRTK.c:32
s_tcd::prio
uint8_t prio
Definition: eRTK.c:31

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.

255  { //tcd[tid] aus der ready list austragen
256  if( !tid ) deadbeef( SYS_NULLPTR ); //idle task darf nicht suspendiert werden
257  if( !tcd[tid].pbefore && !tcd[tid].pnext ) deadbeef( SYS_VERIFY ); //war nicht in ready list
258  s_tcd *pthis=pTaskRdy;
259  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
260  do {
261  if( pthis->tid==tid ) {
262  removeat( pthis );
263  break;
264  }
265  } while( ( pthis=pthis->pnext ) );
266  }
267  }
tcd
s_tcd tcd[VANZTASK+1]
Definition: eRTK.c:38
s_tcd::tid
uint8_t tid
Definition: eRTK.c:30
s_tcd
Definition: eRTK.c:27
pTaskRdy
s_tcd * pTaskRdy
Definition: eRTK.c:40
s_tcd::pnext
struct s_tcd * pnext
Definition: eRTK.c:28
deadbeef
void deadbeef(tsys reason)

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.

280  {
281  while( ms ) {
282  if( ms>255 ) {
283  eRTK_wefet( 255 );
284  ms-=255;
285  }
286  else {
287  eRTK_wefet( ms );
288  ms=0;
289  }
290  }
291  }
eRTK_wefet
void eRTK_wefet(uint8_t timeout)
Definition: eRTK.c:269

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.

515  {
516 #if defined (__AVR_ATmega2560__)
517  timer0_init();
518 #elif defined (__AVR_ATxmega128A1U__)
519 #endif
520  }

Here is the caller graph for this function:

void eRTK_WaitUntil ( uint8_t  then)

Definition at line 469 of file eRTK.c.

469  {
470  eRTK_wefet( then-eRTK_GetTimer8() );
471  }
eRTK_GetTimer8
uint8_t eRTK_GetTimer8(void)
Definition: eRTK.c:457
eRTK_wefet
void eRTK_wefet(uint8_t timeout)
Definition: eRTK.c:269

Here is the call graph for this function:

void eRTK_wefet ( uint8_t  timeout)

Definition at line 269 of file eRTK.c.

269  {
270  if( timeout ) { //sonst klinkt sich die task in einem wait_until() fuer immer aus
271  ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) { //14+2=16 cycles pro loop -> 16MHz -> 1000 inc/ms
272  if( tcd[akttask].timer ) deadbeef( SYS_UNKNOWN );
273  tcd[akttask].timer=timeout;
274  eRTK_SetSuspended( akttask );
275  eRTK_scheduler();
276  }
277  }
278  }
tcd
s_tcd tcd[VANZTASK+1]
Definition: eRTK.c:38
deadbeef
void deadbeef(tsys reason)
akttask
volatile uint8_t akttask
Definition: eRTK.c:24
eRTK_SetSuspended
void eRTK_SetSuspended(uint8_t tid)
Definition: eRTK.c:255
s_tcd::timer
uint8_t timer
Definition: eRTK.c:32

Here is the call graph for this function:

Here is the caller graph for this function:

void sema_init ( void  )

Definition at line 322 of file eRTK.c.

322  {
323  static uint8_t n;
324  for( n=0; n<ANZSEMA; n++ ) {
325  sema[n]=0; /* ff=keine task wartend */
326  }
327  }
ANZSEMA
#define ANZSEMA
Definition: eRTK.c:294
n
push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in __SP_H__ n sts r0 n
Definition: eRTK.c:93

Here is the caller graph for this function:

Variable Documentation

volatile uint8_t akttask

Definition at line 24 of file eRTK.c.

volatile uint8_t eRTK_cnt_overload

Definition at line 57 of file eRTK.c.

volatile uint8_t eRTK_iperf

Definition at line 55 of file eRTK.c.

union { ... } eRTK_m_timer
volatile uint16_t eRTK_perfcount

Definition at line 53 of file eRTK.c.

volatile uint16_t eRTK_perfcounter[256]

Definition at line 54 of file eRTK.c.

volatile uint16_t eRTK_ticks

Definition at line 56 of file eRTK.c.

volatile uint8_t eRTK_up

Definition at line 52 of file eRTK.c.

push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in __SP_H__ n sts r0 n

Definition at line 93 of file eRTK.c.

push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in __SP_H__ n sts pp_stack

Definition at line 85 of file eRTK.c.

s_tcd* pTaskRdy

Definition at line 40 of file eRTK.c.

push r0 npush r1 npush r2 npush r3 npush r4 npush r5 npush r6 npush r7 npush r8 npush r9 npush r10 npush r11 npush r12 npush r13 npush r14 npush r15 npush r16 npush r17 npush r18 npush r19 npush r20 npush r21 npush r22 npush r23 npush r24 npush r25 npush r26 npush r27 npush r28 npush r29 npush r30 npush r31 n in __SP_L__ n sts r0 n in r0

Definition at line 93 of file eRTK.c.

void* stackptr[VANZTASK+1]

Definition at line 22 of file eRTK.c.

s_tcd tcd[VANZTASK+1]

Definition at line 38 of file eRTK.c.

volatile uint16_t timer16

Definition at line 454 of file eRTK.c.

volatile uint8_t timer8[2]

Definition at line 453 of file eRTK.c.

Generated on Thu Jun 11 2015 10:00:00 for eRTK by   doxygen 1.8.7