Proiectul Smart Thermal Monitor este un sistem embedded de monitorizare și alertare termică, controlat cu Arduino UNO, realizat pentru a demonstra integrarea mai multor periferice externe și funcționalități software într-un produs fizic coerent. Dispozitivul funcționează în mod real, prin citirea temperaturii de la senzorul digital DS18B20, dar include și un mod de testare, activat cu ajutorul unui comutator, în care temperatura este simulată printr-un potențiometru (ADC).

Utilizatorul poate observa în timp real temperatura și starea sistemului prin intermediul unui afișaj LCD I2C, iar o temperatură ridicată este semnalizată vizual și auditiv printr-un buzzer și un ansamblu de 4 LED-uri controlate direct din registre (DDRx și PORTx). Sistemul este controlat manual printr-un buton ON/OFF implementat cu fire și detectare software, fără debounce hardware.

Proiectul se axează pe respectarea cerințelor academice, înglobând concepte studiate în cadrul laboratorului de PM, precum utilizarea GPIO, ADC, I2C, UART și control direct al perifericelor prin accesarea registrelor microcontrolerului. De asemenea, este evidențiată separarea logicii de test față de logica de funcționare reală, aspect esențial în dezvoltarea sistemelor embedded robuste.

Sistemul este centrat pe un microcontroller Arduino UNO, care gestionează toate funcțiile dispozitivului. Senzorul de temperatură DS18B20 furnizează date în modul real, iar potențiometrul este utilizat în modul de test, permițând simularea valorii temperaturii. Comutarea între cele două moduri se realizează cu ajutorul unui switch dedicat.

Temperatura este citită, procesată și afișată în timp real pe un LCD I2C. În funcție de valoarea detectată, sistemul activează o alertă acustică printr-un buzzer și o alertă vizuală prin intermediul a patru LED-uri controlate direct prin registre (DDRx, PORTx). Un buton fizic (ON/OFF) permite activarea și dezactivarea sistemului în mod manual, fără resetarea plăcii.

Astfel, proiectul combină citirea de date, afișarea în timp real, controlul logic pe praguri și utilizarea eficientă a perifericelor externe, acoperind toate cerințele hardware și software prevăzute pentru proiect. Implementarea controlului LED-urilor prin registre oferă un plus de eficiență și demonstrează înțelegerea nivelului hardware al microcontrolerului.

🔹 Microcontroller

• Arduino Uno R3 (compatibil)

🔹 Afișaj

• LCD 16×2 cu interfață I2C (adresă 0x27)

🔹 Senzori și comenzi

• Senzor de temperatură DS18B20 digital
• Potențiometru 10kΩ linear (pentru setare temperatură simulată)
• Switch 2 poziții ON-OFF (pentru comutare mod Real / Test)
• Buton tactil 12mm (pentru ON/OFF general)

🔹 Semnalizare

• Buzzer activ 5V
• LED roșu 5mm (pentru indicator stare)
• Rezistor limitare curent LED (220Ω)

🔹 Control încălzire

• MOSFET IRF540N / IRLZ44N (pentru comanda rezistenței)
• Rezistență încălzire:
• Rezistență ceramică 5–10W (10Ω)

🔹 Conexiuni și structură

• Breadboard 400 puncte
• Set fire jumper male-male, male-female, female-female
• Adaptor alimentare 12V 2A DC

#include <Wire.h> #include <LiquidCrystal_I2C.h> #include <OneWire.h> #include <DallasTemperature.h>

Pini #define BUTTON_PIN 5 #define SWITCH_PIN 7 #define TEMP_SENSOR_PIN 2 #define LED_PIN 4 #define PWM_PIN 6 #define POT_PIN A0 potentiometru pentru modul test

LiquidCrystal_I2C lcd(0x27, 16, 2);

OneWire oneWire(TEMP_SENSOR_PIN); DallasTemperature sensors(&oneWire);

bool systemOn = false; float overheatThreshold = 25.0;

void setup() {

pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(SWITCH_PIN, INPUT_PULLUP);
pinMode(LED_PIN, OUTPUT);
pinMode(PWM_PIN, OUTPUT);
pinMode(POT_PIN, INPUT);

lcd.init();
lcd.backlight();

Serial.begin(9600);
sensors.begin();

lcd.setCursor(0, 0);
lcd.print("Sistem: OPRIT");
lcd.setCursor(0, 1);
lcd.print("Mod: ---");

}

void loop() {

static bool lastButtonState = HIGH;
bool currentButtonState = digitalRead(BUTTON_PIN);

if (lastButtonState == HIGH && currentButtonState == LOW) {
  systemOn = !systemOn;

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Sistem: ");
  lcd.print(systemOn ? "PORNIT" : "OPRIT");

  Serial.print("Sistem: ");
  Serial.println(systemOn ? "PORNIT" : "OPRIT");

  delay(300);
}

lastButtonState = currentButtonState;

if (systemOn) {
  bool isTestMode = digitalRead(SWITCH_PIN) == LOW;

  if (!isTestMode) {
    // === MOD REAL ===
    sensors.requestTemperatures();
    float tempC = sensors.getTempCByIndex(0);

    lcd.setCursor(0, 0);
    lcd.print("Temp: ");
    lcd.print(tempC, 1);
    lcd.print((char)223);
    lcd.print("C   ");

    Serial.print("Temp reala: ");
    Serial.println(tempC);

    if (tempC > overheatThreshold) {
      lcd.setCursor(0, 1);
      lcd.print("ALERTA: OVERHEAT");

      digitalWrite(LED_PIN, LOW);
      analogWrite(PWM_PIN, 0);
    } else {
      lcd.setCursor(0, 1);
      lcd.print("Mod: REAL       ");

      if (tempC < 25.0) {
        digitalWrite(LED_PIN, HIGH);
      } else {
        digitalWrite(LED_PIN, LOW);
      }

      int pwmValue = map(tempC, 0, 60, 255, 0);
      pwmValue = constrain(pwmValue, 0, 255);
      analogWrite(PWM_PIN, pwmValue);
    }

  } else {
    // === MOD TEST ===
    int rawValue = analogRead(POT_PIN);
    float fakeTemp = map(rawValue, 0, 1023, 0, 100);

    lcd.setCursor(0, 0);
    lcd.print("Temp sim: ");
    lcd.print(fakeTemp, 1);
    lcd.print((char)223);
    lcd.print("C   ");

    Serial.print("Temp simulata: ");
    Serial.println(fakeTemp);

    if (fakeTemp > overheatThreshold) {
      lcd.setCursor(0, 1);
      lcd.print("ALERTA: OVERHEAT");

      digitalWrite(LED_PIN, LOW);
      analogWrite(PWM_PIN, 0);
    } else {
      lcd.setCursor(0, 1);
      lcd.print("Mod: TEST        ");

      if (fakeTemp < 25.0) {
        digitalWrite(LED_PIN, HIGH);
      } else {
        digitalWrite(LED_PIN, LOW);
      }

      int pwmValue = map(fakeTemp, 0, 60, 255, 0);
      pwmValue = constrain(pwmValue, 0, 255);
      analogWrite(PWM_PIN, pwmValue);
    }
  }

} else {
  lcd.setCursor(0, 0);
  lcd.print("Sistem: OPRIT    ");
  lcd.setCursor(0, 1);
  lcd.print("Mod: ---         ");

  digitalWrite(LED_PIN, LOW);
  analogWrite(PWM_PIN, 0);
}

delay(300);

}

Care au fost rezultatele obţinute în urma realizării proiectului vostru.

Puteți avea și o secțiune de jurnal în care să poată urmări asistentul de proiect progresul proiectului.