Echtzeit Betriebssystem ======================= RTOS = Realtime Operating System Multitasking ohne RTOS * Siehe den Artikel von Bill Earl: Multi-tasking the Arduino. https://learn.adafruit.com/multi-tasking-the-arduino-part-1 Motivation * https://gitlab.informatik.hs-augsburg.de/es2/es2-nucl476/taskswitch * https://gitlab.informatik.hs-augsburg.de/es2/es2-nucl476/shared-data-problem .. include:: cmsisrtos.rst Beispielprogramme ----------------- Die Beispielprogramme für Nucleo L476 sind auf gitlab: https://gitlab.informatik.hs-augsburg.de/es2/es2-nucl476/cube-demos Alle Beispiele sind mit CMSIS-RTOS v1 API! Damit Sie die Beispiele besser studieren können, navigieren Sie wieder mit dem Tags Mechanismus in Vim. * FreeRTOS_EXTI * FreeRTOS_LowPower * FreeRTOS_Mail * FreeRTOS_Mutexes * FreeRTOS_Queues * FreeRTOS_Semaphore * FreeRTOS_Semaphore3 * FreeRTOS_SemaphoreFromISR * FreeRTOS_Signal * FreeRTOS_SignalFromISR * FreeRTOS_ThreadCreation * FreeRTOS_ThreadCreation2 * FreeRTOS_Timers **Veranschaulichung durch "Bildchen"** .. figure:: img/rtosimg7.png FreeRTOS_ThreadCreation .. figure:: img/rtosimg1.png FreeRTOS_Semaphore und FreeRTOS_Signal .. figure:: img/rtosimg2.png FreeRTOS_EXTI und FreeRTOS_Queue .. figure:: img/rtosimg3.png FreeRTOS_Mail und FreeRTOS_Timers .. figure:: img/rtosimg4.png FreeRTOS_Mutexes .. figure:: img/rtosimg5.png FreeRTOS_SignalFromISR .. .. figure:: img/rtosimg6.png FreeRTOS_ThreadCreation2 (kam urspr. von Nucleo-L452RE/...) FreeRTOS -------- Multitasking mit RTOS * FreeRTOS als freies Projekt von Richard Barry seit 15 Jahren https://www.freertos.org * Kleines Echtzeit-Betriebssystem, das viele verschiedene Entwicklungsumgebungen und CPU Architekturen unterstützt. Siehe dazu im FreeRTOS Quelltext das Verzeichnis: ``FreeRTOSv10.1.1/FreeRTOS/Source/portable/`` * Von Amazon 2017 aufgekauft, deshalb nun "Amazon FreeRTOS" im Bereich der "Amazon Web Services" (AWS). https://aws.amazon.com/blogs/opensource/announcing-freertos-kernel-v10/ * MIT Lizenz **Quelltext von FreeRTOS in Cube Bibliothek** * ``Middlewares/Third_Party/FreeRTOS/`` **CMSIS RTOS** "Wrapper" um FreeRTOS * Siehe im Verzeichnis ``Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS/`` * Dateien ``cmsis_os.c`` und ``cmsis_os.h``. **Variablennamen** Präfixe * ``u`` - unsigned * ``p`` - pointer * ``uc`` - uint8_t * ``v`` - void * ``pc`` - pointer to char * ``pv`` - pointer to char * ``s`` - int16_t * ``l`` - int32_t * ``x`` - BaseType_t ("bester" Integer Datentyp auf Architektur) **Tasks** [BARRY]_, Kap. 3 Zustandsdiagramm * Im SUSPENDED Zustand ist die Task nicht für den Scheduler verfügbar. * Aus dem BLOCKED Zustand kommt man nur durch a) Zeitliche Events, oder b) Synchronisations Events .. figure:: img/taskdiagramm.png Zustandsdiagramm einer Task ([BARRY]_, S. 67) **Task Timing** .. figure:: img/task-timing1.png Zeitdiagramm zum Taskwechsel ([BARRY]_, S. 62) **Task Priorität** * 0 ist die niedrigste Priorität * Bereich: 0 ... configMAX_PRIORITIES-1 **Tasks anlegen und löschen** * xTaskCreate() * vTaskDelete() * vTaskStartScheduler() Beispiel: :: /* Args: Ptr to C fkt, descriptive name, stack depth, task parameter void*, priority, ptr to task handle Returns PASS or FAIL. */ xTaskCreate( prvQueueReceiveTask, "Rx", configMINIMAL_STACK_SIZE, NULL, mainQUEUE_RECEIVE_TASK_PRIORITY, NULL ); ... /* sample task */ prvQueueReceiveTask(void *pvParameters); **Tasks steuern** * vTaskDelay() * vTaskDelayUntil() * vTaskSuspend() * vTaskResume() * vTaskResumeFromISR() **Timer** ([BARRY]_, Kap. 5) "One-shot" und "Periodic timers" Zustände: Dormant, Running API: * xTimerCreate() * xTimerDelete() * xTimerStart() * xTimerDelete() * xTimerStop() * xTimerReset() * xTimerChangePeriod() Callback Funktion: ``void ATimerCallback( TimerHandle_t xTimer );`` Beispiel für STM32F100 mit Timer, Queue und zwei Tasks: https://www.freertos.org/FreeRTOS-for-Cortex-M3-STM32-STM32F100-Discovery.html **Synchronisationsmittel** * queues ([BARRY]_ Kap. 4 - Queues) - Mailboxen (Sonderfall einer Queue der Länge 1, [BARRY]_, Kap. 4.7, S. 144) * binary semaphores ([BARRY]_, Kap. 6 - Interrupt Management) * counting semaphores * mutexes ([BARRY]_, Kap. 7 - Resource Management) * recursive mutexes * event groups ([BARRY]_, Kap. 8 - Event Groups) * direct to task notifications ([BARRY]_, Kap. 9 - Task Notifications) * gatekeeper task ([BARRY]_, Kap. 7 - Resource Management) .. figure:: img/queue.png In [BARRY]_, Kap 4, S. 105 (Queue Management) sieht man einen Ablauf von mehreren Send/Receive Operationen. **Semaphore** ([BARRY]_, Kap. 6 - Interrupt Management) * vSemaphoreCreateBinary (Queue der Länge 1) * vSemaphoreCreateCounting * vSemaphoreCreateMutex * vSemaphoreTake (synonym: Take, P, decrement, down) * vSemaphoreGive (synonym: Give, V, incr, up) * vSemaphoreGiveFromISR Siehe Abb. in [BARRY]_, S. 194 (Synchronisieren einer Task mit einem Interrupt über eine binäre Semaphore). **Queue Management** ([BARRY]_, Kap. 4 - Queues) * Queues sind FIFO buffer. * Daten werden in die Queue kopiert. * Können von mehreren Tasks aus angesprochen werden. * Blockierzeit beim Lesen und beim Schreiben einstellbar. - Mehrere Schreiber können blockieren, wenn die Queue voll ist. Wenn Platz frei ist, wird nur ein Schreiber aktiviert. - Falls mehrere Leser blockieren, dann wird nur ein Leser bei Datenempfang aktiviert. * Queues können gruppiert werden ("queue sets"). API * xQueueCreate * xQueueSend * xQueueReceive **Mutex** ([BARRY]_, Kap. 7 - Resource Management) * mutex = MUTual EXclusion * Spezielle Form einer binären Semaphore um auf eine Resource zuzugreifen, die von mehreren Tasks geteilt wird. * Beispiel: vPrintString() * xSemaphoreCreateMutex() * Abb. [BARRY]_, S. 245 * Prioritätsinversion ([BARRY]_, S. 250) * Rekursive Mutexe * Gatekeeper Tasks - Gegenseitiger Ausschluss ohne Prioritätsinversion oder Deadlock - Dem Gatekeeper "gehört" die Resource - "Klienten" des Gatekeeper senden Nachricht über Queue - vPrintString() jetzt mit Gatekeeper **Signale** * kommen in FreeRTOS eigentlich nicht vor, sondern in CMSIS RTOS (siehe [YIUDG]_, Kap. 19) * API: ``osSignalSet()``, ``osSignalWait()``, ``osSignalClear()`` * Siehe Beispiele - es2-nucl476/cube-demos/FreeRTOS_Signal() - es2-nucl476/cube-demos/FreeRTOS_SignalFromISR() **Heap Management** [BARRY]_, Kap. 2 * pvPortMalloc() * vPortFree() Verschiedene Strategien: * heap1: deterministisch (kein free()) * heap2: best fit (nicht deterministisch) * heap3: stdlib malloc() und free() * heap4: first fit algo **API** .. figure:: _static/freertos-api.png :target: _static/freertos-api.png FreeRTOS API Literatur zum RTOS Kapitel -------------------------- *FreeRTOS* .. [BARRY] Mastering the FreeRTOS Real Time Kernel, 2016. https://hhoegl.informatik.hs-augsburg.de/es2/prog/rtos/Mastering-FreeRTOS-2016.pdf 1. The FreeRTOS distribution #. Heap Memory Management #. Task Management #. Queue Management #. Software Timer Management #. Interrupt Management #. Resource Management #. Event Groups #. Task Notifications #. Low Power Support #. Developer support .. [BARRY2] Real Time Application Design Tutorial. Using FreeRTOS in small embedded systems. https://www.freertos.org/tutorial lokale Kopie: https://hhoegl.informatik.hs-augsburg.de/es2/prog/rtos/freertos-designguide/freertos-designtipps.html .. [BROWN] Kap. 16 (Real-Time Operating Systems), S. 217-235. https://hhoegl.informatik.hs-augsburg.de/es2/Buecher/Brown-Discovering-the-STM32-2016/book.pdf .. [UM1722] Developing Applications on STM32Cube with RTOS, 26 Seiten. Erklärt auch kurz die FreeRTOS Beispiele (mit CMSIS-RTOS API!) in der CubeF4 Bibliothek. https://hhoegl.informatik.hs-augsburg.de/es2/prog/rtos/UM1722-Cube-FreeRTOS.pdf .. [FREERTOS] FreeRTOS Konzepte https://www.freertos.org/implementation/main.html .. [AOSARTOS] The Architecture of Open-Source Applications (Volume II), FreeRTOS https://www.aosabook.org/en/freertos.html .. [OSBOOKS] Allgemein zu empfehlen sind auch alle Standardwerke zu Betriebssystemen: Tanenbaum, Silberschatz, Stallings ... - Tanenbaum, Modern Operating Systems, Kap. "Processes and Threads". - Silberschatz, Operating System Concepts, Kap. 6 "Synchronization". - Stallings, Operating Systems. Internals and Design Principles, Kap. 5 "Concurrency: Mutual Exclusion and Synchronization". ---- Verweise auf die allgemeinen Literaturangaben :numref:`lit`. [YIUDG]_, Kap. 19 (Using Embedded Operating Systems), S. 605-645. Behandelt CMSIS-RTOS, nicht FreeRTOS. https://hhoegl.informatik.hs-augsburg.de/es2/Buecher/DGCM3andCM4-3e-ch19.pdf [MARTIN]_, Kap. 6 (Developing with CMSIS RTOS), S. 165-216 (erste Auflage von 2013). [WHITE]_, Kap. 5 (Managing the Flow of Activity) [NOVIELLO]_, Kap. 23 (Running FreeRTOS), S. 635-703. .. ARM MBED Dokumentation, Kapitel über "CMSIS-RTOS" https://os.mbed.com/handbook/CMSIS-RTOS CMSIS-RTOS Homepage der Fa. Keil https://www.keil.com/cmsis/rtos