Proiectul constă în realizarea unui sistem embedded pentru monitorizarea umidității solului unei plante. Sistemul măsoară nivelul de umiditate folosind un senzor higrometru capacitiv, afișează valoarea măsurată și statusul plantei pe un display LCD 16×2, iar atunci când umiditatea scade sub un prag prestabilit, avertizează utilizatorul prin aprinderea unui LED roșu și pornirea unui buzzer activ.

Scopul proiectului este de a ajuta utilizatorul să știe când planta are nevoie de apă și de a urmări evoluția umidității solului în timp. Pentru acest lucru, sistemul salvează măsurătorile pe un card microSD, împreună cu data și ora obținute de la un modul RTC DS3231. De asemenea, valorile măsurate și statisticile calculate pot fi transmise prin Bluetooth către un telefon sau laptop, folosind un modul HC-05.

Care este ideea de la care am pornit și de ce este util? Ei bine, eu toată viața mea, am avut 3 ghivece cu plante: primul eram in gimnaziu, era o floare, a ținut 1 lună, al doilea eram în liceu și am avut un cactus (m-a ținut 3 luni) și acum am unul de o lună și cred că e timpul să accept decesul. Mereu uit să ud plantele și știu sigur că este o problemă pentru multe persoane. Statisticile transmise prin bluetooth mă pot ajuta să-mi dau seama în fazele neoportune ale plantei dacă e din cauza udatului excesiv sau udatului prea rar sau non existent.

Sistemul are la bază o placă Arduino UNO R3, care coordonează toate componentele proiectului. Senzorul de umiditate este introdus în sol și trimite către placă o valoare analogică, în funcție de cât de umed sau uscat este pământul. Această valoare este citită prin pinul A0, apoi este transformată într-un procent de umiditate și comparată cu un prag stabilit în program.

Dacă umiditatea scade sub pragul ales, sistemul consideră că planta trebuie udată. În această situație, LED-ul roșu se aprinde, buzzerul pornește, iar pe LCD apare un mesaj de avertizare. Dacă nivelul de umiditate este normal, LED-ul și buzzerul rămân oprite, iar pe ecran este afișat statusul plantei.

Pentru a putea urmări măsurătorile în timp, proiectul folosește un modul RTC DS3231, care oferă data și ora fiecărei citiri. Valorile sunt salvate pe un card microSD într-un fișier de tip `.csv`, astfel încât pot fi analizate ulterior. În plus, prin modulul Bluetooth HC-05, datele curente și statisticile calculate pot fi transmise către un dispozitiv.

Sistemul include și un buton Start/Stop, care permite pornirea sau oprirea monitorizării fără a deconecta alimentarea plăcii.

• Arduino UNO R3
• Breadboard HQ 830 puncte
• Senzor de umiditate a solului
• LCD 1602 cu interfață I2C
• LED roșu
• Set rezistențe
• Modul cu buzzer activ
• Buton Start/Stop
• Modul RTC DS3231
• Baterie CR2032 3V
• Modul microSD
• Card microSD 4GB
• Modul Bluetooth HC-05
• Fire jumper tată-tată
• Fire jumper mamă-tată
• Cablu USB pentru Arduino UNO

Senzor VCC  -> Arduino 5V
Senzor GND  -> Arduino GND
Senzor AOUT -> Arduino A0

LCD SDA -> A4
LCD SCL -> A5

RTC SDA -> A4
RTC SCL -> A5

microSD CS   -> D10
microSD MOSI -> D11
microSD MISO -> D12
microSD SCK  -> D13

HC-05 TXD -> D5
HC-05 RXD -> D6 prin divizor de tensiune
HC-05 VCC -> 5V
HC-05 GND -> GND

D6 Arduino -> rezistență 1kΩ -> nod comun -> HC-05 RXD
nod comun -> rezistență 2kΩ -> GND

D7 -> rezistență 220Ω -> LED roșu -> GND
D8 -> buzzer activ -> GND
D2 -> buton -> GND

Firmware-ul proiectului este dezvoltat în:

• PlatformIO în Visual Studio Code

Codul este scris în C/C++ pentru Arduino UNO R3.

Proiectul este organizat pe mai multe fișiere, pentru a separa logica aplicației de partea de configurare hardware și de calculul statisticilor.

soil_moisture_monitor/
│
├── platformio.ini
│
├── include/
│   ├── config.h
│   ├── hardware.h
│   └── statistics.h
│
├── src/
│   ├── main.cpp
│   ├── hardware.cpp
│   └── statistics.cpp
│
├── README.md
└── ChangeLog.md

Pinii proiectului sunt definiți în fișierul `config.h`.

const uint8_t PIN_SOIL_SENSOR = A0;
const uint8_t PIN_BUTTON = 2;
 
const uint8_t PIN_BT_RX = 5;
const uint8_t PIN_BT_TX = 6;
 
const uint8_t PIN_LED = 7;
const uint8_t PIN_BUZZER = 8;
 
const uint8_t PIN_SD_CS = 10;

Pinii A4 și A5 sunt folosiți automat pentru comunicația I2C:

A4 -> SDA
A5 -> SCL

Pentru modulul microSD sunt folosiți pinii SPI ai plăcii Arduino UNO:

D10 -> CS
D11 -> MOSI
D12 -> MISO
D13 -> SCK

Valorile de calibrare ale senzorului sunt definite în `config.h`:

const int SENSOR_DRY_ADC = 750;
const int SENSOR_WET_ADC = 350;
const int HUMIDITY_THRESHOLD_PERCENT = 35;

Aceste valori sunt orientative și trebuie ajustate după testarea senzorului real. Se citește valoarea senzorului în sol uscat și în sol umed, apoi aceste valori sunt introduse în cod.

Conversia valorii ADC în procent se face în funcția `convertAdcToHumidityPercent()`:

int convertAdcToHumidityPercent(int adcValue) {
  long humidity = map(adcValue, SENSOR_DRY_ADC, SENSOR_WET_ADC, 0, 100);
  humidity = constrain(humidity, 0, 100);
  return (int)humidity;
}

La pornirea sistemului:

1. se inițializează statisticile;
2. se configurează pinii pentru LED, buzzer și buton;
3. se pornește comunicația serială și comunicația Bluetooth;
4. se inițializează magistrala I2C;
5. se pornește LCD-ul;
6. se inițializează modulul RTC DS3231;
7. se inițializează cardul microSD;
8. se afișează mesajul de pornire pe LCD.

În bucla principală:

1. se verifică dacă butonul Start/Stop a fost apăsat;
2. dacă sistemul este oprit logic:
   • LED-ul este stins;
   • buzzerul este oprit;
   • LCD-ul afișează mesajul „Sistem oprit”;
3. dacă sistemul este pornit:
   • se citește valoarea analogică de la senzor;
   • valoarea ADC este convertită în procent de umiditate;
   • se stabilește dacă planta este în status „OK” sau „USCAT”;
   • se actualizează statisticile;
   • se controlează LED-ul și buzzerul;
   • se actualizează LCD-ul;
   • se salvează periodic datele pe cardul microSD;
   • se transmit periodic datele prin Bluetooth.

Statusul plantei este stabilit prin compararea umidității curente cu pragul definit în `config.h`.

currentDry = currentHumidity < HUMIDITY_THRESHOLD_PERCENT;
currentStatus = currentDry ? "USCAT" : "OK";

Dacă umiditatea este sub prag, LED-ul și buzzerul sunt pornite. Dacă umiditatea este peste prag, acestea sunt oprite.

void setAlerts(bool systemActive, bool isDry) {
  if (systemActive && isDry) {
    digitalWrite(PIN_LED, HIGH);
    digitalWrite(PIN_BUZZER, HIGH);
  } else {
    digitalWrite(PIN_LED, LOW);
    digitalWrite(PIN_BUZZER, LOW);
  }
}

Statisticile sunt păstrate într-o structură numită `MoistureStats`.

struct MoistureStats {
  bool initialized;
  unsigned long count;
  long sum;
  int minimum;
  int maximum;
  int first;
  int previous;
  int current;
  unsigned long dryCount;
};

Această structură permite calcularea următoarelor informații:

• numărul total de măsurători;
• suma valorilor măsurate;
• media umidității;
• valoarea minimă;
• valoarea maximă;
• prima valoare măsurată;
• valoarea anterioară;
• valoarea curentă;
• numărul de măsurători în care solul a fost uscat.

La fiecare măsurătoare, funcția `updateStats()` actualizează valorile statistice.

void updateStats(MoistureStats &stats, int humidityPercent, bool isDry) {
  if (!stats.initialized) {
    stats.initialized = true;
    stats.first = humidityPercent;
    stats.previous = humidityPercent;
    stats.current = humidityPercent;
    stats.minimum = humidityPercent;
    stats.maximum = humidityPercent;
  } else {
    stats.previous = stats.current;
    stats.current = humidityPercent;
 
    if (humidityPercent < stats.minimum) {
      stats.minimum = humidityPercent;
    }
 
    if (humidityPercent > stats.maximum) {
      stats.maximum = humidityPercent;
    }
  }
 
  stats.sum += humidityPercent;
  stats.count++;
 
  if (isDry) {
    stats.dryCount++;
  }
}

Media este calculată astfel:

int getAverageHumidity(const MoistureStats &stats) {
  if (stats.count == 0) {
    return 0;
  }
 
  return (int)(stats.sum / (long)stats.count);
}

Tendința este calculată prin compararea valorii curente cu valoarea anterioară.

const char* getTrend(const MoistureStats &stats) {
  if (!stats.initialized || stats.count < 2) {
    return "STABIL";
  }
 
  int diff = stats.current - stats.previous;
 
  if (diff > 2) {
    return "CRESTERE";
  }
 
  if (diff < -2) {
    return "SCADERE";
  }
 
  return "STABIL";
}

Datele sunt salvate pe cardul microSD în fișierul:

umid.csv

Header-ul fișierului este:

date,time,adc,humidity,status,average,min,max,trend,delta_from_first,dry_count,count

Exemplu de linie salvată:

2026-05-08,16:40:00,522,28,USCAT,45,28,72,SCADERE,-14,3,10

Prin modulul HC-05 se transmite periodic un raport cu valorile curente și statisticile calculate.

----------------
Timp: 2026-05-08 16:40:00
ADC: 522
Umiditate: 28%
Status: USCAT
Media: 45%
Minim: 28%
Maxim: 72%
Tendinta: SCADERE
Diferenta fata de start: -14 pct
Masuratori sol uscat: 3
SD: OK

Butonul Start/Stop este configurat folosind rezistența internă de pull-up a microcontrollerului.

pinMode(PIN_BUTTON, INPUT_PULLUP);

Astfel:

buton neapăsat -> HIGH
buton apăsat   -> LOW

Funcția `buttonPressedEvent()` detectează apăsarea butonului și schimbă starea sistemului între pornit și oprit.

if (buttonPressedEvent()) {
  systemActive = !systemActive;
}

Intervalele de timp sunt definite în `config.h`.

const unsigned long MEASURE_INTERVAL_MS = 1000;
const unsigned long LCD_INTERVAL_MS = 1000;
const unsigned long SD_LOG_INTERVAL_MS = 10000;
const unsigned long BT_SEND_INTERVAL_MS = 3000;

Astfel:

• senzorul este citit la fiecare 1 secundă;
• LCD-ul este actualizat la fiecare 1 secundă;
• datele sunt salvate pe microSD la fiecare 10 secunde;
• raportul Bluetooth este trimis la fiecare 3 secunde.

Export to PDF