Acest proiect este un Sistem Inteligent de Monitorizare și Udare Automată a Plantelor, conceput pentru a automatiza îngrijirea plantelor prin monitorizarea condițiilor de mediu și activarea unei pompe de apă atunci când este necesar. Este potrivit pentru utilizare în interior sau în sere de dimensiuni mici.

Proiectul integrează senzori pentru a măsura umiditatea solului și, opțional (în extinderi viitoare), temperatura și nivelul de lumină, toate fiind procesate de un microcontroler compatibil cu Arduino Uno. În funcție de valorile obținute, sistemul poate activa o pompă de apă, aprinde un modul LED sau afișa date pe un ecran.

• Placă Arduino Uno compatibilă - controlerul central al sistemului
• Senzor de umiditate a solului - citește umiditatea solului pentru a decide dacă planta are nevoie de apă
• Senzor de lumină (viitor) - măsoară lumina ambientală
• Senzor de temperatură (viitor) - monitorizează temperatura mediului
• Pompă de apă (viitor) - udă automat planta în funcție de nivelul de umiditate
• Tranzistor + rezistențe (viitor) - folosite pentru controlul pompei
• Modul LED - indică starea sistemului
• Display (viitor) - afișează date precum umiditatea solului și temperatura

Se activează pompa și LED-ul dacă solul este prea uscat:

if (moistureLevel < threshold) {
  digitalWrite(pumpPin, HIGH);
  digitalWrite(ledPin, HIGH);
} else {
  digitalWrite(pumpPin, LOW);
  digitalWrite(ledPin, LOW);
}

• Pompa este controlată printr-un tranzistor, comutat de placa Arduino
• LED-ul indică acțiunea curentă a sistemului (pornit/oprit)

• Adăugarea unui modul Wi-Fi (ex. ESP32) pentru trimiterea datelor către telefon
• Notificări pe telefon când planta are nevoie de apă
• Salvarea datelor într-un fișier sau în cloud

Aici gasesti fișa tehnică ATmega328P (PDF)

Schema Block:

Documentația completă pentru modulul ESP-01 poate fi găsită aici: ESP-01 Datasheet și Specificații

Caracteristici principale:

• Tensiune de alimentare: 3.3V
• Curent consumat: 70mA - 300mA (vârf)
• Protocol WiFi: 802.11 b/g/n
• Stivă TCP/IP integrată
• Comunicație UART la 115200 bps
• Curent consumat în modul power down: <10µA
• Memorie Flash: 1MB
• Securitate: WPA/WPA2
• Dimensiuni: 14.3 x 24.8 mm

Modulul wireless ESP-01 integrează cipul ESP8266, un microcontroler puternic cu funcționalitate WiFi, care permite comunicarea prin rețea fără fir. Pentru a-l folosi împreună cu o placă Arduino, se utilizează conexiunea serială UART, la o viteză de transmisie de 115200 bps (baudrate).

Modulul dispune de 1 MB memorie flash pentru stocarea programelor și a datelor, precum și de doi pini GPIO (General Purpose Input/Output), care pot fi controlați similar cu pinii digitali ai plăcii Arduino. Acești pini pot fi folosiți pentru a citi sau controla senzori și actuatori în proiectele voastre.

Astfel, prin intermediul unei interfețe seriale, Arduino poate trimite și primi comenzi către modulul ESP-01 pentru a se conecta la o rețea WiFi și pentru a comunica cu alte dispozitive sau servicii cloud.

Asemenea altor module prezentate, dispozitivul funcționează la o tensiune de alimentare de 3.3 V. Aceasta poate fi furnizată în siguranță, direct de pe plăcuța Arduino. În schimb, pentru restul conexiunilor este nevoie să folosim un modul de conversie de niveluri logice, de la 5 V la 3.3 V. O posibilă modalitate de a evita utilizarea unui astfel de convertor de niveluri logice, fără a risca distrugerea modulului ESP-01 este utilizarea unei conexiuni precum cea figurată din imaginea de mai sus.

Pentru a comunica cu plăcuța Arduino pinul RX al modulului WiFi se conectează la pinul RX al plăcuței, iar pinul TX la pinul TX Arduino. Dacă nu folosiți un convertor de nivel, puteți folosi un divizor de tensiune realizat din două rezistoare: Pinul Arduino va genera o tensiune de 5 V. Pe pinul modulului WiFi vom obține:

Pentru detalii suplimentare, accesați Datasheet-ul oficial.

🔧 Prezentare generală a circuitului intern

Pompa submersibilă mini 5V cu mufa USB este o pompă mică, cu motor DC fără perii (BLDC), folosită frecvent în proiecte DIY, acvarii și sisteme mici de circulație a apei.

Componente incluse în circuit:

• Stator: Partea staționară cu mai multe bobine care sunt energizate secvențial pentru a crea un câmp magnetic rotativ.

• Rotor: Partea rotativă echipată cu magneți permanenți care urmează câmpul magnetic generat de stator.

• Circuitul de control (driver): Un controller electronic care gestionează secvențierea și sincronizarea curentului către bobinele statorului, adesea folosind feedback de la senzori pentru a determina poziția rotorului.

⚙️ Diagrama Funcțională (Simplificată)

O diagramă funcțională generalizată a unei astfel de pompe include următoarele componente:

• Intrare de alimentare: 5V DC furnizat prin mufa USB.

• Reglarea tensiunii: Asigură o tensiune stabilă pentru circuitul driver.

• Microcontroler sau circuit logic: Gestionează secvențierea fazelor motorului.

• Driver motor: Amplifică semnalele de control pentru a conduce bobinele motorului.

• Bobine motor (Stator): Bobine electromagnetice dispuse în jurul rotorului.

• Rotor cu magneți permanenți: Se rotește ca răspuns la câmpul magnetic generat de stator.

🔄 Control și Integrare

Pentru a integra această pompă într-un proiect folosesc urmatorul mecanism de comutare: un tranzistor + rezistentele necesare pentru a controla alimentarea pompei.

🔧 Descrierea circuitului intern

Senzorul de umiditate a solului de la Optimus Digital este un senzor rezistiv, care măsoară umiditatea solului prin rezistența electrică dintre cele două sonde metalice. Circuitul intern include:

• Sonde metalice – Două sonde care sunt plasate în sol pentru a măsura rezistența electrică.
• Rezistor de referință – Un rezistor intern care ajută la stabilirea valorilor de referință pentru măsurători.
• Comparator LM393 – Un comparator de tensiune care compară semnalul de intrare cu o tensiune de referință.
• Ieșire analogică (AOUT) – Pin care furnizează un semnal analogic proporțional cu umiditatea solului.
• Ieșire digitală (DOUT) – Pin care furnizează un semnal digital (0 sau 1), în funcție de pragul setat.

🔌 Conectarea senzorului

Senzorul are patru pini:

• VCC – Alimentare (de obicei 3.3V – 5V).
• GND – Masă (referință).
• AOUT – Ieșire analogică (0-5V), conectată la un pin analogic al microcontrolerului.
• DOUT – Ieșire digitală (0 sau 1), conectată la un pin digital al microcontrolerului.

🔧 Cum am realizat testarea senzorului?

Am creat urmatorul circuit cu led-uri, placa compatibila arduino uno R3, fire, breadboard si am folosit un ghemotoc de vata uda pentru a testa senzorul.

Pentru mai multe informatii, verificati link-ul: YL-69-HL-69 Sensor Specifications

🔧 Specificații tehnice

Dimensiuni: 56 x 21 x 11 mm LED-uri: Roșu, Galben, Verde Dimensiune LED: 5 mm Tensiune de alimentare: 3.3V sau 5V DC Tip LED: Catod comun Intrare: Digitală Rezistori integrați: Da

🔍 Circuit intern

Fiecare LED este conectat în serie cu un rezistor de limitare a curentului. Toate LED-urile au catodul comun, ceea ce înseamnă că partea negativă a fiecărui LED este conectată la un punct comun, iar partea pozitivă este controlată individual.

Senzorul de nivel pe bază de plutitor funcționează prin închiderea unui circuit electric atunci când nivelul apei atinge o anumită înălțime, activând un contact reed magnetic. Este simplu, fiabil și ideal pentru aplicații de detectare a prezenței lichidului. Material : polipropilena Putere comutata : 10W Curent max comutat : 0.5A Temperatura de operare max : 85C

Este similiar cu cel gasit la documentatia: plutitor_En

Schema Electrica:

Circuit de control al unei pompe de apă folosind un tranzistor NPN pentru a comuta curentul care alimentează pompa, pe baza semnalului digital trimis de un pin de pe Arduino. Iată cum funcționează circuitul:

Semnal de control de la Arduino: Pinul digital D7 de pe Arduino trimite un semnal HIGH (5V). Acest semnal trece printr-un rezistor de aproximativ 1kΩ, care protejează baza tranzistorului și limitează curentul care ajunge la acesta.

Comutarea tranzistorului NPN: Semnalul HIGH (5V) ajunge la baza tranzistorului NPN (2N2222). Curentul trece prin rezistor și ajunge la baza tranzistorului, ceea ce face ca tranzistorul să intre în modul de saturație (ON). Când tranzistorul este ON, colectorul (C) este conectat la emitor (E), creând astfel un traseu de curent prin pompa de apă, care este conectată la 5V.

Pornirea pompei: Deoarece tranzistorul este în modul ON, pompa de apă este conectată la GND, ceea ce permite curentului să circule prin ea și să o pornească.

Oprirea pompei: Când pinul D7 este setat pe LOW (0V), curentul nu mai ajunge la baza tranzistorului. Tranzistorul se oprește și curentul nu mai trece prin pompa de apă, astfel că aceasta se oprește.

Componente necesare: 1x tranzistor NPN

1x rezistor ~1kΩ (pentru baza tranzistorului)

1x diodă pentru a proteja pompa de efectele curentului invers, conectată invers pe terminalele pompei;

—Înlocuiri de Componente pentru Simulare—

Pentru a simula circuitul într-un mod realist, am efectuat câteva înlocuiri de componente în scopul obținerii unui comportament funcțional corespunzător. Detaliile acestor înlocuiri sunt următoarele:

• Senor de nivel de apă analogic:

În locul unui senzor de nivel de apă analogic specific, am utilizat un potențiometru pentru a simula schimbările de rezistență și, implicit, varierea nivelului apei. Acest potențiometru permite ajustarea valorii de tensiune de ieșire pentru a simula diferite niveluri de apă, de la nivel scăzut (uscat) până la nivel înalt (plin).

💡 Ce face: Potențiometrul simulează creșterea/scăderea nivelului apei. Valoarea variază de la 0 (gol) la 1023 (plin). Se poate roti butonul în timpul simulării pentru a vedea cum se schimbă valoarea în Serial Monitor.

• Diode de protecție (Flyback):

În locul unei diode flyback dedicate, am adăugat o diode 1N4007 pentru protecția circuitului în fața tensiunilor induse de sarcini inductive. Aceasta diodă a fost plasată paralel cu sarcina inductivă pentru a proteja componentele sensibile, cum ar fi Arduino sau tranzistorii, de eventualele spike-uri de tensiune.

• Pompa De Apa:

Pentru a simula pompa de apa am utilizat componentele de bază din Tinkercad: motor, transistor NPN, înlocuind necesitatea unui sistem fizic real.

Schematic:

Circuit:

Lista Componente:

Această secțiune explică exact ce pin de pe microcontroller este conectat la fiecare componentă, motivul alegerii și indică ce elemente sunt planificate pentru viitor.

• Pin utilizat: `A0` (pin analogic)
• Motiv: Senzorul măsoară nivelul apei și oferă un semnal analogic ce trebuie convertit digital prin ADC.

• Pin utilizat: `A1` (pin analogic)
• Motiv: Senzorul returnează o valoare analogică ce reflectă umiditatea solului. Este necesar un pin ADC pentru a o converti într-o valoare digitală.

• LED Verde – Pin D3
  • Indicarea stării „sol umed”.
  • Permite control PWM pentru a varia intensitatea în funcție de nivelul de umiditate.

• LED Roșu – Pin D5
• Stare „sol uscat”.
• Aprins constant când pragul de uscăciune este depășit.

• LED Galben – Pin D4 `(future)`
• Neutilizat în prezent.
• Planificat pentru funcționalități viitoare, cum ar fi avertizarea de nivel critic sau diagnostic sistem.

• Pin utilizat: `D7` (digital output)
• Motiv: Controlează activarea pompei (via tranzistor sau releu).
• Pinul poate fi comutat HIGH/LOW pentru pornire/oprire sau folosit cu PWM pentru control fin al debitului (dacă pompa permite).

• Pin planificat: `D2`
• Motiv: Este un pin care suportă întreruperi hardware.
• Se va folosi `attachInterrupt()` pentru:
  • Activarea manuală a pompei
  • Oprire de urgență a sistemului

• Pin planificați:
  • `D0 (RX)` ← conectat la `TX` de la ESP
  • `D1 (TX)` → conectat la `RX` de la ESP (cu divizor de tensiune!)
• Motiv: Comunicarea serială între microcontroller și modulul ESP pentru transmiterea valorilor senzorului în cloud.
• Se pot trimite comenzi AT sau se poate integra un protocol ca HTTP sau MQTT.
• Alimentarea modulului ESP se face separat la 3.3V!

Notă: Alegerea pinilor a ținut cont de:
* Necesitatea ADC pentru senzori (analogRead)
* Compatibilitate PWM pentru LED-uri și control tranzistor
* Pinuri hardware dedicate pentru UART și întreruperi
* Extensibilitate pentru funcții viitoare

Vizualizează conexiunile și comportamentul sistemului:

• 🔗 Apasă aici pentru a deschide simularea electrică

Notă: Această simulare arată conexiunile dintre:
* senzorul de umiditate,
* LED-urile de stare,
* pompa de apă,
* microcontrollerul,
* senzorul de nivel (reostat).

Proiectul integrează concepte și tehnologii abordate în cadrul mai multor laboratoare, după cum urmează:

• Laboratorul 0: GPIO
  • LED-urile (roșu, galben, verde) sunt controlate prin pinii digitali folosind funcțiile `digitalWrite()` și `analogWrite()` pentru indicarea stării solului și a apei.
  • Pompa este activată printr-un pin digital (prin tranzistor), iar butonul de reset și plutitorul de nivel scăzut al apei sunt conectați la pini digitali cu citire (`digitalRead()`).
  • Pini configurați ca `INPUT`, `INPUT_PULLUP` și `OUTPUT`, conform cerințelor hardware.

• Laboratorul 1: UART
  • Comunicarea serială este utilizată atât cu monitorul serial (USB), cât și cu modulul ESP8266 pentru conectivitate WiFi.
  • Se folosesc `Serial` și `SoftwareSerial` pentru a trimite date despre umiditate și nivelul apei, cât și pentru a primi răspunsuri de la ESP.
  • Comunicarea AT cu modulul ESP implică trimiterea de comenzi și interpretarea răspunsurilor.

• Laboratorul 2: Întreruperi
  • O întrerupere pe Timer2 este folosită pentru a verifica apăsarea butonului de reset la fiecare 1ms.
  • Se folosește `ISR(TIMER2_COMPA_vect)` pentru a citi starea butonului într-un mod eficient și responsiv, fără a bloca restul execuției.
  • Setarea întreruperilor cu `cli()`, `sei()` și registrii `TCCR2A/B`, `OCR2A`, `TIMSK2`.

• Laboratorul 3: Timere și PWM
  • Timer1 este utilizat pentru a limita timpul de funcționare al pompei (10 secunde), evitând suprafuncționarea.
  • PWM este aplicat pentru controlul intensității LED-urilor roșu și verde, în funcție de valoarea senzorului de umiditate, folosind `analogWrite()`.

• Laboratorul 4: ADC
  • Conversia analog-digitală este realizată prin `analogRead()` pe pinul A1 pentru a citi valorile de la senzorul de umiditate a solului.
  • Valorile digitale rezultate sunt utilizate pentru a decide când pompa trebuie pornită sau oprită, și pentru a ajusta intensitatea LED-urilor.

• YL-69 / HL-69 – Senzor de umiditate a solului
  • Utilizat pentru a măsura umiditatea solului și a decide automat dacă este necesară udarea plantei.
  • Valoarea analogică este citită cu ajutorul ADC (analogRead pe pinul A1).

• LED-uri de stare (roșu, galben, verde)
  • Oferă feedback vizual în funcție de nivelul de umiditate: uscat (roșu), mediu (galben), umed (verde).
  • Conectate la pini digitali (GPIO), două dintre ele fiind controlate și prin PWM pentru intensitate variabilă.

• Pompa de apă
  • Controlată printr-un tranzistor NPN sau releu.
  • Activarea este realizată prin GPIO (digitalWrite), iar funcționarea este limitată în timp cu ajutorul unui timer.

• Buton fizic de reset
  • Permite resetarea stării sistemului și a LED-urilor.
  • Citirea se face într-un handler de întrerupere (Timer2).

• Plutitor (float switch) pentru nivelul apei
  • Senzor digital care detectează dacă rezervorul de apă este gol.
  • Conectat la un pin digital configurat ca `INPUT`.
  • Dacă apa lipsește, pompa este blocată, iar LED-ul galben se aprinde.

• Modul ESP8266 (ESP-01)
  • Comunică prin UART software cu microcontrollerul.
  • Trimite periodic date despre nivelul de umiditate și starea apei către platforma ThingSpeak prin WiFi.

Chiar dacă hardware-ul este simplu, logica software a fost concepută modular și include:

• Interpretarea datelor de la senzor (ADC)
• Controlul ieșirilor digitale (GPIO, PWM)
• Comunicare serială (UART)
• Separarea logicii pe funcții personalizate
• Cod propriu >100 linii, nepreluat din biblioteci externe
• Utilizarea întreruperilor (Timer2)

Aceste aspecte asigură aplicarea efectivă a cunoștințelor dobândite în cadrul laboratorului și îndeplinirea cerințelor minime de complexitate software impuse de proiect.

Functii Peronalizate

* setupTimer2ForButton()

Scop: Configurează Timer2 în mod CTC pentru a genera întreruperi la fiecare 1 ms, folosite pentru a detecta apăsarea butonului de reset.

+------------------------------+
| setupTimer2ForButton()      |
+------------------------------+
| - Dezactivează întreruperile|
| - Setează Timer2 în mod CTC |
| - OCR2A = 249 (1kHz rate)   |
| - Activează întreruperea    |
| - Activează întreruperile   |
+------------------------------+

* ISR(TIMER2_COMPA_vect)

Scop: Rutina de întrerupere asociată Timer2 care detectează tranziția de la HIGH la LOW a butonului pentru reset.

+--------------------------------+
| ISR(TIMER2_COMPA_vect)        |
+--------------------------------+
| - Citește starea butonului     |
| - Dacă trece de la HIGH -> LOW |
|   → setează `resetRequested`  |
| - Actualizează `lastState`     |
+--------------------------------+

* pumpTimeoutISR()

Scop: Rutina apelată automat de Timer1 după 10 secunde; setează flag-ul pumpTimeout pentru a opri pompa.

+---------------------------+
| pumpTimeoutISR()         |
+---------------------------+
| - Setează pumpTimeout = 1 |
+---------------------------+

* checkPumpTimeout()

Scop: Verifică dacă pompa trebuie oprită din cauza expirării temporizatorului.

+------------------------------+
| checkPumpTimeout()          |
+------------------------------+
| IF pumpTimeout && pumpOn:   |
|   → Oprește pompa           |
|   → Resetare flaguri/timer  |
+------------------------------+

* lockPump()

Scop: Oprește și „blochează” pompa atunci când nivelul de apă este scăzut pentru prea mult timp.

+---------------------------+
| lockPump()               |
+---------------------------+
| - Oprește pompa          |
| - Setează pumpLocked     |
| - Resetează timerul      |
+---------------------------+

* unlockPump()

Scop: Resetează blocarea pompei, permițându-i să fie pornită din nou.

+---------------------------+
| unlockPump()             |
+---------------------------+
| - Resetează toate flagurile |
| - Oprește timerul          |
+---------------------------+

* connectToWiFi()

Scop: Trimite comenzi AT către modulul ESP pentru a-l conecta la rețeaua WiFi.

+--------------------------------+
| connectToWiFi()               |
+--------------------------------+
| - Trimite AT+RST              |
| - Setează modul pe CWMODE=1   |
| - Trimite AT+CWJAP cu SSID    |
| - Așteaptă conectarea         |
+--------------------------------+

* sendToThingSpeak(int soilValue, int waterLevel)

Scop: Trimite datele de la senzor către ThingSpeak folosind o comandă HTTP GET.

+------------------------------------------------+
| sendToThingSpeak(soilValue, waterLevel)       |
+------------------------------------------------+
| - Trimite AT+CIPSTART (TCP către ThingSpeak)  |
| - Construiește string GET cu cheie API        |
| - Trimite dimensiunea mesajului               |
| - Trimite datele (field1, field2)             |
| - Închide conexiunea cu AT+CIPCLOSE           |
+------------------------------------------------+

* loop() (parțial personalizat) Scop: Conține o structură modulară care:

• Citește umiditatea solului și controlează pompa și LED-urile corespunzător.
• Monitorizează plutitorul și oprește pompa dacă nivelul apei este scăzut prea mult timp.
• Trimite periodic date către ThingSpeak.
• Permite resetarea sistemului prin buton.

Pentru testarea hardware-ului cu un software simplu s-a utilizat platforma Tinkercad Circuits pentru simularea inițială a circuitului, permițând testarea logicii de control într-un mediu vizual interactiv.

Urmatoare imagine reflecta logica simpla pe care am folosit-o pentru a simula circuitul.

Ulterior, implementarea firmware-ului s-a realizat în Arduino IDE, un mediu de dezvoltare open-source destinat programării microcontrolerelor compatibile cu platforma Arduino. Acesta a oferit facilități de scriere, compilare și upload al codului către placă, precum și un monitor serial pentru debug și testare.

Testare mai avansata - inainte de optimizari si de aplicarea cunostintelor despre protocoalele invatate in laboratoare. Fisierul cu codul pentru aceasta testare se gaseste la: .\PlantCareSystem\Software\TestingPurpose\sketch_may15a ( in commit-urile mai vechi).

Aceasta este schema de baza de la care am plecat si peste care am implementat primul soft dupa care am testat:

START
  |
  V
Citeste valoarea senzorului de umiditate (ADC - A1)
  |
  V
Afiseaza valoarea in Serial Monitor (UART)
  |
  V
Comparare cu praguri:
  |-- [Valoare > dryThreshold (uscat)] --> LED rosu ON, LED verde OFF
  |                                      Activare pompa (D7 HIGH)
  |                                      Afisare status pompa (UART)
  |                                      Asteapta 3 secunde
  |                                      Dezactivare pompa (D7 LOW)
  |
  |-- [Valoare < wetThreshold (umed)] --> LED verde ON, LED rosu OFF
  |                                      Asigura pompa oprita (D7 LOW)
  |
  |-- [Alt caz] -----------------------> Toate LED-urile OFF
                                         Asigura pompa oprita (D7 LOW)
  |
  V
Asteapta 2 secunde si repeta

Aceasta este schema de baza a soft-ului complet, dupa care am realizat implementarea finala:

START
  |
  V
Inițializări:
 - Pini: LED-uri, pompă, senzor, plutitor, buton reset
 - UART și SoftwareSerial pentru ESP
 - Timer1 (10s) pentru oprirea pompei
 - Timer2 pentru citirea butonului de reset (cu ISR)
 - Conectare la WiFi prin ESP
  |
  V
LOOP:
  |
  V
Dacă au trecut 2 secunde:
  |
  +--> Citește valoare umiditate sol (A1)
  |
  +--> Afișează în UART (opțional)
  |
  +--> Comparare valoare:
  |     |
  |     |-- [valoare > dryThreshold]:
  |     |      - LED roșu ON (intensitate proporțională cu uscăciunea)
  |     |      - LED verde OFF
  |     |      - Dacă pompa e oprită și nu e blocată:
  |     |          - Pornește pompa (D7 HIGH)
  |     |          - Pornește Timer1 pentru 10s
  |     |
  |     |-- [valoare < wetThreshold]:
  |     |      - LED verde ON
  |     |      - LED roșu OFF
  |     |      - Verifică dacă Timer1 a expirat (checkPumpTimeout)
  |     |
  |     |-- [între praguri]:
  |            - LED-uri cu intensitate intermediară
  |            - Verifică dacă Timer1 a expirat
  |
  +--> Verificare nivel apă (plutitor - D2):
        |
        |-- [float HIGH (nivel OK)]:
        |      - Nu face nimic special
        |
        |-- [float LOW (nivel scăzut)]:
               - LED galben ON
               - Pornește timer de 30s dacă nu e deja pornit
               - Dacă au trecut 30s:
                   - Dezactivează pompa
                   - Oprește Timer1 (blochează pompa)
  |
  +--> Trimitere date către ThingSpeak:
         - Soil moisture + nivel apă
  |
  +--> Verificare buton reset (prin ISR):
         - Dacă a fost apăsat:
             - Resetează blocarea pompei
             - Oprește LED galben
  |
  V
REPETĂ LOOP

Laborator 1 – UART

• Plan inițial:
  1. Inițializare UART cu `Serial.begin(9600)`
  2. Trimitere valori senzor prin `Serial.print()`
  3. (Plănuit) Comunicare cu modul ESP prin comenzi AT

• Modificări realizate:
  1. ✅ Trimiterea valorilor senzorului de umiditate funcționează corect.
  2. ✅ Testare și documentare flux date pe monitor serial.
  3. ✅ Integrare completă cu modul ESP-01 pentru trimiterea datelor în cloud prin comenzi AT.
  4. ✅ Datele sunt transmise către platforma cloud (ThingSpeak) și pot fi monitorizate remote.

Laborator 2 – Întreruperi

• Plan inițial:
  1. Folosirea `attachInterrupt()` pentru activarea manuală a pompei și oprire de urgență.
  2. ISR setează un flag verificat în loop.

• Modificări realizate:
  1. ✅ Buton conectat pe pinul 2 cu întrerupere externă (INT0).
  2. ✅ ISR setează corect flag-ul de oprire.
  3. ✅ Control pompa pe baza flag-ului în loop, fără delay-uri.
  4. 🔄 Timer2 folosit pentru debounce și citire buton, în locul `attachInterrupt()`, pentru o gestionare mai stabilă a butonului reset.

Laborator 3 – Timere și PWM

• Plan inițial:
  1. Control PWM prin `analogWrite()`
  2. Înlocuire `delay()` cu `millis()` pentru program non-blocant.

• Modificări realizate:
  1. ✅ Control PWM pentru LED-uri (verde și roșu) pe baza valorii senzorului.
  2. ✅ Timer1 folosit pentru oprirea automată a pompei după 10 secunde.
  3. ✅ `millis()` folosit pentru citirea senzorului la intervale regulate fără blocare.
  4. ✅ Timer2 în modul CTC folosit pentru gestionarea debounce-ului butonului de reset.

Laborator 4 – ADC

• Plan inițial:
  1. Citirea senzorului prin `analogRead(A1)`
  2. Mapare valori și control LED RGB în funcție de umiditate

• Modificări realizate:
  1. ✅ Mapare precisă între valori analogice și intensitatea LED-urilor roșu/verde.
  2. ✅ Indicator vizual al nivelului de umiditate prin LED-uri variabil aprinse.
  3. ✅ Logica de praguri ajustată pentru praguri de „uscat” și „umed”.
  4. ✅ Implementare logică de monitorizare a nivelului apei (senzor plutitor) și blocarea pompei dacă nivelul este scăzut prea mult timp.

Extinderi Posibile

• 🌐 Integrare modul ESP-01 pentru trimitere date în cloud (HTTP/MQTT) - DONE.
• 🖥️ Interfață web sau aplicație mobilă pentru monitorizare remote
• 💾 Salvare date pe cloud pentru log istoric - DONE.
• 📊 Ajustare automată a pragurilor în funcție de datele istorice

1. TimerOne.h

• Bibliotecă pentru configurarea și utilizarea timerului hardware Timer1 pe plăcile Arduino.
• Permite setarea perioadelor precise și a funcțiilor de întrerupere pe baza timerului, fără blocarea programului.
• În proiect: folosită pentru control precis al temporizărilor și evitarea blocării cu delay().

2. AVR IO și Interrupts

• `avr/io.h` – accesează registrele hardware AVR pentru controlul avansat al perifericelor.
• `avr/interrupt.h` – gestionează funcțiile de întrerupere (ISR).
• În proiect: folosite pentru configurarea și gestionarea timerului 2 și întreruperilor la nivel de hardware.
• Pentru Timer 2 s-a lucrat direct cu registrele, fără a folosi o bibliotecă dedicată.

3. SoftwareSerial

• Permite crearea unui port serial suplimentar pe pini digitali arbitrari.
• Util pentru comunicarea serială cu modulul ESP-01 pe Arduino UNO, care are un singur port hardware.
• În proiect: utilizată pentru trimiterea și recepția comenzilor AT către modulul WiFi ESP-01.

4. Definirea pinilor

Configuratia actuala a pinilor:

Notă:

• Utilizarea timerelor hardware împreună cu SoftwareSerial poate necesita atenție, deoarece timer-ele pot afecta temporizarea comunicării seriale.
• Recomandare: Testare riguroasă pentru a evita conflictele între librării.

1. Pins:
   1. Pin 9 (OC1A) – Output Compare A
   2. Pin 10 (OC1B) – Output Compare B

1. Used for PWM outputs on pins 9 and 10.

1. Pins:
   1. Pin 3 (OC2B) – Output Compare B
   2. Pin 11 (OC2A) – Output Compare A

1. Used for PWM outputs on pins 3 and 11.

Notes

1. When using Timer1, avoid using pins 9 and 10 for other PWM or timer-related functions.
2. When using Timer2, avoid using pins 3 and 11 for other PWM or timer-related functions.

Recommended pins for other I/O or SoftwareSerial

1. Pins: 2, 4, 5, 6, 7, 8, 12, 13
2. Note: Pins 5 and 6 are PWM pins controlled by Timer0.
3. Pins 0 and 1 are hardware serial pins (avoid if using USB serial).

Aplicația are ca scop automatizarea controlului unei pompe de apă, în funcție de nivelul detectat de un senzor de umiditate. Logica principală implică:

• Citirea valorii analogice de la un senzor de nivel de apă (simulat cu un potențiometru în faza de testare online);
• Citirea valorii date de senzorul de umiditate;
• Compararea acestor valori cu threshold-uri stabilite în funcție de testele făcute fizic;
• Activarea/dezactivarea unei pompe de apă printr-un tranzistor NPN, în funcție de nivelul detectat și de umiditatea detectată;
• Utilizarea de semnale vizuale (LED-uri) pentru a indica starea sistemului;
• Afișarea valorilor în Serial Monitor pentru debugging în timp real;
• Conectare Wi-Fi pentru transmiterea datelor către platforma ThingSpeak (actualizat - funcții `connectToWiFi()` și `sendToThingSpeak()` implementate);
• Gestionarea unui buton de reset pentru deblocarea manuală a pompei, detectat prin întrerupere hardware pe Timer2 (actualizat - implementare ISR `TIMER2_COMPA_vect` și configurare Timer2 prin registrii AVR);
• Control precis al timpului de funcționare a pompei folosind Timer1 cu biblioteca TimerOne.h, pentru oprire automată după 10 secunde;
• Siguranță suplimentară prin blocarea pompei dacă nivelul apei este scăzut pentru mai mult de 30 de secunde (logică de blocare/deblocare inclusă).

Structura firmware-ului este organizată în jurul funcțiilor `setup()` și `loop()`, caracteristice platformei Arduino, cu separarea clară a inițializărilor față de logica repetitivă de rulare.

Actualizare: S-a adăugat suport complet pentru controlul pompei cu temporizări precise folosind Timer1, detecția butonului reset prin Timer2 configurat la nivel de registri (fără bibliotecă), precum și comunicarea Wi-Fi prin modulul ESP cu trimiterea datelor către ThingSpeak. Aceste modificări extind funcționalitatea inițială și îmbunătățesc robustetea sistemului.

În urma implementării proiectului, s-a reușit automatizarea cu succes a sistemului de irigare, conform cerințelor stabilite. Pompa este controlată automat în funcție de valorile obținute de la senzorul de umiditate și de la senzorul de nivel al apei (simulat cu un potențiometru). Funcțiile de siguranță, precum oprirea temporizată a pompei și blocarea în caz de nivel scăzut al apei, au fost implementate cu succes. De asemenea, s-a realizat transmiterea datelor către platforma ThingSpeak prin conexiune Wi-Fi și s-a integrat un buton de deblocare a pompei, gestionat prin întrerupere.

Toate funcționalitățile propuse au fost testate și validate în mediu de simulare, demonstrând stabilitatea și eficiența soluției.

Export to PDF