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 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 Embedded Systems

Task Konzept Task Task Control Block Task Zustände 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 Embedded Systems

Taskzustände suspended ready busy waiting suspended: Die Task nimmt nicht am Geschehen teil. busy ready: Die Task ist ablauf-fä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. waiting 19.3.2010 Embedded Systems

Task Management ready busy waiting suspended Dispatcher Scheduler Tasks werden kreiert suspended Prozessor ist verfügbar Dispatcher busy RTX166tiny: Beim Start wird Task 0 ausgeführt, sie aktiviert alle erforderlichen weiteren Tasks. Wartebedingung ist erfüllt waiting Scheduler 19.3.2010 Embedded Systems

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 Embedded Systems

Task Interaction - Synchronization Asynchronous via Mailbox Synchronous via Message Passing  Sender Task Receiver Sender Task Receiver 19.3.2010 Embedded Systems

Real Time Operating System RTX166 RTX166 Full Task Switching Round Robin Cooperative 256 Tasks max.  128 task priorities signal passing message passing with mailbox system semaphores "os_wait" function  interrupt timeout signal from task or interrupt message from task or interrupt semaphore 19.3.2010 Embedded Systems

Real Time Operating System RTX166 RTX166 Tiny Task Switching Round Robin Cooperative 32 Tasks max. signal passing "os_wait" function  interval timeout signal from task or interrupt 19.3.2010 Embedded Systems

Real Time Operating System RTX166 Single Task Program int counter; void main (void) { counter = 0; while (1) { /* repeat forever */ counter++; /* increment counter */ } 19.3.2010 Embedded Systems

Real Time Operating System RTX166 Round-Robin Task Switching #include <rtx166t.h> int counter0, counter1; void job0 (void) _task_ 0 { os_create_task (1); /* Mark task 1 as "ready" */ while (1) { /* Endless loop */ counter0++; /* Increment counter 0 */ } void job1 (void) _task_ 1 { while (1) { /* Endless loop */ counter1++; /* Increment counter 1 */ Rtx_1 19.3.2010 Embedded Systems

Real Time Operating System RTX166 Cooperative Task Switching: Wait for Timeout #include <rtx166t.h> int counter0, counter1; void job0 (void) _task_ 0 { os_create_task (1); while (1) { counter0++; /* Increment counter 0 */ os_wait (K_TMO, 3, 0); /* Wait 3 timer ticks */ } void job1 (void) _task_ 1 { counter1++; /* Increment counter 1 */ os_wait (K_TMO, 5, 0); /* Wait 5 timer ticks */ Rtx_1 19.3.2010 Embedded Systems

Real Time Operating System RTX166 Cooperative Task Switching: Wait for Signal #include <rtx166t.h> int counter0, counter1; void job0 (void) _task_ 0 { os_create_task (1); while (1) { if (++counter0 == 0) { /* On counter 0 overflow*/ os_send_signal (1);/* Send signal to task 1*/ } void job1 (void) _task_ 1 { os_wait (K_SIG, 0, 0); /* Wait for signal; no timeout */ counter1++; /* Increment counter 1 */ Rtx_1 19.3.2010 Embedded Systems