Real Time Operating System Tasks voneinander weitgehend unabhngige

Real Time Operating System • Tasks voneinander weitgehend unabhängige Aufgaben die möglichst gleichzeitig auszuführen sind. • Operating System übernimmt die Verwaltung und Koordination der Tasks. Task 1 Task 2 Task 3 • Real Time möglichst rechtzeitige Reaktion auf eintreffende Ereignisse, möglichst exaktes Einhalten von Zeitanforderungen 19. 3. 2010 D µ Embedded Systems

Real Time Operating System • Task Management Task kreieren. Task terminieren. Scheduler: Untersucht ob Wartebedingungen erfüllt sind. Dispatcher: Entscheidet welche der wartenden Tasks zur Ausführung kommt. • Resource Management Speicher-Verwaltung I/O-Verwaltung Dateiverwaltung Protokoll-Stacks, usw. • Reliability Fehlererkennung, -behandlung. • Security Zugriffskontrolle Object Protection 19. 3. 2010 D µ Embedded Systems

Task Konzept • Task Funktionelle und strukturelle Einheit des Betriebssystems – Programm mit eigener abgeschlossener Umgebung. • Task Control Block – Informationen über Zustand und Priorität der Task – CPU und System Context • Task Zustände – ready, running, waiting, suspended. 19. 3. 2010 D µ Embedded Systems 3

Taskzustände suspended: Die Task nimmt nicht am Geschehen teil. ready: Die Task ist ablauffähig und wartet auf die Zuteilung des Prozessors. busy: Der Code der Task wird ausgeführt waiting: Die Task wartet auf das Eintreten eines Ereignisses. 19. 3. 2010 D µ ready busy waiting Embedded Systems

Task Management Tasks werden kreiert suspended Prozessor ist verfügbar busy RTX 166 tiny: Beim Start wird Task 0 ausgeführt, sie aktiviert alle erforderlichen weiteren Tasks. D Dispatcher Wartebedingung ist erfüllt waiting 19. 3. 2010 ready ready µ Embedded Systems Scheduler

Task Management • Scheduler sorgt für die Bereitstellung der Tasks (u. U. unter Berücksichtigung der Taskpriorität): – Zeitscheiben: Maximale Zeit, die der Task zur Verfügung steht. Round-Robin-Scheduling - preemptive Scheduling – Kooperatives Scheduling: Task wartet auf Eintreten eines Ereignisses non preemptive Scheduling • Dispatcher sorgt für die korrekte Umschaltung zur bereitgestellten Task • Synchronization Interprozesskommunikation mittels: – Signal – Semaphore – Mailboxes – Messages 19. 3. 2010 D µ Embedded Systems 6

Task Interaction - Synchronization Asynchronous via Mailbox Sender Task 19. 3. 2010 D Receiver Task µ Synchronous via Message Passing Sender Task Embedded Systems Receiver Task 7

Real Time Operating System RTX 166 Full • Task Switching • • • – Round Robin – Cooperative • 256 Tasks max. signal passing message passing with mailbox system semaphores 128 task priorities "os_wait" function 19. 3. 2010 D µ interrupt timeout signal from task or interrupt message from task or interrupt semaphore Embedded Systems 8

Real Time Operating System RTX 166 Tiny • Task Switching • signal passing – Round Robin – Cooperative • 32 Tasks max. "os_wait" function 19. 3. 2010 D µ interval timeout signal from task or interrupt Embedded Systems 9

Real Time Operating System RTX 166 Single Task Program int counter; void main (void) { counter = 0; while (1) { /* repeat forever */ counter++; /* increment counter */ } } 19. 3. 2010 D µ Embedded Systems

Real Time Operating System RTX 166 Round-Robin Task Switching #include <rtx 166 t. h> int counter 0, counter 1; void job 0 (void) _task_ 0 os_create_task (1); while (1) { counter 0++; } } { /* Mark task 1 as "ready" */ /* Endless loop */ /* Increment counter 0 */ void job 1 (void) _task_ 1 { while (1) { /* Endless loop */ counter 1++; /* Increment counter 1 */ } } Rtx_1 19. 3. 2010 D µ Embedded Systems

Real Time Operating System RTX 166 Cooperative Task Switching: Wait for Timeout #include <rtx 166 t. h> int counter 0, counter 1; void job 0 (void) _task_ 0 { os_create_task (1); while (1) { counter 0++; os_wait (K_TMO, 3, 0); } } void job 1 (void) _task_ 1 { while (1) { counter 1++; os_wait (K_TMO, 5, 0); } } /* Increment counter 0 */ /* Wait 3 timer ticks */ /* Increment counter 1 */ /* Wait 5 timer ticks */ Rtx_1 19. 3. 2010 D µ Embedded Systems

Real Time Operating System RTX 166 Cooperative Task Switching: Wait for Signal #include <rtx 166 t. h> int counter 0, counter 1; void job 0 (void) _task_ 0 { os_create_task (1); while (1) { if (++counter 0 == 0) { /* On counter 0 overflow*/ os_send_signal (1); /* Send signal to task 1*/ } } } void job 1 (void) _task_ 1 { while (1) { os_wait (K_SIG, 0, 0); /* Wait for signal; no timeout */ counter 1++; /* Increment counter 1 */ } Rtx_1 } 19. 3. 2010 D µ Embedded Systems