Create a new version of paste:

// ------------------------------------------------------------------------------------------------------------ //
// ---    StationROOT      Wi-FI      B Y   T O M A S Z   M A J C H E R                                     --- //
// ------------------------------------------------------------------------------------------------------------ //
// 
//  by Tomasz Majcher (TLG) Trans Line Group, Lubin POLSKA
//  NIP:    692-201-09-78
//  TEL:    667-08-21-21
//  mail:   transline.majcher@gmail.com
//
//  Trans Line Group Tomasz Majcher
//  * usługi transportowe (wywrotki, silosy) - 
//  * sprzedaw kruszyw (piasek, żwir, pospółka, grysy, tłuczeń, mieszanki, żużel, kryszywa)
//  * automatyka przemysłowa i domowa
//
// ------------------------------------------------------------------------------------------------------------ //
// --- HISTORIA WERSJI ---------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
//
//  StationROOT v0.47   (03.05.2021)  - dodano obsługę fotorezystora (do wątku CORE1 TASK1)
//  StationROOT v0.46   (03.05.2021   - GRUNTOWNY TEST 
//  StationROOT v0.45   (03.05.2021)  - dodano obsługę czujnika DHT11 (do wątku CORE0 TASK2)
//  StationROOT v0.44   (03.05.2021)  - rozbudowa debug'era dla zdarzeń TELEGRAM
//  StationROOT v0.43   (02.05.2021)  - dodano : obsługa IMIENIN - miesiąc STYCZEN, LUTY, MARZEC, KWIECIEN
//  StationROOT v0.42   (02.05.2021)  - dodano : obsługa IMIENIN - miesiąc WRZESIEŃ, PAŹDZIERNIK, LISTOPAD, GRUDZIEN
//  StationROOT v0.41   (02.05.2021)  - dodano : obsługa IMIENIN - miesiąc LIPIEC, SIERPIEN
//  StationROOT v0.40   (02.05.2021)  - dodano : obsługa IMIENIN - miesiąc MAJ, CZERWIEC
//  StationROOT v0.39   (02.05.2021)  - rozbudowa MAX : MARZEC i KWIECIEN (tylko dla PL_MAX)
//  StationROOT v0.38   (02.05.2021)  - rozbudowa MAX : STYCZEN i LUTY (tylko dla PL_MAX)
//  StationROOT v0.37   (02.05.2021)  - rozbudowa MAX : LISTOPAD i GRUDZIEŃ (tylko dla PL_MAX)
//  StationROOT v0.36   (02.05.2021)  - rozbudowa MAX : WRZESIEŃ i PAŹDZIERNIK (tylko dla PL_MAX)
//  StationROOT v0.35   (02.05.2021)  - rozbudowa MAX : LIPIEC i SIERPIEŃ (tylko dla PL_MAX)
//
//  StationROOT v0.34   (02.05.2021)  - Stabilna. Free RAM ~171kBajtów, Free Flash ~2MegaBajtów (HUGE Memory Model)
//
//  StationROOT v0.33   (02.05.2021)  - rozbudowa MAX ---> dodano struktury miesiący
//  StationROOT v0.32   (02.05.2021)  - rozbudowa MAX ---> Final Dni Tygodnia no WiKi_PAROLA LIB version
//  StationROOT v0.31   (01.05.2021)  - rozbudowa MAX
//  StationROOT v0.30   (01.05.2021)  - rozbudowa MAX, dodano prototypy funkcji do kodu
//  StationROOT v0.29   (01.05.2021)  - rozbudowa MAX
//  StationROOT v0.28   (01.05.2021)  - rozbudowa MAX
//  StationROOT v0.27   (01.05.2021)  - rozbudowa MAX
//  StationROOT v0.26   (31.04.2021)  - rozbudowa MAX
//  StationROOT v0.25   (30.04.2021)  - rozbudowa MAX
//  StationROOT v0.24   (29.04.2021)  - rozbudowa MAX
//  StationROOT v0.23   (28.04.2021)  - rozbudowa MAX
//  StationROOT v0.22   (27.04.2021)  - rozbudowa MAX
//  StationROOT v0.21   (26.04.2021)  - rozbudowa MAX
//  StationROOT v0.20   (25.04.2021)  - przebudowa paneli myInlineKbd i myInlineKbd2 dla TELEGRAM (na moje potrzeby)
//  StationROOT v0.19   (25.04.2021)  - usunięto tokena i miasto ze ścieżek WEATHER, konfiguracja w sekcji DEFINE
//  StationROOT v0.18   (25.04.2021)  - dodano teksty dla dni tygodnia i godziny dla MAX
//  StationROOT v0.17   (25.04.2021)  - dodano wyświetlanie długej daty (dzien tygodnia, dzien, miesiac, rok)
//  StationROOT v0.16   (25.04.2021)  - dodano obsługę JAKOŚCI POWIETRZA wg. standardu EPA
//  StationROOT v0.15   (25.04.2021)  - test : OK
//  StationROOT v0.14   (25.04.2021)  - modernizacja Translatarów dla MAX - usunięcie z CORE (przepełnienie stosu)
//  StationROOT v0.13   (25.04.2021)  - modernizacja Translatorów dla SERIAL - usunięcie z CORE (przepełnienie stosu)
//  StationROOT v0.12   (24.04.2021)  - przeniosiona Translator Opisu Pogody na TASK2 dla CORE0 CPU
//  StationROOT v0.11   (24.04.2021)  - przeniosiona Translator Faz Księżyca na TASK3 dla CORE0 CPU
//  StationROOT v0.10   (24.04.2021)  - dodano Translator Opisy Pogody (EN/PL)
//  StationROOT v0.09   (24.04.2021)  - dodano Translator Faz Księżyca (EN/PL)
//  StationROOT v0.08   (24.04.2021)  - dodano obsługę zdarzenia włączenia/wyłączenia przekaźnika na MAXLED
//  StationROOT v0.07   (23.04.2021)  - dodano obsługę matrycy MAXLED
//  StationROOT v0.06   (21.04.2021)  - zbudowane na bazie DarnNET MESH Server (v0.06)
//
// ------------------------------------------------------------------------------------------------------------ //
// --- DOŁĄCZONE NAGŁÓWKI BIBLIOTEK --------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
#include <AsyncTelegram.h>
#include <Arduino.h>
#include <WiFiClient.h>
#include <NTPClient.h>                                           // NTP klient (czas)
#include <TimeLib.h>                                             // parser 
#include <WiFiUdp.h>                                             // UDP Wi-Fi
#include <HTTPClient.h>                                                             
#include <Arduino_JSON.h>
#include <ESP32Time.h>                                           // zegar RTC ESP32Time
#include <MD_Parola.h>                                           // MATRYCA
#include <MD_MAX72xx.h>                                          // MATRYCA
#include "DHTesp.h"
#include "SoftwareSerial.h"                                      // RX TX - jeszcze nie zaimplementowano
#include "global.h"                                              // struktury ze zmiennymi
#include "max.h"                                                 // wyświetlacz PAROLA

typedef byte BAJT;

#define   SERIAL              1                           // włącz terminal SERIAL.MONITOR
#define   SPEED               115200                      // prędkość terminala SERIAL
#define   THREAD_INFO         0
#define   CORE0_TASK1         1
#define   RxTxSpeed           19200                       // prędkość transmisji RxTx

// ------------------------------------------------------------------------------------------------------------ //
// --- P R O T O T Y P Y    F U N K C J I --------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

void PrintLine(byte lenght);
void PrintMSG(const char * wiadomosc_1, const char * wiadomosc_2, const char * wiadomosc_3);
void PrintEND();
void Pogoda2PL();
void PogodaAktualizuj();
void Astronomia2PL();
void AstronomiaAktualizuj();
void PowietrzeAktualizuj();
void PrognozaAktualizuj();
void MyTask();
void TelegramInit();
String TelegramPogoda();
String TelegramNTP();
String TelegramASTRO();
String TelegramAIR();
String TelegramSYSTEM();
String TelegramSwitchRelay(byte relayNR);
String TelegramRELAY_ALL_ON();
String TelegramRELAY_ALL_OFF();
String TelegramRELAY();
void Telegram();

// ------------------------------------------------------------------------------------------------------------ //
// --- D E F I N I C J E -------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

#define   SSID        "DIABLO"                    // nazwa sieci Wi-Fi (router podłączony do sieci)
#define   PASSWORD    "xxxxxxxxxxxxxxxxxxxxxx"    // hasło sieci Wi-Fi (router podłączony do sieci)

String PogodaToken  = "xxxxxxxxxxxxxxxxxxxxxx";    // token serwera pogodowego http://api.weatherapi.com
String PogodaMiasto = "xxxxxxxxxxxxxxxxxxxxxx";    // miasto dla ścieżki HTTP  http://api.weatherapi.com


// USTAWIENIA DLA MAX_LED x8 ------------------------------------------------------------------ //

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW          
#define MAX_DEVICES 8         

// UWAGA !!! ESP32 ma Hardware SPI na następujących pinach ------------------------------------ //

#define CLK_PIN   13      // SPI ESP32 !!! VSPI SCK (P18 na płycie)
#define DATA_PIN  11      // SPI ESP32 !!! VSPI MOSI (P23 na płycie)
#define CS_PIN    15      // SPI ESP32 !!! VSPI CS (P15 na płycie)

#define RELAY1_CALLBACK  "Relay1"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY2_CALLBACK  "Relay2"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY3_CALLBACK  "Relay3"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY4_CALLBACK  "Relay4"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY5_CALLBACK  "Relay5"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY6_CALLBACK  "Relay6"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY7_CALLBACK  "Relay7"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define RELAY8_CALLBACK  "Relay8"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define EXIT1_CALLBACK   "EXIT1"   // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define EXIT2_CALLBACK   "EXIT2"   // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define PANEL1_CALLBACK  "PANEL11" // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 
#define PANEL2_CALLBACK  "PANEL11" // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku 

// ------------------------------------------------------------------------------------------------------------ //
// --- P R O T O T Y P Y    C P U ----------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

void Core0_Task1( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 0 CPU         
void Core0_Task2( void * pvParameters );                            // funkcja Task2 dla rdzenia nr. 0 CPU         

void Core1_Task1( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 1 CPU        
void Core1_Task2( void * pvParameters );                            // funkcja Tasl2 dla rdzenia nr. 1 CPU    
                                   

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

WiFiUDP ntpUDP;                                                     // dla NTP (pobieranie czasu z internetu)
NTPClient timeClient(ntpUDP, "pool.ntp.org", 7200);                 // dla NTP (pobieranie czasu z internetu)
                                                             
WiFiClient wifiClient;                                              // obiekt WiFi
HTTPClient http;                                                    // obiekt HTTP

ESP32Time rtc;                                                      // zegar RTC

JSONVar JSON_Astronomy;                                             // obiekt Astronomia
JSONVar JSON_Weather;                                               // obiekt Pogoda    
JSONVar JSON_Forecast;                                              // obiekt Forecast
JSONVar JSON_Air;                                                   // obiekt Powietrze
JSONVar JSON_Mesh;                                                  // obiekt Mesh Incoming

TaskHandle_t CPU_Core_0;                                            // rdzeń nr. 0 CPU - ESP32
TaskHandle_t CPU_Core_1;                                            // rdzeń nr. 1 CPU - ESP32

AsyncTelegram myBot;                                                // obiekt Telegram
ReplyKeyboard myReplyKbd;                                           // obiekt klawiatury Reply
ReplyKeyboard myReplyKbd2;                                          // obiekt klawiatury Reply
InlineKeyboard myInlineKbd;                                         // obiekt klawiatury Inline
InlineKeyboard myInlineKbd2;                                        // obiekt klawiatury Inline


MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);        // obiekt MD_Parola
MAX       M(P);                                                     // pseudo-obiekt MD_Parola

SoftwareSerial wireS(10,11);                                        // komunikacja Serial

#define DHTpin 22                                                   // czujnik temp i wilgotności
DHTesp dht;                                                         // obiekt modułu

#define FOTOpin 34;                                                 // czujnik światła
byte  Oswietlenie = 0;                                              // natężenie światła w pokoju


// ------------------------------------------------------------------------------------------------------------ //
// --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
// --- F L A G I ---------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

bool F_Astronomia         = false;          // flaga  : czy aktualizacja astronomii
bool F_Pogoda             = false;          // flaga  : czy aktualizacja pogody
bool F_Prognoza           = false;          // flaga  : czy aktualizacja prognozy
bool F_Powietrze          = false;          // flaga  : czy aktualizacja powietrza
bool F_Zegar              = false;          // flaga  : Czy aktualizacja zegara
bool F_BigClock           = true;           // flaga  : WYŚWIETL ZEGAR MAXLED (true = pokaz, false = nie pokazuj)
bool F_MaxDemo            = false;          // flaga  : wysietlacz DEMO
bool F_Przekaznik         = false;          // flaga  : włączono/wyłączono przekaźnik
bool F_DataUpdate         = false;          // flaga  : aktualizacja daty
bool isKeyboardActive;                      // zapisz, jeśli wyświetlana jest klawiatura odpowiedzi


// ------------------------------------------------------------------------------------------------------------ //
// --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
// --- M I L L I S -------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

unsigned long timeZERO = 0;  
unsigned long task01m = 0;
unsigned long task01s = 0;
unsigned long task05m = 0;
unsigned long task10m = 0;
unsigned long task15m = 0;
unsigned long task01h = 0;
unsigned long timeout_task01m = 0;
unsigned long timeout_task01s = 0;
unsigned long timeout_task05m = 0;
unsigned long timeout_task10m = 0;
unsigned long timeout_task15m = 0;
unsigned long timeout_task01h = 0;

// ------------------------------------------------------------------------------------------------------------ //
// --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
// --- T E L E G R A M ---------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

const char *token = "xxxxxxxxxxxxxxxxxxxxxx";       // token BOT
const char *chatid = "xxxxxxxxxxxxxxxxxxxxxx";      // chat ID BOT (nie korzystam)

//
// ------------------------------------------------------------------------------------------------------------ //
// ---                              M U L T I - C O R E   T A S K                                           --- //
// ------------------------------------------------------------------------------------------------------------ //
//
//    void Core0_Task1( void * pvParameters )       --->  aktualizacja czasu i daty  
//    void Core0_Task2( void * pvParameters )       --->  
//    void Core1_Task1( void * pvParameters )       --->  data updata (buduje bufory dla MAX)
//    void Core1_Task2( void * pvParameters )       --->  
//
// ------------------------------------------------------------------------------------------------------------ //
// ---        CORE0 TASK1     POBIERANIE CZASU i DATY Z SERWERA NTP i AKTUALIZACJA ZEGARA ESP32 RTC         --- //
// ------------------------------------------------------------------------------------------------------------ //
//
void Core0_Task1( void * pvParameters )                           
{                                                                 
    for(;;)                                                        
    {                                                             
        #if THREAD_INFO
            PrintLine(80);
            PrintMSG("ESP32","CORE", "Wykonuje watek TASK1 na CORE0");
        #endif      

        timeClient.update();
        
        unsigned long epochTime = timeClient.getEpochTime();                                               
        struct tm *ptm = gmtime ((time_t *)&epochTime);      
                                                                                   
        zegar.Godzina           =   timeClient.getHours();                  
        zegar.Minuta            =   timeClient.getMinutes();                
        zegar.Sekunda           =   timeClient.getSeconds();                
        zegar.SformatowanyCzas  =   timeClient.getFormattedTime();                                
        zegar.DzienTygodnia     =   timeClient.getDay();                                          
        zegar.DzienMiesiaca     =   ptm->tm_mday;                                                 
        zegar.Miesiac           =   ptm->tm_mon+1;                                                
        zegar.Rok               =   ptm->tm_year+1900; 

        if (zegar.Godzina < 10)
        {
            zegar.SformatowanyCzasHM = "0" + String (zegar.Godzina) + ":";            
        }
        else zegar.SformatowanyCzasHM = String(zegar.Godzina) + ":";            

        if (zegar.Minuta < 10)
        {
            zegar.SformatowanyCzasHM += "0" + String (zegar.Minuta) + ":";            
        }
        else zegar.SformatowanyCzasHM += String(zegar.Minuta);            
        

        if (zegar.Rok !=1970)
        {
            if(zegar.DzienMiesiaca < 10) 
            {
                zegar.SformatowanaData   = "0" + String(zegar.DzienMiesiaca) + ".";
                zegar.SformatowanaDataPL = "0" + String(zegar.DzienMiesiaca) + " ";
            }
            else  
            {
                zegar.SformatowanaData   = String(zegar.DzienMiesiaca) + ".";
                zegar.SformatowanaDataPL = String(zegar.DzienMiesiaca) + " ";
            }

            if(zegar.Miesiac < 10)
            {
                zegar.SformatowanaData += "0" + String(zegar.Miesiac) + ".";
                zegar.SformatowanaDataPL += String(MONTH[zegar.Miesiac]) + " ";
            }
            else  
            {
                zegar.SformatowanaData += String(zegar.Miesiac) + ".";
                zegar.SformatowanaDataPL += String(MONTH[zegar.Miesiac]) + " ";
            }

            zegar.SformatowanaData  += String(zegar.Rok);
            zegar.SformatowanaDataPL += String(zegar.Rok);

            // --- zapisz aktualny czas pobrany z serwera NTP do zegara RTC --------------------------------------- //
            
            rtc.setTime(zegar.Sekunda, zegar.Minuta, zegar.Godzina-1, zegar.DzienMiesiaca, zegar.Miesiac, zegar.Rok);

            if (!F_DataUpdate)
            {
                Data2Bufor();         // aktualizuj jeśli flaga jest FALSE
                F_DataUpdate = true;  // Bufor Daty zbudowany, nie aktualizuj co minutę, rób to co godzinę
            }

            // --- zbuduj obiekty typu (JSON STRING) do odesłania na żadanie do innego ESP w sieci MESH

                    
            #if CORE0_TASK1    
                Serial.printf("\nData i Czas :");
                PrintLine(60);                       
                PrintMSG("CORE0_TASK1", "NTP Time", zegar.SformatowanyCzas.c_str());          
                PrintMSG("CORE0_TASK1", "NTP Date", zegar.SformatowanaData.c_str()); 
                Serial.printf("\n[CORE0_TASK1] [RTC Time] ");  
                Serial.print(rtc.getTime());
                Serial.printf("\n[CORE0_TASK1] [RTC Date] ");  
                Serial.print(rtc.getDate());
                Serial.printf("\n[CORE0_TASK1] [FREE RAM] ");
                Serial.print(ESP.getFreeHeap());
                PrintLine(60);
                PrintEND();       
            #endif
               
            F_Zegar = true;   // dane OK, flaga na true
        }
        else F_Zegar = false; // dane złe, flaga na false
        
        vTaskDelay(60000 / portTICK_PERIOD_MS);                 // wykonuj 1 minutę
    }                                                             
}      
//
// ------------------------------------------------------------------------------------------------------------ //
// ---        CORE0 TASK2                                                                                   --- //
// ------------------------------------------------------------------------------------------------------------ //
//
void Core0_Task2( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
{                                                                 // początek                           
    for(;;)                                                       // nieskończona pętla                 
    {                                                             // początek FOR              
        TempAndHumidity odczyt = dht.getTempAndHumidity();

        pogoda.in_temperatura = odczyt.temperature;
        pogoda.in_wilgotnosc  = odczyt.humidity;

        #if SERIAL
            Serial.printf("\nDHT11 Info :");
            PrintLine(60);
            Serial.printf("\n[CORE0] [TASK2] Temperatura w pokoju :  %2.2f [st.C]", pogoda.in_temperatura);
            Serial.printf("\n[CORE0] [TASK2] Wilgotność w pokoju  :  %2.2f [%% rH]", pogoda.in_wilgotnosc);
            PrintLine(60);
        #endif

        DHT11Bufor();                                           // uwaga na stos - sprawdzić
        
        delay(90000);                                           // wykonuj co 90 sekund
    }                                                             
}   
//
// ------------------------------------------------------------------------------------------------------------ //
// ---        CORE1 TASK1     
// ------------------------------------------------------------------------------------------------------------ //

void Core1_Task1( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
{                                                                 // początek                           
    for(;;)                                                       // nieskończona pętla                 
    {                                                             // początek FOR                                    
        int analog_value = analogRead(34);                        // czytaj z czujnika LDR na pinie 34
        Oswietlenie = map(analog_value, 0, 4095, 100, 0);         // mapuj odczyt do wartości (0-100)      
        LDR2Bufor();                                              // zbuduj bufor dla MAX7819
        delay(75000);                                             // wykonuj co 1 minutę i 35 sekund
    }                                                             
}      

// ------------------------------------------------------------------------------------------------------------ //
// ---        CORE1 TASK2     
// ------------------------------------------------------------------------------------------------------------ //

void Core1_Task2( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
{                                                                 // początek                           
    for(;;)                                                       // nieskończona pętla                 
    {                                                             // początek FOR                              
        
        delay(3600000);                                           // wykonuj co 1 godzinę
    }                                                             
}      

// ------------------------------------------------------------------------------------------------------------ //
// --- Aktualizacja Pogody z Serwera  ------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
//
String httpGETRequest(const char* serverName)                                                         
{                                                                                                     
    HTTPClient http;                                                                                  
    http.begin(serverName);                                                                           
    int httpResponseCode = http.GET();                                                                
    String bufor = "{}";                                                                              
                                                                                                      
    if ( httpResponseCode > 0 )                                                                       
    {                                                                                                 
        #if SERIAL
            //Serial.print("\nHTTP Response code: ");                                                   
            //Serial.print(httpResponseCode);                                                       
        #endif          
                                                                                      
        bufor = http.getString();                                                                     
    }                                                                                                 
    else                                                                                              
    {                                                                                                 
        #if SERIAL                                                                                  
            //Serial.print("Error code: ");                                                           
            //Serial.println(httpResponseCode);                                                       
        #endif                                                                                        
    }                                                                                                
    http.end();                                                                            
    return bufor;                                                                                     
} 

// ------------------------------------------------------------------------------------------------------------ //
// --- Tłumasz opis pogody  ----------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //

void Pogoda2PL()
{
    if      ( pogoda.kondycja == "Sunny" )                                    pogoda.kondycja_pl = "Słonecznie";
    else if ( pogoda.kondycja == "Partly cloudy" )                            pogoda.kondycja_pl = "Częściowe zachmurzenie";
    else if ( pogoda.kondycja == "Cloudy" )                                   pogoda.kondycja_pl = "Pochmurnie";
    else if ( pogoda.kondycja == "Overcast" )                                 pogoda.kondycja_pl = "Posępnie";
    else if ( pogoda.kondycja == "Mist" )                                     pogoda.kondycja_pl = "Zamglenie";
    else if ( pogoda.kondycja == "Patchy rain possible" )                     pogoda.kondycja_pl = "Możliwy przelotny deszcz";
    else if ( pogoda.kondycja == "Patchy snow possible" )                     pogoda.kondycja_pl = "Możliwe nieregularne opady śniegu";
    else if ( pogoda.kondycja == "Patchy sleet possible" )                    pogoda.kondycja_pl = "Możliwe niejednolite opady śniegu";
    else if ( pogoda.kondycja == "Patchy freezing drizzle possible" )         pogoda.kondycja_pl = "Możliwa nieregularna marznąca mżawka";
    else if ( pogoda.kondycja == "Thundery outbreaks possible" )              pogoda.kondycja_pl = "Możliwe wybuchy piorunów";
    else if ( pogoda.kondycja == "Blowing snow" )                             pogoda.kondycja_pl = "Śnieżyca";
    else if ( pogoda.kondycja == "Blizzard" )                                 pogoda.kondycja_pl = "Burza śnieżna";
    else if ( pogoda.kondycja == "Fog" )                                      pogoda.kondycja_pl = "Mgła";
    else if ( pogoda.kondycja == "Freezing fog" )                             pogoda.kondycja_pl = "Marznąca mgła";
    else if ( pogoda.kondycja == "Patchy light drizzle" )                     pogoda.kondycja_pl = "Nieregularna lekka mżawka";
    else if ( pogoda.kondycja == "Light drizzle" )                            pogoda.kondycja_pl = "Lekka mżawka";
    else if ( pogoda.kondycja == "Freezing drizzle" )                         pogoda.kondycja_pl = "Marznąca mżawka";
    else if ( pogoda.kondycja == "Heavy freezing drizzle" )                   pogoda.kondycja_pl = "Silna marznąca mżawka";
    else if ( pogoda.kondycja == "Patchy light rain" )                        pogoda.kondycja_pl = "Niejednolity, lekki deszcz";
    else if ( pogoda.kondycja == "Light rain" )                               pogoda.kondycja_pl = "Lekki deszcz";
    else if ( pogoda.kondycja == "Moderate rain at times" )                   pogoda.kondycja_pl = "Czasami umiarkowany deszcz";
    else if ( pogoda.kondycja == "Moderate rain" )                            pogoda.kondycja_pl = "Umiarkowany deszcz";
    else if ( pogoda.kondycja == "Heavy rain at times" )                      pogoda.kondycja_pl = "Czasami ulewny deszcz";
    else if ( pogoda.kondycja == "Heavy rain" )                               pogoda.kondycja_pl = "Ulewa";
    else if ( pogoda.kondycja == "Light freezing rain" )                      pogoda.kondycja_pl = "Lekki marznący deszcz";
    else if ( pogoda.kondycja == "Moderate or heavy freezing rain" )          pogoda.kondycja_pl = "Umiarkowany lub silny marznący deszcz";
    else if ( pogoda.kondycja == "Light sleet" )                              pogoda.kondycja_pl = "Lekki deszcz ze śniegiem";
    else if ( pogoda.kondycja == "Moderate or heavy sleet" )                  pogoda.kondycja_pl = "Umiarkowany lub obfity deszcz ze śniegiem";
    else if ( pogoda.kondycja == "Patchy light snow" )                        pogoda.kondycja_pl = "Niejednolity, lekki śnieg";
    else if ( pogoda.kondycja == "Light snow" )                               pogoda.kondycja_pl = "Lekkie opady śniegu";
    else if ( pogoda.kondycja == "Patchy moderate snow" )                     pogoda.kondycja_pl = "Puszysty, umiarkowany śnieg";
    else if ( pogoda.kondycja == "Moderate snow" )                            pogoda.kondycja_pl = "Średnie opady śniegu";
    else if ( pogoda.kondycja == "Patchy heavy snow" )                        pogoda.kondycja_pl = "Niejednolity, ciężki śnieg";
    else if ( pogoda.kondycja == "Heavy snow" )                               pogoda.kondycja_pl = "Duże opady śniegu";
    else if ( pogoda.kondycja == "Ice pellets" )                              pogoda.kondycja_pl = "Granulki lodu";
    else if ( pogoda.kondycja == "Light rain shower" )                        pogoda.kondycja_pl = "Lekki deszczyk";
    else if ( pogoda.kondycja == "Moderate or heavy rain shower" )            pogoda.kondycja_pl = "Umiarkowany lub ulewny deszcz";
    else if ( pogoda.kondycja == "Torrential rain shower" )                   pogoda.kondycja_pl = "Ulewny deszcz";
    else if ( pogoda.kondycja == "Light sleet showers" )                      pogoda.kondycja_pl = "Lekkie opady deszczu ze śniegiem";
    else if ( pogoda.kondycja == "Moderate or heavy sleet showers" )          pogoda.kondycja_pl = "Umiarkowane lub obfite opady deszczu ze śniegiem";
    else if ( pogoda.kondycja == "Light snow showers" )                       pogoda.kondycja_pl = "Lekkie opady śniegu";
    else if ( pogoda.kondycja == "Moderate or heavy snow showers" )           pogoda.kondycja_pl = "Umiarkowane lub obfite przelotne opady śniegu";
    else if ( pogoda.kondycja == "Light showers of ice pellets" )             pogoda.kondycja_pl = "Lekkie opady granulatu lodu";
    else if ( pogoda.kondycja == "Moderate or heavy showers of ice pellets" ) pogoda.kondycja_pl = "Umiarkowane lub obfite opady granulatu lodu";
    else if ( pogoda.kondycja == "Patchy light rain with thunder" )           pogoda.kondycja_pl = "Nieregularny, lekki deszcz z grzmotami";
    else if ( pogoda.kondycja == "Moderate or heavy rain with thunder" )      pogoda.kondycja_pl = "Umiarkowany lub ulewny deszcz z grzmotami";
    else if ( pogoda.kondycja == "Moderate or heavy snow with thunder" )      pogoda.kondycja_pl = "Umiarkowany lub ciężki śnieg z grzmotami";
          
    else pogoda.kondycja_pl = pogoda.kondycja;   // nie zdefiniowane skopiuj  
}

//
// ------------------------------------------------------------------------------------------------------------ //
// ---        A K T U A L I Z A C J A   P O G O D Y                                                         --- //     
// ------------------------------------------------------------------------------------------------------------ //
//
void PogodaAktualizuj()
{
    PrintLine(60);
    PrintMSG("ESP32","MyTask", "Aktualizję pogodę z serwera : api.weatherapi.com");
    
    String path = "http://api.weatherapi.com/v1/current.json?key=" + PogodaToken + "&q=" + PogodaMiasto + "&lang=en";
    String jsonBuffer = httpGETRequest(path.c_str());    
        
    JSON_Weather = JSON.parse(jsonBuffer);                     

    if (JSON.typeof(JSON_Weather) == "undefined")                                                 
    {                                                                                         
        PrintLine(60);
        PrintMSG("DarkNet", "POGODA PARSER", "BŁĄD, BRAK DANYCH" );                                                                   
    }      

    pogoda.miejscowosc                =   JSON_Weather["location"]["name"];
    pogoda.kraj                       =   JSON_Weather["location"]["country"];
    pogoda.szerokosc_geograficzna     =   JSON_Weather["location"]["lat"];
    pogoda.dlugosc_geograficzna       =   JSON_Weather["location"]["lon"];
    pogoda.id                         =   JSON_Weather["location"]["tz_id"];
    pogoda.czas_epoch                 =   JSON_Weather["location"]["localtime_epoch"];
    pogoda.czas_lokalny               =   JSON_Weather["location"]["localtime"];
    pogoda.ostatnia_aktualizacja      =   JSON_Weather["current"]["last_updated"];
    pogoda.temperatura_C              =   JSON_Weather["current"]["temp_c"];
    pogoda.temperatura_C_odczuwalna   =   JSON_Weather["current"]["feelslike_c"];
    pogoda.kondycja                   =   JSON_Weather["current"]["condition"]["text"];
    pogoda.predkosc_wiatru_kph        =   JSON_Weather["current"]["wind_kph"];
    pogoda.kierunek_wiatru_stopnie    =   JSON_Weather["current"]["wind_degree"];
    pogoda.kierunek_wiatru_kompas     =   JSON_Weather["current"]["wind_dir"];
    pogoda.podmuchy_wiatru            =   JSON_Weather["current"]["gust_kph"];
    pogoda.cisnienie                  =   JSON_Weather["current"]["pressure_mb"];
    pogoda.opady                      =   JSON_Weather["current"]["precip_mm"];
    pogoda.wilgotnosc                 =   JSON_Weather["current"]["humidity"];
    pogoda.zachmurzenie               =   JSON_Weather["current"]["cloud"];
    pogoda.widzialnosc                =   JSON_Weather["current"]["vis_km"];
    pogoda.index_uv                   =   JSON_Weather["current"]["uv"];

    if(pogoda.miejscowosc == PogodaMiasto)
    {
        Pogoda2PL();
        OpisPogody2Bufor();
        Pogoda2Bufor();
        Serial.printf("\nJSON Weather Data :");
        PrintLine(60);
        Serial.printf("\n[DarkNet] [Pogoda] Miejscowość \t\t: ");
        Serial.print(pogoda.miejscowosc);
        Serial.printf("\n[DarkNet] [Pogoda] Kraj \t\t: ");
        Serial.print(pogoda.kraj);
        Serial.printf("\n[DarkNet] [Pogoda] Szer.Geograficzna \t: %2.2f",pogoda.szerokosc_geograficzna);
        Serial.printf("\n[DarkNet] [Pogoda] Dług.Geograficzna \t: %2.2f",pogoda.dlugosc_geograficzna);            
        Serial.printf("\n[DarkNet] [Pogoda] Czas Epoch \t\t: %u",pogoda.czas_epoch );            
        Serial.printf("\n[DarkNet] [Pogoda] Serwer ID \t\t: ");
        Serial.print( pogoda.id );     
        Serial.printf("\n[DarkNet] [Pogoda] Czas Epoch \t\t: %u",pogoda.czas_epoch );            
        Serial.printf("\n[DarkNet] [Pogoda] Czas Lokalny \t: ");       
        Serial.print( pogoda.czas_lokalny );        
        Serial.printf("\n[DarkNet] [Pogoda] Aktualizacja \t: ");       
        Serial.print( pogoda.ostatnia_aktualizacja );       
        Serial.printf("\n[DarkNet] [Pogoda] Temperatura \t\t: %2.2f [st.C]",pogoda.temperatura_C);
        Serial.printf("\n[DarkNet] [Pogoda] Temp.Odczuwalna \t: %2.2f [st.C]",pogoda.temperatura_C_odczuwalna);   
        Serial.printf("\n[DarkNet] [Pogoda] Opis pogody PL\t: ");
        Serial.print(pogoda.kondycja_pl);   
        Serial.printf("\n[DarkNet] [Pogoda] Opis pogody EN\t: ");
        Serial.print(pogoda.kondycja);   
        Serial.printf("\n[DarkNet] [Pogoda] Predkosc wiatru \t: %2.2f [km/h]",pogoda.predkosc_wiatru_kph);
        Serial.printf("\n[DarkNet] [Pogoda] Podmuchy wiatru \t: %2.2f [km/h]",pogoda.podmuchy_wiatru);   
        Serial.printf("\n[DarkNet] [Pogoda] Kierunek wiatru \t: %2.2f",pogoda.kierunek_wiatru_stopnie);   
        Serial.printf("\n[DarkNet] [Pogoda] Kierunek wiatru \t: ");
        Serial.print(pogoda.kierunek_wiatru_kompas);   
        Serial.printf("\n[DarkNet] [Pogoda] Cisnienie \t\t: %d [mPA]",pogoda.cisnienie);   
        Serial.printf("\n[DarkNet] [Pogoda] Opady deszczu \t: %2.2f [mm]",pogoda.opady);   
        Serial.printf("\n[DarkNet] [Pogoda] Wilgotnosc \t\t: %d [%%rH]",pogoda.wilgotnosc);   
        Serial.printf("\n[DarkNet] [Pogoda] Zachmurzenie \t: %d [%%]",pogoda.zachmurzenie);   
        Serial.printf("\n[DarkNet] [Pogoda] Widzialnosc \t\t: %d [km]",pogoda.widzialnosc);   
        Serial.printf("\n[DarkNet] [Pogoda] Index UV \t\t: %d",pogoda.index_uv);   
             
        PrintLine(60);
        PrintEND();
        F_Pogoda = true;      // dane OK, ustaw flagę na true
    }
    else  F_Pogoda = false;   // dane ZŁE, ustaw flagę na false

}

//
// ------------------------------------------------------------------------------------------------------------ //
// ---        A S T R O N O M I A   Z   A N G I E L S K I   D O   P O L S K I                               --- //     
// ------------------------------------------------------------------------------------------------------------ //
//

void Astronomia2PL()
{
    if (astronomia.faza_ksiezyca == "Waxing Crescent")
    {
        astronomia.faza_ksiezyca_pl = "Sierp przybywający";    
    }
    else
    if (astronomia.faza_ksiezyca == "New Moon")
    {
        astronomia.faza_ksiezyca_pl = "Nów";
    }
    else
    if (astronomia.faza_ksiezyca == "First Quarter")
    {
        astronomia.faza_ksiezyca_pl = "Pierwszy kwartał";
    }
    else
    if (astronomia.faza_ksiezyca == "Waxing Gibbous")
    {
        astronomia.faza_ksiezyca_pl = "Przybywający Księżyc";
    }
    else
    if (astronomia.faza_ksiezyca == "Full Moon")
    {
        astronomia.faza_ksiezyca_pl = "Pełnia Księżyca";
    }
    else
    if (astronomia.faza_ksiezyca == "Waning Gibbous")
    {
        astronomia.faza_ksiezyca_pl = "Ubywający Księżyc";
    }
    else    
    if (astronomia.faza_ksiezyca == "Last Quarter")
    {
        astronomia.faza_ksiezyca_pl = "Ostatni kwartał";
    }
    else    
    if (astronomia.faza_ksiezyca == "Waning Crescent")
    {
        astronomia.faza_ksiezyca_pl= "Powiększający się Księżyc";
    }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// ---        A K T U A L I Z A C J A   A S T R O N O M I I                                                 --- //     
// ------------------------------------------------------------------------------------------------------------ //
//

void AstronomiaAktualizuj()
{
    PrintLine(60);
    PrintMSG("ESP32","MyTask", "Aktualizję astronomię z serwera : api.weatherapi.com");    

    // pobierz dane astronomiczne z serwera dla miasta LUBIN
        
    String path = "http://api.weatherapi.com/v1/astronomy.json?key=" + PogodaToken + "&lang=pl&q=" + PogodaMiasto;
    String jsonBuffer = httpGETRequest(path.c_str());    
        
    JSON_Astronomy = JSON.parse(jsonBuffer);                 

    if (JSON.typeof(JSON_Astronomy) == "undefined")                                                 
    {                                                                                         
        PrintLine(60);
        PrintMSG("DarkNet", "ASTRONOMIA PARSER", "BŁĄD, BRAK DANYCH" );                                                                               
    }      
      
    astronomia.miejscowosc              =   JSON_Astronomy["location"]["name"];
    astronomia.kraj                     =   JSON_Astronomy["location"]["country"];
    astronomia.szerokosc_geograficzna   =   JSON_Astronomy["location"]["lat"];
    astronomia.dlugosc_geograficzna     =   JSON_Astronomy["location"]["lon"];        
    astronomia.czas_epoch               =   JSON_Astronomy["location"]["localtime_epoch"];        
    astronomia.czas_lokalny             =   JSON_Astronomy["location"]["localtime"]; 
    astronomia.wschod_slonca            =   JSON_Astronomy["astronomy"]["astro"]["sunrise"];
    astronomia.zachod_slonca            =   JSON_Astronomy["astronomy"]["astro"]["sunset"];
    astronomia.wschod_ksiezyca          =   JSON_Astronomy["astronomy"]["astro"]["moonrise"];            
    astronomia.zachod_ksiezyca          =   JSON_Astronomy["astronomy"]["astro"]["moonset"];
    astronomia.faza_ksiezyca            =   JSON_Astronomy["astronomy"]["astro"]["moon_phase"]; 
    astronomia.oswietlenie_ksiezyca     =   JSON_Astronomy["astronomy"]["astro"]["moon_illumination"];    

    if(astronomia.miejscowosc == PogodaMiasto)
    {
       Astronomia2Bufor();
       Astronomia2PL();
       
       Serial.printf("\nJSON Astronomy Data :");
       PrintLine(60);
       Serial.printf("\n[DarkNet] [Astronomia] Miejscowość \t\t: ");
       Serial.print(astronomia.miejscowosc);
       Serial.printf("\n[DarkNet] [Astronomia] Kraj \t\t\t: ");
       Serial.print(astronomia.kraj);
       Serial.printf("\n[DarkNet] [Astronomia] Szer.Geograficzna \t: %2.2f",astronomia.szerokosc_geograficzna);
       Serial.printf("\n[DarkNet] [Astronomia] Dług.Geograficzna \t: %2.2f",astronomia.dlugosc_geograficzna);            
       Serial.printf("\n[DarkNet] [Astronomia] Czas Epoch \t\t: %u",astronomia.czas_epoch );            
       Serial.printf("\n[DarkNet] [Astronomia] Czas Lokalny \t\t: ");
       Serial.print( astronomia.czas_lokalny );            
       Serial.printf("\n[DarkNet] [Astronomia] Wschód Słońca \t\t: ");
       Serial.print(astronomia.wschod_slonca );
       Serial.printf("\n[DarkNet] [Astronomia] Zachód Słońca \t\t: ");
       Serial.print(astronomia.zachod_slonca );
       Serial.printf("\n[DarkNet] [Astronomia] Wschód Księżyca \t\t: ");
       Serial.print(astronomia.wschod_ksiezyca );
       Serial.printf("\n[DarkNet] [Astronomia] Zachód Księżyca \t\t: ");
       Serial.print(astronomia.zachod_ksiezyca );
       Serial.printf("\n[DarkNet] [Astronomia] Faza Księżyca \t\t: ");
       Serial.print(astronomia.faza_ksiezyca_pl);
       Serial.printf("\n[DarkNet] [Astronomia] Oświetlenie Księżyca \t: ");
       Serial.print(astronomia.oswietlenie_ksiezyca );            
       PrintLine(60);
       PrintEND();

       F_Astronomia = true;       // dane w porządku, ustaw flagę na TRUE
    }
    else  F_Astronomia = false;   // dane ZŁE, ustaw flagę na false
}
//
// ------------------------------------------------------------------------------------------------------------ //
// ---        A K T U A L I Z A C J A   J A K O Ś C I   P O W I E T R Z A                                   --- //     
// ------------------------------------------------------------------------------------------------------------ //
//

void PowietrzeAktualizuj()
{
    PrintLine(60);
    PrintMSG("ESP32","MyTask", "Aktualizję jakość powietrza z serwera : api.weatherapi.com");    

    // pobierz dane jakości powietrza z serwera dla miasta LUBIN
        
    String path = "http://api.weatherapi.com/v1/current.json?key=" + PogodaToken + "&q=" + PogodaMiasto + "&aqi=yes";
    String jsonBuffer = httpGETRequest(path.c_str());      
        
    JSON_Air = JSON.parse(jsonBuffer);                 

    if (JSON.typeof(JSON_Air) == "undefined")                                                 
    {                                                                                         
        PrintLine(60);
        PrintMSG("DarkNet", "AIR PARSER", "BŁĄD, BRAK DANYCH" );                                                                               
    }        

    powietrze.co     = JSON_Air["current"]["air_quality"]["co"];
    powietrze.o3     = JSON_Air["current"]["air_quality"]["o3"];
    powietrze.no2    = JSON_Air["current"]["air_quality"]["no2"];
    powietrze.so2    = JSON_Air["current"]["air_quality"]["so2"];
    powietrze.pm25   = JSON_Air["current"]["air_quality"]["pm2_5"];
    powietrze.pm10   = JSON_Air["current"]["air_quality"]["pm10"];
    powietrze.Defra  = JSON_Air["current"]["air_quality"]["gb-defra-index"];
    powietrze.EPA    = JSON_Air["current"]["air_quality"]["us-epa-index"];

    switch (powietrze.EPA)
    {
        case  1:  powietrze.opis = "dobra"; break;
        case  2:  powietrze.opis = "umiarkowana"; break;
        case  3:  powietrze.opis = "niezdrowa dla alergików"; break;
        case  4:  powietrze.opis = "niezdrowa"; break;
        case  5:  powietrze.opis = "bardzo niezdrowa"; break;
        case  6:  powietrze.opis = "niebezpieczna"; break;
        default:  powietrze.opis = "Błąd odczytu"; break;
    }

    if (powietrze.co != 0)
    {
        Powietrze2Bufor();
        Day2Bufor();
        Imieniny2Bufor();
        Serial.printf("\nJSON Air Data :");
        PrintLine(60);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Tlenek węgla \t\t: %2.3f [μg/ m3]", powietrze.co);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Dwutlenek azotu \t\t: %2.3f [μg/ m3]", powietrze.no2);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Ozon \t\t\t: %2.3f [μg/m3]", powietrze.o3);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Pyły i aerozole PM2.5 \t: %2.3f [μm]", powietrze.pm25);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Pyły i aerozole PM10 \t: %2.3f [μm]", powietrze.pm10);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Index jakości \t\t: %d DEFRA", powietrze.Defra);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Index jakości \t\t: %d EPA", powietrze.EPA);
        Serial.printf("\n[DarkNet] [Jakość Powietrza] Jakość powietrza \t\t: %s ", powietrze.opis.c_str());
        
        PrintLine(60);
        PrintEND();
   
        F_Powietrze  = true;          
    }
    else F_Powietrze  = false;
}
//
// ------------------------------------------------------------------------------------------------------------ //
// ---        A K T U A L I Z A C J A   P R O G N O Z Ę                                                     --- //     
// ------------------------------------------------------------------------------------------------------------ //
//

void PrognozaAktualizuj()
{
    PrintLine(60);
    PrintMSG("ESP32","MyTask", "Aktualizję prognozę z serwera : api.weatherapi.com");    

    // pobierz dane astronomiczne z serwera dla miasta LUBIN
        
    String path = "http://api.weatherapi.com/v1/forecast.json?key=" + PogodaToken + "&q=" + PogodaMiasto + "&days=1&aqi=no&alerts=no";
    String jsonBuffer = httpGETRequest(path.c_str());    
        
    JSON_Forecast = JSON.parse(jsonBuffer);                 

    if (JSON.typeof(JSON_Forecast) == "undefined")                                                 
    {                                                                                         
        PrintLine(60);
        PrintMSG("DarkNet", "AIR PARSER", "BŁĄD, BRAK DANYCH" );                                                                               
    }        
}
//
// ------------------------------------------------------------------------------------------------------------ //
// --- MyTask ------------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
//

void MyTask()
{
    timeZERO = millis();                                    // zapisz czas 0
    task01s = timeZERO - timeout_task01s;                   // wyznacz nowy
    task01m = timeZERO - timeout_task01m;                   // wyznacz nowy
    task05m = timeZERO - timeout_task05m;                   // wyznacz nowy
    task10m = timeZERO - timeout_task10m;                   // wyznacz nowy
    task15m = timeZERO - timeout_task15m;                   // wyznacz nowy
    task01h = timeZERO - timeout_task01h;                   // wyznacz nowy    

    if (F_MaxDemo) M.ShowTest();

    // --- ZADANIE co 1 sekundę ------------------------------------------------------------------------------- //

    if(task01m >= 1000UL)                      // wykonuj co 1 sekundę
    {   
        if (F_BigClock)                        // jeśli flaga TRUE włącz duży zegar
        {
            M.ShowBigClock();                  // pokaż duży zegar                      
        }
                
        timeout_task01s = timeZERO;  
    }

    // --- ZADANIE co 1 minutę ------------------------------------------------------------------------------- //

    if(task01m >= 60000UL)                                  // wykonuj co 1 minutę
    {
        if (!F_Astronomia)  AstronomiaAktualizuj();         // jeśli BRAK DANYCH wykonuj co minutę
        if (!F_Pogoda)      PogodaAktualizuj();             // jeśli BRAK DANYCH wykonuj co minutę
        if (!F_Powietrze)   PowietrzeAktualizuj();          // jeśli BRAK DANYCH wykonuj co minutę
        //if (!F_Prognoza)    PrognozaAktualizuj();           // jeśli BRAK DANYCH wykonuj co minutę

        // --- ustawianie czasowe flag ---------------------------------------
        if (rtc.getMinute() % 5)        // jeśli minuta nie dzieli się przez 5
        {
           F_BigClock = false;          // wyłącz zegar na matrycy MAX
           F_MaxDemo  = true;
        }
        else                            // jeśli minuta dzieli się przez 5
        {            
            F_BigClock =true;           // włącz zegar na matrycy MAX
            F_MaxDemo = false;
        }
        // -------------------------------------------------------------------
               
        timeout_task01m = timeZERO;  
    }

    // --- ZADANIE co 5 minut -------------------------------------------------------------------------------- //

    if(task05m >= 300000UL)                                 // wykonuj co 5 minut
    {
        if (F_Pogoda)      PogodaAktualizuj();              // jeśli DANE OK co 5 minut
        timeout_task05m = timeZERO;  
    }

    // --- ZADANIE co 10 minut ------------------------------------------------------------------------------- //

    if(task10m >= 600000UL)                                 // wykonuj co 10 minut
    {
        if (F_Astronomia)  AstronomiaAktualizuj();          // jeśli DANE OK co 15 minut
        timeout_task10m = timeZERO;    
    }

    // --- ZADANIE co 15 minut ------------------------------------------------------------------------------- //

    if(task15m >= 900000UL)                                 // wykonuj co 15 minut
    {
        if (F_Powietrze)   PowietrzeAktualizuj();           // jeśli DANE OK co 15 minut        
        //if (F_Prognoza)    PrognozaAktualizuj();            // jeśli BRAK DANYCH wykonuj co minutę
        
        timeout_task15m = timeZERO;                         // resetuj LICZNIK
    }

    // --- ZADANIE co 1 godzinę ------------------------------------------------------------------------------- //

    if(task01h >= 3600000UL)                                  // wykonuj co 1 godzinę      
    {
        if (F_DataUpdate) Data2Bufor();                     // aktualizuj i buduj bufor 
      
        #if SERIAL
            Serial.printf("\n[ESP32] [MyTask] dzis imieniny mają : %c", BImieniny);
        #endif
        
        timeout_task01h = timeZERO;                           // resetuj LICZNIK
    }
  
}    

//
// ------------------------------------------------------------------------------------------------------------ //
// --- TELEGRAM INIT ------------------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void TelegramInit()
{
    myBot.setInsecure(false);
    myBot.setClock("CET-1CEST,M3.5.0,M10.5.0/3");   //Aby zapewnić walidację certyfikatu, WiFiClientSecure wymaga aktualizacji czasu
    myBot.setUpdateTime(1000);                      // Ustaw właściwości bota Telegrama
    myBot.setTelegramToken(token);
    
    Serial.printf("\nESP","Telegram Start","Czy wszystko w porzadku?");    
    myBot.begin() ? Serial.println("OK") : Serial.println("NIE");           // daj odpowiedz na Serial

    isKeyboardActive = false;                                               // ustaw klawiature

    // --- klawiatura REPLY 1 -----------------------------------------------------------------
  
    myReplyKbd.addButton("Pogoda");                                         // dodaj przycisk
    myReplyKbd.addButton("Astro");                                          // Astronomia
    myReplyKbd.addButton("Time");                                           // dodaj przycisk
    myReplyKbd.addButton("Air");                                            // dodaj przycisk    

    myReplyKbd.addRow();                                                    // nowy wiersz

    myReplyKbd.addButton("System");                                         // nowy przycisk
    myReplyKbd.addButton("Help");                                           // nowy przycisk
    myReplyKbd.addButton("Exit");                                           // nowy przycisk    

    myReplyKbd.addRow();                                                    // nowy wiersz

    myReplyKbd.addButton("R Status");                                       // nowy przycisk
    myReplyKbd.addButton("R All ON");                                       // wyświetl dostępne opcje
    myReplyKbd.addButton("R All OFF");                                      // zamknik Panel Dolny wyświetl MENU
    myReplyKbd.enableResize();   
    

    // --- klawiatura REPLY 2 -----------------------------------------------------------------
  
    myReplyKbd2.addButton("Relay 1");                                        // przekaznik 1
    myReplyKbd2.addButton("Relay 2");                                        // przekaznik 2
    myReplyKbd2.addButton("Relay 3");                                        // przekaznik 3
    myReplyKbd2.addButton("Relay 4");                                        // przekaznik 4

    myReplyKbd2.addRow();                                                    // dodaj kolejny wiersz                                           

    myReplyKbd2.addButton("Relay 5");                                        // przekaznik 5
    myReplyKbd2.addButton("Relay 6");                                        // przekaznik 6
    myReplyKbd2.addButton("Relay 7");                                        // przekaznik 7
    myReplyKbd2.addButton("Relay 8");                                        // przekaznik 8 

    myReplyKbd2.addRow();                                                    // dodaj kolejny wiersz                                           

    myReplyKbd2.addButton("R Status");                                       // POMOC
    myReplyKbd2.addButton("Help");                                           // EXIT

    myReplyKbd2.enableResize();                                              // wlacz auto-rozmiar

    // --- klawiatura INLINE -----------------------------------------------------------------

    myInlineKbd.addButton("R1", RELAY1_CALLBACK, KeyboardButtonQuery);    // przycisk -> przekaźnik nr. 1
    myInlineKbd.addButton("R2", RELAY2_CALLBACK, KeyboardButtonQuery);    // przycisk -> przekaźnik nr. 2
    myInlineKbd.addRow();    
    myInlineKbd.addButton("R3", RELAY3_CALLBACK, KeyboardButtonQuery);    // przycisk -> przekaźnik nr. 3    
    myInlineKbd.addButton("R4", RELAY4_CALLBACK, KeyboardButtonQuery);    // przycisk -> przekaźnik nr. 4 
    
    // --- klawiatura INLINE -----------------------------------------------------------------

    myInlineKbd2.addButton("R5", RELAY5_CALLBACK, KeyboardButtonQuery);   // przycisk -> przekaźnik nr. 5
    myInlineKbd2.addButton("R6", RELAY6_CALLBACK, KeyboardButtonQuery);   // przycisk -> przekaźnik nr. 6
    myInlineKbd2.addRow();    
    myInlineKbd2.addButton("R7", RELAY7_CALLBACK, KeyboardButtonQuery);   // przycisk -> przekaźnik nr. 7    
    myInlineKbd2.addButton("R8", RELAY8_CALLBACK, KeyboardButtonQuery);   // przycisk -> przekaźnik nr. 8  
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- W i F i   R E C O N E C T ------------------------------------------------------------------------------ //
// ------------------------------------------------------------------------------------------------------------ //
//

void WiFiEvent(WiFiEvent_t event) 
{
    switch (event) 
    {
        case SYSTEM_EVENT_STA_GOT_IP:         Serial.printf("\n[ESP] [WiFiEvent] [Polaczono z Wi-Fi]");  break;

        case SYSTEM_EVENT_STA_DISCONNECTED:   Serial.printf("\n[ESP] [WiFiEvent] [Utracono połączenia z Wi-Fi]");
                                              WiFi.setAutoReconnect(true);
                                              myBot.reset();
                                              break;
        default:                              break;
  }
}

//
// ------------------------------------------------------------------------------------------------------------ // 
// --- Telegram --- Pogoda do String  ------------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ // 
//

String TelegramPogoda()
{
    String bufor;                                   // bufor tekstowy dla danych pogodowych

        bufor   =   "Miejscowosc : "  + pogoda.miejscowosc + "\n";
        bufor  +=   "aktualizacja : " + pogoda.ostatnia_aktualizacja + "\n";
        bufor  +=   "Temperatura = " + String( pogoda.temperatura_C ) + " st.C\n";
        bufor  +=   "Wilgotnosc = " + String( pogoda.wilgotnosc ) + " %\n";
        bufor  +=   "Cisnienie =  " + String( pogoda.cisnienie ) + " mPa\n";
        bufor  +=   "Opady deszczu = " + String( pogoda.opady ) + " mm\n";
        bufor  +=   "Predkosc wiatru = " + String(pogoda.predkosc_wiatru_kph ) + " km/h\n";
        bufor  +=   "Kierunek wiatru = " + pogoda.kierunek_wiatru_kompas + " \n";
        bufor  +=   "Index UV = " + String( pogoda.index_uv ) + "\n";
        bufor  +=   "Opis skrocony EN: " + pogoda.kondycja + "\n";        
        bufor  +=   "Opis skrocony PL: " + pogoda.kondycja_pl + "\n"; 

        #if SERIAL
          Serial.printf("\n[ESP32] Aktualna pogoda");
          Serial.printf("\n..........................\n");
          Serial.print(bufor);
      #endif

    return bufor;                                   // zwróć bufor i wyślij na smarphona
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Data i Czas do String  -------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ // 
//

String TelegramNTP()
{
    String  bufor;

      bufor  = "Data: " + zegar.SformatowanaData + "\n";
      bufor += "Czas: " + zegar.SformatowanyCzas + "\n";  

      #if SERIAL
          Serial.printf("\n[ESP32] Wysłano na smartphona: \n");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Astronomia do String  --------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramASTRO()
{
    String  bufor;

      bufor   =  "Miejscowosc : "   + astronomia.miejscowosc + "\n";
      bufor  +=  "Wschod Slonca = " + astronomia.wschod_slonca + "\n";          
      bufor  +=  "Zachod Slonca = " + astronomia.zachod_slonca + "\n";          
      bufor  +=  "Wschod Ksiezyca = " + astronomia.wschod_ksiezyca + "\n";
      bufor  +=  "Zachod Ksiezyca = " + astronomia.zachod_ksiezyca + "\n";
      bufor  +=  "Faza Ksiezyca EN = " + astronomia.faza_ksiezyca + "\n";
      bufor  +=  "Faza Ksiezyca PL = " + astronomia.faza_ksiezyca_pl + "\n";
      bufor  +=  "Oświetlenie Ksiezyca = " + astronomia.oswietlenie_ksiezyca + "\n";

      #if SERIAL
          Serial.printf("\n[ESP32] Astronomia");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Powietrze do String  ---------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramAIR()
{
    String  bufor;

      bufor   =  "Miejscowosc : "   + astronomia.miejscowosc + "\n";
      bufor  +=  "Tlenek węgla = " + String(powietrze.co) + " μg/m3\n";          
      bufor  +=  "Ozon = " + String(powietrze.o3) + " μg/m3\n";          
      bufor  +=  "Dwutlenek azotu = " + String(powietrze.no2) + " μg/m3\n";
      bufor  +=  "Dwutlenek siarki = " + String(powietrze.so2) + " μg/m3\n";
      bufor  +=  "Aerozole PM2.5 = " + String(powietrze.pm25) + " μm\n";
      bufor  +=  "Aerozole PM10 = " + String(powietrze.pm10) + " μm\n";
      bufor  +=  "Index Jakości = " + String(powietrze.Defra) + " DEFRA\n";
      bufor  +=  "Jakość powietrza = " + powietrze.opis;

      #if SERIAL
          Serial.printf("\n[ESP32] Jakość powietrza");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- System do String  ------------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramSYSTEM()
{
    String  bufor;

      bufor   =    "CPU Freq : " + String(ESP.getCpuFreqMHz()) + " MHz\n";
      bufor   +=   "Free Heap Size : " + String(ESP.getFreeHeap()/1000) + " kB\n";      
      bufor   +=   "Min Free Heap : " + String(ESP.getMinFreeHeap()/1000) + " kB\n";      
      bufor   +=   "Max Alloc Heap : " + String(ESP.getMaxAllocHeap()/1000) + " kB\n";      
      bufor   +=   "Heap Size : " + String(ESP.getHeapSize()/1000) + " kB\n";  

       #if SERIAL
          Serial.printf("\n[ESP32] Stan systemu");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Relay Switch do String  ------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramSwitchRelay(byte relayNR)
{
    String bufor;

        if (przekaznik[relayNR].relaySTATUS)                                // jeśli przekaźnik włączony to OFF
        {
            przekaznik[relayNR].relaySTATUS = false;
            przekaznik[relayNR].relayOPIS   = "OFF";
            bufor  = "Przekaznik [" + String(relayNR + 1) + "] został wyłączony !!!";  
            RelayInfo = "Przeka\251nik nr. " + String(relayNR+1) + " zosta\247 wy\247\252czony.";          
        }
        else                                                                // jeśli przekaźnik wyłączony to ON
        {
            przekaznik[relayNR].relaySTATUS = true;
            przekaznik[relayNR].relayOPIS   = "ON";  
            bufor  = "Przekaznik [" + String(relayNR + 1) + "] został wyłączony !!!";              
            RelayInfo = "Przeka\251nik nr. " + String(relayNR+1) + " zosta\247 w\247\252czony.";          
        }

        bufor += "\nPrzekaznik [" + String(relayNR +1) + "] : " + przekaznik[relayNR].relayOPIS + " \n";  

        F_Przekaznik = true;                                            // zarejestruj zdarzenie do flagi
        F_BigClock = false;                                             // wyłącz zegar
        F_MaxDemo  = true;                                              // włącz Demo

        #if SERIAL
            Serial.println();
            PrintLine(40);
            Serial.print(bufor);
            PrintLine(40);
        #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Relay All ON do String  ------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramRELAY_ALL_ON()
{
    String bufor;

      for (byte r = 0; r < 8; r ++)                       // przejedź wszystkie przekaznini
      {
          przekaznik[r].relaySTATUS = true;               // status przekaźnika : true (włączony)
          przekaznik[r].relayOPIS   = "ON";               // opis przekaźnika   : ON (włączony)
      }

      bufor  =  "[TELEGRAM] Wszystkie przekaźniki zostały włączone\n";
      bufor  += TelegramRELAY();     

      RelayInfo = "Wszystkie przeka\251niki zosta\247y w\247\252czone.";

      #if SERIAL
          Serial.printf("\n[ESP32] Stan przekaźników");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

      F_Przekaznik = true;                                            // zarejestruj zdarzenie do flagi
      F_BigClock = false;                                             // wyłącz zegar
      F_MaxDemo  = true;                                              // włącz Demo
      

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Relay All OFF do String  ------------------------------------------------------------------ // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramRELAY_ALL_OFF()
{
    String bufor;

      for (byte r = 0; r < 8; r ++)                       // przejedź wszystkie przekaznini
      {
          przekaznik[r].relaySTATUS = false;              // status przekaźnika : true (włączony)
          przekaznik[r].relayOPIS   = "OFF";              // opis przekaźnika   : ON (włączony)
      }

      bufor  =  "[TELEGRAM] Wszystkie przekaźniki zostały wyłączone\n";
      bufor  += TelegramRELAY();  
      
      RelayInfo = "Wszystkie przeka\251niki zosta\247y wy\247\252czone.";   

      #if SERIAL
          Serial.printf("\n[ESP32] Stan przekaźników");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

      F_Przekaznik = true;                                            // zarejestruj zdarzenie do flagi
      F_BigClock = false;                                             // wyłącz zegar
      F_MaxDemo  = true;                                              // włącz Demo
      
    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- RELAY STATUS do String  ------------------------------------------------------------------- // 
// ------------------------------------------------------------------------------------------------------------ //  
//

String TelegramRELAY()
{
    String  bufor;     

      bufor   =    "Przekaznik [1] : " + przekaznik[0].relayOPIS + " \n";      
      bufor   +=   "Przekaznik [2] : " + przekaznik[1].relayOPIS + " \n";
      bufor   +=   "Przekaznik [3] : " + przekaznik[2].relayOPIS + " \n";
      bufor   +=   "Przekaznik [4] : " + przekaznik[3].relayOPIS + " \n";
      bufor   +=   "Przekaznik [5] : " + przekaznik[4].relayOPIS + " \n";
      bufor   +=   "Przekaznik [6] : " + przekaznik[5].relayOPIS + " \n";
      bufor   +=   "Przekaznik [7] : " + przekaznik[6].relayOPIS + " \n";
      bufor   +=   "Przekaznik [8] : " + przekaznik[7].relayOPIS + " \n";

      #if SERIAL
          Serial.printf("\n[ESP32] Stan przekaźników");
          PrintLine(40);
          Serial.print(bufor);
          PrintLine(40);
      #endif

    return bufor;
}

//
// ------------------------------------------------------------------------------------------------------------ //  
// --- Telegram --- Główna Funckja do obsługi Smartphona ------------------------------------------------------ // 
// ------------------------------------------------------------------------------------------------------------ //  
//

void Telegram()
{
    TBMessage msg;

    if (myBot.getNewMessage(msg))  // jesli nadeszła wiadomość
    {
        String tgReply;
        MessageType msgType = msg.messageType;
        
      switch (msgType) 
      {
          case MessageText :            // odebrano wiadomosc tekstową
        
                            tgReply = msg.text;

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 1"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 1");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(0).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 2"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 2");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(1).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 3"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 3");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(2).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 4"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 4");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(3).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 5"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 5");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(4).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 6"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 6");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(5).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 7"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 7");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(6).c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
                            
                            if(tgReply.equalsIgnoreCase("Relay 8"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Przekaźnik nr. 8");
                                #endif

                                myBot.sendMessage(msg, TelegramSwitchRelay(7).c_str());   // wyślij pogodę
                            }
                            
                            // --- jeśli w apce Telegram wciśnięto przycisk "Pogoda" ----------------------- //
                            
                            if(tgReply.equalsIgnoreCase("Pogoda"))                              
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
                                #endif

                                myBot.sendMessage(msg, TelegramPogoda().c_str());   // wyślij pogodę
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk "Data i Czas" ------------------ //

                            else if(tgReply.equalsIgnoreCase("Time"))
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij datę i czas");
                                #endif

                                myBot.sendMessage(msg, TelegramNTP().c_str());      // wyślij datę i czas
                            }
                        
                            // --- jeśli w apce Telegram wcisnieto przycisk "Wolny RAM --------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("System"))
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyślij dane o systemie");
                                #endif
                                
                                myBot.sendMessage(msg, TelegramSYSTEM().c_str());
                            }
                            
                            // --- jeśli w apce Telegram wcisnieto przycisk Astronomia --------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("Astro"))              // wyślij astronomię
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij astronomie");
                                #endif

                                myBot.sendMessage(msg, TelegramASTRO().c_str());
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk Air ---------------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("Air"))                // wyślij powietrze
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij powietrze");
                                #endif

                                myBot.sendMessage(msg, TelegramAIR().c_str());
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("R Status"))                // stan przekaźników
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
                                #endif

                                myBot.sendMessage(msg, TelegramRELAY().c_str());
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("R All ON"))                // wszystkie włącz
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
                                #endif

                                myBot.sendMessage(msg, TelegramRELAY_ALL_ON().c_str());
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //                            
                            
                            else if(tgReply.equalsIgnoreCase("R All OFF"))                // wszystkie wyłącz
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
                                #endif

                                myBot.sendMessage(msg, TelegramRELAY_ALL_OFF().c_str());
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk EXIT ---------------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("Exit"))                // wyślij powietrze
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Zamknij Panel Dolny");
                                #endif
                                
                                isKeyboardActive = false;
                                myBot.sendMessage(msg, "/przekazniki\n/system\n/relay1\n/relay2\n");
                                myBot.removeReplyKeyboard(msg, "Ukryto klawiature");                                
                                
                            }

                            // --- jeśli w apce Telegram wcisnieto przycisk EXIT ---------------------------- //
                            
                            else if(tgReply.equalsIgnoreCase("Help"))                // wyślij powietrze
                            {
                                #if SERIAL
                                    Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Help");
                                #endif
                                
                                myBot.sendMessage(msg, "/przekazniki\n/system\n/relay1\n/relay2\n");                                
                            }

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

                            else if (tgReply.equalsIgnoreCase("/system"))       // pokaż panel systemowy (DOLNY)
                            {
                                myBot.sendMessage(msg, "PANEL SYSTEMOWY", myReplyKbd);
                                isKeyboardActive = true;
                            }

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

                            else if (tgReply.equalsIgnoreCase("/przekazniki"))  // pokaż panel przekaźników (DOLNY)
                            {
                                myBot.sendMessage(msg, "PANEL PRZEKAZNIKOW", myReplyKbd2);
                                isKeyboardActive = true;
                            }

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

                            else if (tgReply.equalsIgnoreCase("/relay1")) 
                            {
                                myBot.sendMessage(msg, "To jest PANEL REYAL 1", myInlineKbd);          
                            }

                            // ----------------------------------------------------------------------------- //
                            
                            else if (tgReply.equalsIgnoreCase("/relay2")) 
                            {
                                myBot.sendMessage(msg, "To jest PANEL REYAL 2", myInlineKbd2);          
                            }

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

                            if (isKeyboardActive) 
                            {
                                if (tgReply.equalsIgnoreCase("EXIT")) 
                                {
                                    myBot.removeReplyKeyboard(msg, "Ukryto klawiature");
                                    isKeyboardActive = false;
                                } 
                                else 
                                {
                                    myBot.sendMessage(msg, msg.text);
                                }
                            } 

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

                            else if(tgReply.equalsIgnoreCase("/start")) 
                            {          
                                myBot.sendMessage(msg, "/przekazniki\n/system\n/relay1\n/relay2\n");
                            }
                            break;

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

          case MessageQuery:      // wiadomosc dla CallBacka
        
                            tgReply = msg.callbackQueryData;
                            Serial.print("\nCallback, odebrano wiadomosc: ");
                            Serial.println(tgReply);
        
                            if (tgReply.equalsIgnoreCase(RELAY1_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 1");
                                myBot.endQuery(msg, "Przekaznik 1", true);
                            } 
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY2_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 2");
                                myBot.endQuery(msg, "Przekaznik 2", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY3_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 3");
                                myBot.endQuery(msg, "Przekaznik 3", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY4_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 4");
                                myBot.endQuery(msg, "Przekaznik 4", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY5_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 5");
                                myBot.endQuery(msg, "Przekaznik 5", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY6_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 6");
                                myBot.endQuery(msg, "Przekaznik 6", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY7_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 7");
                                myBot.endQuery(msg, "Przekaznik 7", true);
                            }
                            else 
                            if (tgReply.equalsIgnoreCase(RELAY8_CALLBACK)) 
                            {
                                Serial.println("\nPrzekaznik 8");
                                myBot.endQuery(msg, "Przekaznik 8", true);
                            }
                            break;

          case MessageLocation:   
                            char bufL[200];
                            snprintf(bufL, sizeof(bufL), "Dlugosc geograficzna: %f\nSzerokosc geograficzna: %f\n", msg.location.longitude, msg.location.latitude) ;
                            myBot.sendMessage(msg, bufL);
                            Serial.println(bufL);
                            break;

          case MessageContact:
                            char bufC[50];
                            snprintf(bufC, sizeof(bufC), "Otrzymano kontakt: %s - %s\n", msg.contact.firstName, msg.contact.phoneNumber ) ;                            
                            myBot.sendMessage(msg, bufC);
                            Serial.println(bufC);
                            break;
          default:          break;
    }
  }
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- S E T U P ---------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
//
void setup() 
{
   #if SERIAL
        Serial.begin(SPEED);                // ustaw prędkość terminala SERIAL
    #endif
      
    WiFi.onEvent(WiFiEvent);                // funkcja zdarzenie Event
    WiFi.setAutoConnect(true);              // auto-reconnect
    WiFi.begin(SSID, PASSWORD);             // WiFi start
    WiFi.mode(WIFI_STA);                    // tryb pracy WiFi
    
    while ( WiFi.status() != WL_CONNECTED )                                                     
    {                                                                                           
        Serial.print(".");
        delay(50);                                                                     
    }             
    
    timeClient.begin();                           // włącz klienta NTP (pobieranie czasu z internetu)

    // --- CPU_Core_0 ----------------------------------------------------------------------------------
                                                                                                        
    xTaskCreatePinnedToCore(Core0_Task1, "CPU_Core_0", 8000, NULL, 1, &CPU_Core_0, 0);                
    vTaskDelay(500 / portTICK_PERIOD_MS);                                                               
                                                                                                        
    xTaskCreatePinnedToCore(Core0_Task2, "CPU_Core_0", 4000, NULL, 1, &CPU_Core_0, 0);                
    vTaskDelay(500 / portTICK_PERIOD_MS);  
        
    
    // --- CPU_Core_1 ---------------------------------------------------------------------------------- 

    xTaskCreatePinnedToCore(Core1_Task1, "CPU_Core_1", 1000, NULL, 1, &CPU_Core_1, 1);                 
    vTaskDelay(500 / portTICK_PERIOD_MS);      
                                                                                                         
    xTaskCreatePinnedToCore(Core1_Task2, "CPU_Core_1", 1000, NULL, 1, &CPU_Core_1, 1);                 
    vTaskDelay(500 / portTICK_PERIOD_MS);

    // --- MATRYCA ------------------------------------------------------------------------------------- 

    P.begin();                                // włącz matrycę 
    P.setIntensity(1);                        // ustaw jasność wyświetlacza
    M.Setup();                                // skonfiguruj matrycę   
    TelegramInit();                           // start Telegram

    // resetuj przekaźniki (aczkowilek domyślnie do tego ESP nie będą podłączone)
    // dane będą zczytywany z innego ESP który będzie je obsługiwał 
    // tu tylko sterowanie na tym ESP i wyświetlanie będzie 

    for(byte i = 0; i < 8; i ++ )
    {
        przekaznik[i].relayID = i;
        przekaznik[i].relaySTATUS = false;
        przekaznik[i].relayOPIS = "OFF";
    }

     dht.setup(DHTpin, DHTesp::DHT11);
}

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

void loop() 
{
    MyTask();  
    Telegram();
}

//
// ------------------------------------------------------------------------------------------------------------ //
// --- E N D  ------------------------------------------------------------------------------------------------- //
// ------------------------------------------------------------------------------------------------------------ //
//
//
//
//
//
//
//
// ----------------------------------------------------------------------------------------------------------- //
// --- T O O L S --------------------------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------- //
// --- drukuje poziomą linię o zadanej długości -------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------- //
//

void PrintLine(byte lenght)
{
    Serial.printf("\n");   
    for(byte start = 0; start < lenght; start ++ ) Serial.write("-");
}

//
// ----------------------------------------------------------------------------------------------------------- //
// --- pokazuje wiadomosc (na wejsciu 3 x char) -------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------- //
//

void PrintMSG(const char * wiadomosc_1, const char * wiadomosc_2, const char * wiadomosc_3)     
{                                                                                                              
    Serial.printf("\n[%s] [%s] %s", wiadomosc_1, wiadomosc_2, wiadomosc_3);                                    
}

//
// ----------------------------------------------------------------------------------------------------------- //
// --- drukuje znak końca linii  ----------------------------------------------------------------------------- //
// ----------------------------------------------------------------------------------------------------------- //
//

void PrintEND()     
{                                                                                                              
    Serial.printf("\n");
} 

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