Differences
This shows you the differences between two versions of the page.
|
pm:prj2026:bianca.popa1106:cezar_andrei.enciu [2026/05/16 19:29] cezar_andrei.enciu |
pm:prj2026:bianca.popa1106:cezar_andrei.enciu [2026/05/18 18:25] (current) cezar_andrei.enciu |
||
|---|---|---|---|
| Line 8: | Line 8: | ||
| ==== Descriere generala ==== | ==== Descriere generala ==== | ||
| - | Reflex Analyzer este un sistem embedded pentru masurarea precisa a timpului de reactie uman. Placa ESP32 DevKit V1 primeste o comanda de start dintr-o aplicatie desktop (sau prin WiFi), genereaza un interval de asteptare pseudo-aleator intre 1 si 4 secunde, dupa care emite simultan un semnal sonor (buzzer) si unul luminos (LED). La apasarea butonului de catre utilizator, cronometrul se opreste, iar rezultatul — exprimat in milisecunde — este trimis aplicatiei prin USB-Serial. Display-ul LCD 2004 I2C afiseaza starea sistemului in timp real. Aplicatia centralizeaza rezultatele si prezinta statistici: medie, minim, maxim si un grafic al evolutiei pe sesiune. | + | Reflex Analyzer este un sistem embedded pentru masurarea precisa a timpului de reactie uman. Placa ESP32 DevKit V1 primeste comanda de start prin USB-Serial, genereaza un interval de asteptare pseudo-aleator intre 1 si 4 secunde, dupa care emite simultan un semnal sonor prin buzzer si un semnal luminos prin LED. La apasarea butonului de catre utilizator, cronometrul se opreste, iar rezultatul — exprimat in milisecunde — este afisat pe display-ul LCD 2004 I2C si transmis in Monitorul Serial. |
| + | |||
| + | Sistemul functioneaza independent, fara aplicatie desktop externa, folosind doar firmware-ul incarcat pe ESP32 si componentele hardware conectate. | ||
| ==== Scop ==== | ==== Scop ==== | ||
| - | Crearea unui instrument simplu, precis si portabil care sa masoare obiectiv reflexele unui utilizator si sa permita urmarirea progresului in timp, cu o precizie superioara aplicatiilor software pure. | + | Crearea unui instrument simplu, precis si portabil care sa masoare obiectiv reflexele unui utilizator, folosind componente hardware accesibile si o implementare embedded bazata pe ESP32. |
| ==== Ideea de baza ==== | ==== Ideea de baza ==== | ||
| - | Microcontrollerul **ESP32 DevKit V1** cronometreaza timpul de reactie folosind functia **millis()** cu rezolutie de 1ms, activata in momentul emiterii semnalului si oprita prin intreruperea pe **GPIO4** la apasarea butonului. Rezultatul este trimis prin **USB-Serial (115200 baud)** catre o aplicatie desktop **Python + PyQt5**. Un display **LCD 2004 I2C (0x27)** ofera feedback local in timp real. Buzzer-ul pasiv este controlat prin modulul **LEDC (PWM hardware)** al ESP32. | + | Microcontrollerul **ESP32 DevKit V1** cronometreaza timpul de reactie folosind functia **millis()** cu rezolutie de 1ms. Cronometrul porneste in momentul activarii semnalului luminos si sonor, iar oprirea se face prin intreruperea de pe **GPIO4**, declansata la apasarea butonului. |
| + | |||
| + | Rezultatul este afisat local pe display-ul **LCD 2004 I2C (0x27)** si este transmis prin **USB-Serial (115200 baud)** pentru debugging si verificare. Buzzer-ul pasiv este controlat prin modulul **LEDC (PWM hardware)** al ESP32. | ||
| ==== Utilitate practica ==== | ==== Utilitate practica ==== | ||
| - | * **Sportivi** care vor sa isi masoare si imbunateasca reflexele in antrenament | + | * **Sportivi** care vor sa isi masoare si imbunatateasca reflexele in antrenament |
| * **Utilizatori generali** curiosi sa isi testeze timpul de reactie cu precizie reala | * **Utilizatori generali** curiosi sa isi testeze timpul de reactie cu precizie reala | ||
| - | * **Demonstratii educationale** — ilustreaza concret timere hardware, intreruperi si comunicatie seriala | + | * **Demonstratii educationale** — ilustreaza concret timere, intreruperi, PWM, I2C si comunicatie seriala |
| ==== De ce e util ==== | ==== De ce e util ==== | ||
| - | * Precizie hardware reala (1ms rezolutie millis()) vs. aplicatii web/mobile cu latenta de zeci de ms | + | * Precizie hardware reala, cu rezolutie de 1ms folosind millis() |
| - | * Detectie **false start** — apasare buton inainte de semnal, tratata si raportata separat | + | * Detectie **false start** — apasare buton inainte de semnal, tratata separat |
| - | * Delay **pseudo-aleator** — nu se poate anticipa momentul semnalului | + | * Delay **pseudo-aleator** intre 1 si 4 secunde, pentru a evita anticiparea semnalului |
| - | * **Display local** (LCD 2004 I2C) — feedback instant fara a privi spre ecranul PC-ului | + | * **Display local LCD 2004 I2C** — afiseaza starea sistemului si rezultatul fara a depinde de o aplicatie externa |
| - | * **WiFi integrat** pe ESP32 — posibilitate de extindere wireless | + | * Feedback dublu: semnal luminos prin LED si semnal sonor prin buzzer |
| - | * **Export CSV** din aplicatie pentru analiza ulterioara | + | * Implementare clara folosind automat de stari, intreruperi si PWM hardware |
| ===== Descriere generala ===== | ===== Descriere generala ===== | ||
| Line 37: | Line 41: | ||
| Schema bloc a sistemului: | Schema bloc a sistemului: | ||
| - | {{ :pm:prj2026:bianca.popa1106:schema_bloc_cezar.png?700 |Schema bloc Reflex Analyzer}} | + | {{ :pm:prj2026:bianca.popa1106:schema_bloc_cezar_1.png?700 |Schema bloc Reflex Analyzer}} |
| - | Fluxul de date pe scurt: | + | Fluxul de functionare pe scurt: |
| - | - Aplicatia desktop trimite comanda START prin portul serial catre ESP32. | + | - Utilizatorul trimite comanda START prin Monitorul Serial catre ESP32. |
| - | - Microcontrollerul genereaza un delay aleator (1-4s) cu random(), dupa care activeaza LED-ul si buzzer-ul simultan. | + | - Microcontrollerul genereaza un delay aleator intre 1 si 4 secunde cu random(). |
| - | - Display-ul LCD trece de la "Asteptare..." la "Gata..." si apoi la "GO!" la momentul semnalului. | + | - Display-ul LCD trece de la "Asteptare" la "Gata..." si apoi la "GO!". |
| - | - Utilizatorul apasa butonul — intreruperea pe GPIO4 opreste cronometrul si calculeaza diferenta de timp. | + | - La momentul semnalului, ESP32 activeaza simultan LED-ul si buzzer-ul. |
| - | - Rezultatul in milisecunde este trimis prin Serial aplicatiei si afisat pe LCD. | + | - Utilizatorul apasa butonul, iar intreruperea de pe GPIO4 opreste cronometrul. |
| - | - Daca butonul e apasat inainte de semnal, sistemul semnalizeaza false start si se reseteaza automat. | + | - Timpul de reactie este calculat in milisecunde, afisat pe LCD si trimis prin Serial. |
| + | - Daca butonul este apasat inainte de semnal, sistemul detecteaza false start, emite 3 beep-uri scurte si se reseteaza automat. | ||
| ===== Hardware Design ===== | ===== Hardware Design ===== | ||
| Line 70: | Line 75: | ||
| ^ Pin ESP32 ^ Componenta ^ | ^ Pin ESP32 ^ Componenta ^ | ||
| - | | GPIO5 | Anod LED rosu (prin rezistor 220 Ohm la GND) | | + | | GPIO5 | Anod LED rosu, prin rezistor 220 Ohm | |
| - | | GPIO18 | Buzzer pasiv + pin (semnal PWM prin LEDC) | | + | | GPIO18 | Buzzer pasiv + pin, semnal PWM prin LEDC | |
| - | | GPIO4 | Buton tactil (INPUT_PULLUP, cealalta latura la GND) | | + | | GPIO4 | Buton tactil, configurat INPUT_PULLUP, cealalta latura la GND | |
| | GPIO21 / SDA | SDA display LCD 2004 I2C | | | GPIO21 / SDA | SDA display LCD 2004 I2C | | ||
| | GPIO22 / SCL | SCL display LCD 2004 I2C | | | GPIO22 / SCL | SCL display LCD 2004 I2C | | ||
| | VIN (5V) | VCC display LCD 2004 I2C | | | VIN (5V) | VCC display LCD 2004 I2C | | ||
| - | | GND | GND comun (LED, Buzzer, Buton, LCD) | | + | | GND | GND comun pentru LED, buzzer, buton si LCD | |
| - | **Nota:** ESP32 lucreaza la 3.3V logic. LCD-ul necesita VCC 5V (pin VIN), dar semnalele I2C (SDA/SCL) la 3.3V sunt compatibile cu modulul I2C PCF8574 de pe LCD. | + | **Nota:** ESP32 lucreaza la 3.3V logic. LCD-ul este alimentat din VIN/5V, iar comunicatia I2C se face prin liniile SDA si SCL. Modulul I2C al LCD-ului foloseste de obicei adresa **0x27**, dar unele module pot folosi **0x3F**. |
| ===== Software Design ===== | ===== Software Design ===== | ||
| Line 84: | Line 89: | ||
| ==== Mediu de dezvoltare ==== | ==== Mediu de dezvoltare ==== | ||
| - | * **Arduino IDE 2.x** cu suport ESP32 (Espressif ESP32 board package) | + | * **Arduino IDE 2.x** cu suport ESP32 prin pachetul Espressif ESP32 |
| - | * **VS Code + PlatformIO** — alternativa pentru editare cod firmware | + | * **VS Code + PlatformIO** — alternativa pentru editare si incarcare firmware |
| - | * **Python 3.11 + PyQt5** — aplicatie desktop | + | * **Monitor Serial (115200 baud)** — trimitere comenzi si verificare mesaje de stare |
| - | * **Monitor Serial (115200 baud)** — debugging in timp real | + | |
| ==== Librarii folosite ==== | ==== Librarii folosite ==== | ||
| - | |||
| - | === Firmware (Arduino / ESP32) === | ||
| ^ Librarie ^ Sursa ^ Rol ^ | ^ Librarie ^ Sursa ^ Rol ^ | ||
| - | | Wire.h | Arduino built-in | Comunicare I2C (SDA/SCL) | | + | | Wire.h | Arduino built-in | Comunicare I2C intre ESP32 si LCD | |
| | LiquidCrystal_I2C | Library Manager | Control display LCD 2004 I2C | | | LiquidCrystal_I2C | Library Manager | Control display LCD 2004 I2C | | ||
| - | | Arduino ESP32 LEDC | ESP32 built-in | PWM hardware pentru buzzer | | + | | Arduino ESP32 LEDC | ESP32 built-in | Generare PWM hardware pentru buzzer | |
| - | | attachInterrupt() | Arduino built-in | Intrerupere GPIO4 pentru buton | | + | | attachInterrupt() | Arduino built-in | Intrerupere pe GPIO4 pentru detectarea apasarii butonului | |
| - | === Aplicatie Desktop (Python) === | + | ==== Algoritm de functionare ==== |
| - | ^ Librarie ^ Rol ^ | + | Programul ruleaza pe ESP32 si este organizat sub forma unui automat finit de stari. Sistemul porneste in starea **IDLE**, unde asteapta comanda START primita prin USB-Serial. Dupa primirea comenzii, intra in starea **WAITING**, unde genereaza un delay pseudo-aleator intre 1 si 4 secunde. In aceasta perioada, daca utilizatorul apasa butonul, sistemul detecteaza un **false start**. |
| - | | pyserial | Comunicare seriala cu ESP32 prin USB | | + | |
| - | | PyQt5 | Interfata grafica (ferestre, butoane, tabele) | | + | |
| - | | matplotlib | Grafic evolutie timp de reactie pe sesiune | | + | |
| - | | csv | Export rezultate in format CSV | | + | |
| - | ==== Algoritm de functionare ==== | + | Dupa expirarea delay-ului, sistemul intra in starea **SIGNAL**, activeaza LED-ul si buzzer-ul si salveaza momentul de start folosind functia **millis()**. Cand utilizatorul apasa butonul, intreruperea pe GPIO4 seteaza un flag, iar in loop() se calculeaza timpul de reactie ca diferenta dintre momentul apasarii si momentul semnalului. |
| - | Sistemul functioneaza pe baza unui automat cu 5 stari. La primirea comenzii START pe Serial, se genereaza un delay aleator (random 1-4s). Dupa expirarea delay-ului, LED-ul si buzzer-ul sunt activate simultan, millis() salveaza momentul semnalului. Intreruperea pe GPIO4 (buton) opreste cronometrul si calculeaza timpul de reactie. Daca butonul e apasat inainte de semnal, se detecteaza false start si se emite avertisment sonor (3 beep-uri scurte). | + | Rezultatul este afisat pe LCD 2004 I2C si transmis prin Serial sub forma `RESULT:<ms>`. Dupa cateva secunde, sistemul revine automat in starea IDLE. |
| ==== Automat de stari ==== | ==== Automat de stari ==== | ||
| Line 117: | Line 115: | ||
| Sistemul are 5 stari: | Sistemul are 5 stari: | ||
| - | * **IDLE** — asteapta comanda START de la aplicatie prin Serial; LCD afiseaza "Asteptare..." | + | * **IDLE** — asteapta comanda START prin Serial; LCD afiseaza mesajul de asteptare |
| - | * **WAITING** — genereaza delay aleator 1-4s; LCD afiseaza "Gata... Nu apasa inca!"; GPIO4 activ pentru detectie false start | + | * **WAITING** — genereaza delay aleator 1-4s; LCD afiseaza "Gata..." si "Nu apasa inca!" |
| - | * **SIGNAL** — emite LED + buzzer (1kHz), salveaza millis(); LCD afiseaza "GO!"; asteapta apasare buton | + | * **SIGNAL** — activeaza LED-ul si buzzer-ul; LCD afiseaza "GO!" |
| - | * **RESULT** — calculeaza si trimite timpul prin Serial (RESULT:<ms>); afiseaza pe LCD cu rating; reset automat dupa 3s | + | * **RESULT** — calculeaza timpul de reactie, il afiseaza pe LCD si il trimite prin Serial |
| - | * **FALSE_START** — buton apasat inainte de semnal; 3 beep-uri de eroare + mesaj LCD "FALSE START!" + mesaj Serial; reset automat dupa 2s | + | * **FALSE_START** — detecteaza apasarea prea devreme a butonului, emite 3 beep-uri si afiseaza mesaj de eroare |
| ==== Comenzi Serial ==== | ==== Comenzi Serial ==== | ||
| ^ Comanda ^ Directie ^ Efect ^ | ^ Comanda ^ Directie ^ Efect ^ | ||
| - | | START | PC -> ESP32 | Porneste o runda noua | | + | | START | Utilizator -> ESP32 | Porneste o runda noua | |
| - | | RESET | PC -> ESP32 | Reseteaza in starea IDLE | | + | | RESET | Utilizator -> ESP32 | Reseteaza sistemul in starea IDLE | |
| - | | RESULT:<ms> | ESP32 -> PC | Trimite timpul de reactie in ms | | + | | RESULT:<ms> | ESP32 -> Serial Monitor | Trimite timpul de reactie in milisecunde | |
| - | | FALSE_START | ESP32 -> PC | Semnaleaza false start | | + | | FALSE_START | ESP32 -> Serial Monitor | Semnaleaza apasarea butonului inainte de semnal | |
| - | | STATE:<stare> | ESP32 -> PC | Notifica schimbarea starii curente | | + | | STATE:<stare> | ESP32 -> Serial Monitor | Afiseaza starea curenta a sistemului | |
| ==== Surse si functii principale ==== | ==== Surse si functii principale ==== | ||
| - | * setup() — initializare pini, LEDC, I2C, LCD, interrupt | + | * **setup()** — initializeaza Serial, pini, LED, buzzer, I2C, LCD si intreruperea pe buton |
| - | * showIdle() / startWaiting() / startSignal() — tranzitii de stare | + | * **loop()** — citeste comenzile Serial si gestioneaza tranzitiile automatului de stari |
| - | * showResult(ms) — afisare si trimitere rezultat | + | * **showIdle()** — trece sistemul in starea IDLE si afiseaza mesajul initial pe LCD |
| - | * goFalseStart() — tratare false start cu beep-uri de eroare | + | * **startWaiting()** — genereaza delay-ul aleator si pregateste sistemul pentru semnal |
| - | * onButtonPress() — ISR IRAM_ATTR pe GPIO4, debounce 50ms | + | * **startSignal()** — activeaza LED-ul si buzzer-ul si porneste cronometrul |
| - | * resetToIdle() — reset automat la starea initiala | + | * **showResult(ms)** — afiseaza timpul de reactie pe LCD si il trimite prin Serial |
| + | * **goFalseStart()** — trateaza cazul in care butonul este apasat prea devreme | ||
| + | * **onButtonPress()** — rutina de intrerupere pentru buton, cu debounce software de 50ms | ||
| + | * **resetToIdle()** — reseteaza sistemul la starea initiala | ||
| - | ==== Aplicatie Desktop ==== | + | ==== Detalii de implementare ==== |
| - | Interfata grafica ofera butoanele Start proba, Stop sesiune si Export CSV. Comunicarea seriala ruleaza pe un thread separat pentru a nu bloca UI-ul. La fiecare proba finalizata, aplicatia adauga rezultatul in tabel, actualizeaza statisticile (medie, minim, maxim) si graficul matplotlib. | + | Butonul este conectat pe **GPIO4** si este configurat cu **INPUT_PULLUP**, astfel incat pinul este in stare HIGH in repaus si trece in LOW cand butonul este apasat. Detectia se face prin intrerupere pe front descrescator, folosind `attachInterrupt(digitalPinToInterrupt(PIN_BUTTON), onButtonPress, FALLING)`. |
| + | |||
| + | Pentru evitarea citirilor multiple cauzate de zgomotul mecanic al butonului, in rutina de intrerupere se foloseste un debounce software de 50ms. Variabila `buttonPressed` este declarata `volatile`, deoarece este modificata in ISR si citita in functia `loop()`. | ||
| + | |||
| + | Buzzer-ul pasiv este controlat cu PWM hardware prin modulul **LEDC** al ESP32. Pentru semnalul de start se foloseste o frecventa de 1000Hz, iar pentru false start se emit 3 beep-uri scurte la 300Hz. La finalizarea unei probe valide, sistemul emite un beep scurt la 1500Hz. | ||
| + | |||
| + | Display-ul LCD 2004 I2C este controlat prin magistrala I2C folosind pinii **GPIO21** pentru SDA si **GPIO22** pentru SCL. Pe LCD sunt afisate mesajele corespunzatoare fiecarei stari: asteptare, pregatire, semnal, rezultat si false start. | ||
| ===== Rezultate Obtinute ===== | ===== Rezultate Obtinute ===== | ||
| - | * Sistem functional end-to-end: buton -> ESP32 -> Serial -> aplicatie desktop | + | * Sistem functional end-to-end: buton -> ESP32 -> LCD 2004 I2C / Serial Monitor |
| - | * Precizie masurare timp de reactie: 1 milisecunda (millis() pe ESP32 la 240MHz) | + | * Masurare a timpului de reactie cu rezolutie de 1 milisecunda folosind millis() |
| - | * Latenta Serial sub 5ms intre apasare buton si afisarea rezultatului in aplicatie | + | * Detectie false start functionala prin intreruperea de pe GPIO4 |
| - | * Detectie false start functionala in toate scenariile testate | + | * Feedback vizual prin LED si feedback sonor prin buzzer pasiv controlat PWM |
| - | * Display LCD 2004 afiseaza starile stabil, cu mesaje clare pe 4 randuri | + | * Display-ul LCD 2004 I2C afiseaza starile sistemului si rezultatul final pe 4 randuri |
| + | * Reset automat dupa afisarea rezultatului sau dupa detectarea unui false start | ||
| ===== Concluzii ===== | ===== Concluzii ===== | ||
| - | * Utilizarea functiei millis() pe ESP32 (240MHz) ofera o rezolutie de 1ms, suficienta pentru masurarea precisa a timpului de reactie uman. | + | * Utilizarea functiei millis() pe ESP32 ofera o rezolutie de 1ms, suficienta pentru masurarea timpului de reactie uman. |
| - | * Arhitectura FSM (automat de stari) s-a dovedit esentiala — o implementare liniara ar fi ratat evenimentele de intrerupere sau ar fi blocat comunicatia Serial. | + | * Arhitectura FSM (automat de stari) s-a dovedit utila pentru separarea clara a etapelor: asteptare, semnal, rezultat si false start. |
| - | * ISR-ul pe GPIO4 cu debounce software (50ms) elimina zgomotul mecanic al butonului fara componente externe. | + | * ISR-ul pe GPIO4 cu debounce software de 50ms permite detectarea rapida a apasarii butonului si reduce efectul zgomotului mecanic. |
| - | * ESP32 ofera WiFi integrat, permitand extinderea viitoare a proiectului cu control wireless sau salvarea rezultatelor in cloud. | + | * Display-ul LCD 2004 I2C permite afisarea locala a starilor si rezultatului, fara a depinde de o aplicatie externa. |
| - | * Provocarea principala: variabilele partajate intre loop() si ISR necesita declarare volatile si debounce corect. | + | * PWM-ul hardware LEDC al ESP32 permite controlul buzzer-ului fara a bloca permanent executia programului. |
| + | * Provocarea principala a fost sincronizarea corecta intre intreruperea butonului si logica principala din loop(), prin folosirea variabilelor volatile. | ||
| ===== Jurnal ===== | ===== Jurnal ===== | ||
| Line 170: | Line 179: | ||
| | 2026-05-13 | Implementare PWM buzzer (LEDC) + LED, testare false start | | | 2026-05-13 | Implementare PWM buzzer (LEDC) + LED, testare false start | | ||
| | 2026-05-15 | Implementare driver LCD 2004 I2C, integrare FSM complet | | | 2026-05-15 | Implementare driver LCD 2004 I2C, integrare FSM complet | | ||
| - | | 2026-05-17 | Scriere aplicatie Python + PyQt5, grafic matplotlib | | + | | 2026-05-17 | Testare comenzi Serial START/RESET si afisare rezultat pe LCD | |
| - | | 2026-05-19 | Testare end-to-end, debugging | | + | | 2026-05-19 | Testare end-to-end: LED, buzzer, buton, LCD si Serial Monitor | |
| | 2026-05-21 | Documentatie OCW, scheme, poze montaj final | | | 2026-05-21 | Documentatie OCW, scheme, poze montaj final | | ||
| Line 178: | Line 187: | ||
| - [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32/|ESP32 Technical Reference Manual]] | - [[https://docs.espressif.com/projects/esp-idf/en/latest/esp32/|ESP32 Technical Reference Manual]] | ||
| - [[https://github.com/espressif/arduino-esp32|Arduino ESP32 GitHub]] | - [[https://github.com/espressif/arduino-esp32|Arduino ESP32 GitHub]] | ||
| - | - [[https://pyserial.readthedocs.io|pyserial documentatie]] | ||
| - | - [[https://www.riverbankcomputing.com/software/pyqt/|PyQt5 documentatie]] | ||
| - [[https://github.com/johnrickman/LiquidCrystal_I2C|LiquidCrystal_I2C librarie]] | - [[https://github.com/johnrickman/LiquidCrystal_I2C|LiquidCrystal_I2C librarie]] | ||
| - Cursurile PM - Lab 1 USART, Lab 2 Intreruperi Timere, Lab 3 PWM, Lab 6 I2C | - Cursurile PM - Lab 1 USART, Lab 2 Intreruperi Timere, Lab 3 PWM, Lab 6 I2C | ||
| - | |||
