Project_Dzialka_v1.3

// --------------------------------------------------------------------------------------------------------------------------------- //
//
// Projekt   :   Działka Project 1 - Zegar NANO :-) coś z tym badziewiem w szufladzie trzeba zrobić...
// Autor     :   Tomasz Majcher
//
//
// --------------------------------------------------------------------------------------------------------------------------------- //

//  wersja 1.3    :   DHT - AI
//  wersja 1.2    :   DHT
//  wersja 1.1    :   LDR - AI
//  wersja 1.0    :   LDR
//  wersja 0.9    :   DIODY (RED,ORANGE,GREEN) dla czujnika PIR
//  wersja 0.8    :   PIR - AI
//  wersja 0.7    :   PIR
//  wersja 0.6    :   zmiana biblioteki PCF8574
//  wersja 0.5    :   relay test ( O.K. ) power 5V 1A
//  wersja 0.4    :   relay test ( fall ) no more power :-)
//  wersja 0.3    :   led & key
//  wersja 0.2    :   wyświetlacz TM1637
//  wersja 0.1    :   zegar RTC
//
// --------------------------------------------------------------------------------------------------------------------------------- //


#include <virtuabotixRTC.h>             // biblioteka zegar RTC
#include <TM1637Display.h>              // wyświetlacz TM1637
#include "wiring_shift_mod.h"           // wiring
#include "PCF8574.h"                    // expander'y1
#include "DHT.h"

#define SerialSpeed 9600                // serial prędkość
#define SERIAL      true                // serial wyświetl tak (true) / nie (false)
#define RTC_SET     false               // aktualizacja manualna zegara RTC

// ----------------- expander'y ------------------------------- //

#define exp1_adres    0x20
#define exp2_adres    0x27

// ------------------------------------------------------------ //
// ----------------- P I R ------------------------------------ //
// ------------------------------------------------------------ //
//        !!! NANO piny A6 i A7 są tylko analogowe !!!          //
// ------------------------------------------------------------ //
//
//   pirAI_Time   ---> czas auto wyłączenie przekaźnika
//   pirAI_Relay  ---> numer przekaznika podpiętego pod PIR
//   pirPin       ---> pin I/O gdzie wpięty jest czujnik PIR
//

#define pirPin A3
#define pirAI_Time  180000UL
#define pirAI_Relay 0

// ----------------- wyswietlacz TM1637 ----------------------- //

#define CLK 2
#define DIO 3

// ----------------- CZUJNIK LDR ----------------------------- //

#define LDR A5
#define ldrAI_Relay 1
#define ldrAI_Time  300000UL
#define minLight 35
int Oswietlenie;

// ----------------- CZUJNIK DHT ----------------------------- //

#define DHTTYPE DHT11
#define DHTPIN 7
#define dhtAI_Time 600000UL
#define dhtAI_Relay 2
#define maxTemp 23

float temperatura = 0;     // temperatura
float wilgotnosc = 0;      // wilgotnosc

// ----------------- SYGNALIZATOR ---------------------------- //

#define ORANGE 9
#define GREEN  10
#define RED    8

bool OrangeLed = true;    // stan logiczny diody ORANGE

// ----------------- panel LED & KEY -------------------------- //

#define str_pin   4
#define clk_pin   5
#define dat_pin   6

#define CLOCK_TYPE CLOCK_INVERT
#define CLOCK_DELAY_US 1

uint8_t przycisk = 0;

const uint8_t LED_adres[] = { 0xC1, 0xC3, 0xC5, 0xC7, 0xC9, 0xCB, 0xCD, 0xCF};                   // adresy LED moduły LED & KEY

const uint8_t DIGIT_adres[] = { 0xC0, 0xC2, 0xC4, 0xC6, 0xC8, 0xCA, 0xCC, 0xCE};                 // adresy DIGIT moduły LED & KEY

                                /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
const uint8_t digits[] =      { 0x3f, 0x06, 0x5b, 0x4f, 0x66, 0x6d, 0x7d, 0x07, 0x7f, 0x6f };    // cyfry bez kropki

                                /*0*/ /*1*/ /*2*/ /*3*/ /*4*/ /*5*/ /*6*/ /*7*/ /*8*/ /*9*/
const uint8_t digits_dots[] = { 0xBF, 0x86, 0xdb, 0xcf, 0xe6, 0xed, 0xfd, 0x87, 0xff, 0xef };    // cyfry z kropką

// ----------------- PRZEKAZNIKI -------------------------- //

bool R_Status [8];        // stan logiczny przekaźników

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- O B I E K T Y --------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //


virtuabotixRTC myRTC(A0, A1, A2);                         // obiekt myRTC
TM1637Display display = TM1637Display(CLK, DIO);          // obiekt DISPLAY
PCF8574 expander1(exp1_adres);                            // expander 1
PCF8574 expander2(exp2_adres);                            // expander 2
DHT dht(DHTPIN, DHTTYPE);

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Zmienne globalne ------------------------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

struct RTC
{
    uint8_t   godzina = 0;
    uint8_t   minuta  = 0;
    uint8_t   sekunda = 0;
    uint8_t   dzien_tygodnia = 0;
    uint8_t   dzien = 0;
    uint8_t   miesiac = 0;
    uint16_t  rok = 0;
}
zegar;


unsigned long aktualnyCzas = 0;

unsigned long zapamietanyCzas1 = 0;    // dla millis
unsigned long roznicaCzasu1 = 0;       // dla millis

unsigned long zapamietanyCzas2 = 0;    // dla millis
unsigned long roznicaCzasu2 = 0;       // dla millis

unsigned long zapamietanyCzas3 = 0;    // dla millis
unsigned long roznicaCzasu3 = 0;       // dla millis

unsigned long zapamietanyCzas4 = 0;    // dla millis
unsigned long roznicaCzasu4 = 0;       // dla millis

unsigned long zapamietanyCzas5 = 0;    // dla millis
unsigned long roznicaCzasu5 = 0;       // dla millis

bool F_sec = false;                    // sekundnik wyświetlacza TM1637 (:)

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- P I R ----------------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

int                 calibrationTime = 30;
long unsigned int   lowIn;
long unsigned int   pause = 5000;
boolean             lockLow = true;
boolean             takeLowTime;
int                 PIRValue = 0;

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

void AktualizujCzas()
{
    myRTC.updateTime();                               // pobierz czas z zegara

    zegar.godzina         =   myRTC.hours;            // pobierz i zapisz godzinę
    zegar.minuta          =   myRTC.minutes;          // pobierz i zapisz minutę
    zegar.sekunda         =   myRTC.seconds;          // pobierz i zapisz sekundę
    zegar.dzien           =   myRTC.dayofmonth;       // pobierz i zapisz dzień miesiąca
    zegar.dzien_tygodnia  =   myRTC.dayofweek;        // pobierz i zapisz dzień tygodnia
    zegar.miesiac         =   myRTC.month;            // pobierz i zapisz miesiąc
    zegar.rok             =   myRTC.year;             // pobierz i zapisz rok
}
// --------------------------------------------------------------------------------------------------------------------------------- //
// --- Aktualizuj Czas do Strukrury zegar ------------------------------------------------------------------------------------------ //
// --------------------------------------------------------------------------------------------------------------------------------- //

void WyswietlCzas()
{
    int clock;
    byte bufor;

    bufor = zegar.godzina / 10;       // (HH / 10)    - podziel, wyznacz część całkowitą (dziesiątki) godziny
    clock = 1000 * bufor;             // (Hh * 1000)  - zapisz Hx:xx

    bufor = zegar.godzina % 10;       // (HH % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) godziny
    clock = clock + (bufor * 100);    // (hH * 100)   - zapisz xH:xx

    bufor = zegar.minuta / 10;        // (MM / 10)    - podziel, wyznacz część całkowitą (dziesiątki) minuty
    clock = clock + (bufor * 10);     // (Mm * 10)    - zapisz xx:Mx

    bufor = zegar.minuta % 10;        // (MM % 10)    - reszcza z dzielenia, wyznacz część całkowitą (jedności) minuty
    clock = clock + (bufor * 1);      // (mM * 1)     - zapisz xx:xM

    if (F_sec)                                                           // jeśli flaga jest prawdziwa (true)
    {
        display.showNumberDecEx(clock, 0b11100000, true, 4, 0);          // wyświetl dwukropek między godziną a minutą
        F_sec = false;                                                   // przestaw flagę na fałszywą (false)
        if (OrangeLed) digitalWrite(ORANGE, LOW);
    }
    else                                                                 // jeśli flaga jest fałszywa (false)
    {
        display.showNumberDecEx(clock, 0b00000000, true, 4, 0);          // nie wyświetlaj dwukropka między godziną a minutą
        F_sec = true;                                                    // przestaw flagę na prawdziwą (true)
        if (OrangeLed) digitalWrite(ORANGE, HIGH);
    }
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- S E T    R T C -------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void setRTC()
{
    myRTC.setDS1302Time(0, 36, 9, 1, 17, 5, 2021);
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- E X P A N D E R   I N I T    1 ---------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void ExpanderInit_1()
{
    expander1.begin();
    expander1.pinMode(P0, OUTPUT);
    expander1.pinMode(P1, OUTPUT);
    expander1.pinMode(P2, OUTPUT);
    expander1.pinMode(P3, OUTPUT);
    expander1.pinMode(P4, OUTPUT);
    expander1.pinMode(P5, OUTPUT);
    expander1.pinMode(P6, OUTPUT);
    expander1.pinMode(P7, OUTPUT);
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- E X P A N D E R   I N I T    2 ---------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void ExpanderInit_2()
{
    expander2.begin();


}

// --------------------------------------------------------------------------------------------------------------------------------- //
// ---P I R   I N I T    ----------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void PirInit()
{
    pinMode(pirPin, INPUT);        // czujnik ruchu
}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- S E T U P ------------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void setup()
{
    #if SERIAL
        Serial.begin(SerialSpeed);
        Serial.print(F("[SETUP] [SERIAL] Serial Speed : "));
        Serial.print(SerialSpeed);
    #endif

    pinMode(A0,OUTPUT);                   // RTC Clock -> pin CLK
    pinMode(A1,OUTPUT);                   // RTC Clock -> pin DAT
    pinMode(A2,OUTPUT);                   // RTC Clock -> pin RST


    display.clear();
    display.setBrightness(7);

    #if RTC_SET
        setRTC();
    #endif

    pinMode(str_pin, OUTPUT);              // digital 4 OUT dla strobe (LED & KEY)
    pinMode(clk_pin, OUTPUT);              // digital 3 OUT dla clock (LED & KEY)
    pinMode(dat_pin, OUTPUT);              // digital 2 OIT dla data (LED & KEY)

    sendCommand(0x8f);                     // activate LED & KEY
    reset();                               // reset LED & KEY
    flash_LEDKEY();
    flash_LEDKEY();
    flash_LEDKEY();

    for(byte i = 0; i < 8; i++)
    {
        RelayTurnOff(i);                   // diody i wyświetlacz dla przekaźników OFF
        R_Status[i] = false;               // status przekaźników FALSE ( OFF )
    }

    ExpanderInit_1();                      // inicjuj EXPANDER 1 (adres 0x20)
    ExpanderInit_2();                      // inicjuj EXPANDER 2 (adres 0x27)

    PirInit();

    pinMode(RED, OUTPUT);
    pinMode(ORANGE, OUTPUT);
    pinMode(GREEN, OUTPUT);

    dht.begin();                          // moduł DHT

}

// --------------------------------------------------------------------------------------------------------------------------------- //
// --- L O O P --------------------------------------------------------------------------------------------------------------------- //
// --------------------------------------------------------------------------------------------------------------------------------- //

void loop()
{

    aktualnyCzas = millis();

    roznicaCzasu1 = aktualnyCzas - zapamietanyCzas1;
    roznicaCzasu2 = aktualnyCzas - zapamietanyCzas2;
    roznicaCzasu3 = aktualnyCzas - zapamietanyCzas3;    // czujnik PIR
    roznicaCzasu4 = aktualnyCzas - zapamietanyCzas4;    // czujnik LDR
    roznicaCzasu5 = aktualnyCzas - zapamietanyCzas5;    // czujnik DHT

    PIRSensor();

    // --- warunek wykonywany co 1 minutę ------------------------------------------------------- //

    if (roznicaCzasu2 >= 10000UL)                                 // wykonuj co minutę
    {
        AktualizujCzas();                                         // zapisz z zegara do struktury
        LDRSensor();                                              // zrób pomiar oświetlenia
        DHTSensor();                                              // zrób pomiar temperatury i wilgotnosci
        zapamietanyCzas2 = aktualnyCzas;                          // resetuj warunek
    }

    // --- warunek wykonywany co 1 sekundę ------------------------------------------------------ //

    if (roznicaCzasu1 >= 1000UL)                                 // wykonuj co 1 sekundę
    {
        WyswietlCzas();                                           // wyświetl czas na TM1637
        zapamietanyCzas1 = aktualnyCzas;                          // resetuj warunek
    }

    // ------------------------------------------------------------------------------------------ //

    if (roznicaCzasu3 >= pirAI_Time)                              // wejdz po 3 minutach
    {
        RelayTurnOff(pirAI_Relay);                                // wyłącz przekaźnik (PIR Time Out)
        OrangeLed = true;
        digitalWrite(RED, LOW);
        digitalWrite(GREEN, LOW);
        zapamietanyCzas3 = aktualnyCzas;                          // resetuj warunek
    }

    // ------------------------------------------------------------------------------------------ //

    if (roznicaCzasu4 >= ldrAI_Time)                              // wejdz po 3 minutach
    {
        RelayTurnOff(ldrAI_Relay);                                // wyłącz przekaźnik (LDR Time Out)
        zapamietanyCzas4 = aktualnyCzas;                          // resetuj warunek
    }

    // ------------------------------------------------------------------------------------------ //

    if (roznicaCzasu5 >= dhtAI_Time)                              // wejdz po 5 minutach
    {
        RelayTurnOff(dhtAI_Relay);                                // wyłącz przekaźnik (DHT Time Out)
        zapamietanyCzas5 = aktualnyCzas;                          // resetuj warunek
    }

    // ------------------------------------------------------------------------------------------ //

    przycisk = readButtons();

    switch (przycisk)
    {
        case      1   :   RelaySwitch(0);   break;
        case      2   :   RelaySwitch(1);   break;
        case      4   :   RelaySwitch(2);   break;
        case      8   :   RelaySwitch(3);   break;
        case     16   :   RelaySwitch(4);   break;
        case     32   :   RelaySwitch(5);   break;
        case     64   :   RelaySwitch(6);   break;
        case    128   :   RelaySwitch(7);   break;
        default       : break;

    }

    // ------------------------------------------------------------------------------------------ //
}

///////////////////////////////////////////////////////////////////////////////////////////////
//  RelaySwitch
///////////////////////////////////////////////////////////////////////////////////////////////

void RelaySwitch(byte nr)
{
    if ( R_Status[nr])
    {
        RelayTurnOff(nr);
        R_Status[nr] = false;
    }
    else
    if (!R_Status[nr])
    {
        RelayTurnOn(nr);
        R_Status[nr] = true;
    }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  *** L E D   &   K E Y   C O M M A N D ***                                                                              //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void sendCommand(uint8_t value)
{
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, value);
    digitalWrite(str_pin, HIGH);
}


/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   *** R E S E T   L E D   &   K E Y ***                                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void reset()
{
    sendCommand(0x40);
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0xc0);       // reset od adresu 0

    for (uint8_t i = 0; i < 16; i++)                                                 // petla 16x
    {
        shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x00);   // 8x LED + 8x DIGIT reset
    }
    digitalWrite(str_pin, HIGH);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   *** D E M O   N A   S T A R C I E   A R D U I N O ***                                                                 //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void flash_LEDKEY()
{
    for (uint8_t i = 0; i < 16; i++)                                   // zapal diody 1-8 z przerwą 100ms
    {
        if (i < 8) setLed(1, i);                                       // zapal diodę na pozycji i jesli i<8
        else setLed(0, i - 8);                                         // zgas diodę na pozycji i jeśli i>8
        delay(100);
    }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   *** Z A P A L   L U B   Z G A Ś   D I O D Ę   N A   L E D   &   K E Y ***                                             //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setLed(uint8_t flaga, uint8_t adres)
{
    pinMode(dat_pin, OUTPUT);
    sendCommand(0x44);
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, LED_adres[adres]);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, flaga);
    digitalWrite(str_pin, HIGH);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//  *** O D C Z Y T A J   P R Z Y C I S K   Z    L E D   &   K E Y ***                                                     //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

uint8_t readButtons(void)
{
    uint8_t buttons = 0;
    digitalWrite(str_pin, LOW);
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x42);

    pinMode(dat_pin, INPUT);

    for (uint8_t i = 0; i < 4; i++)
    {
        uint8_t v = shiftInMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US) << i;
        buttons |= v;
    }

    pinMode(dat_pin, OUTPUT);
    digitalWrite(str_pin, HIGH);
    delay(200);

    return buttons;                                               // zwróć kod przycisku
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// ***  W Y Ł Ą C Z   P R Z E K A Ź N I K  ***                                                                             //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void RelayTurnOff(byte adres)
{
    digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x5c);                  // ustaw 0 (0x3f)
    digitalWrite(str_pin, HIGH);                                                                // zapal OFF na wyświetlaczu
    setLed(0, adres);                                                                           // wyłącz diodę dla przekaźnika
    expander1.digitalWrite(adres, HIGH);                                                        // wyłącz przekaźnik na expander1
    R_Status[adres] = false;                                                                    // ustaw status przekaźnika na OFF
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   *** W Ł Ą C Z   P R Z E K A Ź N I K ***                                                                               //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void RelayTurnOn(byte adres)
{
    digitalWrite(str_pin, LOW);                                                                 // pin strobe na OFF
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, DIGIT_adres[adres]);    // ustaw adres
    shiftOutMod(dat_pin, clk_pin, LSBFIRST, CLOCK_TYPE, CLOCK_DELAY_US, 0x63);                  // ustaw 1 (0x3f)
    digitalWrite(str_pin, HIGH);                                                                // zapal ON na wyświetlaczu
    setLed(1, adres);                                                                           // włącz diodę dla przekaźnika
    expander1.digitalWrite(adres, LOW);                                                         // włącz przekaźnik na expander1
    R_Status[adres] = true;                                                                     // ustaw status przekaźnika na ON
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//   *** P I R   S E N S O R  ***                                                                                          //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void PIRSensor()
{
   if(digitalRead(pirPin) == HIGH)
   {
        if(lockLow)
        {
            PIRValue = 1;
            lockLow = false;

            zapamietanyCzas3 = aktualnyCzas;
            RelayTurnOn(pirAI_Relay);

            #if SERIAL
                Serial.print(F("\n[PIR] Wykryto ruch..."));
            #endif

            digitalWrite(RED,LOW);        // wyłącz diodę czerwoną
            digitalWrite(GREEN,HIGH);     // włącz diodę zieloną
            digitalWrite(ORANGE,LOW);     // zgas diode pomaranczowa

            OrangeLed = false;            // wylacz syngalizacje czuwania

          delay(50);
      }

      takeLowTime = true;
   }

   if(digitalRead(pirPin) == LOW)
   {
        if(takeLowTime)
        {
            lowIn = millis();
            takeLowTime = false;
        }

        if(!lockLow && millis() - lowIn > pause)
        {
            PIRValue = 0;
            lockLow = true;

            #if SERIAL
                Serial.print(F("\n[PIR} Brak ruchu..."));
            #endif

            digitalWrite(RED,HIGH);       // zapal diodę czerwoną
            digitalWrite(GREEN,LOW);      // zgaś diodę zieloną
            digitalWrite(ORANGE,LOW);     // zgas diode pomaranczowa

            OrangeLed = false;            // wylacz syngalizacje czuwania

            delay(50);
        }
    }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// LDR
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void LDRSensor()
{
      int analog_value = analogRead(LDR);
      Serial.print("\nanalog : ");
      Serial.print(analog_value);
      Oswietlenie = map(analog_value, 0, 1025, 99, 0);         // mapuj odczyt do wartości (0-100) i odwróć wartości

      #if SERIAL
          Serial.print(F("\n[LDR] Oswietlenie [%] "));
          Serial.print(Oswietlenie);
      #endif

      if (Oswietlenie < minLight)                              // jeśli oświetlenie < minLight włącz przekaźnik ldrAI_Relay
      {
            zapamietanyCzas4 = aktualnyCzas;
            RelayTurnOn(ldrAI_Relay);
      }
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// DHT 11
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void DHTSensor()
{
    wilgotnosc   = dht.readHumidity();
    temperatura  = dht.readTemperature();

    if ( isnan(wilgotnosc) || isnan(temperatura) )
    {
        #if SERIAL
            Serial.print(F("\n[DHT] Blad odczytu z czujnika DHT11 !"));
        #endif

        return;
    }
    else
    {
        #if SERIAL
            Serial.print(F("\n[DHT] Temperatura : "));
            Serial.print(temperatura);
            Serial.print(F(" st.C"));
            Serial.print(F("\n[DHT] Wilgotnosc  : "));
            Serial.print(wilgotnosc);
            Serial.print(F(" %rH"));
        #endif

        if (temperatura > maxTemp)                              // jeśli temperatura < maxTemp włącz przekaźnik dhtAI_Relay
        {
            zapamietanyCzas5 = aktualnyCzas;
            RelayTurnOn(dhtAI_Relay);
        }
    }
}