Structuri de Meniu în ESP32

Structuri de Meniu în ESP32

• Structurile de tip Menultem facilitează gestionarea stărilor și legăturilor logice (următor, anterior, părinte, copil) ale itemilor din meniu.
• Membrul child dintr-o structură Menultem indică submeniul asociat.
• Afișarea unui item de meniu selectat pe un LCD 16x2 se face prin curățarea ecranului cu Icd.clear() și apoi afișarea textului cu Icd.print(item->label).
• Funcția callback asociată unui item de meniu execută acțiunea specifică acelui item la selectare.
• Parcurgerea unui meniu cu un encoder rotativ se face prin incrementarea/decrementarea indexului curent.
• Funcția goToParent() permite revenirea la meniul părinte.
• Legăturile previous și next asigură navigarea laterală între itemi la același nivel în structura meniului.
• Un pointer de tip Menultem* este folosit pentru a defini structura itemilor într-un meniu.
• Stabilitatea afișajului la rotirea rapidă a encoderului se asigură prin actualizarea afișajului doar dacă poziția s-a schimbat.
• Trecerea în afara limitelor meniului este prevenită prin verificarea dacă pointerul next este NULL înainte de accesare.
• Variabila currentMenu reprezintă pointerul către itemul curent din meniu.
• În definirea meniurilor statice, initializarea tuturor legăturilor în setup() este o practică bună.
• Un meniu cu mai mult de două opțiuni pe un LCD 16x2 se afișează prin schimbarea paginii afișate la fiecare două itemi.
• Implementarea unui meniu "circular" se face prin asignarea primului item la next atunci când se ajunge la ultimul item: if(next == NULL) next = firstItem;.
• Folosirea unui pointer constant (const Menultem*) pentru meniuri statice reduce memoria RAM utilizată, deoarece itemii constanți pot fi stocați în flash.

Procese în Fundal

• millis() este preferat lui delay() deoarece permite execuția non-blocantă, verificând condițiile fără a opri programul.
• Un refresh periodic al ecranului fără blocarea execuției se realizează prin compararea millis() cu un timestamp anterior.
• Dacă timestamp-ul nu se resetează după un trigger millis(), evenimentul se va repeta constant fără pauză.
• Multitasking-ul soft cu flag-uri implică folosirea flag-urilor (shouldUpdate, trigger, etc.) pentru controlul execuției în loop() fără delay.
• Conflictele între procese care folosesc același timer (millis()) sunt evitate prin declararea a două variabile timestamp separate pentru fiecare proces.
• Valoarea returnată de millis() revine la 0 după aproximativ 49.7 zile (overflow), necesitând precauție.
• Actualizarea non-blocantă a unei variabile de afișaj se realizează cu if (millis() - lastRefresh > 100), verificând timpul necesar fără blocare.
• Utilizarea while(true) în loop() oprește complet procesele de fundal.
• Biblioteca TaskScheduler.h poate fi folosită pentru multitasking simplu pe ESP32.
• Variabilele globale modificate de mai multe task-uri trebuie protejate în procese paralele, deoarece pot crea condiții de cursă.
• Funcția vTaskDelay() amână executarea unui task în FreeRTOS pe ESP32 fără a bloca restul sistemului.
• Unitatea de timp implicită pentru vTaskDelay(1000) în FreeRTOS este Ticks, unde 1 tick ≠ 1 ms și depinde de frecvența sistemului.
• Un task care rulează fără vTaskDelay() într-un sistem FreeRTOS acaparează toată execuția CPU.
• Sincronizarea între două task-uri în ESP32/FreeRTOS se realizează cu xSemaphore sau xQueue.
• Un task separat pentru controlul LCD-ului permite delay-uri în paralel cu restul logicii.

Controlul Afișajelor LCD

• Orice doi pini de pe ESP32 pot fi conectați la LCD-ul I2C, fiind configurați ca SDA și SCL la inițializare prin Wire.begin(SDA, SCL).
• Comanda corectă pentru inițializarea unui LCD I2C 16x2 este Icd.init(); Icd.backlight().
• Curățarea afișajului LCD fără flicker se face prin Icd.setCursor(0,0); lcd.print(" ");, care suprascrie linia cu spații.
• Poziția cursorului pe LCD se controlează cu Icd.setCursor(col, row), metoda standard.
• Animația de scroll pe un ecran 16x2 se creează cu Icd.scrollDisplayLeft(), care derulează întregul display.
• Comanda Icd.noBacklight() oprește iluminarea de fundal, economisind curent.
• Suprascrierea unui text scurt peste unul mai lung pe LCD se evită prin adăugarea de spații la finalul textului.
• Dacă se încearcă scrierea pe rândul 2 (index 1) înainte de Icd.begin(), nu apare nimic pe ecran deoarece LCD-ul trebuie inițializat corect.
• Caractere custom pe un LCD 16x2 se crează cu Icd.createChar(nr, pattern[]), LCD-urile 16x2 suportând până la 8 caractere speciale.
• Limita standard de caractere customizabile pentru un LCD clasic HD44780 este de 8 caractere, definite de utilizator în CGRAM.
• Afișarea rapidă fără întârziere între caractere se asigură prin scrierea într-un buffer (string) și afișarea completă.
• Biblioteca necesară pentru a folosi LCD-ul cu I2C în Arduino IDE este LiquidCrystal_I2C.h.
• Dacă se scriu mai mult de 16 caractere pe un rând, textul continuă în afara ecranului, fiind invizibil.
• Simbolul ° (grad) pe un LCD 16x2 se afișează cu lcd.print((char)223), codul ASCII 223 corespunzând simbolului de grad.
• Consumul energetic al unui LCD când nu e necesar afișajul se reduce cu lcd.noBacklight(); şi lcd.noDisplay();, care opresc iluminarea și afișajul dar mențin conexiunea activă.

Butoane și Encodere

• Conectarea corectă a unui buton la un pin ESP32 pentru a obține LOW la apăsare se face între pin și GND, cu activare INPUT_PULLUP, care folosește rezistența internă.
• Efectul de "bounce" la un buton sunt apăsări false cauzate de oscilații rapide.
• Debounce-ul software se realizează cu debounce logic cu millis(), care ignoră tranzițiile rapide.
• Citirea butonului care evită blocarea loop() se face printr-o implementare de tip millis() non-blocking.
• Un encoder rotativ generează două semnale digitale în cuadratură la rotire.
• Direcția de rotație a unui encoder se determină comparând semnalele A și B.
• Reacția imediată la o schimbare de stare a unui buton se obține cu attachInterrupt() pe pin.
• O limitare a folosirii întreruperilor cu encodere rotative este pierderea semnalului dacă se rotește rapid, dacă codul ISR nu este optimizat.
• Un encoder cu 3 pini utilizează două cuadraturi și un pin LOW/HI pentru buton.
• Biblioteca Arduino frecvent utilizată pentru encodere este Encoder.h.
• Pentru un encoder standard (20 pulsuri), se obțin 40 de stări distincte per clic dacă se citesc ambele faze (A și B).
• Filtrarea zgomotului la encoder la nivel hardware se face cu condensatori pe semnale.
• Asigurarea citirii corecte a encoderului în loop() fără întreruperi se face verificând fiecare pin individual și deducând rotația.
• O abordare eficientă pentru debounce software al encoderului este millis() cu verificare de tranziție.
• Funcția read() asigură citirea non-blocking a unui encoder în biblioteca Encoder.h, returnând poziția actuală fără a bloca rularea programului.

EEPROM

• ESP32 folosește memoria Flash (emulare EEPROM) pentru stocarea datelor persistente, neavând EEPROM reală.
• Biblioteca EEPROM.h trebuie inclusă pentru a folosi EEPROM pe ESP32.
• Funcția EEPROM.begin(size) trebuie apelată pentru a începe lucrul cu EEPROM, ESP32 necesitând rezervarea memoriei în flash.
• Scrierea unui int la adresa 0 în EEPROM pe ESP32 se face cu EEPROM.put(0, val).
• Funcția EEPROM.commit() este esențială după scrierea în EEPROM pentru salvarea datelor în memoria flash.
• Dimensiunea maximă ce poate fi alocată prin EEPROM.begin() pe ESP32 este de 4096 bytes (4KB).
• Citirea unei structuri de date din EEPROM se face cu EEPROM.get(adr, var).
• Un risc al scrierii frecvente în EEPROM este uzura memoriei flash.
• Scrierile repetate inutile în EEPROM se evită verificând dacă valoarea s-a schimbat.
• O structură personalizată este recomandată pentru salvarea mai multor parametri în EEPROM.
• După salvarea datelor cu EEPROM.put(), este necesar să se apeleze EEPROM.commit() pentru salvarea fizică.
• Datele salvate în EEPROM pot fi "șterse" prin rescrierea cu valori 0 sau default.
• Pentru a salva 2 structuri diferite în EEPROM, este necesar să se aloce zone diferite de memorie.
• Funcția EEPROM.get() returnează datele salvate ca referință în EEPROM.
• Accesul concurent la EEPROM dintr-un task paralel (FreeRTOS) necesită protecție, altfel datele se pot corupe.

PWM

• Funcția ledcAttachPin(pin, channel) asociază un canal PWM cu un pin pe ESP32.
• ESP32 nu setează frecvență implicită a semnalului PWM – este obligatoriu să o definești cu ledcSetup().
• Funcția ledcSetup(channel, freq, resolution) setează frecvența și rezoluția unui canal PWM.
• Valoarea maximă a duty-cycle-ului pentru o rezoluție de 8 biți este 255.
• ESP32 permite 16 canale PWM independente (0-15).
• Setarea unui semnal PWM de 10kHz și 10 biți pe canalul 2 se face cu ledcSetup(2, 10000, 10).
• Nivelul de duty-cycle pe un canal PWM se setează cu ledcWrite(channel, duty).
• Frecvența unui canal PWM se modifică în timp real apelând ledcSetup() din nou cu noua frecvență.
• Setearea unei rezoluții de 16 biți și a unei frecvențe mare pe PWM poate duce la instabilitatea semnalului sau la nefuncționarea acestuia, din cauza consumului ridicat de resurse.
• Dacă două canale PWM diferite controlează același pin, doar ultimul atașat va funcționa, suprascriind legătura pinului.
• ESP32 poate genera semnale PWM simultan pe mai multe piese hardware (e.g., LED + motor) cu canale diferite.
• Un avantaj al PWM software față de PWM hardware este că orice pin poate fi folosit, deoarece nu este legat de timere hardware.
• Controlul luminozității unui LED cu PWM se realizează cu ledcWrite() pe ESP32.
• Canalele PWM care folosesc același timer pot fi sincronizate precis.

ADC

• PWM este o metodă de modulare a duratei impulsurilor.
• Funcția analogRead(pin) citește o valoare analogică pe ESP32.
• Rezoluția implicită a ADC-ului pe ESP32 este de 12 biți, valoarea returnată de analogRead() fiind între 0 și 4095.
• ADC-ul ESP32 funcționează fără calibrare specială în intervalul de tensiune 0-3.3V.
• Funcția analogSetBits(bits) setează rezoluția ADC-ului pe ESP32, controlând câți biți are conversia analogică.
• O problemă care apare adesea la citirea semnalelor analogice brute pe ESP32 este zgomotul și fluctuațiile mari.
• Media mai multor citiri reduce fluctuațiile la citirea valorilor analogice.
• Anumiți pini (GPIOs) care NU sunt folosiți de SPI/Flash sunt siguri pentru citire analogică pe ESP32.
• Valoarea brută analogRead() poate fi convertită într-o tensiune (V) cu formula: tensiune = analogRead(pin) / 4095.0 * 3.3;.
• Funcția analogSetAttenuation() setează factorul de atenuare al canalului ADC, crescând intervalul de tensiune măsurabil.
• Dacă un senzor de