Curs 4 - RTOS și Planificarea Sarcinilor în Embedded Systems

Acest curs explorează sistemele de operare în timp real (RTOS), planificarea sarcinilor și gestionarea resurselor într-un sistem embedded.

1. Ce este un RTOS?

RTOS (Real-Time Operating System) este un sistem de operare optimizat pentru execuția predictibilă a sarcinilor critice în timp real. Este utilizat în sisteme embedded unde latența redusă și fiabilitatea sunt esențiale, cum ar fi sistemele industriale, automotive și medicale.

2. Diferențe între un RTOS și un OS convențional

Spre deosebire de un sistem de operare general (ex: Linux, Windows), un RTOS are timpi de răspuns predictibili și gestionează eficient resursele hardware pentru a executa task-urile într-un mod determinist.

3. Tipuri de RTOS

- Hard Real-Time RTOS: Respectă strict constrângerile de timp (ex: sisteme de control aeronautic).

- Soft Real-Time RTOS: Întârzierile ocazionale sunt acceptabile (ex: streaming media).

- Firm Real-Time RTOS: Timpii de răspuns sunt importanți, dar nu critici (ex: control robotic industrial).

4. Arhitectura unui RTOS

Un RTOS este alcătuit din mai multe componente, printre care:

- Kernel RTOS: Coordonează execuția task-urilor și gestionează resursele.

- Scheduler: Decide ordinea în care task-urile sunt executate.

- Task-uri (Threads/Processes): Unități independente de execuție.

- Mecanisme de sincronizare (Mutex, Semaphores, Queues): Evită conflictele între task-uri.

- Interrupții și Timere: Permite reacții rapide la evenimente externe.

5. Planificarea Sarcinilor în RTOS

RTOS utilizează algoritmi de planificare pentru a decide ordinea în care sunt executate task-urile.

a) Algoritmi de planificare

- Preemptiv: Task-urile cu prioritate mai mare pot întrerupe execuția altor task-uri.

- Round-Robin: Fiecare task primește un timp fix de execuție.

- Rate Monotonic Scheduling (RMS): Task-urile cu perioada mai scurtă au prioritate mai mare.

- Earliest Deadline First (EDF): Task-ul cu deadline-ul cel mai apropiat este executat primul.

6. Crearea unui Task în FreeRTOS

FreeRTOS este unul dintre cele mai utilizate RTOS-uri open-source. Exemplu de creare a unui task în FreeRTOS:

void vTaskFunction(void *pvParameters) {
    while (1) {
        printf("Task executat\n");
        vTaskDelay(1000 / portTICK_PERIOD_MS); // Așteaptă 1 sec
    }
}

int main() {
    xTaskCreate(vTaskFunction, "Task1", 1000, NULL, 1, NULL);
    vTaskStartScheduler(); // Pornește planificatorul RTOS
    while(1);
}

7. Gestionarea Resurselor în RTOS

RTOS utilizează mecanisme pentru a preveni accesul simultan la resurse partajate, cum ar fi memoria sau perifericele.

a) Semaphores

Semaphoarele sunt utilizate pentru a sincroniza accesul la resurse între mai multe task-uri.

SemaphoreHandle_t xSemaphore;

void vTaskFunction(void *pvParameters) {
    if (xSemaphoreTake(xSemaphore, portMAX_DELAY)) {
        // Acces la resursa
        xSemaphoreGive(xSemaphore); // Eliberare resursă
    }
}

b) Mutex

Mutexul permite acces exclusiv la o resursă pentru un singur task la un moment dat.

xSemaphore = xSemaphoreCreateMutex();
if (xSemaphore != NULL) {
    xSemaphoreTake(xSemaphore, portMAX_DELAY);
    // Folosește resursa
    xSemaphoreGive(xSemaphore);
}

c) Queues

Queues sunt utilizate pentru comunicarea între task-uri.

QueueHandle_t xQueue;
int data = 10;
xQueueSend(xQueue, &data, portMAX_DELAY);

8. Interacțiunea între RTOS și Interrupții

RTOS trebuie să gestioneze corect întreruperile pentru a evita blocarea task-urilor critice.

void ISR_Handler(void) {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    xSemaphoreGiveFromISR(xSemaphore, &xHigherPriorityTaskWoken);
    portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}

9. Exercițiu Practic - Implementare a unui Scheduler Simplu

Scrie un program care creează două task-uri în FreeRTOS, unul care aprinde un LED la fiecare 500ms și altul care citește un senzor la fiecare 1s.

Resurse suplimentare:

• FreeRTOS Documentation
• RTOS Scheduling Algorithms
• Synchronization in RTOS