Schița subiectului

    • Curs
    •••
    Lucrări pr.
    1
    2
    3
    4
    5
    6
    Lucru ind.
    •••
    Evaluări
    •••
    Suport teoretic
    •••

    • T1. Introducere în programarea aplicațiilor de timp real

      Obiective
      • Definirea sistemelor de timp real (hard vs. soft real-time) și a termenilor esențiali.
      • Înțelegerea determinismului, latenței și a termenelor-limită (deadline).
      • Prezentarea platformei STM32 și a ecosistemului HAL/CMSIS.
      Cuvinte-cheie: timp real determinism deadline STM32 HAL/CMSIS
      timp real: sistem în care corectitudinea depinde și de momentul obținerii rezultatului, nu doar de valoare.
      determinism: comportament previzibil; aceleași intrări → aceleași timming-uri/rezultate.
      deadline: termen-limită până la care rezultatul trebuie furnizat.
      STM32: familie de microcontrolere ARM Cortex-M (M0/M3/M4/M7) pentru aplicații embedded.
      HAL/CMSIS: biblioteci ST (HAL) & standard ARM (CMSIS) pentru acces periferice și nucleu.
      Exemplu aplicativ – Task periodic cu SysTick (CMSIS)
      // Cortex-M SysTick @1ms; toggling LED la fiecare 100 ms
volatile uint32_t ticks = 0;
void SysTick_Handler(void){ ticks++; }
int main(void){
  SystemCoreClockUpdate();
  SysTick_Config(SystemCoreClock/1000); // 1ms
  __HAL_RCC_GPIOC_CLK_ENABLE();
  GPIOC->MODER |= (1u << (13*2)); // PC13 output
  while(1){
    if(ticks % 100 == 0){ GPIOC->ODR ^= (1u << 13); }
  }
}

      T2. Sisteme de control de timp real pentru controlul proceselor industriale

      Obiective
      • Modele funcționale: achiziție → control → actuare → feedback.
      • Implementarea buclelor PID pe STM32 și considerente de timming.
      • Gestionarea erorilor, watchdog și siguranță funcțională de bază.
      Cuvinte-cheie: PID watchdog feedback jitter overrun
      PID: regulator Proporțional–Integral–Derivativ pentru control continuu.
      watchdog: timer hardware care resetează sistemul dacă software-ul nu răspunde.
      feedback: măsurarea ieșirii și corecția comenzii în funcție de eroare.
      jitter: variația nedorită a momentului execuției unui eveniment periodic.
      overrun: când execuția unei sarcini depășește fereastra/periodul planificat.
      Exemplu – Buclă PID discretă la perioadă fixă (Timer + HAL)
      typedef struct { float kp, ki, kd, e_prev, integ; } pid_t;
pid_t pid = {.kp=0.8f, .ki=0.05f, .kd=0.01f};
float pid_step(pid_t* p, float setp, float meas){
  float e = setp - meas; p->integ += e; float deriv = e - p->e_prev; p->e_prev = e;
  return p->kp*e + p->ki*p->integ + p->kd*deriv;
}
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef* h){ if(h->Instance==TIM2){
  float y = ReadSensorADC(); float u = pid_step(&pid, 50.0f, y);
  SetPWM(u); // saturare/anti-windup în SetPWM()
}}

      T3. Structura echipamentelor utilizate în sisteme de control de timp real

      Obiective
      • Identificarea blocurilor: MCU, senzori, actuatori, surse, protecții.
      • Topologii hardware pentru determinism și imunitate EM.
      • Introducere în DMA, întreruperi și periferice critice în timp.
      Cuvinte-cheie: DMA ISR EMI/EMC redundanță fail-safe
      DMA: transfer de date fără implicarea CPU, cu latență redusă.
      ISR: rutină de tratare a întreruperilor, executată la eveniment hardware.
      EMI/EMC: interferențe electromagnetice / compatibilitate electromagnetică.
      redundanță: elemente duble pentru creșterea fiabilității.
      fail-safe: trecere într-o stare sigură la defect.
      Exemplu – ADC cu DMA dublu-buffer (HAL)
      #define N 128
uint16_t bufA[N], bufB[N];
void start_adc_dma(void){
  HAL_ADC_Start_DMA(&hadc1, (uint32_t*)bufA, N); // în CubeMX: DMA circular + double buffer
  __HAL_DMA_ENABLE_IT(hadc1.DMA_Handle, DMA_IT_HT | DMA_IT_TC);
}
void HAL_ADC_ConvHalfCpltCallback(ADC_HandleTypeDef* h){ Process(bufA, N/2); }
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* h){ Process(bufA+N/2, N/2); }

      T4. Programarea dispozitivelor intrare/ieșire în aplicații de timp real

      Obiective
      • Configurarea GPIO, EXTI, timere, PWM, ADC/DAC pentru răspuns determinist.
      • Debouncing, filtrare și timestamping de evenimente.
      • Optimizarea latențelor prin ISR scurte și bufferizare.
      Cuvinte-cheie: GPIO/EXTI debounce timestamp PWM ISR minimă
      GPIO/EXTI: pini digitali și întreruperi externe pe front/ nivel.
      debounce: eliminarea tremurului mecanic al contactelor butoanelor.
      timestamp: marcarea exactă în timp a unui eveniment (timer free-running).
      PWM: modulare în durată pentru control motoare/LED-uri.
      ISR minimă: rutina de întrerupere trebuie să fie cât mai scurtă, logica grea în task.
      Exemplu – Buton EXTI cu debounce software (HAL)
      volatile uint32_t last_ms = 0;
void HAL_GPIO_EXTI_Callback(uint16_t pin){
  if(pin==GPIO_PIN_0){
    uint32_t now = HAL_GetTick();
    if(now - last_ms > 30){ // 30ms debounce
      ToggleStateMachine();
      last_ms = now;
    }
  }
}

      T5. Sisteme de operare de timp real (RTOS) multitasking

      Obiective
      • Concepte RTOS: task, prioritate, scheduler, preempțiune.
      • Sincronizare: semafoare, cozi, mutex; timere software.
      • Portare FreeRTOS pe STM32 și management stack/heap.
      Cuvinte-cheie: FreeRTOS task prioritate semafor/mutex queue
      FreeRTOS: RTOS open-source pentru MCU-uri cu scheduler preemptiv.
      task: fir de execuție cu stivă proprie; rulează sub controlul scheduler-ului.
      prioritate: nivel de importanță; task-urile mai mari preiau CPU.
      semafor/mutex: mecanisme pentru protecția resurselor și sincronizare.
      queue: coadă pentru schimb de mesaje între task-uri/ISR.
      Exemplu – Două task-uri + coadă (FreeRTOS pe STM32)
      QueueHandle_t q;
void vProducer(void*){ uint32_t v=0; for(;;){ xQueueSend(q,&v,0); vTaskDelay(pdMS_TO_TICKS(10)); v++; } }
void vConsumer(void* p){ uint32_t r; for(;;){ if(xQueueReceive(q,&r,portMAX_DELAY)==pdPASS){ Process(r); } } }
int main(void){
  HAL_Init(); SystemClock_Config();
  q = xQueueCreate(16, sizeof(uint32_t));
  xTaskCreate(vProducer,"prod",256,NULL, tskIDLE_PRIORITY+2, NULL);
  xTaskCreate(vConsumer,"cons",256,NULL, tskIDLE_PRIORITY+1, NULL);
  vTaskStartScheduler(); for(;;){}
}

      T6. Algoritmi de planificare a task-urilor cu constrângeri rigide

      Obiective
      • Prezentarea RM (Rate Monotonic) și EDF (Earliest Deadline First).
      • Analiza de schedulabilitate și utilizarea procesorului.
      • Mapping pe priorități FreeRTOS/STM32 și verificare jitter.
      Cuvinte-cheie: RM EDF utilizare CPU schedulabilitate jitter
      RM: priorități după perioadă (perioadă mai mică → prioritate mai mare).
      EDF: preempțiune după cel mai apropiat deadline.
      utilizare CPU: suma rapoartelor execuție/perioadă (Ui = Ci/Ti).
      schedulabilitate: posibilitatea de a respecta toate deadline-urile.
      jitter: variații în timming-ul momentelor de start/finish ale task-urilor.
      Exemplu – Alocare priorități RM (FreeRTOS)
      // T1: 5ms, T2: 10ms, T3: 20ms  ⇒ RM: T1>T2>T3
xTaskCreate(T1,"T1",256,NULL, tskIDLE_PRIORITY+3, NULL); // cea mai mare prioritate
xTaskCreate(T2,"T2",256,NULL, tskIDLE_PRIORITY+2, NULL);
xTaskCreate(T3,"T3",256,NULL, tskIDLE_PRIORITY+1, NULL);

      T7. Comunicația în timp real. Protocoale de comunicație

      Obiective
      • Evaluarea UART, SPI, I²C, CAN și Ethernet pentru cerințe de timp real.
      • DMA pentru comunicații deterministe și reducerea latențelor.
      • Strategii anti-blocaj: timeouts, watchdog, reconectare.
      Cuvinte-cheie: UART/SPI/I²C CAN Ethernet DMA timeout
      UART/SPI/I²C: protocoale seriale punct-la-punct (UART) sau magistrală (SPI/I²C).
      CAN: rețea robustă multi-master, arbitraj pe ID, ideală auto/industrial.
      Ethernet: comunicație de mare viteză; cu stack-uri RT și QoS poate servi control.
      DMA: transfer fără CPU → latență/jitter reduse.
      timeout: limită de timp pentru a preveni blocaje la așteptări.
      Exemplu – UART DMA TX/RX non-blocant (HAL)
      uint8_t rx[64], tx[] = "RT Hello\r\n";
void start_uarts(void){
  HAL_UART_Receive_DMA(&huart2, rx, sizeof(rx));
  HAL_UART_Transmit_DMA(&huart2, tx, sizeof(tx)-1);
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef* h){
  // procesare buffer rx; rearmare DMA
  HAL_UART_Receive_DMA(h, rx, sizeof(rx));
}

    • LP1. Crearea task-urilor în aplicații de timp real

      Obiective
      • Familiarizarea cu conceptele de task și multitasking în sistemele de timp real.
      • Crearea și pornirea mai multor task-uri cu priorități diferite în FreeRTOS.
      • Observarea comportamentului sistemului la preempțiune și schimb de context.
      Sarcini de lucru
      • Configurează un proiect STM32CubeMX cu suport FreeRTOS activat.
      • Definește două task-uri care aprind și sting LED-uri la intervale diferite (ex. 200ms și 500ms).
      • Analizează efectul schimbului de context asupra timming-ului LED-urilor.
      • Adaugă un al treilea task care trimite un mesaj periodic pe UART.
      • Testează proiectul în simulare sau pe placă reală (STM32F4, Nucleo, BluePill etc.).

      Evaluare și raport de laborator

      • Program și funcționare: 5p — task-uri create corect, executate concurent, fără blocaje.
      • Schema și conexiuni: 2p — LED-uri/UART configurate corect.
      • Raport și documentare: 2p — capturi FreeRTOS viewer / osciloscop.
      • Originalitate: 1p — task suplimentar sau comportament sincronizat.
      Structura raportului 
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (task-uri FreeRTOS)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului. 

    • LP2. Crearea planificatorului de task-uri

      Obiective
      • Înțelegerea mecanismului de planificare în sistemele RTOS.
      • Implementarea unui planificator simplu bazat pe perioade fixe (Rate Monotonic).
      • Observarea diferențelor între planificare cooperativă și preemptivă.
      Sarcini de lucru
      • Scrie un scheduler cooperativ bazat pe SysTick (fără RTOS).
      • Adaugă trei funcții care rulează periodic la 5ms, 10ms și 20ms.
      • Calculează utilizarea procesorului (încărcarea CPU) pentru fiecare task.
      • Compară implementarea proprie cu FreeRTOS (preemptiv).

      Evaluare și raport de laborator

      • Program și funcționare: 5p — execuție corectă și sincronizată a task-urilor.
      • Schema și conexiuni: 2p — verificarea semnalelor de ieșire pe LED-uri.
      • Raport și documentare: 2p — analiza timming-urilor și a încărcării CPU.
      • Originalitate: 1p — includerea unui task adaptiv (dinamic).
      Structura raportului
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (scheduler și task-uri)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului.

    • LP3. Crearea semafoarelor binare, numărătoare și mutex

      Obiective
      • Utilizarea semafoarelor binare și contorizate pentru sincronizare.
      • Protejarea resurselor partajate prin mutex.
      • Verificarea ordinii de execuție în condiții de concurență.
      Sarcini de lucru
      • Definește un semafor binar pentru sincronizarea unui ISR cu un task.
      • Implementează un semafor contorizat pentru acces multiplu (ex. trei resurse).
      • Folosește un mutex pentru protejarea unei variabile comune.
      • Testează efectul priorităților asupra ordinii de execuție.

      Evaluare și raport de laborator

      • Program și funcționare: 5p — sincronizare corectă, fără deadlock.
      • Schema și conexiuni: 2p — indicarea clară a resurselor partajate.
      • Raport și documentare: 2p — descriere clară a mecanismelor RTOS folosite.
      • Originalitate: 1p — combinarea mai multor tipuri de semafoare.
      Structura raportului
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (semafoare și mutex)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului.

    • LP4. Distribuția resurselor hardware utilizând semafoare

      Obiective
      • Aplicarea semafoarelor pentru partajarea resurselor hardware (ex. ADC, UART, SPI).
      • Evitarea coliziunilor de acces și a blocărilor de resurse.
      • Utilizarea mutex-urilor pentru protecția perifericelor critice.
      Sarcini de lucru
      • Creează două task-uri care utilizează aceeași interfață UART, coordonate cu un semafor binar.
      • Adaugă o secțiune critică pentru acces la ADC protejată prin mutex.
      • Verifică ordinea execuției și timpul de eliberare a resurselor.

      Evaluare și raport de laborator

      • Program și funcționare: 5p — utilizarea corectă a semafoarelor și a mutex-urilor.
      • Schema și conexiuni: 2p — evidențierea resurselor hardware utilizate.
      • Raport și documentare: 2p — descriere clară a accesului coordonat la resurse.
      • Originalitate: 1p — optimizare prin timeout-uri și priorități dinamice.
      Structura raportului
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (semafoare și mutex pentru resurse)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului.

    • LP5. Implementarea unui sistem de conducere cu platformă mobilă omnidirecțională

      Obiective
      • Aplicarea mecanismelor multitasking pentru controlul motoarelor și senzorilor.
      • Implementarea controlului vitezei și direcției pe platforme omnidirecționale.
      • Integrarea semnalelor de feedback și a comunicației seriale.
      Sarcini de lucru
      • Configurează patru canale PWM pentru motoare cu curent continuu sau controlere ESC.
      • Implementează un algoritm de control al direcției (cinematică Mecanum sau omnidirecțională).
      • Adaugă un task de comunicație serială pentru comandă și telemetrie.
      • Testează sincronizarea mișcărilor și reacția la comenzi.

      Evaluare și raport de laborator

      • Program și funcționare: 5p — control corect al mișcării și comunicație stabilă.
      • Schema și conexiuni: 2p — configurare completă PWM și senzori.
      • Raport și documentare: 2p — descriere cinematică și timming-uri.
      • Originalitate: 1p — moduri automate de deplasare sau corecție.
      Structura raportului
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (control mișcare și comunicație)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului.

    • LP6. Implementarea unui sistem de urmărire a traseului cu platformă servo-direcționată

      Obiective
      • Realizarea controlului unui vehicul servo-direcționat în buclă închisă.
      • Utilizarea senzorilor IR, ultrasonic sau cameră pentru detecția traseului.
      • Implementarea unei logici de urmărire adaptivă a traiectoriei.
      Sarcini de lucru
      • Configurează servo-direcția și două canale PWM pentru tracțiune.
      • Integrează un senzor de linie (de tip IR array) și filtrează semnalul.
      • Proiectează un controler simplu (P sau PD) pentru menținerea traseului.
      • Generează telemetrie prin UART pentru diagnostic în timp real.

      Evaluare și raport de laborator

      • Program și funcționare: 5p — urmărire stabilă a traseului, răspuns corect la erori.
      • Schema și conexiuni: 2p — integrarea corectă a servoului, motoarelor și senzorilor.
      • Raport și documentare: 2p — diagrame, capturi de telemetrie, discuție asupra parametrilor.
      • Originalitate: 1p — moduri automate (stop la obstacol, recalculare traseu).
      Structura raportului 
      1. Titlu și scopul lucrării
      2. Schema și descriere hardware
      3. Programul realizat (control servo și algoritm de urmărire)
      4. Rezultate și capturi
      5. Concluzii
      Integritate academică: Proiectul trebuie să fie original și documentat individual. Copierea fără referințe poate duce la anularea punctajului.

    • Lucrare individuală semestrială — Sistem de timp real pe platformă STM32

      Durata proiectului

      Lucrarea individuală se desfășoară pe parcursul întregului semestru (15 săptămâni), cu etape de implementare progresivă, verificate periodic în cadrul orelor de laborator.

      Obiective
      • Conceperea, implementarea și testarea unui sistem de timp real bazat pe microcontroler STM32.
      • Integrarea mecanismelor RTOS (FreeRTOS) pentru gestionarea multitasking-ului și sincronizării.
      • Utilizarea interfețelor de comunicație (UART, SPI, I²C, CAN) pentru schimbul de date în timp real.
      • Monitorizarea proceselor și vizualizarea parametrilor printr-o interfață PC sau panou LCD.
      Sarcina de lucru

      Studentul va elabora un proiect de timp real. Cadrul didactic responsabil va distribui una dintre următoarele tematici propuse:

      • 1. Sistem de achiziție și transmitere a datelor de la senzori în timp real (ex. temperatură, presiune, umiditate).
      • 2. Sistem de control al unui motor DC/BLDC cu reglare PID și feedback de viteză sau poziție.
      • 3. Sistem de conducere autonomă a unei platforme mobile cu evitare de obstacole.
      • 4. Sistem distribuit de comunicație CAN între două sau mai multe microcontrolere STM32.
      • 5. Sistem hibrid (STM32 + Raspberry Pi sau ESP32) cu monitorizare în cloud.

      Proiectul va include componente hardware (microcontroler STM32, senzori, interfețe), software (cod C/C++ cu HAL/FreeRTOS) și opțional o aplicație de vizualizare (serială, web sau desktop).

      Etape recomandate
      1. Alegerea temei și analiza cerințelor sistemului (săptămânile 1–2).
      2. Proiectarea schemei hardware și alegerea componentelor (săptămânile 3–4).
      3. Implementarea software a driverelor și task-urilor principale (săptămânile 5–8).
      4. Integrarea RTOS și a comunicației inter-task (săptămânile 9–10).
      5. Testarea, optimizarea și documentarea finală (săptămânile 11–15).
      Evaluare finală
      • Funcționalitate sistem: 40% — sistem complet operațional și stabil.
      • Calitatea implementării software: 30% — structură RTOS, cod clar și bine comentat.
      • Documentare tehnică: 20% — raport complet, cu diagrame, capturi și rezultate măsurate.
      • Originalitate și inovație: 10% — funcționalități extinse, interfețe adiționale sau integrare externă.
      Structura raportului final
      1. Titlu, autor, coordonator
      2. Descrierea sistemului și scopul aplicației
      3. Schema bloc și componentele hardware utilizate
      4. Implementarea software (diagrame, funcții, task-uri)
      5. Rezultate experimentale și grafice
      6. Concluzii și perspective de dezvoltare
      Integritate academică: Proiectul trebuie să fie original și realizat individual. Toate sursele externe (cod, diagrame, biblioteci) trebuie citate corespunzător. Copierea fără referințe poate duce la anularea punctajului.