Kombinovaný snímač teploty a vlhkosti DHT22: Rozdiel medzi revíziami

Verzia z 21:29, 2. máj 2025

Záverečný projekt predmetu MIPS / LS2025 - Martin Hubocký

Zadanie

Mojím zadaním bolo vytvoriť program, ktorý bude zo senzoru DHT22 (Snímač teploty a vlhkosti) čítať a spracovávať dáta a cez UART sériovú komunikáciu ich vypísať na obrazovku monitoru. V prípade že sa mi to podarí spravím rozšírenie programu aby sa dáta zobrazovali na displeji typu LCD (Liquid Crystal Display).

Analýza a opis riešenia

Postup vypracovávania projektu a opis činnosti zariadenia

Najskôr som vo vývojovom prostredí Arduino IDE overil funkčnosť snímača. V tomto prostredí sa nachádza množstvo knižníc, takže mi "spojazdnenie" snímaču trvalo pár minút. Keď som si bol istý že snímač funguje, prešiel som do prostredia AVR, kde to bez knižníc bolo trochu tažšie (trochu dosť :) ). Najskôr sa mi dlhú dobu nedarilo, potom sa mi podarilo cez UART vypísať celočíselné hodnoty, a napokon aj desatinné miesta. Na komunikáciu cez UART som samozrejme použil knižnicu, ktorú sme si vytvárali na cvičení z predmetu.

Ďalej som postupoval s pripojením displeja k mikrokontroléru podľa návodu na stránke (Tu), kde bol takisto aj link na stiahnutie knižnice lcd_ch.h (a lcd_ch.c), ktorú takisto vo svojom programe používam. Vytvoril (zadefinoval) som si dva vlastné znaky. 1. bol znak "°" (Stupeň Celzia), a 2. bol znak "ť" ktorý sa mi nepodaril práve najkrajšie (Pretože displej ktorý vo svojom projekte používam vykresľuje jeden znak pomocou políčka o rozmeroch 5x7 pixelov a nie 5x8 pixelov ako niektoré iné modely). Takisto som vypol kurzor displeju pretože mi osobne vadil. Zo začiatku som si myslel že displej nefunguje, no neskôr som si uvedomil svoju amatérsku chybu keď som zistil že som pomocou potenciometra nemal nastavený správny jas. Okrem toho som s displejom žiadny iný problém nemal.

Týmto som mal hlavnú úlohu svojho projektu splnenú, no rozhodol som sa ho ešte obohatiť o svetelnú a zvukovú signalizáciu. Do zapojenia som pridal dve RGB LED diódy (aj s rezistormi k nim) a jedno Piezo. Jedna dióda mala signalizovať stav teploty a druhá stav vlhkosti. Každá má 5 stavov:

1. Veľmi nízka hodnota - Biela farba - (1. Teplota je nižšia ako 28 °C), (2. Vlhkosť je nižšia ako 50 %)

2. Nízka hodnota - Modrá farba - (1. Teplota je v rozmedzí 28 - 32 °C), (2. Vlhkosť je v rozmedzí 50 - 60 %)

3. Stredná hodnota - Zelená farba - (1. Teplota je v rozmedzí 32 - 36 °C), (2. Vlhkosť je v rozmedzí 60 - 70 %)

4. Vysoká hodnota - Červená farba - (1. Teplota je v rozmedzí 36 - 40 °C), (2. Vlhkosť je v rozmedzí 70 - 80 %)

5. Veľmi vysoká hodnota - Fialová farba - (1. Teplota je vyššia ako 40 °C), (2. Vlhkosť je vyššia ako 80 %)

Úlohou pieza je signalizovať zmenu týchto 5 stavov (pípaním). Keďže piezo je len jedno, signalizuje zmenu stavu aj pre teplotu aj pre vlhkosť, no rozdiel je v tom že pri zmene stavu teploty spraví "krátke pípnutie" a pri zmene vlhkosti "dlhé pípnutie". Piezo rozlišuje aj to, či sa stav zmenil smerom nahor alebo nadol (teda napríklad či sa teplota zvýšila alebo znížila), a to tak, že pri zmene stavu nahor (inkrementácii), pípne dva krát a pri zmene stavu nadol (dekrementácii), pípne len raz. Teda ak sa napríklad zvýši stav vlhkosti, piezo spraví dve dlhé pípnutia, ak sa napríklad zníži stav teploty piezo spraví jedno krátke pípnutie a pod. Ak sa stane že teplota alebo vlhkosť dosiahne posledný 5. stav (najvyšší), piezo bude pípať "stále" (v skutočnosti bude pípať 5x v každej main() slučke programu). V tomto prípade som nepredpokladal že by som pri mojom "amatérskom testovaní" mohol vytvoriť také podmienky, že by mohlo dôjsť k 5. stavu teploty aj vlhkosti súčasne keďže zo zvyšujúcou sa teplotou vlhkosť klesá a zas naopak.

Poslednou vecou ktorú som spravil bolo, že som si zo starej stavebnice poskladal držiak na ktorý som umiestnil snímač aby som si uľahčil testovaciu (overovaciu) časť tohto projektu.

Schéma zapojenia a jej popis

Mikrokontrolér Arduino UNO R3

- MASTER (riadiaci orgán celého zariadenia)

- sú k nemu pripojené všetky ostatné zariadenia a súčiastky použité v projekte

- je napájaný priamo z notebooku pomocou USB kábla (a zároveň je ním aj programovaný)

Snímač teploty a vlhkosti DHT22

- má 3 piny:

    VCC   - pripojený k 5V pinu mikrokontroléra
    GND   - pripojený ku GND (Zem) pinu mikrokontroléra
    DATA  - pripojený k D8 pinu mikrokontroléra
            --> Cez tento pin prichádzajú do mikrokontroléra dáta v tvare: 
               [Vlhkosť celé číslo, Vlhkosť desatinné číslo, Teplota celé číslo, Teplota desatinné číslo, Kontrolný súčet]
               [8 bitov, 8 bitov, 8 bitov, 8 bitov, 8 bitov; 8 + 8 + 8 + 8 + 8 = 40 bitový prenos]

Liquid Crystal Display typu DEM16216

- má 16 pinov:

    VSS   - pripojený ku GND (Zem) pinu mikrokontroléra
    VDD   - pripojený k 5V pinu mikrokontroléra
            --> Piny VSS a VDD slúžia na napájanie displeja
    VO    - je naň prostredníctvom potenciometra privedené napätie
            --> Týmto pinom sa v závislosti od privedeného napätia nastavuje jas (kontrast)
    RS    - je pripojený k D2 pinu mikrokontroléra
            --> Slúži na výber registra (Command RS=0; DATA RS=1)
    R/W   - je pripojený k D3 pinu mikrokontroléra
            --> Slúži na výber medzi čítaním alebo zápisom (READ R/W=1; WRITE R/W=0)
    E     - je pripojený k D4 pinu mikrokontroléra
            --> Slúži na spustenie časového signálu (Hovorí displeju kedy má čítať) (Reaguje pri dobežnej hrane)
    D0-D3 - sú nezapojené (pretože nepoužívam 8 bitový mód ale len 4 bitový)
    D4-D7 - sú zapojené k pinom D9-D12 mikrokontroléru
            --> Slúžia na 4 bitový prenos dát
    A     - pripojený ku GND (Zem) pinu mikrokontroléra
    K     - pripojený k 5V pinu mikrokontroléra
            --> Piny A a K slúžia na zapnutie podsvietenia displeja

RGB LED Diódy

- každá má 4 piny:

    R     - sú cez odpory R6 a R3 (220 Ω) pripojené k A0 (LED1) a A3 (LED2) pinom mikrokontroléra
            --> Slúžia na zapínanie červenej LED diódy (privedením log. 1)
    G     - sú cez odpory R5 a R2 (220 Ω) pripojené k A1 (LED1) a A4 (LED2) pinom mikrokontroléra
            --> Slúžia na zapínanie zelenej LED diódy (privedením log. 1)
    B     - sú cez odpory R4 a R1 (220 Ω) pripojené k A2 (LED1) a A5 (LED2) pinom mikrokontroléra
            --> Slúžia na zapínanie modrej LED diódy (privedením log. 1)
    GND     - obidva piny (LED1 aj LED2) sú pripojené ku GND (Zem) pinu mikrokontroléra

Piezo

- má 2 piny:

    VCC     - pripojený k D13 pinu mikrokontroléra
              --> V závislosti od signálu vydá piezo zvuk (V mojom prípade je to vždy log. 1 a teda frekvencia zvuku je vždy rovnaká)
    GND     - pripojený ku GND (Zem) pinu mikrokontroléra

Algoritmus a program

Vo svojom hlavnom programe som si vytvoril nasledovné funkcie:

void lcd_print_float(float hodnota);
void Vlastne_znaky(void);
void RGB_teplota(uint8_t cervena, uint8_t zelena, uint8_t modra);
void RGB_vlhkost(uint8_t cervena, uint8_t zelena, uint8_t modra);
void Farba_teplota(float teplota);
void Farba_vlhkost(float vlhkost);
void Pipnutie(uint8_t pocet_pipnuti);
void Pipnutie_dlhe(uint8_t pocet_pipnuti);
uint8_t Precitaj_senzor(void);

Myslím si, že som svoj kód prehľadne okomentoval a preto nebudem v tejto časti vysvetľovať jeho funkčnosť.

Okrem týchto funkcií nepriamo využívam aj pár pomocných funkcií z knižníc. Tie používam dve:

uart.h (a uart.c) - Túto knižnicu sme si robili na cvičení z predmetu počas semestru
lcd_ch.h (a lcd_ch.c) - Túto knižnicu som podľa dohody s vyučujúcim použil z web-stránky ktorej odkaz je uvedený na spodku pod názvom "Práca s displejom"

Tu je výpis celého kódu aj spolu s knižnicami:

Hlavný programuart.cuart.hlcd_ch.clcd_ch.h

// Semestrálny projekt z predmetu Mikropočítačové systémy (MIPS)
// Téma: Kombinovaný snímač teploty a vlhkosti DHT22
// Vypracoval: Martin Hubocký
// Školský rok: 2024/2025

// ======================[ Knižnice (+ frekvencia) ]======================

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>
#include "uart.h"
#include "lcd_ch.h"

// ======================[ Definície a premenné ]======================

#define Snimac_DHT22 PB0
uint8_t Pole_udajov[5];

#define RGB_teplota_cervena PC0
#define RGB_teplota_zelena PC1
#define RGB_teplota_modra PC2
#define RGB_vlhkost_cervena PC3
#define RGB_vlhkost_zelena PC4
#define RGB_vlhkost_modra PC5

#define Piezo PB5

int aktualny_stav_teplota = 0;
int posledny_stav_teplota = 0;
int aktualny_stav_vlhkost = 0;
int posledny_stav_vlhkost = 0;

// ======================[ Deklarácie pomocných funkcií ]====================== 
// (Bez tohto to malo problém s kompiláciou lebo mám funkcie definované až za main(), pretože mi to osobne prišlo prehľadnejšie)

void lcd_print_float(float hodnota);
void Vlastne_znaky(void);
void RGB_teplota(uint8_t cervena, uint8_t zelena, uint8_t modra);
void RGB_vlhkost(uint8_t cervena, uint8_t zelena, uint8_t modra);
void Farba_teplota(float teplota);
void Farba_vlhkost(float vlhkost);
void Pipnutie(uint8_t pocet_pipnuti);
void Pipnutie_dlhe(uint8_t pocet_pipnuti);
uint8_t Precitaj_senzor(void);

// ======================[ Hlavná funkcia main() ]======================

int main(void) {
	
    // Inicializácia výstupov RGB LED-iek a Pieza
	
    DDRC |= (1<<RGB_teplota_cervena) | (1<<RGB_teplota_zelena) | (1<<RGB_teplota_modra) | (1<<RGB_vlhkost_cervena) | (1<<RGB_vlhkost_zelena) | (1<<RGB_vlhkost_modra);
    DDRB |= (1 << Piezo);

    uart_init();                                                         // Inicializácia sériovej komunikácie (UART)
    lcd_init();                                                          // Inicializácia displeju
    lcd_command(0x0C);                                                   // Vypnutie kurzoru

    Vlastne_znaky();                                                     // Definovanie vlastných znakov (°C a ť)

    char buffer[32], pole_teplota[10], pole_vlhkost[10];                 // Definície pomocných polí a ich dĺžok (budú využité neskôr v programe (UART))

    uart_puts("Spustenie\n");
    _delay_ms(1000);
    Precitaj_senzor();                                                   // Načítam dáta zo senzoru teploty a vlhkosti (DHT22)
    _delay_ms(2000);

    while (1) {
        _delay_ms(2000);

        if (Precitaj_senzor()) {                                         // Ak sa podarí načítať dáta zo senzoru...
			
            // Výpočet vlhkosti (resp. spracovanie do float premennej)
            uint16_t raw_vlhkost = ((uint16_t)Pole_udajov[0] << 8) | Pole_udajov[1];
            float vlhkost = raw_vlhkost / 10.0;
			
            // Výpočet teploty (resp. spracovanie do float premennej)
            uint16_t raw_teplota = ((uint16_t)Pole_udajov[2] << 8) | Pole_udajov[3];
            float teplota = raw_teplota / 10.0;
			
			
            if (Pole_udajov[2] & 0x80) {                                 // Ak je teplota záporná uloží znamienko mínus
                teplota = -((raw_teplota & 0x7FFF) / 10.0);
            }

            // Výpis cez UART
			dtostrf(teplota, 5, 1, pole_teplota);                        // Uloží hodnotu teploty do pole_teplota ktoré sa vypíše cez UART
            dtostrf(vlhkost, 5, 1, pole_vlhkost);                        // Uloží hodnotu vlhkosti do pole_vlhkost ktoré sa vypíše cez UART
			
            sprintf(buffer, "Teplota: %s C\n", pole_teplota);
            uart_puts(buffer);
            sprintf(buffer, "Vlhkost: %s %%\n", pole_vlhkost);
            uart_puts(buffer);
			
            // Výpis na displej
			// (1. Riadok displeju)
            lcd_command(0x80);
            zob_text("Teplota:");
            Vypis_na_displej(teplota);
            lcd_data(1);                                                 // znak °
            lcd_data('C');
            // (2. Riadok displeju)
            lcd_command(0xC0);
            zob_text("Vlhkos");
            lcd_data(2);                                                 // znak ť
            lcd_data(':');
            Vypis_na_displej(vlhkost);
            lcd_data('%');
			
			// Nastavenie farieb RGB LED-iek
            Farba_teplota(teplota);
            Farba_vlhkost(vlhkost);
			}
			
			else {                                                       // Ak by došlo k chybe pri načítaní dát zo senzoru... (Len sa vypíše na UART a displej)
            uart_puts("Chyba pri nacitani dat zo senzoru (DHT22)\n");
            lcd_command(0x80);
            zob_text("Chyba senzora   ");
            lcd_command(0xC0);
            zob_text("                ");
        }
    }
}

// ======================[ Funkcie pre farebnú signalizáciu a zvukovú signalizáciu ]======================

// Prevedie (Zasvieti) požadovanú farbu RGB diódy teploty na "kód"
void RGB_teplota(uint8_t cervena, uint8_t zelena, uint8_t modra) {       // Ak má príslušná farba RGB LED-ky zasvietiť musím zapísať log. 1, inak nesvieti
    if (cervena) PORTC |= (1<<RGB_teplota_cervena); else PORTC &= ~(1<<RGB_teplota_cervena);
    if (zelena) PORTC |= (1<<RGB_teplota_zelena); else PORTC &= ~(1<<RGB_teplota_zelena);
    if (modra) PORTC |= (1<<RGB_teplota_modra); else PORTC &= ~(1<<RGB_teplota_modra);
}

// Prevedie (Zasvieti) požadovanú farbu RGB diódy vlhkosti na "kód"
void RGB_vlhkost(uint8_t cervena, uint8_t zelena, uint8_t modra) {       // Ak má príslušná farba RGB LED-ky zasvietiť musím zapísať log. 1, inak nesvieti
    if (cervena) PORTC |= (1<<RGB_vlhkost_cervena); else PORTC &= ~(1<<RGB_vlhkost_cervena);
    if (zelena) PORTC |= (1<<RGB_vlhkost_zelena); else PORTC &= ~(1<<RGB_vlhkost_zelena);
    if (modra) PORTC |= (1<<RGB_vlhkost_modra); else PORTC &= ~(1<<RGB_vlhkost_modra);
}

// Na základe veľkosti hodnoty teploty vyhodnotí príslušnú farbu ktorou má RGB LED-ka svietiť, stav teploty (5 stavov (28°C; 40°C; interval 4°C)) a ak došlo k zmene stavu vyhodnotí smer zmeny t.j. či teplota stúpla alebo klesla (využije sa neskôr pri zvukovej signalizácii) 
void Farba_teplota(float teplota) {
	
	// Vyhodnotenie veľkosti hodnoty teploty a priradenie stavu
    if (teplota <= 28.0) {                                               // Ak je teplota menšia alebo rovná ako 28°C zaviesti biela farba a určí stav teploty ako stav 1
        RGB_teplota(1, 1, 1); aktualny_stav_teplota = 1;
    } else if (teplota <= 32.0) {                                        // Ak je teplota menšia alebo rovná ako 32°C zaviesti modrá farba a určí stav teploty ako stav 2
        RGB_teplota(0, 0, 1); aktualny_stav_teplota = 2;
    } else if (teplota <= 36.0) {                                        // Ak je teplota menšia alebo rovná ako 36°C zaviesti zelená farba a určí stav teploty ako stav 3
        RGB_teplota(0, 1, 0); aktualny_stav_teplota = 3;
    } else if (teplota <= 40.0) {                                        // Ak je teplota menšia alebo rovná ako 40°C zaviesti červená farba a určí stav teploty ako stav 4
        RGB_teplota(1, 0, 0); aktualny_stav_teplota = 4;
    } else {                                                             // Ak je teplota vaačšia ako 40°C zaviesti fialová farba a určí stav teploty ako stav 5
        RGB_teplota(1, 0, 1); aktualny_stav_teplota = 5;                 // (Keďže tento stav sa považuje "akože" za nebezpečný, piezo bude pípať (Nebude pípať nonstop ale bude pípať za každým keď program main() spraví jeden cyklus))
        Pipnutie(5);
    }

    // Vyhodnotenie zmeny a smeru zmeny teploty 
    if (aktualny_stav_teplota > posledny_stav_teplota) Pipnutie(2);      // Ak teplota stúpla piezo pípne dva krát (len ak došlo k zmene)
    else if (aktualny_stav_teplota < posledny_stav_teplota) Pipnutie(1); // Ak teplota klesla piezo pípne jeden krát (len ak došlo k zmene)
    posledny_stav_teplota = aktualny_stav_teplota;
}

// Na základe veľkosti hodnoty vlhkosti vyhodnotí príslušnú farbu ktorou má RGB LED-ka svietiť, stav vlhkosti (5 stavov (50%; 80%; interval 10%)) a ak došlo k zmene stavu vyhodnotí smer zmeny t.j. či vlhkosť stúpla alebo klesla (využije sa neskôr pri zvukovej signalizácii) 
void Farba_vlhkost(float vlhkost) {
    
	// Vyhodnotenie veľkosti hodnoty vlhkosti a priradenie stavu
	if (vlhkost <= 50.0) {                                               // Ak je vlhkosť menšia alebo rovná ako 50% zaviesti biela farba a určí stav vlhkosti ako stav 1
        RGB_vlhkost(1, 1, 1); aktualny_stav_vlhkost = 1;
    } else if (vlhkost <= 60.0) {                                        // Ak je vlhkosť menšia alebo rovná ako 60% zaviesti modrá farba a určí stav vlhkosti ako stav 2
        RGB_vlhkost(0, 0, 1); aktualny_stav_vlhkost = 2;
    } else if (vlhkost <= 70.0) {                                        // Ak je vlhkosť menšia alebo rovná ako 70% zaviesti zelená farba a určí stav vlhkosti ako stav 3
        RGB_vlhkost(0, 1, 0); aktualny_stav_vlhkost = 3;
    } else if (vlhkost <= 80.0) {                                        // Ak je vlhkosť menšia alebo rovná ako 80% zaviesti červená farba a určí stav vlhkosti ako stav 4
        RGB_vlhkost(1, 0, 0); aktualny_stav_vlhkost = 4;
    } else {                                                             // Ak je vlhkosť väčšia ako 80% zaviesti fialová farba a určí stav vlhkosti ako stav 5
        RGB_vlhkost(1, 0, 1); aktualny_stav_vlhkost = 5;                 // (Keďže tento stav sa považuje "akože" za nebezpečný, piezo bude pípať (pípnutie je dlhšie ako pri teplote) (Nebude pípať nonstop ale bude pípať za každým keď program main() spraví jeden cyklus))
        Pipnutie_dlhe(5);
    }

    // Vyhodnotenie zmeny a smeru zmeny vlhkosti
    if (aktualny_stav_vlhkost > posledny_stav_vlhkost) Pipnutie_dlhe(2); // Ak vlhkost stúpla piezo pípne dva krát (pípnutie je dlhšie ako pri teplote) (len ak došlo k zmene)
    else if (aktualny_stav_vlhkost < posledny_stav_vlhkost) Pipnutie_dlhe(1); // Ak vlhkost stúpla piezo pípne jeden krát (pípnutie je dlhšie ako pri teplote) (len ak došlo k zmene)
    posledny_stav_vlhkost = aktualny_stav_vlhkost;
}

// ======================[ Piezo reproduktor ]======================

// Pípanie pre teplotu
void Pipnutie(uint8_t pocet_pipnuti) {
    for (uint8_t i = 0; i < pocet_pipnuti; i++) {                        // Piezo pípa požadovaný "pocet_pipnuti" krát pre teplotu t. j. pípa krátko (100ms hučí a 100ms je ticho)
        PORTB |= (1 << Piezo);
        _delay_ms(100);
        PORTB &= ~(1 << Piezo);
        _delay_ms(100);
    }
}

// Pípanie pre vlhkosť
void Pipnutie_dlhe(uint8_t pocet_pipnuti) {                              // Piezo pípa požadovaný "pocet_pipnuti" krát pre vlhkosť t. j. pípa dlho (500ms hučí a 100ms je ticho)
    for (uint8_t i = 0; i < pocet_pipnuti; i++) {
        PORTB |= (1 << Piezo);
        _delay_ms(500);
        PORTB &= ~(1 << Piezo);
        _delay_ms(100);
    }
}

// ======================[ Čítanie zo senzora DHT22 ]======================

uint8_t Precitaj_senzor() {
	
    uint8_t bity[5] = {0};  // Pole pre 5 bajtov prijatých zo senzora (po 8 bitov) (2 bajty pre vlhkosť (celé číslo, desatinné číslo), 2 bajty pre teplotu (celé číslo, desatinné číslo), 1 bajt pre kontrolný súčet)
    uint8_t i, j;

    // Odoslanie "Štartovacieho" signálu
    DDRB |= (1 << Snimac_DHT22);
    PORTB &= ~(1 << Snimac_DHT22);
    _delay_ms(2);
    PORTB |= (1 << Snimac_DHT22);
    _delay_us(30);
    DDRB &= ~(1 << Snimac_DHT22);

    // Čakanie na odpoveď
    uint16_t timeout;
    timeout = 100;
    while ((PINB & (1 << Snimac_DHT22)) && timeout--) _delay_us(1);
    if (timeout == 0) return uart_puts("Timeout LOW\n"), 0;
    timeout = 100;
    while (!(PINB & (1 << Snimac_DHT22)) && timeout--) _delay_us(1);
    if (timeout == 0) return uart_puts("Timeout HIGH\n"), 0;
    timeout = 100;
    while ((PINB & (1 << Snimac_DHT22)) && timeout--) _delay_us(1);
    if (timeout == 0) return uart_puts("Timeout koniec HIGH\n"), 0;

    // Príjem dát (5*8 = 40 bitov)
    for (j = 0; j < 5; j++) {
        for (i = 0; i < 8; i++) {
            timeout = 100;
            while (!(PINB & (1 << Snimac_DHT22)) && timeout--) _delay_us(1);
            if (timeout == 0) return uart_puts("Timeout bit start\n"), 0;

            uint8_t count = 0;
            while ((PINB & (1 << Snimac_DHT22))) {
                _delay_us(1);
                if (++count > 100) break;
            }

            if (count > 40) bity[j] |= (1 << (7 - i));
        }
    }

    // Kontrola prijatých dát (Posledný bajt je súčtom 4 pred ním)
    if ((uint8_t)(bity[0] + bity[1] + bity[2] + bity[3]) != bity[4]) {
        uart_puts("Chyba: Kontrolny sucet\n");
        return 0;
    }

    // Uloženie hodnôt
    for (i = 0; i < 5; i++) Pole_udajov[i] = bity[i];
    return 1;
}

// ======================[ Výpis float hodnoty na LCD ]======================

void Vypis_na_displej(float hodnota) {
	// Toto je všetko len formátovanie aby sa to vypísalo na displej "pekne"
	
	// Rozdelenie na celé čísla a čísla za desatinnou čiarkou (DHT22 má rozlíšenie len na jedno desatinné miesto)
    int jednotky = (int)hodnota;
    int desatiny = (int)((hodnota - jednotky) * 10);
    
	// V prípade že by teplota bola záporná (Nemal som ako vyskúšať takže neviem či je to úplne správne)
    if (hodnota < 0) {
        lcd_data('-');
        jednotky = -jednotky;
        desatiny = -desatiny;
    }
	
    // Vypísanie jednotiek
    if (jednotky >= 10)
        lcd_data('0' + (jednotky / 10));
    else
        lcd_data('0');
		
    // Vypísanie desatín
    lcd_data('0' + (jednotky % 10));
    lcd_data('.');
    lcd_data('0' + (desatiny % 10));
}

// ======================[ Vlastné znaky pre LCD ]======================

void Vlastne_znaky(void) {
    unsigned char znak_stupen[8] = {0x06, 0x09, 0x09, 0x06, 0x00, 0x00, 0x00, 0x00};    // Vytvorenie vlastného znaku "°" pomocou jednotlivých pixelov (Samotný displej je síce 5*7 pixelov no mal som problém s kompiláciou a preto je všade 8 hodnôt (tvárim sa že je jeden znak je 5*8))
    unsigned char znak_t_makcen[8] = {0x0D, 0x0A, 0x1C, 0x08, 0x08, 0x09, 0x06, 0x00};  // Vytvorenie vlastného znaku "ť"
	
	// Uložím znaky aby si ich pamätal displej
    def_znak(znak_stupen, 1); 
    def_znak(znak_t_makcen, 2);
}

#include <avr/io.h>
//#include <util/setbaud.h>
#define BAUD 9600
#define F_CPU 16000000UL
void uart_init( void ) 
{
     UBRR0 =103;
/*
#if USE_2X
    UCSR0A |= _BV(U2X0);
#else
    UCSR0A &= ~(_BV(U2X0));
#endif*/

    UCSR0C = _BV(UCSZ01) | _BV(UCSZ00); /* 8-bit data */
    UCSR0B = _BV(RXEN0) | _BV(TXEN0);   /* Enable RX and TX */
}


void uart_putc(char c) 
{
   if (c == '\n') 
    {
       uart_putc('\r');
    }
   loop_until_bit_is_set(UCSR0A, UDRE0); /* Wait until data register empty. */
   UDR0 = c;
}


void uart_puts(const char *s)
{
  
  while(*s!='\0'){
	  uart_putc(*s);
	  s++;
  }
}
char uart_getc(void) {
    loop_until_bit_is_set(UCSR0A, RXC0); /* Wait until data exists. */
    return UDR0;
}

#ifndef UART_H_
#define UART_H_
#define BAUD 9600
#define F_CPU 16000000UL

void uart_init( void );
void uart_putc( char c );
void uart_puts( const char *s );

char uart_getc( void );

#endif

#include "lcd_ch.h"

unsigned char Znak_OO[8]= {0x00,0x00,0x00,0x00,0x00,0x00,0x15,0};// Prazdny znak	dole su tri bodky

unsigned char Znak_SC[8]= {0x1A,0x1D,0x04,0x04,0x04,0x05,0x02,0};// st.C	
unsigned char Znak_SM[8]= {0x0A,0x04,0x0E,0x10,0x0E,0x01,0x1E,0};//  s + mekcen	
unsigned char Znak_CM[8]= {0x0A,0x04,0x0E,0x10,0x10,0x11,0x0C,0};//  c + mekcen

// Vynulovanie CGRAM
void def_Clear_spec_znaky(void){
	// zapis specialneho znaku do CGRAM  na poziciu 0, a 7
	for(char i = 0; i < 8; i++) def_znak( Znak_OO,i);
	lcd_command(0x80);
} 


 
void def_spec_znaky(void){
// zapis vlastnych znakkov do CGRAM  na poziciu 4, a 0 (8) 


 def_znak( Znak_SC,4);// stupen Celzia
 def_znak( Znak_SM,0);// s + makcen
 // obnovenie obsahu AC. AC nastvime na 1. riadok, 1. znak
 lcd_command(0x80);
}		

#ifndef _Shield_LCD
void def_spec_znaky_AC(void){
// zapis specialneho znaku do CGRAM  na poziciu 7

unsigned char obsah_AC = 0;
 obsah_AC = lcd_read_AC(); //     
 // kon_vyp = obsah_AC;

 // sem dame nove vlastne znaky
 def_znak( Znak_CM,7);// c + makcen
 // obnovenie obsahu AC. AC 

lcd_command(0x80|obsah_AC);

}		
#endif
	 
void ini_ports(void){	 	
	
/* inicializacia portov - vstupy / vystupy 
oba typy displaja */
// nasledovna # riadky su spolocne pre oba typy LCD
LCD_CTRL_DDR |= (1<<LCD_EN_pin);	//  (Enable)    output  
LCD_CTRL_DDR |= (1<<LCD_RS_pin);	//  (RS)        output  	
LCD_DATA_DDR |= (1<<LCD_D4_pin)|(1<<LCD_D5_pin)|(1<<LCD_D6_pin)|(1<<LCD_D7_pin);	// Datove piny ako Output (Data pre display)
#ifndef _Shield_LCD
// klasicky LCD vyuziva aj RW pin
LCD_CTRL_DDR |= (1<<LCD_RW_pin);	//	(RW)        output  
	
#endif
}	


void En_imp(void) {
	LCD_CTRL_PORT |= (1<<LCD_EN_pin);	// -> "log.1"
	LCD_DELAY;							// cca 400 ns
	LCD_CTRL_PORT &= ~(1<<LCD_EN_pin);	// -> "log.0"  spolu cca 500 ns
}

void lcd_init(void)
{   // 4 bitove pripojenie display-a
	ini_ports(); // inicializacia porov
	 _delay_ms(15);
	// 1. -------------------
	LCD_CTRL_PORT &= ~(1 << LCD_RS_pin);		// set RS  = to "log. 0"  Instruction Register (IR)
#ifndef _Shield_LCD
	LCD_CTRL_PORT &= ~(1 << LCD_RW_pin)	;		// set R/W = to "log. 0" - Write
#endif
	// RS R/W   DB7 DB6 DB5 DB4   DB3 DB2 DB1 DB0
	// 0  0     0   0   1   1     x   x   x   x     = 0x30
	PORT_DATA_WR_H(0x30);	// 8-bitove pripojenie
	En_imp();
	// 2. -------------------
    // zopakujem  8-bitove pripojenie
	_delay_ms(5); En_imp();
	// 3. -------------------
	// zopakujem  8-bitove pripojenie
    _delay_ms(1); En_imp(); // -  stacilo by delay 0.1ms, momentalne najkratsie nastavitelne je 1ms
	// 4. -------------------
	// zmenim na 4-bitove pripojenie
	// RS R/W    DB7 DB6 DB5 DB4    DB3 DB2 DB1 DB0
	// 0  0      0   0   1   0      x   x   x   x    = 0x20
	PORT_DATA_WR_H(0x20);	// 4-bitove pripojenie
	_delay_ms(1); En_imp(); // -  stacilo by delay 0.04ms
	// -------------------		
	// LCD function set      mod: DL = 0 - 4-bitove data, N = 1 - 2 riadky, F = 0 - 5x7 dots 
	// RS R/W    DB7 DB6 DB5 DB4    DB3 DB2 DB1 DB0
	// 0  0      0   0   1   DL     N   F   x   x     = 0x28
	// Mozeme nasledujuci prikaz pre LCD vynechat?
	_delay_ms(2);
	lcd_command(0x28);
	// RS R/W    DB7 DB6 DB5 DB4    DB3 DB2 DB1 DB0
	// 0  0      0   0   0   0	    0   0   0   1     = 0x01 , Display clear
	// Mozeme nasledujuci prikaz pre LCD vynechat?
	_delay_ms(2);
	lcd_command(0x01);
	// RS R/W    DB7 DB6 DB5 DB4    DB3 DB2 DB1 DB0
	// 0  0      0   0   0   0	    0   1   I/D S      = 0x06, I/D = 1 - inkrement
	// Mozeme nasledujuci prikaz pre LCD vynechat?
	_delay_ms(2);
	lcd_command(0x02);
	// RS R/W    DB7 DB6 DB5 DB4    DB3 DB2 DB1 DB0
	// 0  0      0   0   0   0	    1   D   C   B      = 0x0E, D = C = 1 - Display a kurzor zapnute
	// Mozeme nasledujuci prikaz pre LCD vynechat?
	_delay_ms(2);
	lcd_command(0x0E);								// B = 0 - blikanie vypnute
}


//zapis data do Data Register
void lcd_data(unsigned char data){	
	while(busy_flag() & 0x80);
	//while(rd_BF()); // test BF sa da realizovat pre klasicky LCD, nie Shield
	LCD_CTRL_PORT |= (1<<LCD_RS_pin);		//    (RS = High)  
#ifndef _Shield_LCD
	LCD_CTRL_PORT &= ~(1<<LCD_RW_pin);		//    (RW = Low, write) 
#endif
	wr_data (data);	
}

// zapis commandu do Instruction Register
void lcd_command(unsigned char command){ 
	while(busy_flag() & 0x80);
	//while(rd_BF()); // test BF sa da realizovat pre klasicky LCD, nie Shield
	LCD_CTRL_PORT &= ~(1<<LCD_RS_pin);		//   (RS = Low)  
#ifndef _Shield_LCD
	LCD_CTRL_PORT &= ~(1<<LCD_RW_pin);		//   (RW = Low, write) 
#endif
	wr_data (command);	
}

void wr_data(unsigned char data) { 
	PORT_DATA_WR_H(data);		// data High nibble
	En_imp();
			
	PORT_DATA_WR_L(data);		// data Low nibble
	En_imp();
}

#ifdef _Shield_LCD
// namiesto testu BF "pockam". 
// LCD typu Shield ma WR pripojene na GND		
unsigned char busy_flag(void){
	_delay_ms(2);	
	return(0);
}	
#else
// namiesto testu BF "pockam". Vacsine prikazov tento cas vyhovuje		
/*int busy_flag(void){
	_delay_ms(2);	
	return(0);
}
*/
// klasicke pripojenie LCD umozni aj test BF
unsigned char busy_flag(void){ //  rd_BF   
	unsigned char pom = 0;
	LCD_CTRL_PORT &= ~(1<<LCD_RS_pin);	//   (RS = Low)  
	LCD_CTRL_PORT |= (1<<LCD_RW_pin);	//    (RW = High, read) 
    // port B, datove bity budu teraz input
	LCD_DATA_DDR &= ~((1<<LCD_D4_pin)|(1<<LCD_D5_pin)|(1<<LCD_D6_pin)|(1<<LCD_D7_pin));	//  Datove piny nastavime  na input, (Data pre disp)
	
	// Spravne by sa malo vycitavaj pred dobeznou hranou EN impulzu. Je tam urcity presah. Mozeme vycitat aj po dobeznej hrane.
	En_imp();
	pom = PORT_DATA_RD_H; // vycitam High nibble AC
	En_imp();
	pom |= PORT_DATA_RD_L; // vycitam Low nibble AC
	// datove bity zase output
	LCD_DATA_DDR |= (1<<LCD_D4_pin)|(1<<LCD_D5_pin)|(1<<LCD_D6_pin)|(1<<LCD_D7_pin);	// Datove piny nastavime na output (Data pre disp) 
	//if(pom & 0x80) return 1;	// display je busy
	//else 
	return pom;					// display je not busy
}

#endif
	

void zob_text(char *s){
	register unsigned char c;
	while((c = *s++))	lcd_data(c); // retazec konci "nulou"
}

void def_znak(unsigned char *ZnakArray,unsigned char kam) {	
	lcd_command(0x40|(kam << 3)); //nastavenie adresy znaku v CGRAM
	for(unsigned char i = 0; i < 8; i++) lcd_data( *(ZnakArray + i));		
}


/* ********************************************************	*/
/* vypis retazca na poziciu, resp. podla nasledovnych 		*/
/* formatovacich prikazov                                       */
/*   : \r - prechod na novy riadok                              */
/*   : \f - prechod na zaciatok displeja                        */
/* ********************************************************     */
 void lcd_puts(  const char *s)   /* definicia funkcie		*/
{
  
}

#ifndef _Shield_LCD
int8_t lcd_read_AC(void){ //  rd_BF   
	char pom_AC ;
	
	while((pom_AC = busy_flag( )) & 0x80);
	// kedze po BF = 0 este cca 4us sa nezmenil obsah AC
	// treba vycitat este raz  
	pom_AC = busy_flag( );
	return pom_AC;					// display not busy
	
}
#endif

#ifndef F_CPU
 #define F_CPU 16000000UL	/* Define CPU frequency here 16MHz */
#endif

#ifndef LCD_CH_H_
 #define LCD_CH_H_

#include <avr/io.h>
#include <util/delay.h>

/* Nasledovne define rozhodne ktora cast programu sa prelozi: 
   LCD Shiled (WR ma pripojene na GND) a
   priradenie pinov je dane napr.:
   "zamrzne"
   -    https://www.14core.com/wiring-the-lcd-16x2-keypad-shield-on-arduino/
   -	https://wiki.dfrobot.com/LCD_KeyPad_Shield_For_Arduino_SKU__DFR0009
   resp. 
   LCD, zapojenie vid. stranka MIPS
   "zamrzne"
   - http://senzor.robotika.sk/sensorwiki/index.php/LCD_displej_s_radi%C4%8Dom_HD44780
   , ktore ma pripojene aj pin WR
   t.j. moze sa testovat aj pin BF
*/

 /* !!!!!!! 
    #define _Shield_LCD
    !!!!!!! */
extern unsigned char kon_vyp;

#ifdef _Shield_LCD
	#define LCD_CTRL_DDR DDRB
	#define LCD_CTRL_PORT PORTB

	#define LCD_DATA_DDR DDRD
	#define LCD_DATA_PORT PORTD

	// Riadiaca zbernica display-a
	#define LCD_RS_pin 0
	#define LCD_RW_pin = 0
	#define LCD_EN_pin 1
	// Datova zbernica
	#define LCD_D4_pin 4
	#define LCD_D5_pin 5
	#define LCD_D6_pin 6
	#define LCD_D7_pin 7

#else
	// LCD  klasik yapojenie vid. MIPS
	#define LCD_CTRL_DDR DDRD
	#define LCD_CTRL_PORT PORTD

	#define LCD_DATA_DDR DDRB
	#define LCD_DATA_PORT PORTB
	#define LCD_DATA_PIN PINB

	#define LCD_RS_pin 2
	#define LCD_RW_pin 3
	#define LCD_EN_pin 4

	#define LCD_D4_pin 1
	#define LCD_D5_pin 2
	#define LCD_D6_pin 3
	#define LCD_D7_pin 4

#endif
 



// Oneskorenie 6 SC
#define NOP() asm("nop")	
#define LCD_DELAY	NOP();NOP();NOP();NOP();NOP();NOP();

#ifdef _Shield_LCD
// formatovanie dat
#define PORT_DATA_WR_H(x) LCD_DATA_PORT &=0b00001111; LCD_DATA_PORT |= (x & 0xF0 )
#define PORT_DATA_WR_L(x) LCD_DATA_PORT &=0b00001111; LCD_DATA_PORT |= (x & 0x0F )<<4
#else

#define PORT_DATA_WR_H(x) LCD_DATA_PORT &=0b11100001; LCD_DATA_PORT |= (x & 0xF0 )>>3
#define PORT_DATA_WR_L(x) LCD_DATA_PORT &=0b11100001; LCD_DATA_PORT |= (x & 0x0F )<<1

#define PORT_DATA_RD_H ((LCD_DATA_PIN & ((1<<LCD_D4_pin)|(1<<LCD_D5_pin)|(1<<LCD_D6_pin)|(1<<LCD_D7_pin)))<<3)
#define PORT_DATA_RD_L ((LCD_DATA_PIN & ((1<<LCD_D4_pin)|(1<<LCD_D5_pin)|(1<<LCD_D6_pin)|(1<<LCD_D7_pin)))>>1)


#endif

/* Public functions for your use */
#ifndef _Shield_LCD
int8_t lcd_read_AC(void);   
void def_spec_znaky_AC(void);
#endif
	
void lcd_init(void);
void lcd_data(unsigned char );
void lcd_command(unsigned char );
// void lcd_puts(const char *s);  /* deklaracia funkcie  */



void ini_ports(void);
void En_imp(void);

void wr_data (unsigned char );
unsigned char busy_flag(void);

void zob_text(char *);
void def_Clear_spec_znaky(void);


void def_znak(unsigned char *,unsigned char );
void def_spec_znaky(void);

#endif /* LCD_CH_H_ */

Kompletný projekt nájdete tu:

Zdrojový kód: ProjektMartinHubocky.zip

Overenie funkčnosti zariadenia

Funkčnosť zariadenia som overil veľmi jednoducho a to tak že som menil teplotu a vlhkosť v okolí snímača a sledoval či sa zariadenie správa tak ako som chcel. Vlhkosť som menil tak že som na snímač dýchal ústami čím sa mi podarilo zvýšiť vlhkosť niekedy až na 90%. Účinok je takmer instantný a rovnako tak je aj pokles naspäť veľmi rýchly. No a ako som menil teplotu? (.....) Bohužiaľ ma nenapadlo nič "inteligentnejšie" ako ohrievať snímač zospodu zapaľovačom. Bolo to pomerne rýchle, no ale samozrejme som svoju "šikovnosť" nezaprel a raz sa mi podarilo snímač "opáliť". Našťastie stále funguje...

Na obrázku číslo 5 môžete vidieť funkčnosť UART-u a nižšie je video kde môžete vidieť priebeh testovania zariadenia. Rád by som podotkol že na videu sú farby RGB LED diód veľmi skreslené a ťažko ich od seba odlíšiť (niekedy sa zdá že sa farby ani nezmenili), za čo sa ospravedlňujem.

Video:

Literatúra a použité zdroje

Dokumentácia k mikrokontroléru:

Dokumentácia k snímaču DHT22:

Kombinovaný snímač teploty a vlhkosti DHT22 - DATASHEET

Dokumentácia k LCD displeju: