AutosarOS
/github/workspace/AutosarOS/App.c
Go to the documentation of this file.
1 
16 #include "assert.h"
17 
18 #include "OS_API.h"
19 
20 #include <avr/io.h>
21 #include <util/delay.h>
22 
23 #if defined(EXTERNAL_APP)
24 #include EXTERNAL_APP
25 #else /* defined(EXTERNAL_APP) */
26 
27 #if defined(OS_CONFIG_SIM) && OS_CONFIG_SIM == true
28 #define DELAY_MS(ms)
29 #else
30 #define DELAY_MS(ms) _delay_ms(ms)
31 #endif /* defined(OS_CONFIG_SIM) && OS_CONFIG_SIM == true */
32 
33 TASK(Idle)
34 {
35  while (1);
36 }
37 
38 TASK(T1)
39 {
40  while (1) {
41  PORTB &= ~(1 << 1); // turn LED on
42  DELAY_MS(1000);
43  PORTB |= (1 << 1); // turn LED off
44  DELAY_MS(1000);
45 
46  StatusType stat = IncrementCounter(C7);
47  assert(stat == E_OK);
48  }
49 }
50 
51 TASK(T2)
52 {
53  static uint8_t t = 0;
54 
55  ActivateTask(T6);
56 
57  SetRelAlarm((AlarmType) 128, 123, 321);
58 
59  AppModeType mode = GetActiveApplicationMode();
60  assert(mode == OSDEFAULTAPPMODE);
61 
62  SuspendAllInterrupts();
63  ResumeAllInterrupts();
64 
65  SuspendOSInterrupts();
66  ResumeOSInterrupts();
67 
68  if (t == 0) {
69  StatusType stat;
70  for (uint64_t i = 0; i < 10; i++) {
71  stat = IncrementCounter(C1);
72  assert(stat == E_OK);
73  }
74 
75  TickType tick = 0;
76  TickType eTick = 0;
77  stat = GetCounterValue(C1, &tick);
78  assert(stat == E_OK && tick == 10);
79  stat = IncrementCounter(C1);
80  assert(stat == E_OK);
81  stat = GetCounterValue(C1, &tick);
82  assert(stat == E_OK && tick == 0);
83 
84  stat = SetAbsAlarm(Alarm9, 3, 5);
85  assert(stat == E_OK);
86  stat = GetAlarm(Alarm9, &tick);
87  assert(stat == E_OK && tick == 3);
88 
89  for (uint64_t i = 0; i < 5; i++) {
90  stat = IncrementCounter(C1);
91  assert(stat == E_OK);
92  }
93 
94  tick = 0;
95  stat = GetElapsedValue(C1, &tick, &eTick);
96  assert(stat == E_OK && tick == 5 && eTick == 5);
97 
98  stat = GetAlarm(Alarm9, &tick);
99  assert(stat == E_OK && tick == 3);
100 
101  stat = CancelAlarm(Alarm9);
102  assert(stat == E_OK);
103  stat = SetAbsAlarm(Alarm9, 1, 3);
104  assert(stat == E_OK);
105  stat = GetAlarm(Alarm9, &tick);
106  assert(stat == E_OK && tick == 7);
107 
108  for (uint64_t i = 0; i < 7; i++) {
109  stat = IncrementCounter(C1);
110  assert(stat == E_OK);
111  }
112 
113  tick = 5;
114  stat = GetElapsedValue(C1, &tick, &eTick);
115  assert(stat == E_OK && tick == 1 && eTick == 7);
116 
117  stat = GetAlarm(Alarm9, &tick);
118  assert(stat == E_OK && tick == 3);
119 
120  stat = CancelAlarm(Alarm9);
121  assert(stat == E_OK);
122 
123  AlarmBaseType info;
124  GetAlarmBase(Alarm5, &info);
125  assert(info.type == HARDWARE);
126  assert(info.maxallowedvalue == UINT32_MAX);
127  assert(info.mincycle == 1);
128  assert(info.ticksperbase == 57);
129  assert(info.secondspertick == 0.017778);
130  }
131 
132  while (1) {
133  StatusType stat;
134 
135  /* These tests should succeed */
136  stat = GetResource(Res1);
137  assert(stat == E_OK);
138  stat = GetResource(Res2);
139  assert(stat == E_OK);
140  stat = GetResource(Res3);
141  assert(stat == E_OK);
142  /* Request resource again => should fail */
143  stat = GetResource(Res3);
144  assert(stat == E_OS_ACCESS);
145  /* Request resource with ceiling priority below static task priority => should fail */
146  stat = GetResource(Res4);
147  assert(stat == E_OS_ACCESS);
148  /* Request resource with invalid ID => should fail */
149  stat = GetResource(64);
150  assert(stat == E_OS_ID);
151 
152  /* These tests should succeed */
153  stat = ReleaseResource(Res3);
154  assert(stat == E_OK);
155  stat = ReleaseResource(Res2);
156  assert(stat == E_OK);
157  stat = ReleaseResource(Res1);
158  assert(stat == E_OK);
159  /* Release same resource again => should fail */
160  stat = ReleaseResource(Res1);
161  assert(stat == E_OS_NOFUNC);
162 
163 
164  PORTB &= ~(1 << 2); // turn LED on
165  DELAY_MS(1000);
166  PORTB |= (1 << 2); // turn LED off
167  DELAY_MS(1000);
168  if (t++ % 3 == 0) {
169  ActivateTask(T3);
170  } else if (t == 20) {
171  ChainTask(T2);
172  } else if (t == 30) {
173  TerminateTask();
174  }
175  }
176 }
177 
178 TASK(T3)
179 {
180  EventMaskType ev = 0;
181  GetEvent(T3, &ev);
182  assert(ev == 0x00);
183 
184  for (uint8_t i = 0; i < 3; i++) {
185  PORTB &= ~(1 << 3); // turn LED on
186  DELAY_MS(1000);
187 
188  WaitEvent(0x01);
189  GetEvent(T3, &ev);
190  assert(ev == 0x01);
191  ClearEvent(0x01);
192 
193  PORTB |= (1 << 3); // turn LED off
194  DELAY_MS(1000);
195 
196  Schedule();
197  }
198 
199  TaskType taskID = INVALID_TASK;
200  GetTaskID(&taskID);
201  assert(taskID == T3);
202 
203  TaskStateType state = SUSPENDED;
204  GetTaskState(T3, &state);
205  assert(state == RUNNING);
206 
207  WaitEvent(0x01);
208  GetEvent(T3, &ev);
209  assert(ev == 0x01);
210 
211  TerminateTask();
212 }
213 
214 TASK(T4)
215 {
216  for (uint8_t i = 0; i < 3; i++) {
217  PORTB &= ~(1 << 4); // turn LED on
218  DELAY_MS(1000);
219  PORTB |= (1 << 4); // turn LED off
220  DELAY_MS(1000);
221  }
222 
223  if (ChainTask(T5) != E_OK) {
224  TerminateTask();
225  }
226 }
227 
228 TASK(T5)
229 {
230  for (uint8_t i = 0; i < 3; i++) {
231  PORTB &= ~(1 << 5); // turn LED on
232  DELAY_MS(1000);
233  PORTB |= (1 << 5); // turn LED off
234  DELAY_MS(1000);
235  }
236 
237  TerminateTask();
238 }
239 
240 TASK(T6)
241 {
242  for (uint8_t i = 0; i < 3; i++) {
243  PORTB &= ~(1 << 6); // turn LED on
244  DELAY_MS(1000);
245  PORTB |= (1 << 6); // turn LED off
246  DELAY_MS(1000);
247  }
248 
249  TerminateTask();
250 }
251 
252 TASK(T7)
253 {
254  CancelAlarm(Alarm3);
255 
256  TickType tick;
257  StatusType stat = GetAlarm(Alarm3, &tick);
258  assert(stat == E_OS_NOFUNC);
259 
260  stat = SetAbsAlarm(Alarm3, 10, 0);
261  assert(stat == E_OK);
262 
263  stat = SetAbsAlarm(Alarm3, 10, 0);
264  assert(stat == E_OS_STATE);
265 
266  WaitEvent(0x01);
267  EventMaskType ev = 0;
268  GetEvent(T7, &ev);
269  assert(ev == 0x01);
270  ClearEvent(0x01);
271 
272  stat = SetAbsAlarm(Alarm3, 15, 5);
273  assert(stat == E_OK);
274 
275  WaitEvent(0x01);
276  ev = 0;
277  GetEvent(T7, &ev);
278  assert(ev == 0x01);
279  ClearEvent(0x01);
280 
281  WaitEvent(0x01);
282  ev = 0;
283  GetEvent(T7, &ev);
284  assert(ev == 0x01);
285  ClearEvent(0x01);
286 
287  stat = CancelAlarm(Alarm3);
288  assert(stat == E_OK);
289 
290  stat = SetRelAlarm(Alarm8, 6840, UINT32_MAX);
291  assert(stat == E_OK);
292 
293  tick = 0;
294  stat = GetAlarm(Alarm8, &tick);
295  assert(stat == E_OK);
296 
297  WaitEvent(0x02);
298  ev = 0;
299  GetEvent(T7, &ev);
300  assert(ev == 0x02);
301  ClearEvent(0x02);
302 
303  stat = CancelAlarm(Alarm8);
304  assert(stat == E_OK);
305 
306  stat = SetRelAlarm(Alarm3, 3, 0);
307  assert(stat == E_OK);
308 
309  for (uint8_t i = 0; i < 5; i++) {
310  PORTB &= ~(1 << 7); // turn LED on
311  DELAY_MS(1000);
312 
313  WaitEvent(0x01);
314  ev = 0;
315  GetEvent(T7, &ev);
316  assert(ev == 0x01);
317  ClearEvent(0x01);
318 
319  stat = CancelAlarm(Alarm3);
320  stat = SetRelAlarm(Alarm3, 10, 15);
321  assert(stat == E_OK);
322 
323  PORTB |= (1 << 7); // turn LED off
324  DELAY_MS(1000);
325 
326  WaitEvent(0x01);
327  ev = 0;
328  GetEvent(T7, &ev);
329  assert(ev == 0x01);
330  ClearEvent(0x01);
331  }
332 
333  TerminateTask();
334 }
335 
336 TASK(T8)
337 {
338  static TickType tick = 0;
339  static TickType currentTick = 0;
340  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
341  GetCounterValue(C5, &currentTick);
342  assert(tick == currentTick);
343 
344  WaitEvent(0b01);
345  EventMaskType ev = 0;
346  GetEvent(T8, &ev);
347  assert(ev == 0b01);
348  ClearEvent(0b01);
349 
350  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
351  GetCounterValue(C5, &currentTick);
352  assert(tick == currentTick);
353 
354  WaitEvent(0b10);
355  ev = 0;
356  GetEvent(T8, &ev);
357  assert(ev == 0b10);
358  ClearEvent(0b10);
359 
360  tick += 5;
361  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
362  GetCounterValue(C5, &currentTick);
363  assert(tick == currentTick);
364 
365  tick += 5;
366  tick += 3;
367 
368  TerminateTask();
369 }
370 
371 TASK(T9)
372 {
373  static TickType tick = 0;
374  static TickType currentTick = 0;
375  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
376  GetCounterValue(C5, &currentTick);
377  assert(tick == currentTick);
378 
379  WaitEvent(0b01);
380  EventMaskType ev = 0;
381  GetEvent(T9, &ev);
382  assert(ev == 0b01);
383  ClearEvent(0b01);
384 
385  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
386  GetCounterValue(C5, &currentTick);
387  assert(tick == currentTick);
388 
389  WaitEvent(0b10);
390  ev = 0;
391  GetEvent(T9, &ev);
392  assert(ev == 0b10);
393  ClearEvent(0b10);
394 
395  tick += 10;
396  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
397  GetCounterValue(C5, &currentTick);
398  assert(tick == currentTick);
399 
400  tick += 3;
401 
402  TerminateTask();
403 }
404 
405 TASK(T10)
406 {
407  static TickType tick = 0;
408  static TickType currentTick = 0;
409  StatusType stat;
410 
411  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
412  GetCounterValue(C5, &currentTick);
413  assert(tick == currentTick);
414 
415  /* Enable ST2 */
416  stat = StartScheduleTableRel(ST2, 3);
417  assert(stat == E_OK);
418 
419  /* Running ST2 */
420 
421  tick += 3;
422 
423  WaitEvent(0b01);
424  EventMaskType ev = 0;
425  GetEvent(T10, &ev);
426  assert(ev == 0b01);
427  ClearEvent(0b01);
428 
429  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
430  GetCounterValue(C5, &currentTick);
431  assert(tick == currentTick);
432 
433  tick += 5;
434 
435  /* Queue ST3 */
436  stat = NextScheduleTable(ST2, ST3);
437  assert(stat == E_OK);
438 
439  WaitEvent(0b10);
440  ev = 0;
441  GetEvent(T10, &ev);
442  assert(ev == 0b10);
443  ClearEvent(0b10);
444 
445  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
446  GetCounterValue(C5, &currentTick);
447  assert(tick == currentTick);
448 
449  tick += 3;
450 
451  /* Switch to ST3 */
452 
453  tick += 1;
454 
455  WaitEvent(0b01);
456  ev = 0;
457  GetEvent(T10, &ev);
458  assert(ev == 0b01);
459  ClearEvent(0b01);
460 
461  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
462  GetCounterValue(C5, &currentTick);
463  assert(tick == currentTick);
464 
465  tick += 2;
466 
467  /* Queue ST2 */
468  stat = NextScheduleTable(ST3, ST2);
469  assert(stat == E_OK);
470 
471  WaitEvent(0b10);
472  ev = 0;
473  GetEvent(T10, &ev);
474  assert(ev == 0b10);
475  ClearEvent(0b10);
476 
477  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
478  GetCounterValue(C5, &currentTick);
479  assert(tick == currentTick);
480 
481  tick += 5;
482 
483  /* Back to ST2 */
484 
485  WaitEvent(0b01);
486  ev = 0;
487  GetEvent(T10, &ev);
488  assert(ev == 0b01);
489  ClearEvent(0b01);
490 
491  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
492  GetCounterValue(C5, &currentTick);
493  assert(tick == currentTick);
494 
495  tick += 5;
496 
497  WaitEvent(0b10);
498  ev = 0;
499  GetEvent(T10, &ev);
500  assert(ev == 0b10);
501  ClearEvent(0b10);
502 
503  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
504  GetCounterValue(C5, &currentTick);
505  assert(tick == currentTick);
506 
507  tick += 3;
508 
509  /* Enable ST3 */
510  currentTick += 5;
511  currentTick = currentTick % (Counter_Cfg[C5]->maxallowedvalue + 1);
512  stat = StartScheduleTableAbs(ST3, currentTick);
513  assert(stat == E_OK);
514 
515  tick += 2;
516 
517  /* Back to ST3 */
518 
519  tick += 1;
520 
521  WaitEvent(0b01);
522  ev = 0;
523  GetEvent(T10, &ev);
524  assert(ev == 0b01);
525  ClearEvent(0b01);
526 
527  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
528  GetCounterValue(C5, &currentTick);
529  assert(tick == currentTick);
530 
531  tick += 2;
532 
533  WaitEvent(0b10);
534  ev = 0;
535  GetEvent(T10, &ev);
536  assert(ev == 0b10);
537  ClearEvent(0b10);
538 
539  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
540  GetCounterValue(C5, &currentTick);
541  assert(tick == currentTick);
542 
543  /* Enable ST2 */
544  tick += Counter_Cfg[C5]->maxallowedvalue;
545  stat = StartScheduleTableAbs(ST2, currentTick);
546  assert(stat == E_OK);
547 
548  /* Back to ST2 */
549 
550  WaitEvent(0b01);
551  ev = 0;
552  GetEvent(T10, &ev);
553  assert(ev == 0b01);
554  ClearEvent(0b01);
555 
556  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
557  GetCounterValue(C5, &currentTick);
558  assert(tick == currentTick);
559 
560  tick += 5;
561 
562  WaitEvent(0b10);
563  ev = 0;
564  GetEvent(T10, &ev);
565  assert(ev == 0b10);
566  ClearEvent(0b10);
567 
568  tick = tick % (Counter_Cfg[C5]->maxallowedvalue + 1);
569  GetCounterValue(C5, &currentTick);
570  assert(tick == currentTick);
571 
572  /* Start ST4 */
573  stat = StartScheduleTableRel(ST4, 50);
574  assert(stat == E_OK);
575 
576  /* Running ST4 */
577 
578  WaitEvent(0b01);
579  ev = 0;
580  GetEvent(T10, &ev);
581  assert(ev == 0b01);
582  ClearEvent(0b01);
583 
584  WaitEvent(0b10);
585  ev = 0;
586  GetEvent(T10, &ev);
587  assert(ev == 0b10);
588  ClearEvent(0b10);
589 
590  /* Start ST5 */
591  stat = StartScheduleTableRel(ST5, 5);
592  assert(stat == E_OK);
593 
594  /* Running ST5 */
595 
596  WaitEvent(0b01);
597  ev = 0;
598  GetEvent(T10, &ev);
599  assert(ev == 0b01);
600  ClearEvent(0b01);
601 
602  WaitEvent(0b10);
603  ev = 0;
604  GetEvent(T10, &ev);
605  assert(ev == 0b10);
606  ClearEvent(0b10);
607 
608  /* Start ST6 */
609  stat = StartScheduleTableRel(ST6, 1);
610  assert(stat == E_OK);
611 
612  /* Running ST6 */
613 
614  WaitEvent(0b01);
615  ev = 0;
616  GetEvent(T10, &ev);
617  assert(ev == 0b01);
618  ClearEvent(0b01);
619 
620  WaitEvent(0b10);
621  ev = 0;
622  GetEvent(T10, &ev);
623  assert(ev == 0b10);
624  ClearEvent(0b10);
625 
626  stat = StopScheduleTable(ST6);
627  assert(stat == E_OK);
628 
629  ScheduleTableStatusType status;
630  stat = GetScheduleTableStatus(ST6, &status);
631  assert(stat == E_OK && status == SCHEDULETABLE_STOPPED);
632 
633  TerminateTask();
634 }
635 
636 TASK(T11)
637 {
638  WaitEvent(0b01);
639  EventMaskType ev = 0;
640  GetEvent(T11, &ev);
641  assert(ev == 0b01);
642  ClearEvent(0b01);
643 
644  StatusType stat = NextScheduleTable(ST8, ST7);
645  assert(stat == E_OK);
646 
647  stat = NextScheduleTable(ST8, ST9);
648  assert(stat == E_OK);
649 
650  WaitEvent(0b01);
651  ev = 0;
652  GetEvent(T11, &ev);
653  assert(ev == 0b01);
654  ClearEvent(0b01);
655 
656  stat = NextScheduleTable(ST9, ST7);
657  assert(stat == E_OK);
658 
659  WaitEvent(0b01);
660  ev = 0;
661  GetEvent(T11, &ev);
662  assert(ev == 0b01);
663  ClearEvent(0b01);
664 
665  stat = StartScheduleTableAbs(ST8, 0);
666  assert(stat == E_OK);
667 
668  stat = StopScheduleTable(ST8);
669  assert(stat == E_OK);
670 
671  for (uint8_t i = 0; i < 10; i++) {
672  stat = IncrementCounter(C8);
673  assert(stat == E_OK);
674 
675  ev = 0;
676  GetEvent(T11, &ev);
677  assert(ev == 0b00);
678  }
679 
680  stat = StartScheduleTableAbs(ST10, 5);
681  assert(stat == E_OK);
682 
683  for (uint8_t i = 0; i < 15; i++) {
684  stat = IncrementCounter(C8);
685  assert(stat == E_OK);
686 
687  ev = 0;
688  GetEvent(T11, &ev);
689  assert(ev == 0b00);
690  }
691 
692  stat = IncrementCounter(C8);
693  assert(stat == E_OK);
694 
695  ev = 0;
696  GetEvent(T11, &ev);
697  assert(ev == 0b01);
698 
699  TerminateTask();
700 }
701 
702 extern void StartupHook(void)
703 {
704  DDRB = 0xFF; // PB as output
705  PORTB = 0xFF; // keep all LEDs off
706 
707  DDRD = 0x00; // PD as input
708  PORTD = 0xFF; // enable PU on PD
709 
710 #if defined(__AVR_ATmega32__)
711  GICR = 1 << INT0 | 1 << INT1; // Enable INT0 and INT1
712  MCUCR = 1 << ISC01 | 0 << ISC00 | 1 << ISC11 | 0 << ISC10; // Trigger INT0 and INT1 on falling edge
713 #elif defined(__AVR_ATmega328P__) || defined(__AVR_ATmega128__) || defined(__AVR_ATmega1284__) || defined(__AVR_ATmega2560__)
714  EICRA = 1 << ISC11 | 0 << ISC10 | 1 << ISC01 | 0 << ISC00; // Trigger INT0 and INT1 on falling edge
715  EIMSK |= 1 << INT1 | 1 << INT0; // Enable INT0 and INT1
716 
717  /* Timer 1 */
718  TCCR1A = 0;
719  TCCR1B = 0;
720  TCNT1 = 0;
721 
722  OCR1A = 14400; // Set compare-match value for 1Hz
723  TCCR1B |= (1 << WGM12); // Enable CTC mode
724  TCCR1B |= (1 << CS12) | (1 << CS10); // Set prescaler to 1024
725 
726 #if defined(__AVR_ATmega128__)
727  TIMSK |= (1 << OCIE1A); // Enable interrupt on compare match
728 #else /* defined(__AVR_ATmega128__) */
729  TIMSK1 |= (1 << OCIE1A); // Enable interrupt on compare match
730 #endif /* defined(__AVR_ATmega128__) */
731 
732  /* Timer 2 */
733 #if defined(OS_CONFIG_SIM) && OS_CONFIG_SIM == true
734 #if defined(__AVR_ATmega128__)
735  TCCR2 = (1 << CS20); // Enable Timer2 with Prescaler 1
736  TIMSK |= 1 << TOIE2; // Enable Overflow Interrupt (Timer2)
737 #else /* defined(__AVR_ATmega128__) */
738  TCCR2B = (1 << CS20); // Enable Timer2 with Prescaler 1
739  TIMSK2 |= 1 << TOIE2; // Enable Overflow Interrupt (Timer2)
740 #endif /* defined(__AVR_ATmega128__) */
741 #endif /* defined(OS_CONFIG_SIM) && OS_CONFIG_SIM == true */
742 #else /* defined(__AVR_ATmega32__) */
743 #error Unknown CPU defined!
744 #endif /* defined(__AVR_ATmega32__) */
745 
746  uint8_t t = 0;
747 
748  while (t < 6) {
749  uint8_t r = PORTB;
750  r ^= (1 << 7);
751  PORTB = r;
752  DELAY_MS(50);
753  t++;
754  }
755 }
756 
757 extern void ShutdownHook(StatusType error)
758 {
759  DDRB = 0xFF; // PB as output
760  PORTB = 0xFF; // keep all LEDs off
761 
762  for (uint8_t i = 0; i < 11; i++) {
763  PORTB ^= 0xFF;
764  DELAY_MS(1000);
765  }
766 }
767 
768 extern void PreTaskHook(void)
769 {
770  TaskType task;
771  GetTaskID(&task);
772  TaskStateType state = SUSPENDED;
773  GetTaskState(task, &state);
774 }
775 
776 extern void PostTaskHook(void)
777 {
778  TaskType task;
779  GetTaskID(&task);
780  TaskStateType state = SUSPENDED;
781  GetTaskState(task, &state);
782 }
783 
784 extern void ErrorHook(StatusType error)
785 {
786  //OSServiceIdType id = OSErrorGetServiceId();
787  //AlarmType alarm = OSError_SetRelAlarm_AlarmID();
788  //TickType inc = OSError_SetRelAlarm_increment();
789  //TickType cyc = OSError_SetRelAlarm_cycle();
790 
791  //assert(id == OSServiceId_SetRelAlarm);
792  //assert(alarm == 128);
793  //assert(inc == 123);
794  //assert(cyc == 321);
795 }
796 
797 extern ProtectionReturnType ProtectionHook(StatusType fatalError)
798 {
799  if (fatalError == E_OS_PARAM_POINTER || fatalError == E_OS_STACKFAULT) {
800  return PRO_TERMINATETASKISR;
801  }
802 
803  return PRO_SHUTDOWN;
804 }
805 
806 ISR(INT0_vect)
807 {
808  assert(isISR && isCat2ISR);
809  ActivateTask(T4);
810 
811  GetResource(Res1);
812  GetResource(Res2);
813  GetResource(Res3);
814 
815  ReleaseResource(Res3);
816  ReleaseResource(Res2);
817  ReleaseResource(Res1);
818 }
819 
820 ISR(INT1_vect)
821 {
822  assert(isISR && isCat2ISR);
823 
824  SetEvent(T3, 0b11);
825 }
826 
827 ISR(TIMER1_COMPA_vect)
828 {
829  IncrementCounter(C2);
830  IncrementCounter(C6);
831 }
832 
833 ALARMCALLBACK(AlarmCb)
834 {
835  ActivateTask(T7);
836 }
837 
838 ISR(TIMER2_OVF_vect)
839 {
840 
841 }
842 
843 #endif /* defined(EXTERNAL_APP) */
TaskType
enum tasks_e TaskType
Type for task reference.
Definition: TaskTypes.h:29
EventMaskType
uint8_t EventMaskType
Data type of the event mask.
Definition: EventTypes.h:21
ProtectionReturnType
enum ProtectionReturnType_e ProtectionReturnType
Return type for protection hook.
PRO_TERMINATETASKISR
@ PRO_TERMINATETASKISR
Terminate faulty task or ISR.
Definition: Types.h:59
StatusType
enum StatusType_e StatusType
Type for status.
AlarmBaseType
volatile struct counter_s AlarmBaseType
Type for alarm base.
Definition: AlarmTypes.h:39
SuspendAllInterrupts
#define SuspendAllInterrupts
Definition: OS_API.h:61
ErrorHook
void ErrorHook(StatusType error)
PostTask hook function.
Definition: App.c:784
Schedule
#define Schedule
Definition: OS_API.h:81
GetAlarmBase
#define GetAlarmBase
Definition: OS_API.h:25
HARDWARE
@ HARDWARE
Counter is implemented in hardware.
Definition: CounterTypes.h:39
ResumeOSInterrupts
#define ResumeOSInterrupts
Definition: OS_API.h:62
E_OS_NOFUNC
@ E_OS_NOFUNC
Definition: Types.h:45
ALARMCALLBACK
ALARMCALLBACK(AlarmCb)
Definition: App.c:833
TickType
uint64_t TickType
Data type of counter values.
Definition: CounterTypes.h:21
AlarmType
enum alarm_e AlarmType
Type for alarm reference.
Definition: AlarmTypes.h:49
StartupHook
void StartupHook(void)
Definition: App.c:702
ClearEvent
#define ClearEvent
Definition: OS_API.h:46
WaitEvent
#define WaitEvent
Definition: OS_API.h:48
ProtectionHook
ProtectionReturnType ProtectionHook(StatusType fatalError)
ProtectionHook function.
Definition: App.c:797
GetTaskState
#define GetTaskState
Definition: OS_API.h:83
GetActiveApplicationMode
#define GetActiveApplicationMode
Definition: OS_API.h:57
assert.h
Assert macros and functions.
ChainTask
#define ChainTask
Definition: OS_API.h:79
IncrementCounter
#define IncrementCounter
Definition: OS_API.h:36
SetAbsAlarm
#define SetAbsAlarm
Definition: OS_API.h:28
TASK
TASK(Idle)
Definition: App.c:33
E_OK
@ E_OK
Definition: Types.h:40
SetEvent
#define SetEvent
Definition: OS_API.h:45
E_OS_ACCESS
@ E_OS_ACCESS
Definition: Types.h:41
RUNNING
@ RUNNING
The task is currently running.
Definition: TaskTypes.h:61
ISR
ISR(INT0_vect)
Definition: App.c:806
counter_s::maxallowedvalue
const TickType maxallowedvalue
Maximum allowed value of counter.
Definition: CounterTypes.h:47
SCHEDULETABLE_STOPPED
@ SCHEDULETABLE_STOPPED
Schedule table is stopped.
Definition: ScheduleTableTypes.h:31
PreTaskHook
void PreTaskHook(void)
PreTask hook function.
Definition: App.c:768
isCat2ISR
volatile uint8_t isCat2ISR
Priority of current Cat 2 ISR (zero if not in Cat 2 ISR)
Definition: OCB.c:21
ActivateTask
#define ActivateTask
Definition: OS_API.h:78
isISR
volatile bool isISR
Is currently ISR context?
Definition: OCB.c:20
StartScheduleTableRel
#define StartScheduleTableRel
Definition: OS_API.h:90
StartScheduleTableAbs
#define StartScheduleTableAbs
Definition: OS_API.h:91
assert
#define assert(expression)
Definition: assert.h:37
SUSPENDED
@ SUSPENDED
The task is suspended and will not be scheduled.
Definition: TaskTypes.h:58
TerminateTask
#define TerminateTask
Definition: OS_API.h:80
GetCounterValue
#define GetCounterValue
Definition: OS_API.h:37
ResumeAllInterrupts
#define ResumeAllInterrupts
Definition: OS_API.h:60
OS_API.h
Operating System API.
CancelAlarm
#define CancelAlarm
Definition: OS_API.h:29
SetRelAlarm
#define SetRelAlarm
Definition: OS_API.h:27
GetAlarm
#define GetAlarm
Definition: OS_API.h:26
OSDEFAULTAPPMODE
@ OSDEFAULTAPPMODE
Definition: Types.h:69
GetTaskID
#define GetTaskID
Definition: OS_API.h:82
NextScheduleTable
#define NextScheduleTable
Definition: OS_API.h:93
ReleaseResource
#define ReleaseResource
Definition: OS_API.h:71
SuspendOSInterrupts
#define SuspendOSInterrupts
Definition: OS_API.h:63
StopScheduleTable
#define StopScheduleTable
Definition: OS_API.h:92
GetElapsedValue
#define GetElapsedValue
Definition: OS_API.h:38
DELAY_MS
#define DELAY_MS(ms)
Definition: App.c:30
E_OS_STATE
@ E_OS_STATE
Definition: Types.h:47
E_OS_ID
@ E_OS_ID
Definition: Types.h:43
PostTaskHook
void PostTaskHook(void)
PostTask hook function.
Definition: App.c:776
ScheduleTableStatusType
enum scheduleTableState_e ScheduleTableStatusType
State of schedule table.
E_OS_STACKFAULT
@ E_OS_STACKFAULT
Definition: Types.h:49
ShutdownHook
void ShutdownHook(StatusType error)
Definition: App.c:757
Counter_Cfg
volatile struct counter_s * Counter_Cfg[]
Current counter control blocks.
TaskStateType
enum OsTaskState_e TaskStateType
Task state.
GetResource
#define GetResource
Definition: OS_API.h:70
PRO_SHUTDOWN
@ PRO_SHUTDOWN
Shutdown system.
Definition: Types.h:62
GetEvent
#define GetEvent
Definition: OS_API.h:47
E_OS_PARAM_POINTER
@ E_OS_PARAM_POINTER
Definition: Types.h:50
GetScheduleTableStatus
#define GetScheduleTableStatus
Definition: OS_API.h:94
AppModeType
enum applicationMode_e AppModeType
Type for application mode.