Embedded Systemarchitekturen und Echtzeitbetriebssysteme

Transkript

1 Hochschule für angewandte Wissenschaften Fachhochschule Würzburg-Schweinfurt Wintersemester 2011/2012 Diplomfachprüfung im Fach Embedded Systemarchitekturen und Echtzeitbetriebssysteme (Prof. Dr.-Ing. Ludwig Eckert) Datum: , Uhr, Raum 0435 Dauer: 90 Minuten Erreichte Punktzahl:... Note:... Hilfsmittel: Ohne schriftliche Unterlagen, ohne Mobiltelefone, Taschenrechner erlaubt. Vorname:... Name:... Matrikelnr:... Erstprüfer:... Zweitprüfer:... Wichtige Hinweise: Bitte tragen Sie alle Antworten auf den folgenden Seiten direkt im Anschluss an die Aufgabentexte ein. Ergebnisse auf Zusatzblättern werden nur in begründeten Ausnahmefällen gewertet. Seite 1 von 24

2 Aufgabe 1: Gegeben ist der nachfolgende Verlauf eines Digitalsignals. Das Signal liegt an dem Port 1, Pin 0 des µcontrollers MSP430x449 an. Beschreiben Sie eine Lösung zur Erfassung des zeitlichen Abstandes zwischen zwei aufeinander folgenden fallenden Signalflanken. Gehen Sie hierbei insbesondere a) auf das Verfahren zur Detektion der fallenden Signalflanken und b) auf das Verfahren zur Bestimmung der zeitlichen Abstände t 1, t 2, t 3 usw. ein. Seite 2 von 24

3 Aufgabe 2: Ordnen Sie die nachstehenden Begriffe den Signalverläufen und den jeweiligen Pfeilen zu. a) wert- und zeitkontinuierlich, b) werte- und zeitdiskret, c) wertdiskret und zeitkontinuierlich, d) wertkontinuierlich und zeitdiskret, e) Abtastung, f) Quantisierung u(t) analoges Signal wert- und zeitkontinuierlich t Quantisierung Abtastung u q (t) u(n T) t wertdiskret zeitkontinuierlich Abtastung u q (n T) t wertkontinuierlich zeitdiskret werte- und zeitdiskret Quantisierung t Seite 3 von 24

4 Aufgabe 3: Zwei Embedded Computer sollen über eine RS232-Schnittstelle direkt gekoppelt werden. a) Geben Sie eine minimale Leitungskonfiguration für die Hardwareverbindung an? b) Welche Konfigurationseinstellungen müssen auf der Sende- und Empfangsseite in dem USART 1 - Baustein eingestellt werden? Aufgabe 4: Gegeben ist ein nach dem Verfahren der sukzessiven Approximation arbeitender 8-Bit A/D-Wandler, dessen innerer Aufbau durch das nachfolgende Bild verdeutlicht wird. Zu Beginn einer Wandlung steht das Approximationsregister auf 00h. Die nachstehende Tabelle zeigt das Approximationsregister N ADC das sich sukzessive dem digitalen Endwert 65h annähert. 1 USART - Universal Synchronous/Asynchronous Receive/Transmit Seite 4 von 24

5 Der nachgeschaltete D/A-Wandler erzeugt eine dem aktuellen Approximationsregister äquivalente analoge Spannung U N (N ADC ). Zeichen Sie bitte den Spannungsverlauf U N (N ADC ) in die nachstehende Skizze ein. Bild: Bildung des Digitalwertes N ADC nach dem Verfahren der sukzessiven Approximation Aufgabe 5: Gegeben sind die nachstehenden Funktionen a) und b), die von verschiedenen Tasks innerhalb eines RTOS basierenden Echtzeitsystems verwendet werden sollen. Geben Sie an, ob diese Funktionen a priori reentrant sind oder nicht und begründen Sie Ihre Antwort. a) void strcpy(char *dest, char *src) while (*dest++ = *src++) ; *dest = NUL; Seite 5 von 24

6 b) int temp; void swap (int *x, int *y) temp = *x; *x = *y; *y = temp; Seite 6 von 24

7 Aufgabe 6: Das nachstehende Bild zeigt verschiedene Schedulingstrategien am Beispiel einer Warteschlange vor einem Kopiergerät. Beschriften Sie die nachstehenden Schedulingstrategien. Bild: Schedulingstrategien am Beispiel einer Warteschlange vor einem Kopiergerät Aufgabe 7: Gegeben sind ein hochpriorer Task, ein niederpriorer Task und eine Interrupt Service Routine (ISR) die den hochprioren Task in den Ready-Zustand versetzt. Der Scheduler arbeitet prioritätsbasiert. In Abhängigkeit des zugrundeliegenden RTOS Kernels verändert sich die Abarbeitungsfolge der Tasks. Bild b) zeigt den Taskablauf unter Zugrundelegung eines non-preemptiven also kooperativ arbeitenden Kernels. Wie verändert sich der Taskablauf, wenn ein preemptiver Kernel zugrunde gelegt werden würde. Ergänzen Sie hierzu die Taskbearbeitung in Bild c). Seite 7 von 24

8 Aufgabe 8: a) Was versteht man unter einer Idle -Task und wann wird dieser Task von dem RTOS- Scheduler aufgerufen? Seite 8 von 24

9 b) Welche Möglichkeiten gibt es in diesem Zusammenhang den Energieverbrauch eines Embedded Systems zu reduzieren? Nennen Sie zwei Maßnahmen. Aufgabe 9: Gegeben ist das nachstehende Blockdiagramm eines Minimal-Betriebssystems. Bitte beschriften Sie die einzelnen Funktionsblöcke und benennen Sie deren Hauptaufgaben (Zweck). Bild: Blockdiagramm des Minimal-Betriebssystems Aufgabe 10: a) Nehmen Sie bitte eine Klassifizierung der Schedulingverfahren vor, indem Sie die nachstehenden Begriffe den grauen Feldern zuordnen. Seite 9 von 24

10 Bild: Klassifizierung der Schedulingverfahren b) Nennen Sie die Unterschiede zwischen dem Earliest-Deadline-First- und dem Least-Laxity- First-Scheduling Verfahren. Seite 10 von 24

11 Aufgabe 11: Gegeben sind drei Tasks mit unterschiedlichen Prioritäten (HIGH, MID, LOW). Es soll ein preemptiver, prioritätsbasiert arbeitender Kernel zum Einsatz kommen. /* includes */ #include "vxworks.h" #include "tasklib.h" #include "loglib.h" /* function prototypes */ void taskone(void); void tasktwo(void); void taskthree(void); /* globals */ #define ITER1 100 #define ITER2 1 #define LONG_TIME #define HIGH 100 /* high priority */ #define MID 101 /* medium priority */ #define LOW 102 /* low priority */ void sched(void) /* function to create the three tasks */ int taskidone, taskidtwo, taskidthree; /* spawn the three tasks */ if((taskidone = taskspawn("task1",low,0x100,20000,(funcptr)taskone,0,0,0,0,0,0,0,0,0,0))==error) printf("taskspawn taskone failed\n"); if((taskidtwo = taskspawn("task2",mid,0x100,20000,(funcptr)tasktwo,0,0,0,0,0,0,0,0,0,0))==error) printf("taskspawn tasktwo failed\n"); if((taskidthree = taskspawn("task3",high,0x100,20000,(funcptr)taskthree,0,0,0,0,0,0,0,0,0,0))==error) printf("taskspawn taskthree failed\n"); void taskone(void) int i,j; for (i=0; i < ITER1; i++) for (j=0; j < ITER2; j++) logmsg("\n",0,0,0,0,0,0); for (j=0; j < LONG_TIME; j++); void tasktwo(void) Seite 11 von 24

12 int i,j; for (i=0; i < ITER1; i++) for (j=0; j < ITER2; j++) logmsg("\n",0,0,0,0,0,0); for (j=0; j < LONG_TIME; j++); void taskthree(void) int i,j; for (i=0; i < ITER1; i++) for (j=0; j < ITER2; j++) logmsg("\n",0,0,0,0,0,0); for (j=0; j < LONG_TIME; j++); a) In welcher Reihenfolge werden die Tasks abgearbeitet? b) Modifizieren Sie nun das Programm durch Hinzufügen von binären Semaphoren so, dass sich die Reihenfolge der Taskausführung wie folgt verändert: "taskone", dann "tasktwo", schließlich "taskthree." Die Taskreihe soll insgesamt 100x ausgeführt werden. Tragen Sie alle Änderungen inkl. der Initialisierungen direkt in das obige Programm ein. Aufgabe 12: Nachfolgend ist das zeitliche Sollverhalten von 4 Rechenprozessen (RP1-RP4) dargestellt, wobei der RP4 die höchste und RP1 die niedrigste Priorität aufweist. Es soll ein preemptiver Multitasking-Kernel, der prioritätsbasiert arbeitet, zugrunde gelegt werden. Seite 12 von 24

13 a) Tragen Sie in das nachstehende Bild die tatsächliche Abarbeitung der Rechenprozesse ein (bis zum normierten Zeitpunkt t/t = 12). Seite 13 von 24

14 b) Ein Prozess gilt als rechtzeitig ausgeführt, wenn das Rechenergebnis noch innerhalb der Zykluszeit des jeweiligen Prozesses vorliegt. Wie beurteilen Sie unter diesem Gesichtspunkt die Rechtzeitigkeit der Rechenprozesse RP1 bis RP4? RP1: RP2: RP3: RP4: c) Berechnen Sie den Auslastungsgrad des Prozessors. Anm.: Es soll ein Ein-Prozessorsystem vorausgesetzt werden! Seite 14 von 24

15 d) Tragen Sie den zeitlichen Verlauf der Taskzustände der Rechenprozesse RP1, RP2 und RP4 in das nachstehende Diagramm ein. Seite 15 von 24

16 laufend bereit wartend/blockiert ruhend t/t Bild: Taskzustände des Rechenprozesses RP3 laufend bereit wartend/blockiert ruhend t/t Bild: Taskzustände des Rechenprozesses RP4 Seite 16 von 24

17 Aufgabe 13: Gegeben ist das nachstehende VxWorks-Programm. Analysieren Sie dieses und beantworten Sie die nachstehenden Fragen. // includes #include "vxworks.h" #include "tasklib.h" #include "semlib.h" #include "stdio.h" // function prototypes void taskone(void); void tasktwo(void); // globals #define ITER 10 SEM_ID sembinary; int global = 0; void binary(void) int taskidone, taskidtwo; // create semaphore with semaphore available and queue tasks on FIFO basis sembinary = sembcreate(sem_q_fifo, SEM_FULL); // spawn the two tasks taskidtwo = taskspawn("t2",90,0x100,2000,(funcptr)tasktwo,0,0,0,0,0,0,0,0,0,0); taskidone = taskspawn("t1",100,0x100,2000,(funcptr)taskone,0,0,0,0,0,0,0,0,0,0); void taskone(void) int i; for (i=0; i < ITER; i++) semtake(sembinary,wait_forever); // wait indefinitely for semaphore printf("i am taskone and global = %d...\n", ++global); semgive(sembinary); // give up semaphore void tasktwo(void) int i; for (i=0; i < ITER; i++) semtake(sembinary,wait_forever); // wait indefinitely for semaphore printf("i am tasktwo and global = %d \n", --global); semgive(sembinary); // give up semaphore Seite 17 von 24

18 a) Protokollieren Sie die Printausgabe, also den Wert der Variablen global über den gesamten Programmablauf. b) Was würde passieren, wenn alle semgive() und semtake() Befehle entfernt werden? Annahme: Der Scheduler arbeitet nach dem First Come First Served Prinzip, ein Round Robin -Verfahren ist nicht implementiert. Protokollieren Sie auch hier die Printausgabe, also den Wert der Variablen global über den gesamten Programmablauf. Aufgabe 14: Im nachstehenden Programm sind die Semaphoroperationen jeweils am Anfang und am Ende der Tasks angeordnet. Ermitteln Sie, ob und in welcher Reihenfolge diese Tasks bei einer Initialisierung nach a) und b) ablaufen. SA, SB und SC stellen Counting-Semaphoren dar. Anm.: Der RTOS-Scheduler arbeitet prioritätsorientiert und nach dem First Come First Served - Prinzip, der Kernel ist non-preemptiv. Die Tasks werden in der Reihenfolge TaskA, TaskB und TaskC initialisiert. Alle Tasks besitzen die Priorität 90. TaskA TaskB TaskC while(1) while(1) while(1) SemTake(SA); SemTake (SB) ; SemTake(SC) ; SemTake(SA); SemTake (SB) ; SemTake(SC) ; SemTake(SA) ;. SemTake(SC) ; // Sourcecode TaskA // Sourcecode TaskB // Sourcecode TaskC SemGive(SC) ; SemGive(SB) ; SemGive(SB); SemGive(SA) ; SemGive(SB) ; Bild: Anordnung der Semaphoren-Operationen in den Tasks Seite 18 von 24

19 Aufgabe a) Werte der Semaphorvariablen Reihenfolge der Tasks SA SB SC Anfangswerte Aufgabe b) Werte der Semaphorvariablen Reihenfolge der Tasks SA SB SC Anfangswerte Seite 19 von 24

20 Aufgabe 15: Im nachstehenden Programm sind die Operationen zur Beeinflussung der Semaphoren jeweils am Anfang und am Ende der Tasks angeordnet. Der RTOS-Scheduler arbeitet prioritätsorientiert und nach dem First Come First Served -Prinzip, der Kernel ist non-preemptiv. Die Tasks werden in der Reihenfolge TaskA, TaskB und TaskC initialisiert. Alle Tasks besitzen die Priorität 90. a) Ermitteln Sie die Anfangswerte für SA, SB und SC so, dass das nachstehende periodische Impulsdiagramm erzeugt werden kann. TaskA TaskB TaskC while(1) while(1) while(1) SemTake(SA); SemTake (SB) ; SemTake(SC) ; SemTake(SA); SemTake(SC) ; SemTake(SA) ; SemTake(SC) ; SetP1.0_LH(); SetP1.1_LH(); SetP1.2_LH(); taskdelay(50); taskdelay(100); taskdelay(200); SetP1.0_HL(); SetP1.1_HL(); SetP1.2_HL(); SemGive(SC) ; SemGive(SB) ; SemGive(SB); SemGive(SA) ; SemGive(SB) ; Bild: Anordnung der Semaphoren-Operationen in den Tasks P1.0 laufend ruhend 0 t [µs] P1.1 laufend ruhend 0 t [µs] P1.2 laufend ruhend t [µs] Bild: Impulsdiagramm Seite 20 von 24

21 b) Geben Sie die Initialisierung der Semaphoren SA, SB und SC an. Verwenden Sie dabei die RTOS-Funktionen im Anhang dieser Aufgabenstellung. Aufgabe 16: In einem Parkhaus mit insgesamt N=50 Parkplätzen werden Ein- und Ausfahrt mit Induktionsschleifen überwacht. An der Einfahrt steht eine Ampel, die auf "rot" geschaltet wird, wenn kein Parkplatz mehr frei ist, gleichzeitig bleibt die Schranke geschlossen. Die Ampel wird auf grün geschaltet, wenn Parkplätze frei sind. Im letzten Fall öffnet sich automatisch die Schranke, wenn die Induktionsschleife1 signalisiert. Für die Programmsteuerung stehen folgende Eingabesignale (Ereignisse) zur Verfügung: - Boolean Kfz_auf_Induktionsschleife1 - Boolean Kfz_auf_Induktionsschleife2 Ebenso stehen folgende Ausgabefunktionen zur Verfügung: - Aktorfunktion Schranke1_öffnen() - Aktorfunktion Schranke1_schließen() - Aktorfunktion Schranke2_öffnen() - Aktorfunktion Schranke2_schließen() - Aktorfunktion Ampel_auf_rot_schalten() - Aktorfunktion Ampel_auf_grün_schalten() a) Erstellen Sie in C-Notation oder in strukturiertem Pseudocode das Anwendungssystem Parkhaus Automatisierung. Es soll ein taskorientiertes, echtzeitfähiges Multitasking-System zugrunde gelegt werden. Dabei soll jeweils ein Prozess für die Zufahrt Task_Zufahrt() und ein Prozess für die Ausfahrt Task_Ausfahrt() und eine allgemeine Initialisierungsfunktion Init() realisiert werden. Sollten weitere Eingabesignale bzw. Ausgabefunktionen benötigt werden, so sind diese entsprechend zu definieren. Seite 21 von 24

22 Verwenden Sie, soweit erforderlich, die RTOS-Funktionen auf der letzten Seite der Aufgabenstellung. Anm.: Die Aufgabenstellung soll mit Hilfe von Counting-Semaphoren gelöst werden. Seite 22 von 24

23 b) Welche Rolle spielen die Prioritäten der beiden Tasks Task_Zufahrt() und Task_Ausfahrt() im Anwendungssystem? Welche Prioritäten weisen Sie den beiden Tasks zu? Befehle zum Taskmanagement und zur Tasksynchronisation SEM_ID = sembcreate(int options, SEM_B_STATE initialstate) // Erzeugung und Initialisierung einer binären Semaphore // SEM_ID: Rückgabewert: Semaphor ID oder NULL, falls die Semaphore nicht erzeugt werden konnte // options: SEM_Q_PRIORITY: Warteschlange nach Priorität und FIFO-Prinzip, // SEM_Q_FIFO: Warteschlange nur nach FIFO-Prinzip. Seite 23 von 24

24 // initalstate: SEM_EMPTY oder SEM_FULL. // Hinweis: Der Semaphor ist nach Aufruf arbeitsbereit. SEM_ID = semmcreate(int options, SEM_B_STATE initialstate) // Erzeugung und Initialisierung einer Mutual Exclusion Semaphore SEM_ID = semccreate(int options, SEM_B_STATE initialstate) // Erzeugung einer Couting Semaphore STATUS = semgive(sem_id semld) // signalisiert die Semaphore semid // STATUS: Rückgabewert: OK oder ERROR, wenn Fehler bei der Signalisierung STATUS = semtake(sem_id semld, int timeout) // nimmt die Semaphore semid // STATUS: Rückgabewert: OK oder ERROR, wenn Semaphore semid nicht vorhanden ist oder wenn // eine Wartezeitüberschreitung aufgetreten ist. // timeout: NOWAIT, WAIT_FOREVER oder Anzahl Ticks warten // Hinweis: Diese Funktion kann nicht in einer ISR aufgerufen werden. STATUS = semdelete(sem_id semld) // Semaphore semid wird durch semdelete() gelöscht. // STATUS: Rückgabewert: OK oder ERROR // Hinweis: Der Semaphor wird gelöscht. STATUS = semflush(sem_id semld) // STATUS: Rückgabewert: OK oder ERROR // Hinweis: Alle Tasks, die auf die Semaphore warten, werden in den Ready-Zustand versetzt. TaskId = taskspawn (name, priority, options, stacksize, entrypoint, arg1,.. arg10) // Task kreieren und aktivieren // TaskId: ist die vom System zugewiesene TaskID // name: Name der Task, bestehend aus ASCI Zeichen, z. B. "tmeine_task" // priority: Priorität in VxWorks wählbar zwischen 0 (höchste) bis 255 (niedrigste) Priorität // options: Optionen z. B. für das "Task-Debugging" // stacksize: Größe des Stackspeichers für einen Task in Bytes // entrypoint: Hier wird der Name der C-Funktion eingetragen, die im Taskkontext ablaufen soll. // arguments: Diese Argumente sind die C-Funktionsübergabeparameter der Entrypoint-Funktion. Seite 24 von 24