Real Time Operating System

Präsentation zum Thema: "Real Time Operating System"—  Präsentation transkript:

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

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

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

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

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

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

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

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

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

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

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

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

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