La acțiunea unui stimul extern pentru senzorul de temperatură se va transmite un semnal către microcontroller. Apoi, software-ul de pe microcontroller va putea transmite către celelalte componente semnale.

Pentru programarea plăcii am folosit Arduino IDE, fără biblioteci specifice Arduino. Singurele biblioteci incluse sunt `<avr/io.h>` și `<util/delay.h>`, în rest s-au folosit funcții implementate manual (fiind un proiect orientat pe software). La baza design-ului software stau laboratoarele de I2C, SPI și datasheet-ul pentru senzorul DHT22, practic am încercat să integrez cât mai mult cod similar cu cel din laborator (plăcile fiind aproape identice). Particularități de implementare:

• Implementarea comunicației I2C:
  1. Am utilizat funcții de nivel jos pentru a inițializa și a trimite date către LCD. Aceste funcții manipulează direct pinii SDA și SCL folosind registrele DDR și PORT. De exemplu:

```

     void i2cStart() {
       digitalWrite(SDA_PIN, LOW);
       _delay_us(4);
       digitalWrite(SCL_PIN, LOW);
     }
     ```
     - Inițializarea magistralei I2C se face setând pinii SDA și SCL ca ieșire folosind registrul `DDR`.
     - Trimiterea unui bit pe magistrala I2C implică setarea stării pinului SDA urmată de un impuls pe pinul SCL.

• Implementarea comunicației SPI:
  1. Am utilizat funcții de nivel jos pentru a comunica cu cardul SD. Inițializarea SPI se face prin configurarea registrelor `SPCR` și `SPSR`:

```cpp

     void spiBegin() {
       pinMode(MOSI_PIN, OUTPUT);
       pinMode(MISO_PIN, INPUT);
       pinMode(SCK_PIN, OUTPUT);
       pinMode(SS_PIN, OUTPUT);

       SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR1) | (1 << SPR0);
       SPSR &= ~(1 << SPI2X); // Clear the SPI2X bit
     }
     ```
     - Registrul `SPCR` (SPI Control Register) este configurat pentru a activa modul SPI, pentru a seta placa în modul master și pentru a seta rata ceasului SPI.
     - Registrul `SPSR` (SPI Status Register) este utilizat pentru a seta sau reseta bitul de dublare a ratei ceasului SPI.

• Citirea datelor de la senzorul DHT22:
  1. Citirea datelor de la senzorul DHT22 se face folosind temporizări precise și manipulări directe ale pinului de date. Funcția `readDHT` inițializează comunicarea trimițând un semnal de start și apoi citește datele folosind cicluri de așteptare și măsurători de timp:

```cpp

     bool readDHT(float &temperature, float &humidity) {
       uint8_t data[5] = {0};
       pinMode(DHTPIN, OUTPUT);
       digitalWrite(DHTPIN, LOW);
       _delay_ms(20);
       digitalWrite(DHTPIN, HIGH);
       _delay_us(40);
       pinMode(DHTPIN, INPUT_PULLUP);

       // Așteptare pentru răspunsul senzorului
       if (!waitForSignal(LOW, 80) || !waitForSignal(HIGH, 80) || !waitForSignal(LOW, 80)) {
         return false;
       }

       // Citire date
       for (uint8_t i = 0; i < 5; i++) {
         data[i] = readByte();
       }

       // Verificare checksum
       if (data[4] == ((data[0] + data[1] + data[2] + data[3]) & 0xFF)) {
         humidity = ((data[0] << 8) + data[1]) * 0.1;
         temperature = (((data[2] & 0x7F) << 8) + data[3]) * 0.1;
         if (data[2] & 0x80) {
           temperature = -temperature;
         }
         return true;
       }
       return false;
     }
     ```

• Controlul buzzerului:
  1. Controlul buzzerului se face folosind funcțiile `tone()` și `noTone()` pentru a emite sunete de avertizare atunci când temperatura depășește un anumit prag.

• Afișarea datelor pe ecranul LCD:
  1. Am implementat funcții pentru inițializare, curățare, setare cursor și scriere text pe LCD utilizând protocolul I2C. Inițializarea LCD-ului implică trimiterea unor comenzi de configurare prin magistrala I2C.

• Utilizarea comunicației seriale:
  1. Pentru debugging și monitorizarea datelor în timpul execuției programului, am folosit funcțiile `Serial.print()` și `Serial.println()`.

Export to PDF