Show page

Differences

This shows you the differences between two versions of the page.

--- pm:prj2025:vstoica:alexandru.ciobotea [2025/05/23 16:04]
alexandru.ciobotea [Software Design]
+++ pm:prj2025:vstoica:alexandru.ciobotea [2025/05/30 00:22] (current)
alexandru.ciobotea [Sistem de Monitorizare al Confortului Termic intr-o Cladire]
@@ Line 1: / Line 1: @@
-====== Sistem de monitorizare al confortului termic intr-o cladire ======
+====== Sistem de Monitorizare al Confortului Termic ======
 ===== Introducere =====
-<note tip>Proiectul Smart Mini Calorifer este un dispozitiv inteligent de încălzire controlat cu Arduino, creat pentru a demonstra integrarea mai multor componente electronice și funcționalități software într-un produs fizic. Dispozitivul poate funcționa atât în mod real, folosind un senzor de temperatură (DS18B20), cât și în mod de test, folosind un potențiometru pentru a simula manual temperatura.
+<note tip>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).
-Prin intermediul unui afișaj LCD, utilizatorul poate monitoriza temperatura curentă, modul activ și statusul sistemului. Controlul automat al încălzirii este realizat cu ajutorul unui MOSFET și al semnalelor PWM, iar supratemperatura este semnalizată printr-un buzzer și un LED. Sistemul include și un mod special de testare pentru verificarea comportamentului software fără a fi necesară încălzirea fizică a elementului rezistiv.
+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 este conceput ca o demonstrație hardware și software, respectând cerințele academice de integrare a multiplelor periferice externe și a noțiunilor de programare embedded studiate în cadrul laboratoarelor.</note>
+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.</note>
 ===== Descriere generala =====
-{{ schema_bloc.png?500 }}
+{{ schema_bloc_ciobi.png?500 }}
-<note tip>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 furnizează valori simulate în modul de test, selectat cu ajutorul unui switch.
+<note tip>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 citită este procesată și afișată pe un LCD I2C, iar în funcție de pragurile setate, Arduino controlează un element de încălzire (simulat în Wokwi cu un LED PWM), un LED de stare și un buzzer pentru semnalizare acustică.
+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 PWM și generarea de alerte, acoperind toate cerințele hardware și software prevăzute pentru proiect.</note>
+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.
+</note>
 ===== Hardware Design =====
-{{ whatsapp_image_2025-05-22_at_00.31.30.jpeg?500 }}
+{{ montajciobee.jpeg?500 }}
 <note tip>
  🔹 Microcontroller
@@ Line 28: / Line 30: @@
   * 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)
+  * Buton tactil 12mm (pentru ON/OFF general) (DEFECT!!!)
  🔹 Semnalizare
   * Buzzer activ 5V
-  * LED roșu 5mm (pentru indicator stare)
+  * LED roșu 5mm (pentru indicator stare) X4
-  * Rezistor limitare curent LED (220Ω)
+  * Rezistor limitare curent LED (220Ω) X4
- 🔹 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
 </note>
 ===== Software Design =====
@@ Line 46: / Line 43: @@
 <note tip>
-#include <Wire.h>
+. Inițializarea pinilor (registre)
-#include <LiquidCrystal_I2C.h>
-#include <OneWire.h>
-#include <DallasTemperature.h>
-// Pini
+<code c>
-#define BUTTON_PIN 5
+#define BUZZER_PIN 2
-#define SWITCH_PIN 7
+#define SWITCH_PIN 8
-#define TEMP_SENSOR_PIN 2
+#define BUTON_ONOFF 5
-#define LED_PIN 4
-#define PWM_PIN 6
-#define POT_PIN A0  // potentiometru pentru modul test
-LiquidCrystal_I2C lcd(0x27, 16, 2);
+// LED-uri: D6 (PD6), D9 (PB1), D10 (PB2), D11 (PB3)
+const byte LED_MASK_D = (1 << PD6);
-OneWire oneWire(TEMP_SENSOR_PIN);
+const byte LED_MASK_B = (1 << PB1) | (1 << PB2) | (1 << PB3);
-DallasTemperature sensors(&oneWire);
-bool systemOn = false;
-float overheatThreshold = 25.0;
 void setup() {
-  pinMode(BUTTON_PIN, INPUT_PULLUP);
+  // Configurare registre pentru LED-uri
-  pinMode(SWITCH_PIN, INPUT_PULLUP);
+  DDRD |= LED_MASK_D;   // setează D6 ca output
-  pinMode(LED_PIN, OUTPUT);
+  DDRB |= LED_MASK_B;   // setează D9, D10, D11 ca output
-  pinMode(PWM_PIN, OUTPUT);
-  pinMode(POT_PIN, INPUT);
-  lcd.init();
+  // Inițial LED-urile sunt stinse
-  lcd.backlight();
+  PORTD &= ~LED_MASK_D;
+  PORTB &= ~LED_MASK_B;
+}
+</code>
-  Serial.begin(9600);
+. Comutarea sistemului ON/OFF cu buton
-  sensors.begin();
-  lcd.setCursor(0, 0);
+<code c>
-  lcd.print("Sistem: OPRIT");
+bool sistemPornit = false;
-  lcd.setCursor(0, 1);
+static bool lastButon = HIGH;
-  lcd.print("Mod: ---");
-}
 void loop() {
-  static bool lastButtonState = HIGH;
+  bool currentButon = digitalRead(BUTON_ONOFF);
-  bool currentButtonState = digitalRead(BUTTON_PIN);
+  if (lastButon == HIGH && currentButon == LOW) {
+    sistemPornit = !sistemPornit;
-  if (lastButtonState == HIGH && currentButtonState == LOW) {
-    systemOn = !systemOn;
     lcd.clear();
     lcd.setCursor(0, 0);
-    lcd.print("Sistem: ");
+    lcd.print(sistemPornit ? "Sistem pornit" : "Sistem oprit");
-    lcd.print(systemOn ? "PORNIT" : "OPRIT");
+    delay(300); // debounce simplu
-    Serial.print("Sistem: ");
-    Serial.println(systemOn ? "PORNIT" : "OPRIT");
-    delay(300);
   }
+  lastButon = currentButon;
+</code>
-  lastButtonState = currentButtonState;
+. Selectarea modului Real / Test
-  if (systemOn) {
+<code c>
-    bool isTestMode = digitalRead(SWITCH_PIN) == LOW;
+bool modTest = digitalRead(SWITCH_PIN) == LOW;
+float tempC;
-    if (!isTestMode) {
+if (modTest) {
-      // === MOD REAL ===
+  int potValue = analogRead(POT_PIN);
-      sensors.requestTemperatures();
+  tempC = map(potValue, 0, 1023, 150, 400) / 10.0;
-      float tempC = sensors.getTempCByIndex(0);
+} else {
+  sensors.requestTemperatures();
+  tempC = sensors.getTempCByIndex(0);
+}
+</code>
-      lcd.setCursor(0, 0);
+. Control alertă: LED-uri + buzzer
-      lcd.print("Temp: ");
-      lcd.print(tempC, 1);
-      lcd.print((char)223);
-      lcd.print("C   ");
-      Serial.print("Temp reala: ");
+<code c>
-      Serial.println(tempC);
+// ALERTĂ de temperatură
+if (tempC >= TEMP_PRAG) {
+  static unsigned long lastStep = 0;
+  static int ledIndex = 0;
-      if (tempC > overheatThreshold) {
+  if (millis() - lastStep >= 150) {
-        lcd.setCursor(0, 1);
+    lastStep = millis();
-        lcd.print("ALERTA: OVERHEAT");
+    for (int i = 0; i < 4; i++) {
+      if (i == ledIndex) {
-        digitalWrite(LED_PIN, LOW);
+        if (i == 0) PORTD |= (1 << PD6);
-        analogWrite(PWM_PIN, 0);
+        else PORTB |= (1 << (PB1 + i - 1));
       } else {
-        lcd.setCursor(0, 1);
+        if (i == 0) PORTD &= ~(1 << PD6);
-        lcd.print("Mod: REAL       ");
+        else PORTB &= ~(1 << (PB1 + i - 1));
-        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);
       }
+    }
+    ledIndex = (ledIndex + 1) % 4;
+  }
+  digitalWrite(BUZZER_PIN, HIGH);
+} else {
+  // LED-uri aprinse continuu, buzzer oprit
+  PORTD |= LED_MASK_D;
+  PORTB |= LED_MASK_B;
+  digitalWrite(BUZZER_PIN, LOW);
+}
+</code>
-    } else {
+</note>
-      // === MOD TEST ===
-      int rawValue = analogRead(POT_PIN);
-      float fakeTemp = map(rawValue, 0, 1023, 0, 100);
-      lcd.setCursor(0, 0);
+===== Rezultate Obţinute =====
-      lcd.print("Temp sim: ");
-      lcd.print(fakeTemp, 1);
-      lcd.print((char)223);
-      lcd.print("C   ");
-      Serial.print("Temp simulata: ");
+<note tip>
-      Serial.println(fakeTemp);
+Proiectul a fost realizat cu succes, respectând toate cerințele tehnice și funcționale impuse. Sistemul a fost testat atât în mod real, folosind senzorul DS18B20 pentru citirea temperaturii ambientale, cât și în mod de test, utilizând un potențiometru pentru simularea valorilor.
-      if (fakeTemp > overheatThreshold) {
+Funcționalitățile implementate și verificate:
-        lcd.setCursor(0, 1);
+  * Afișarea temperaturii în timp real pe ecranul LCD 1602 (I2C)
-        lcd.print("ALERTA: OVERHEAT");
+  * Comutare între mod real și mod test cu ajutorul unui switch
+  * Aprinderea LED-urilor și activarea buzzer-ului la atingerea unui prag critic (28°C)
+  * Controlul LED-urilor direct prin registre (DDRx și PORTx)
+  * Pornirea/oprirea întregului sistem cu ajutorul unui buton fizic
+  * Trimiterea datelor și mesajelor de stare prin Serial Monitor (UART)
-        digitalWrite(LED_PIN, LOW);
+Testele efectuate au confirmat comportamentul așteptat în toate scenariile simulate: încălzire activă, standby și alertă (overheating). Sistemul a răspuns stabil la toate comenzile și a menținut funcționalitatea corectă pe durata rulărilor extinse.
-        analogWrite(PWM_PIN, 0);
-      } else {
-        lcd.setCursor(0, 1);
-        lcd.print("Mod: TEST        ");
-        if (fakeTemp < 25.0) {
+Proiectul demonstrează integrarea eficientă a perifericelor externe și a conceptelor de programare embedded studiate în cadrul laboratorului: GPIO, ADC, UART, I2C, registre directe și timere software.
-          digitalWrite(LED_PIN, HIGH);
-        } else {
-          digitalWrite(LED_PIN, LOW);
-        }
-        int pwmValue = map(fakeTemp, 0, 60, 255, 0);
+În urma implementării acestui proiect, am înțeles mai bine atât interacțiunea dintre componentele hardware, cât și modul de control eficient al acestora la nivel de microcontroler.
-        pwmValue = constrain(pwmValue, 0, 255);
-        analogWrite(PWM_PIN, pwmValue);
-      }
-    }
-  } else {
+</note>
-    lcd.setCursor(0, 0);
-    lcd.print("Sistem: OPRIT    ");
-    lcd.setCursor(0, 1);
-    lcd.print("Mod: ---         ");
-    digitalWrite(LED_PIN, LOW);
+===== Concluzii =====
-    analogWrite(PWM_PIN, 0);
-  }
-  delay(300);
+<note tip> Proiectul Smart Thermal Monitor a demonstrat cu succes capacitatea de a integra multiple componente periferice într-un sistem embedded funcțional, utilizând microcontrolerul Arduino UNO. Am reușit să implementăm un sistem complet care măsoară, afișează și reacționează la variațiile de temperatură în timp real, atât în mod real cât și în mod de testare.
-}
-</note>
+Prin utilizarea directă a registrelor de control (DDRx și PORTx) pentru LED-uri, proiectul evidențiază o înțelegere avansată a modului în care funcționează perifericele digitale la nivel de microcontroler, oferind o alternativă optimizată față de funcțiile de nivel înalt precum `digitalWrite()`.
-===== Rezultate Obţinute =====
+De asemenea, utilizarea I2C, UART și ADC confirmă aplicarea practică a noțiunilor de laborator și creează o bază solidă pentru dezvoltarea de sisteme embedded mai complexe.
-<note tip>
+Proiectul este stabil, fiabil și ușor de extins (de exemplu, prin adăugarea unui sistem real de încălzire, integrarea cu un ecran OLED sau comunicare wireless). Această experiență a oferit o înțelegere aprofundată a fluxului complet de dezvoltare embedded – de la conectarea fizică până la scrierea și optimizarea codului.
-Care au fost rezultatele obţinute în urma realizării proiectului vostru.
-</note>
-===== Concluzii =====
+În concluzie, proiectul reflectă o execuție atent planificată, care îmbină eficient hardware și software într-o soluție practică și educațională.</note>
 ===== Download =====
 <note warning>
-O arhivă (sau mai multe dacă este cazul) cu fişierele obţinute în urma realizării proiectului: surse, scheme, etc. Un fişier README, un ChangeLog, un script de compilare şi copiere automată pe uC crează întotdeauna o impresie bună ;-).
+Codul sursă, commit-urile și istoricul complet al proiectului pot fi consultate la linkul de mai jos:
+[[https://github.com/alexciobotea21/Smart-Thermal-Monitor|🔗 Proiectul complet pe GitHub]]
-Fişierele se încarcă pe wiki folosind facilitatea **Add Images or other files**. Namespace-ul în care se încarcă fişierele este de tipul **:pm:prj20??:c?** sau **:pm:prj20??:c?:nume_student** (dacă este cazul). **Exemplu:** Dumitru Alin, 331CC -> **:pm:prj2009:cc:dumitru_alin**.
 </note>
 ===== Jurnal =====
-<note tip>
-Puteți avea și o secțiune de jurnal în care să poată urmări asistentul de proiect progresul proiectului.
+^ Săptămâna ^ Interval       ^ Activitate                     ^
-</note>
+| 10        | 28 Apr – 2 Mai | Confirmare finală temă proiect și început implementare hardware: test senzor DS18B20 și LCD I2C |
+| 11        | 5 – 9 Mai      | Citirea temperaturii, afișaj pe LCD, integrare comutator mod real/test, testare potențiometru (ADC) |
+| 12        | 12 – 16 Mai    | Adăugare buton ON/OFF, integrare buzzer, LED-uri controlate cu `digitalWrite()` |
+| 13        | 19 – 23 Mai    | Refactorizare LED-uri pe registre (PORTx/DDR), testare completă, integrare serială, cod final și documentație |
+| 14        | 26 – 30 Mai    | Validare funcționalități și încărcare proiect pe OCW și GitHub |
 ===== Bibliografie/Resurse =====
-<note>
-Listă cu documente, datasheet-uri, resurse Internet folosite, eventual grupate pe **Resurse Software** şi **Resurse Hardware**.
-</note>
 <html><a class="media mediafile mf_pdf" href="?do=export_pdf">Export to PDF</a></html>