API tools faq
paste
PowerTGS440

Weather ROOT Station v0.06

PowerTGS440
Apr 22nd, 2021
392
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 76.44 KB | None | 0 0
raw download clone embed print report
  1. // ------------------------------------------------------------------------------------------------------------ //
  2. // ---    StationROOT      Wi-FI   &   B T     B Y   T O M A S Z   M A J C H E R                            --- //
  3. // ------------------------------------------------------------------------------------------------------------ //
  4. //
  5. //  by Tomasz Majcher (TLG) Trans Line Group, Lubin POLSKA
  6. //  NIP:    692-201-09-78
  7. //  TEL:    667-08-21-21
  8. //  mail:   [email protected]
  9. //
  10. //  Trans Line Group Tomasz Majcher
  11. //  * usługi transportowe (wywrotki, silosy) -
  12. //  * sprzedaw kruszyw (piasek, żwir, pospółka, grysy, tłuczeń, mieszanki, żużel, kryszywa)
  13. //  * automatyka przemysłowa i domowa
  14. //
  15. // ------------------------------------------------------------------------------------------------------------ //
  16. // --- HISTORIA WERSJI ---------------------------------------------------------------------------------------- //
  17. // ------------------------------------------------------------------------------------------------------------ //
  18. //
  19. //  StationROOT v0.06   (21.04.2021)  - zbudowane na bazie DarnNET MESH Server (v0.06)
  20. //
  21. // ------------------------------------------------------------------------------------------------------------ //
  22. // --- DOŁĄCZONE NAGŁÓWKI BIBLIOTEK --------------------------------------------------------------------------- //
  23. // ------------------------------------------------------------------------------------------------------------ //
  24.  
  25. #include <AsyncTelegram.h>
  26. #include <Arduino.h>
  27. #include <WiFiClient.h>
  28. #include <NTPClient.h>                                           // NTP klient (czas)
  29. #include <TimeLib.h>                                             // parser
  30. #include <WiFiUdp.h>                                             // UDP Wi-Fi
  31. #include <HTTPClient.h>                                                            
  32. #include <Arduino_JSON.h>
  33. #include <ESP32Time.h>                                           // zegar RTC ESP32Time
  34. #include <MD_Parola.h>                                           // MATRYCA
  35. #include <MD_MAX72xx.h>                                          // MATRYCA
  36. #include "SoftwareSerial.h"                                      // RX TX - jeszcze nie zaimplementowano
  37. #include "global.h"                                              // struktury ze zmiennymi
  38. #include "max.h"                                                 // wyświetlacz PAROLA
  39.  
  40. // ------------------------------------------------------------------------------------------------------------ //
  41. // --- D E F I N I C J E -------------------------------------------------------------------------------------- //
  42. // ------------------------------------------------------------------------------------------------------------ //
  43.  
  44. #define   SSID        "TWOJA_SIEC_WIFI"                    // nazwa sieci Wi-Fi (router podłączony do sieci)
  45. #define   PASSWORD    "TWOJE_HASLO_WIFI"                   // hasło sieci Wi-Fi (router podłączony do sieci)
  46.  
  47. #define   SERIAL              1                           // włącz terminal SERIAL.MONITOR
  48. #define   SPEED               115200                      // prędkość terminala SERIAL
  49. #define   THREAD_INFO         0
  50. #define   CORE0_TASK1         1
  51.  
  52. #define RxTxSpeed    19200          // prędkość transmisji RxTx
  53.  
  54. // USTAWIENIA DLA MAX_LED x8 ------------------------------------------------------------------ //
  55.  
  56. #define HARDWARE_TYPE MD_MAX72XX::FC16_HW          
  57. #define MAX_DEVICES 8        
  58.  
  59. // UWAGA !!! ESP32 ma Hardware SPI na następujących pinach ------------------------------------ //
  60.  
  61. #define CLK_PIN   13      // SPI ESP32 !!! VSPI SCK (P18 na płycie)
  62. #define DATA_PIN  11      // SPI ESP32 !!! VSPI MOSI (P23 na płycie)
  63. #define CS_PIN    15      // SPI ESP32 !!! VSPI CS (P15 na płycie)
  64.  
  65. #define RELAY1_CALLBACK  "Relay1"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST1”
  66. #define RELAY2_CALLBACK  "Relay2"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST2”
  67. #define RELAY3_CALLBACK  "Relay3"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST2”
  68. #define RELAY4_CALLBACK  "Relay4"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST2”
  69. #define RELAY5_CALLBACK  "Relay5"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST1”
  70. #define RELAY6_CALLBACK  "Relay6"  // dane wywołania zwrotnego wysyłane po naciśnięciu przycisku „TEST2”
  71.  
  72. // ------------------------------------------------------------------------------------------------------------ //
  73. // --- P R O T O T Y P Y -------------------------------------------------------------------------------------- //
  74. // ------------------------------------------------------------------------------------------------------------ //
  75.  
  76. void Core0_Task1( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 0 CPU        
  77. void Core0_Task2( void * pvParameters );                            // funkcja Task2 dla rdzenia nr. 0 CPU        
  78.  
  79. void Core1_Task1( void * pvParameters );                            // funkcja Task1 dla rdzenia nr. 1 CPU        
  80. void Core1_Task2( void * pvParameters );                            // funkcja Tasl2 dla rdzenia nr. 1 CPU    
  81.                                    
  82.  
  83. // ------------------------------------------------------------------------------------------------------------ //
  84. // --- O B I E K T Y ------------------------------------------------------------------------------------------ //
  85. // ------------------------------------------------------------------------------------------------------------ //
  86.  
  87. WiFiUDP ntpUDP;                                                     // dla NTP (pobieranie czasu z internetu)
  88. NTPClient timeClient(ntpUDP, "pool.ntp.org", 7200);                 // dla NTP (pobieranie czasu z internetu)
  89.                                                              
  90. WiFiClient wifiClient;                                              // obiekt WiFi
  91. HTTPClient http;                                                    // obiekt HTTP
  92.  
  93. ESP32Time rtc;                                                      // zegar RTC
  94.  
  95. JSONVar JSON_Astronomy;                                             // obiekt Astronomia
  96. JSONVar JSON_Weather;                                               // obiekt Pogoda    
  97. JSONVar JSON_Forecast;                                              // obiekt Forecast
  98. JSONVar JSON_Air;                                                   // obiekt Powietrze
  99. JSONVar JSON_Mesh;                                                  // obiekt Mesh Incoming
  100.  
  101. TaskHandle_t CPU_Core_0;                                            // rdzeń nr. 0 CPU - ESP32
  102. TaskHandle_t CPU_Core_1;                                            // rdzeń nr. 1 CPU - ESP32
  103.  
  104. AsyncTelegram myBot;                                                // obiekt Telegram
  105. ReplyKeyboard myReplyKbd;                                           // obiekt klawiatury Reply
  106. ReplyKeyboard myReplyKbd2;                                          // obiekt klawiatury Reply
  107. InlineKeyboard myInlineKbd;                                         // obiekt klawiatury Inline
  108. InlineKeyboard myInlineKbd2;                                        // obiekt klawiatury Inline
  109.  
  110.  
  111. MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);        // obiekt MD_Parola
  112. MAX       M(P);                                                     // pseudo-obiekt MD_Parola
  113.  
  114. SoftwareSerial wireS(10,11);                                        // komunikacja Serial
  115.  
  116. // ------------------------------------------------------------------------------------------------------------ //
  117. // --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
  118. // ------------------------------------------------------------------------------------------------------------ //
  119. // --- F L A G I ---------------------------------------------------------------------------------------------- //
  120. // ------------------------------------------------------------------------------------------------------------ //
  121.  
  122. bool F_Astronomia         = false;          // flaga  : czy aktualizacja astronomii
  123. bool F_Pogoda             = false;          // flaga  : czy aktualizacja pogody
  124. bool F_Prognoza           = false;          // flaga  : czy aktualizacja prognozy
  125. bool F_Powietrze          = false;          // flaga  : czy aktualizacja powietrza
  126. bool F_Zegar              = false;          // flaga  : Czy aktualizacja zegara
  127. bool F_BigClock           = true;           // flaga  : WYŚWIETL ZEGAR MAXLED (true = pokaz, false = nie pokazuj)
  128. bool isKeyboardActive;                      // zapisz, jeśli wyświetlana jest klawiatura odpowiedzi
  129.  
  130.  
  131.  
  132. // ------------------------------------------------------------------------------------------------------------ //
  133. // --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
  134. // ------------------------------------------------------------------------------------------------------------ //
  135. // --- M I L L I S -------------------------------------------------------------------------------------------- //
  136. // ------------------------------------------------------------------------------------------------------------ //
  137.  
  138. unsigned long timeZERO = 0;  
  139. unsigned long task01m = 0;
  140. unsigned long task01s = 0;
  141. unsigned long task05m = 0;
  142. unsigned long task10m = 0;
  143. unsigned long task15m = 0;
  144. unsigned long task01h = 0;
  145. unsigned long timeout_task01m = 0;
  146. unsigned long timeout_task01s = 0;
  147. unsigned long timeout_task05m = 0;
  148. unsigned long timeout_task10m = 0;
  149. unsigned long timeout_task15m = 0;
  150. unsigned long timeout_task01h = 0;
  151.  
  152. // ------------------------------------------------------------------------------------------------------------ //
  153. // --- Z M I E N N E   G L O B A L N E ------------------------------------------------------------------------ //
  154. // ------------------------------------------------------------------------------------------------------------ //
  155. // --- T E L E G R A M ---------------------------------------------------------------------------------------- //
  156. // ------------------------------------------------------------------------------------------------------------ //
  157.  
  158. const char *token =  "XXXXX_TWOJ_TOKEN_TELEGRAM_XXXXX";       // token BOT
  159. const char *chatid = "XXXXX_TWOJ_CHAT_ID_XXXXX";              // chat ID BOT (nie korzystany)
  160.  
  161. //
  162. // ------------------------------------------------------------------------------------------------------------ //
  163. // ---                              M U L T I - C O R E   T A S K                                           --- //
  164. // ------------------------------------------------------------------------------------------------------------ //
  165. //
  166. //    void Core0_Task1( void * pvParameters )       --->  aktualizacja czasu i daty  
  167. //    void Core0_Task2( void * pvParameters )       --->  pusta
  168. //    void Core1_Task1( void * pvParameters )       --->  pusta    
  169. //    void Core1_Task2( void * pvParameters )       --->
  170. //
  171. // ------------------------------------------------------------------------------------------------------------ //
  172. // ---        CORE0 TASK1     POBIERANIE CZASU i DATY Z SERWERA NTP i AKTUALIZACJA ZEGARA ESP32 RTC         --- //
  173. // ------------------------------------------------------------------------------------------------------------ //
  174. //
  175. void Core0_Task1( void * pvParameters )                          
  176. {                                                                
  177.     for(;;)                                                        
  178.     {                                                            
  179.         #if THREAD_INFO
  180.             PrintLine(80);
  181.             PrintMSG("ESP32","CORE", "Wykonuje watek TASK1 na CORE0");
  182.         #endif      
  183.  
  184.         timeClient.update();
  185.        
  186.         unsigned long epochTime = timeClient.getEpochTime();                                              
  187.         struct tm *ptm = gmtime ((time_t *)&epochTime);      
  188.                                                                                    
  189.         zegar.Godzina           =   timeClient.getHours();                  
  190.         zegar.Minuta            =   timeClient.getMinutes();                
  191.         zegar.Sekunda           =   timeClient.getSeconds();                
  192.         zegar.SformatowanyCzas  =   timeClient.getFormattedTime();                                
  193.         zegar.DzienTygodnia     =   timeClient.getDay();                                          
  194.         zegar.DzienMiesiaca     =   ptm->tm_mday;                                                
  195.         zegar.Miesiac           =   ptm->tm_mon+1;                                                
  196.         zegar.Rok               =   ptm->tm_year+1900;
  197.  
  198.         if (zegar.Godzina < 10)
  199.         {
  200.             zegar.SformatowanyCzasHM = "0" + String (zegar.Godzina) + ":";            
  201.         }
  202.         else zegar.SformatowanyCzasHM = String(zegar.Godzina) + ":";            
  203.  
  204.         if (zegar.Minuta < 10)
  205.         {
  206.             zegar.SformatowanyCzasHM += "0" + String (zegar.Minuta) + ":";            
  207.         }
  208.         else zegar.SformatowanyCzasHM += String(zegar.Minuta);            
  209.        
  210.  
  211.         if (zegar.Rok !=1970)
  212.         {
  213.             if(zegar.DzienMiesiaca < 10)
  214.             {
  215.                 zegar.SformatowanaData   = "0" + String(zegar.DzienMiesiaca) + ".";
  216.                 zegar.SformatowanaDataPL = "0" + String(zegar.DzienMiesiaca) + " ";
  217.             }
  218.             else  
  219.             {
  220.                 zegar.SformatowanaData   = String(zegar.DzienMiesiaca) + ".";
  221.                 zegar.SformatowanaDataPL = String(zegar.DzienMiesiaca) + " ";
  222.             }
  223.  
  224.             if(zegar.Miesiac < 10)
  225.             {
  226.                 zegar.SformatowanaData += "0" + String(zegar.Miesiac) + ".";
  227.                 zegar.SformatowanaDataPL += String(MONTH[zegar.Miesiac]) + " ";
  228.             }
  229.             else  
  230.             {
  231.                 zegar.SformatowanaData += String(zegar.Miesiac) + ".";
  232.                 zegar.SformatowanaDataPL += String(MONTH[zegar.Miesiac]) + " ";
  233.             }
  234.  
  235.             zegar.SformatowanaData  += String(zegar.Rok);
  236.             zegar.SformatowanaDataPL += String(zegar.Rok);
  237.  
  238.             // --- zapisz aktualny czas pobrany z serwera NTP do zegara RTC --------------------------------------- //
  239.            
  240.             rtc.setTime(zegar.Sekunda, zegar.Minuta, zegar.Godzina-1, zegar.DzienMiesiaca, zegar.Miesiac, zegar.Rok);
  241.  
  242.             // --- zbuduj obiekty typu (JSON STRING) do odesłania na żadanie do innego ESP w sieci MESH
  243.  
  244.                    
  245.             #if CORE0_TASK1            
  246.                 PrintLine(60);
  247.                 PrintMSG("CORE0_TASK1", "NTP Time", zegar.SformatowanyCzas.c_str());          
  248.                 PrintMSG("CORE0_TASK1", "NTP Date", zegar.SformatowanaData.c_str());
  249.                 Serial.printf("\n[CORE0_TASK1] [RTC Time] ");  
  250.                 Serial.print(rtc.getTime());
  251.                 Serial.printf("\n[CORE0_TASK1] [RTC Date] ");  
  252.                 Serial.print(rtc.getDate());
  253.                 Serial.printf("\n[CORE0_TASK1] [FREE RAM] ");
  254.                 Serial.print(ESP.getFreeHeap());
  255.                 PrintLine(60);
  256.                 PrintEND();      
  257.             #endif
  258.                
  259.             F_Zegar = true;   // dane OK, flaga na true
  260.         }
  261.         else F_Zegar = false; // dane złe, flaga na false
  262.        
  263.         vTaskDelay(60000 / portTICK_PERIOD_MS);                 // wykonuj 1 minutę
  264.     }                                                            
  265. }      
  266. //
  267. // ------------------------------------------------------------------------------------------------------------ //
  268. // ---        CORE0 TASK2                                                                                   --- //
  269. // ------------------------------------------------------------------------------------------------------------ //
  270. //
  271. void Core0_Task2( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
  272. {                                                                 // początek                          
  273.     for(;;)                                                       // nieskończona pętla                
  274.     {                                                             // początek FOR                              
  275.         vTaskDelay(1000 / portTICK_PERIOD_MS);                    // wykonuj 1 sekundę
  276.     }                                                            
  277. }  
  278. //
  279. // ------------------------------------------------------------------------------------------------------------ //
  280. // ---        CORE1 TASK1    
  281. // ------------------------------------------------------------------------------------------------------------ //
  282.  
  283. void Core1_Task1( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
  284. {                                                                 // początek                          
  285.     for(;;)                                                       // nieskończona pętla                
  286.     {                                                             // początek FOR                      
  287.         #if SERIAL
  288.             PrintLine(80);
  289.             PrintMSG("ESP32","CORE", "Wykonuje watek Task1 na CORE-1");
  290.         #endif      
  291.        
  292.         delay(1800000);                                           // wykonuj co 30 minut                
  293.     }                                                            
  294. }      
  295.  
  296. // ------------------------------------------------------------------------------------------------------------ //
  297. // ---        CORE1 TASK2    
  298. // ------------------------------------------------------------------------------------------------------------ //
  299.  
  300. void Core1_Task2( void * pvParameters )                           // Rdzeń 0 Zadanie 1                  
  301. {                                                                 // początek                          
  302.     for(;;)                                                       // nieskończona pętla                
  303.     {                                                             // początek FOR                      
  304.         #if SERIAL
  305.             PrintLine(80);
  306.             PrintMSG("ESP32","CORE", "Wykonuje watek Task2 na CORE-1");
  307.         #endif      
  308.        
  309.         delay(3600000);                                           // wykonuj co 1 godzinę
  310.     }                                                            
  311. }      
  312.  
  313. // ------------------------------------------------------------------------------------------------------------ //
  314. // --- Aktualizacja Pogody z Serwera  ------------------------------------------------------------------------- //
  315. // ------------------------------------------------------------------------------------------------------------ //
  316. //
  317. String httpGETRequest(const char* serverName)                                                        
  318. {                                                                                                    
  319.     HTTPClient http;                                                                                  
  320.     http.begin(serverName);                                                                          
  321.     int httpResponseCode = http.GET();                                                                
  322.     String bufor = "{}";                                                                              
  323.                                                                                                      
  324.     if ( httpResponseCode > 0 )                                                                      
  325.     {                                                                                                
  326.         #if SERIAL
  327.             //Serial.print("\nHTTP Response code: ");                                                  
  328.             //Serial.print(httpResponseCode);                                                      
  329.         #endif          
  330.                                                                                      
  331.         bufor = http.getString();                                                                    
  332.     }                                                                                                
  333.     else                                                                                              
  334.     {                                                                                                
  335.         #if SERIAL                                                                                  
  336.             //Serial.print("Error code: ");                                                          
  337.             //Serial.println(httpResponseCode);                                                      
  338.         #endif                                                                                        
  339.     }                                                                                                
  340.     http.end();                                                                            
  341.     return bufor;                                                                                    
  342. }
  343. //
  344. // ------------------------------------------------------------------------------------------------------------ //
  345. // ---        A K T U A L I Z A C J A   P O G O D Y                                                         --- //    
  346. // ------------------------------------------------------------------------------------------------------------ //
  347. //
  348. void PogodaAktualizuj()
  349. {
  350.     PrintLine(60);
  351.     PrintMSG("ESP32","MyTask", "Aktualizję pogodę z serwera : api.weatherapi.com");
  352.    
  353.     String path = "http://api.weatherapi.com/v1/current.json?key=TWOJ_TOKEN&q=TWOJE_MIASTO&lang=pl";
  354.     String jsonBuffer = httpGETRequest(path.c_str());    
  355.        
  356.     JSON_Weather = JSON.parse(jsonBuffer);                    
  357.  
  358.     if (JSON.typeof(JSON_Weather) == "undefined")                                                
  359.     {                                                                                        
  360.         PrintLine(60);
  361.         PrintMSG("DarkNet", "POGODA PARSER", "BŁĄD, BRAK DANYCH" );                                                                  
  362.     }      
  363.  
  364.     pogoda.miejscowosc                =   JSON_Weather["location"]["name"];
  365.     pogoda.kraj                       =   JSON_Weather["location"]["country"];
  366.     pogoda.szerokosc_geograficzna     =   JSON_Weather["location"]["lat"];
  367.     pogoda.dlugosc_geograficzna       =   JSON_Weather["location"]["lon"];
  368.     pogoda.id                         =   JSON_Weather["location"]["tz_id"];
  369.     pogoda.czas_epoch                 =   JSON_Weather["location"]["localtime_epoch"];
  370.     pogoda.czas_lokalny               =   JSON_Weather["location"]["localtime"];
  371.     pogoda.ostatnia_aktualizacja      =   JSON_Weather["current"]["last_updated"];
  372.     pogoda.temperatura_C              =   JSON_Weather["current"]["temp_c"];
  373.     pogoda.temperatura_C_odczuwalna   =   JSON_Weather["current"]["feelslike_c"];
  374.     pogoda.kondycja                   =   JSON_Weather["current"]["condition"]["text"];
  375.     pogoda.predkosc_wiatru_kph        =   JSON_Weather["current"]["wind_kph"];
  376.     pogoda.kierunek_wiatru_stopnie    =   JSON_Weather["current"]["wind_degree"];
  377.     pogoda.kierunek_wiatru_kompas     =   JSON_Weather["current"]["wind_dir"];
  378.     pogoda.podmuchy_wiatru            =   JSON_Weather["current"]["gust_kph"];
  379.     pogoda.cisnienie                  =   JSON_Weather["current"]["pressure_mb"];
  380.     pogoda.opady                      =   JSON_Weather["current"]["precip_mm"];
  381.     pogoda.wilgotnosc                 =   JSON_Weather["current"]["humidity"];
  382.     pogoda.zachmurzenie               =   JSON_Weather["current"]["cloud"];
  383.     pogoda.widzialnosc                =   JSON_Weather["current"]["vis_km"];
  384.     pogoda.index_uv                   =   JSON_Weather["current"]["uv"];
  385.  
  386.     if(pogoda.miejscowosc == "Lubin")
  387.     {
  388.         PrintLine(60);
  389.         Serial.printf("\n[DarkNet] [Pogoda] Miejscowość \t\t: ");
  390.         Serial.print(pogoda.miejscowosc);
  391.         Serial.printf("\n[DarkNet] [Pogoda] Kraj \t\t: ");
  392.         Serial.print(pogoda.kraj);
  393.         Serial.printf("\n[DarkNet] [Pogoda] Szer.Geograficzna \t: %2.2f",pogoda.szerokosc_geograficzna);
  394.         Serial.printf("\n[DarkNet] [Pogoda] Dług.Geograficzna \t: %2.2f",pogoda.dlugosc_geograficzna);            
  395.         Serial.printf("\n[DarkNet] [Pogoda] Czas Epoch \t\t: %u",pogoda.czas_epoch );            
  396.         Serial.printf("\n[DarkNet] [Pogoda] Serwer ID \t\t: ");
  397.         Serial.print( pogoda.id );    
  398.         Serial.printf("\n[DarkNet] [Pogoda] Czas Epoch \t\t: %u",pogoda.czas_epoch );            
  399.         Serial.printf("\n[DarkNet] [Pogoda] Czas Lokalny \t: ");      
  400.         Serial.print( pogoda.czas_lokalny );        
  401.         Serial.printf("\n[DarkNet] [Pogoda] Aktualizacja \t: ");      
  402.         Serial.print( pogoda.ostatnia_aktualizacja );      
  403.         Serial.printf("\n[DarkNet] [Pogoda] Temperatura \t\t: %2.2f",pogoda.temperatura_C);
  404.         Serial.printf("\n[DarkNet] [Pogoda] Temp.Odczuwalna \t: %2.2f",pogoda.temperatura_C_odczuwalna);  
  405.         Serial.printf("\n[DarkNet] [Pogoda] Opis pogody \t\t: ");
  406.         Serial.print(pogoda.kondycja);  
  407.         Serial.printf("\n[DarkNet] [Pogoda] Predkosc wiatru \t: %2.2f",pogoda.predkosc_wiatru_kph);
  408.         Serial.printf("\n[DarkNet] [Pogoda] Podmuchy wiatru \t: %2.2f",pogoda.podmuchy_wiatru);  
  409.         Serial.printf("\n[DarkNet] [Pogoda] Kierunek wiatru \t: %2.2f",pogoda.kierunek_wiatru_stopnie);  
  410.         Serial.printf("\n[DarkNet] [Pogoda] Kierunek wiatru \t: ");
  411.         Serial.print(pogoda.kierunek_wiatru_kompas);  
  412.         Serial.printf("\n[DarkNet] [Pogoda] Cisnienie \t\t: %d",pogoda.cisnienie);  
  413.         Serial.printf("\n[DarkNet] [Pogoda] Opady deszczu \t: %2.2f",pogoda.opady);  
  414.         Serial.printf("\n[DarkNet] [Pogoda] Wilgotnosc \t\t: %d",pogoda.wilgotnosc);  
  415.         Serial.printf("\n[DarkNet] [Pogoda] Zachmurzenie \t: %d",pogoda.zachmurzenie);  
  416.         Serial.printf("\n[DarkNet] [Pogoda] Widzialnosc \t\t: %d",pogoda.widzialnosc);  
  417.         Serial.printf("\n[DarkNet] [Pogoda] Index UV \t\t: %d",pogoda.index_uv);  
  418.              
  419.         PrintLine(60);
  420.         PrintEND();      
  421.        
  422.         F_Pogoda = true;      // dane OK, ustaw flagę na true
  423.     }
  424.     else  F_Pogoda = false;   // dane ZŁE, ustaw flagę na false
  425.  
  426. }
  427. //
  428. // ------------------------------------------------------------------------------------------------------------ //
  429. // ---        A K T U A L I Z A C J A   A S T R O N O M I I                                                 --- //    
  430. // ------------------------------------------------------------------------------------------------------------ //
  431. //
  432. void AstronomiaAktualizuj()
  433. {
  434.     PrintLine(60);
  435.     PrintMSG("ESP32","MyTask", "Aktualizję astronomię z serwera : api.weatherapi.com");    
  436.  
  437.     // pobierz dane astronomiczne z serwera dla miasta LUBIN
  438.        
  439.     String path = "http://api.weatherapi.com/v1/astronomy.json?key=TWOJ_TOKEN&lang=pl&q=TWOJE_MIASTO";
  440.     String jsonBuffer = httpGETRequest(path.c_str());    
  441.        
  442.     JSON_Astronomy = JSON.parse(jsonBuffer);                
  443.  
  444.     if (JSON.typeof(JSON_Astronomy) == "undefined")                                                
  445.     {                                                                                        
  446.         PrintLine(60);
  447.         PrintMSG("DarkNet", "ASTRONOMIA PARSER", "BŁĄD, BRAK DANYCH" );                                                                              
  448.     }      
  449.      
  450.     astronomia.miejscowosc              =   JSON_Astronomy["location"]["name"];
  451.     astronomia.kraj                     =   JSON_Astronomy["location"]["country"];
  452.     astronomia.szerokosc_geograficzna   =   JSON_Astronomy["location"]["lat"];
  453.     astronomia.dlugosc_geograficzna     =   JSON_Astronomy["location"]["lon"];        
  454.     astronomia.czas_epoch               =   JSON_Astronomy["location"]["localtime_epoch"];        
  455.     astronomia.czas_lokalny             =   JSON_Astronomy["location"]["localtime"];
  456.     astronomia.wschod_slonca            =   JSON_Astronomy["astronomy"]["astro"]["sunrise"];
  457.     astronomia.zachod_slonca            =   JSON_Astronomy["astronomy"]["astro"]["sunset"];
  458.     astronomia.wschod_ksiezyca          =   JSON_Astronomy["astronomy"]["astro"]["moonrise"];            
  459.     astronomia.zachod_ksiezyca          =   JSON_Astronomy["astronomy"]["astro"]["moonset"];
  460.     astronomia.faza_ksiezyca            =   JSON_Astronomy["astronomy"]["astro"]["moon_phase"];
  461.     astronomia.oswietlenie_ksiezyca     =   JSON_Astronomy["astronomy"]["astro"]["moon_illumination"];      
  462.  
  463.     if(astronomia.miejscowosc == "Lubin")
  464.     {
  465.        PrintLine(60);
  466.        Serial.printf("\n[DarkNet] [Astronomia] Miejscowość \t\t: ");
  467.        Serial.print(astronomia.miejscowosc);
  468.        Serial.printf("\n[DarkNet] [Astronomia] Kraj \t\t\t: ");
  469.        Serial.print(astronomia.kraj);
  470.        Serial.printf("\n[DarkNet] [Astronomia] Szer.Geograficzna \t: %2.2f",astronomia.szerokosc_geograficzna);
  471.        Serial.printf("\n[DarkNet] [Astronomia] Dług.Geograficzna \t: %2.2f",astronomia.dlugosc_geograficzna);            
  472.        Serial.printf("\n[DarkNet] [Astronomia] Czas Epoch \t\t: %u",astronomia.czas_epoch );            
  473.        Serial.printf("\n[DarkNet] [Astronomia] Czas Lokalny \t\t: ");
  474.        Serial.print( astronomia.czas_lokalny );            
  475.        Serial.printf("\n[DarkNet] [Astronomia] Wschód Słońca \t\t: ");
  476.        Serial.print(astronomia.wschod_slonca );
  477.        Serial.printf("\n[DarkNet] [Astronomia] Zachód Słońca \t\t: ");
  478.        Serial.print(astronomia.zachod_slonca );
  479.        Serial.printf("\n[DarkNet] [Astronomia] Wschód Księżyca \t\t: ");
  480.        Serial.print(astronomia.wschod_ksiezyca );
  481.        Serial.printf("\n[DarkNet] [Astronomia] Zachód Księżyca \t\t: ");
  482.        Serial.print(astronomia.zachod_ksiezyca );
  483.        Serial.printf("\n[DarkNet] [Astronomia] Faza Księżyca \t\t: ");
  484.        Serial.print(astronomia.faza_ksiezyca);
  485.        Serial.printf("\n[DarkNet] [Astronomia] Oświetlenie Księżyca \t: ");
  486.        Serial.print(astronomia.oswietlenie_ksiezyca );            
  487.        PrintLine(60);
  488.        PrintEND();
  489.        F_Astronomia = true;      // dane OK, ustaw flagę na true
  490.     }
  491.     else  F_Astronomia = false;   // dane ZŁE, ustaw flagę na false
  492. }
  493. //
  494. // ------------------------------------------------------------------------------------------------------------ //
  495. // ---        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                                   --- //    
  496. // ------------------------------------------------------------------------------------------------------------ //
  497. //
  498. void PowietrzeAktualizuj()
  499. {
  500.     PrintLine(60);
  501.     PrintMSG("ESP32","MyTask", "Aktualizję jakość powietrza z serwera : api.weatherapi.com");    
  502.  
  503.     // pobierz dane jakości powietrza z serwera dla miasta LUBIN
  504.        
  505.     String path = "http://api.weatherapi.com/v1/current.json?key=TWOJ_TOKEN&q=TWOJE_MIASTO&aqi=yes";
  506.     String jsonBuffer = httpGETRequest(path.c_str());      
  507.        
  508.     JSON_Air = JSON.parse(jsonBuffer);                
  509.  
  510.     if (JSON.typeof(JSON_Air) == "undefined")                                                
  511.     {                                                                                        
  512.         PrintLine(60);
  513.         PrintMSG("DarkNet", "AIR PARSER", "BŁĄD, BRAK DANYCH" );                                                                              
  514.     }        
  515.  
  516.     powietrze.co     = JSON_Air["current"]["air_quality"]["co"];
  517.     powietrze.o3     = JSON_Air["current"]["air_quality"]["o3"];
  518.     powietrze.no2    = JSON_Air["current"]["air_quality"]["no2"];
  519.     powietrze.so2    = JSON_Air["current"]["air_quality"]["so2"];
  520.     powietrze.pm25   = JSON_Air["current"]["air_quality"]["pm2_5"];
  521.     powietrze.pm10   = JSON_Air["current"]["air_quality"]["pm10"];
  522.     powietrze.Defra  = JSON_Air["current"]["air_quality"]["gb-defra-index"];
  523.  
  524.     if (powietrze.co != 0)
  525.     {
  526.         PrintLine(60);
  527.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Tlenek węgla \t\t: %2.8f [μg/ m3]", powietrze.co);
  528.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Dwutlenek azotu \t\t: %2.8f [μg/ m3]", powietrze.no2);
  529.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Ozon \t\t\t: %2.8f [μg/m3]", powietrze.o3);
  530.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Pyły i aerozole PM2.5 \t: %2.8f [μm]", powietrze.pm25);
  531.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Pyły i aerozole PM10 \t: %2.8f [μm]", powietrze.pm10);
  532.         Serial.printf("\n[DarkNet] [Jakość Powietrza] Index jakości \t\t: %d IND", powietrze.Defra);
  533.         PrintLine(60);
  534.         PrintEND();
  535.    
  536.         F_Powietrze  = true;  
  537.     }
  538.     else F_Powietrze  = false;
  539. }
  540. //
  541. // ------------------------------------------------------------------------------------------------------------ //
  542. // ---        A K T U A L I Z A C J A   P R O G N O Z Ę                                                     --- //    
  543. // ------------------------------------------------------------------------------------------------------------ //
  544. //
  545. void PrognozaAktualizuj()
  546. {
  547.     PrintLine(60);
  548.     PrintMSG("ESP32","MyTask", "Aktualizję prognozę z serwera : api.weatherapi.com");    
  549.  
  550.     // pobierz dane astronomiczne z serwera dla miasta LUBIN
  551.        
  552.     String path = "http://api.weatherapi.com/v1/forecast.json?key=TWOJ_TOKEN&q=TWOJE_MIASTO&days=1&aqi=no&alerts=no";
  553.     String jsonBuffer = httpGETRequest(path.c_str());    
  554.        
  555.     JSON_Forecast = JSON.parse(jsonBuffer);                
  556.  
  557.     if (JSON.typeof(JSON_Forecast) == "undefined")                                                
  558.     {                                                                                        
  559.         PrintLine(60);
  560.         PrintMSG("DarkNet", "AIR PARSER", "BŁĄD, BRAK DANYCH" );                                                                              
  561.     }        
  562. }
  563. //
  564. // ------------------------------------------------------------------------------------------------------------ //
  565. // --- MyTask ------------------------------------------------------------------------------------------------- //
  566. // ------------------------------------------------------------------------------------------------------------ //
  567. //
  568. void MyTask()
  569. {
  570.     timeZERO = millis();                                    // zapisz czas 0
  571.     task01s = timeZERO - timeout_task01s;                   // wyznacz nowy
  572.     task01m = timeZERO - timeout_task01m;                   // wyznacz nowy
  573.     task05m = timeZERO - timeout_task05m;                   // wyznacz nowy
  574.     task10m = timeZERO - timeout_task10m;                   // wyznacz nowy
  575.     task15m = timeZERO - timeout_task15m;                   // wyznacz nowy
  576.     task01h = timeZERO - timeout_task01h;                   // wyznacz nowy
  577.  
  578.     // --- ZADANIE co 1 sekundę ------------------------------------------------------------------------------- //
  579.  
  580.     if(task01m >= 1000UL)                                  // wykonuj co 1 sekundę
  581.     {
  582.         if (F_BigClock) M.ShowBigClock();                  // pokaż duży zegar      
  583.         timeout_task01s = timeZERO;  
  584.     }
  585.  
  586.     // --- ZADANIE co 1 minutę ------------------------------------------------------------------------------- //
  587.  
  588.     if(task01m >= 60000UL)                                  // wykonuj co 1 minutę
  589.     {
  590.         if (!F_Astronomia)  AstronomiaAktualizuj();         // jeśli BRAK DANYCH wykonuj co minutę
  591.         if (!F_Pogoda)      PogodaAktualizuj();             // jeśli BRAK DANYCH wykonuj co minutę
  592.         if (!F_Powietrze)   PowietrzeAktualizuj();          // jeśli BRAK DANYCH wykonuj co minutę
  593.         //if (!F_Prognoza)    PrognozaAktualizuj();           // jeśli BRAK DANYCH wykonuj co minutę
  594.        
  595.         timeout_task01m = timeZERO;  
  596.     }
  597.  
  598.     // --- ZADANIE co 5 minut -------------------------------------------------------------------------------- //
  599.  
  600.     if(task05m >= 300000UL)                                 // wykonuj co 5 minut
  601.     {
  602.         timeout_task05m = timeZERO;  
  603.     }
  604.  
  605.     // --- ZADANIE co 10 minut ------------------------------------------------------------------------------- //
  606.  
  607.     if(task10m >= 600000UL)                                 // wykonuj co 10 minut
  608.     {
  609.         timeout_task10m = timeZERO;    
  610.     }
  611.  
  612.     // --- ZADANIE co 15 minut ------------------------------------------------------------------------------- //
  613.  
  614.     if(task15m >= 900000UL)                                 // wykonuj co 15 minut
  615.     {
  616.         if (F_Astronomia)  AstronomiaAktualizuj();          // jeśli DANE OK co 15 minut
  617.         if (F_Pogoda)      PogodaAktualizuj();              // jeśli DANE OK co 15 minut
  618.         if (F_Powietrze)   PowietrzeAktualizuj();           // jeśli DANE OK co 15 minut
  619.         //if (F_Prognoza)    PrognozaAktualizuj();            // jeśli BRAK DANYCH wykonuj co minutę
  620.        
  621.         timeout_task15m = timeZERO;                         // resetuj LICZNIK
  622.     }
  623.  
  624.     // --- ZADANIE co 1 godzinę ------------------------------------------------------------------------------- //
  625.  
  626.     if(task01h >= 3600000UL)                                  // wykonuj co 1 godzinę      
  627.     {
  628.         TBMessage msg;                                        // wiadomosc typu TBMessage
  629.         myBot.reset();                                        // resetuj BOT'a
  630.         myBot.sendMessage(msg, "Restart BOT'A" );             // wyślij info o restarcie
  631.  
  632.         #if SERIAL
  633.             Serial.printf("\n[TASK] [TELEGRAM] Restartuje BOT'A");
  634.         #endif
  635.        
  636.         timeout_task01h = timeZERO;                           // resetuj LICZNIK
  637.     }
  638.  
  639. }    
  640.  
  641. // ------------------------------------------------------------------------------------------------------------ //
  642. // --- TELEGRAM INIT ------------------------------------------------------------------------------------------ //
  643. // ------------------------------------------------------------------------------------------------------------ //
  644.  
  645. void TelegramInit()
  646. {
  647.     myBot.setInsecure(false);
  648.     myBot.setClock("CET-1CEST,M3.5.0,M10.5.0/3");   //Aby zapewnić walidację certyfikatu, WiFiClientSecure wymaga aktualizacji czasu
  649.     myBot.setUpdateTime(1000);                      // Ustaw właściwości bota Telegrama
  650.     myBot.setTelegramToken(token);
  651.    
  652.     Serial.printf("\nESP","Telegram Start","Czy wszystko w porzadku?");    
  653.     myBot.begin() ? Serial.println("OK") : Serial.println("NIE");           // daj odpowiedz na Serial
  654.  
  655.     isKeyboardActive = false;                                               // ustaw klawiature
  656.  
  657.     // --- klawiatura REPLY 1 -----------------------------------------------------------------
  658.  
  659.     myReplyKbd.addButton("Pogoda");                                         // dodaj przycisk
  660.     myReplyKbd.addButton("Astro");                                          // Astronomia
  661.     myReplyKbd.addButton("Time");                                           // dodaj przycisk
  662.     myReplyKbd.addButton("Air");                                            // dodaj przycisk    
  663.  
  664.     myReplyKbd.addRow();                                                    // nowy wiersz
  665.  
  666.     myReplyKbd.addButton("System");                                         // nowy przycisk
  667.     myReplyKbd.addButton("Help");                                           // nowy przycisk
  668.     myReplyKbd.addButton("Exit");                                           // nowy przycisk    
  669.  
  670.     myReplyKbd.addRow();                                                    // nowy wiersz
  671.  
  672.     myReplyKbd.addButton("R Status");                                       // nowy przycisk
  673.     myReplyKbd.addButton("R All ON");                                       // wyświetl dostępne opcje
  674.     myReplyKbd.addButton("R All OFF");                                      // zamknik Panel Dolny wyświetl MENU
  675.     myReplyKbd.enableResize();  
  676.    
  677.  
  678.     // --- klawiatura REPLY 2 -----------------------------------------------------------------
  679.  
  680.     myReplyKbd2.addButton("Relay 1");                                        // przekaznik 1
  681.     myReplyKbd2.addButton("Relay 2");                                        // przekaznik 2
  682.     myReplyKbd2.addButton("Relay 3");                                        // przekaznik 3
  683.     myReplyKbd2.addButton("Relay 4");                                        // przekaznik 4
  684.  
  685.     myReplyKbd2.addRow();                                                    // dodaj kolejny wiersz                                          
  686.  
  687.     myReplyKbd2.addButton("Relay 5");                                        // przekaznik 5
  688.     myReplyKbd2.addButton("Relay 6");                                        // przekaznik 6
  689.     myReplyKbd2.addButton("Relay 7");                                        // przekaznik 7
  690.     myReplyKbd2.addButton("Relay 8");                                        // przekaznik 8
  691.  
  692.     myReplyKbd2.addRow();                                                    // dodaj kolejny wiersz                                          
  693.  
  694.     myReplyKbd2.addButton("HELP");                                           // POMOC
  695.     myReplyKbd2.addButton("EXIT");                                           // EXIT
  696.  
  697.     myReplyKbd2.enableResize();                                              // wlacz auto-rozmiar
  698.  
  699.     // --- klawiatura INLINE -----------------------------------------------------------------
  700.  
  701.     myInlineKbd.addButton("R1", RELAY1_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 1
  702.     myInlineKbd.addButton("R2", RELAY2_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 2
  703.     myInlineKbd.addRow();    
  704.     myInlineKbd.addButton("R3", RELAY3_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 3    
  705.     myInlineKbd.addButton("R4", RELAY4_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 4    
  706.     myInlineKbd.addRow();    
  707.     myInlineKbd.addButton("R5", RELAY5_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 3    
  708.     myInlineKbd.addButton("6", RELAY6_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 4  
  709.  
  710.     // --- klawiatura INLINE -----------------------------------------------------------------
  711.  
  712.     myInlineKbd2.addButton("Relay1", RELAY1_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 1
  713.     myInlineKbd2.addButton("Relay2", RELAY2_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 2
  714.     myInlineKbd2.addRow();    
  715.     myInlineKbd2.addButton("Relay3", RELAY3_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 3    
  716.     myInlineKbd2.addButton("Relay4", RELAY4_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 4    
  717.     myInlineKbd2.addRow();    
  718.     myInlineKbd2.addButton("Relay5", RELAY5_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 5    
  719.     myInlineKbd2.addButton("Relay6", RELAY6_CALLBACK, KeyboardButtonQuery);  // przycisk -> przekaźnik nr. 6        
  720. }
  721.  
  722. //
  723. // ------------------------------------------------------------------------------------------------------------ //
  724. // --- W i F i   R E C O N E C T ------------------------------------------------------------------------------ //
  725. // ------------------------------------------------------------------------------------------------------------ //
  726. //
  727.  
  728. void WiFiEvent(WiFiEvent_t event)
  729. {
  730.     switch (event)
  731.     {
  732.         case SYSTEM_EVENT_STA_GOT_IP:         Serial.printf("\n[ESP] [WiFiEvent] [Polaczono z Wi-Fi]");  break;
  733.  
  734.         case SYSTEM_EVENT_STA_DISCONNECTED:   Serial.printf("\n[ESP] [WiFiEvent] [Utracono połączenia z Wi-Fi]");
  735.                                               WiFi.setAutoReconnect(true);
  736.                                               myBot.reset();
  737.                                               break;
  738.         default:                              break;
  739.   }
  740. }
  741.  
  742. //
  743. // ------------------------------------------------------------------------------------------------------------ //
  744. // --- Telegram --- Pogoda do String  ------------------------------------------------------------------------- //
  745. // ------------------------------------------------------------------------------------------------------------ //
  746. //
  747.  
  748. String TelegramPogoda()
  749. {
  750.     String bufor;                                   // bufor tekstowy dla danych pogodowych
  751.  
  752.         bufor   =   "Miejscowosc : "  + pogoda.miejscowosc + "\n";
  753.         bufor  +=   "aktualizacja : " + pogoda.ostatnia_aktualizacja + "\n";
  754.         bufor  +=   "Temperatura = " + String( pogoda.temperatura_C ) + " st.C\n";
  755.         bufor  +=   "Wilgotnosc = " + String( pogoda.wilgotnosc ) + " %\n";
  756.         bufor  +=   "Cisnienie =  " + String( pogoda.cisnienie ) + " mPa\n";
  757.         bufor  +=   "Opady deszczu = " + String( pogoda.opady ) + " mm\n";
  758.         bufor  +=   "Predkosc wiatru = " + String(pogoda.predkosc_wiatru_kph ) + " km/h\n";
  759.         bufor  +=   "Kierunek wiatru = " + pogoda.kierunek_wiatru_kompas + " \n";
  760.         bufor  +=   "Index UV = " + String( pogoda.index_uv ) + "\n";
  761.         bufor  +=   "Opis skrocony : " + pogoda.kondycja + "\n";        
  762.  
  763.     return bufor;                                   // zwróć bufor i wyślij na smarphona
  764. }
  765.  
  766. //
  767. // ------------------------------------------------------------------------------------------------------------ //  
  768. // --- Telegram --- Data i Czas do String  -------------------------------------------------------------------- //
  769. // ------------------------------------------------------------------------------------------------------------ //
  770. //
  771.  
  772. String TelegramNTP()
  773. {
  774.     String  bufor;
  775.  
  776.       bufor  = "Data: " + zegar.SformatowanaData + "\n";
  777.       bufor += "Czas: " + zegar.SformatowanyCzas + "\n";          
  778.  
  779.     return bufor;
  780. }
  781.  
  782. //
  783. // ------------------------------------------------------------------------------------------------------------ //  
  784. // --- Telegram --- Astronomia do String  --------------------------------------------------------------------- //
  785. // ------------------------------------------------------------------------------------------------------------ //  
  786. //
  787.  
  788. String TelegramASTRO()
  789. {
  790.     String  bufor;
  791.  
  792.       bufor   =  "Miejscowosc : "   + astronomia.miejscowosc + "\n";
  793.       bufor  +=  "Wschod Slonca = " + astronomia.wschod_slonca + "\n";          
  794.       bufor  +=  "Zachod Slonca = " + astronomia.zachod_slonca + "\n";          
  795.       bufor  +=  "Wschod Ksiezyca = " + astronomia.wschod_ksiezyca + "\n";
  796.       bufor  +=  "Zachod Ksiezyca = " + astronomia.zachod_ksiezyca + "\n";
  797.       bufor  +=  "Faza Ksiezyca = " + astronomia.faza_ksiezyca + "\n";
  798.       bufor  +=  "Oświetlenie Ksiezyca = " + astronomia.oswietlenie_ksiezyca + "\n";
  799.  
  800.     return bufor;
  801. }
  802.  
  803. //
  804. // ------------------------------------------------------------------------------------------------------------ //  
  805. // --- Telegram --- Powietrze do String  ---------------------------------------------------------------------- //
  806. // ------------------------------------------------------------------------------------------------------------ //  
  807. //
  808.  
  809. String TelegramAIR()
  810. {
  811.     String  bufor;
  812.  
  813.       bufor   =  "Miejscowosc : "   + astronomia.miejscowosc + "\n";
  814.       bufor  +=  "Tlenek węgla = " + String(powietrze.co) + " μg/m3\n";          
  815.       bufor  +=  "Ozon = " + String(powietrze.o3) + " μg/m3\n";          
  816.       bufor  +=  "Dwutlenek azotu = " + String(powietrze.no2) + " μg/m3\n";
  817.       bufor  +=  "Dwutlenek siarki = " + String(powietrze.so2) + " μg/m3\n";
  818.       bufor  +=  "Aerozole PM2.5 = " + String(powietrze.pm25) + " μm\n";
  819.       bufor  +=  "Aerozole PM10 = " + String(powietrze.pm10) + " μm\n";
  820.       bufor  +=  "Index Jakości = " + String(powietrze.Defra) + " DEFRA\n";
  821.  
  822.     return bufor;
  823. }
  824.  
  825. //
  826. // ------------------------------------------------------------------------------------------------------------ //  
  827. // --- Telegram --- System do String  ------------------------------------------------------------------------- //
  828. // ------------------------------------------------------------------------------------------------------------ //  
  829. //
  830.  
  831. String TelegramSYSTEM()
  832. {
  833.     String  bufor;
  834.  
  835.       bufor   =    "CPU Freq : " + String(ESP.getCpuFreqMHz()) + " MHz\n";
  836.       bufor   +=   "Free Heap Size : " + String(ESP.getFreeHeap()/1000) + " kB\n";      
  837.       bufor   +=   "Min Free Heap : " + String(ESP.getMinFreeHeap()/1000) + " kB\n";      
  838.       bufor   +=   "Max Alloc Heap : " + String(ESP.getMaxAllocHeap()/1000) + " kB\n";      
  839.       bufor   +=   "Heap Size : " + String(ESP.getHeapSize()/1000) + " kB\n";  
  840.  
  841.     return bufor;
  842. }
  843.  
  844. //
  845. // ------------------------------------------------------------------------------------------------------------ //  
  846. // --- Telegram --- Relay Switch do String  ------------------------------------------------------------------- //
  847. // ------------------------------------------------------------------------------------------------------------ //  
  848. //
  849.  
  850. String TelegramSwitchRelay(byte relayNR)
  851. {
  852.     String bufor;
  853.  
  854.         if (przekaznik[relayNR].relaySTATUS)                                // jeśli przekaźnik włączony to OFF
  855.         {
  856.             przekaznik[relayNR].relaySTATUS = false;
  857.             przekaznik[relayNR].relayOPIS   = "OFF";
  858.             bufor  = "Przekaznik [" + String(relayNR + 1) + "] został wyłączony !!!";            
  859.         }
  860.         else                                                                // jeśli przekaźnik wyłączony to ON
  861.         {
  862.             przekaznik[relayNR].relaySTATUS = true;
  863.             przekaznik[relayNR].relayOPIS   = "ON";  
  864.             bufor = "Przekaznik [" + String(relayNR + 1) + "] został włączony !!!";
  865.         }
  866.  
  867.         bufor += "\nPrzekaznik [" + String(relayNR +1) + "] : " + przekaznik[relayNR].relayOPIS + " \n";      
  868.        
  869.  
  870.     return bufor;
  871. }
  872.  
  873. //
  874. // ------------------------------------------------------------------------------------------------------------ //  
  875. // --- Telegram --- Relay All ON do String  ------------------------------------------------------------------- //
  876. // ------------------------------------------------------------------------------------------------------------ //  
  877. //
  878.  
  879. String TelegramRELAY_ALL_ON()
  880. {
  881.     String bufor;
  882.  
  883.       for (byte r = 0; r < 8; r ++)                       // przejedź wszystkie przekaznini
  884.       {
  885.           przekaznik[r].relaySTATUS = true;               // status przekaźnika : true (włączony)
  886.           przekaznik[r].relayOPIS   = "ON";               // opis przekaźnika   : ON (włączony)
  887.       }
  888.  
  889.       bufor  =  "[TELEGRAM] Wszystkie przekaźniki zostały włączone\n";
  890.       bufor  += TelegramRELAY();                        
  891.  
  892.     return bufor;
  893. }
  894.  
  895. //
  896. // ------------------------------------------------------------------------------------------------------------ //  
  897. // --- Telegram --- Relay All OFF do String  ------------------------------------------------------------------ //
  898. // ------------------------------------------------------------------------------------------------------------ //  
  899. //
  900.  
  901. String TelegramRELAY_ALL_OFF()
  902. {
  903.     String bufor;
  904.  
  905.       for (byte r = 0; r < 8; r ++)                       // przejedź wszystkie przekaznini
  906.       {
  907.           przekaznik[r].relaySTATUS = false;              // status przekaźnika : true (włączony)
  908.           przekaznik[r].relayOPIS   = "OFF";              // opis przekaźnika   : ON (włączony)
  909.       }
  910.  
  911.       bufor  =  "[TELEGRAM] Wszystkie przekaźniki zostały wyłączone\n";
  912.       bufor  += TelegramRELAY();                          
  913.  
  914.     return bufor;
  915. }
  916.  
  917. //
  918. // ------------------------------------------------------------------------------------------------------------ //  
  919. // --- Telegram --- RELAY STATUS do String  ------------------------------------------------------------------- //
  920. // ------------------------------------------------------------------------------------------------------------ //  
  921. //
  922.  
  923. String TelegramRELAY()
  924. {
  925.     String  bufor;    
  926.  
  927.       bufor   =    "Przekaznik [1] : " + przekaznik[0].relayOPIS + " \n";      
  928.       bufor   +=   "Przekaznik [2] : " + przekaznik[1].relayOPIS + " \n";
  929.       bufor   +=   "Przekaznik [3] : " + przekaznik[2].relayOPIS + " \n";
  930.       bufor   +=   "Przekaznik [4] : " + przekaznik[3].relayOPIS + " \n";
  931.       bufor   +=   "Przekaznik [5] : " + przekaznik[4].relayOPIS + " \n";
  932.       bufor   +=   "Przekaznik [6] : " + przekaznik[5].relayOPIS + " \n";
  933.       bufor   +=   "Przekaznik [7] : " + przekaznik[6].relayOPIS + " \n";
  934.       bufor   +=   "Przekaznik [8] : " + przekaznik[7].relayOPIS + " \n";
  935.  
  936.     return bufor;
  937. }
  938.  
  939. //
  940. // ------------------------------------------------------------------------------------------------------------ //  
  941. // --- Telegram --- Główna Funckja do obsługi Smartphona ------------------------------------------------------ //
  942. // ------------------------------------------------------------------------------------------------------------ //  
  943. //
  944.  
  945. void Telegram()
  946. {
  947.     TBMessage msg;
  948.  
  949.     if (myBot.getNewMessage(msg))  // jesli nadeszła wiadomość
  950.     {
  951.         String tgReply;
  952.         MessageType msgType = msg.messageType;
  953.        
  954.       switch (msgType)
  955.       {
  956.           case MessageText :            // odebrano wiadomosc tekstową
  957.        
  958.                             tgReply = msg.text;
  959.  
  960.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  961.                            
  962.                             if(tgReply.equalsIgnoreCase("Relay 1"))                              
  963.                             {
  964.                                 #if SERIAL
  965.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  966.                                 #endif
  967.  
  968.                                 myBot.sendMessage(msg, TelegramSwitchRelay(0).c_str());   // wyślij pogodę
  969.                             }
  970.  
  971.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  972.                            
  973.                             if(tgReply.equalsIgnoreCase("Relay 2"))                              
  974.                             {
  975.                                 #if SERIAL
  976.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  977.                                 #endif
  978.  
  979.                                 myBot.sendMessage(msg, TelegramSwitchRelay(1).c_str());   // wyślij pogodę
  980.                             }
  981.  
  982.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  983.                            
  984.                             if(tgReply.equalsIgnoreCase("Relay 3"))                              
  985.                             {
  986.                                 #if SERIAL
  987.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  988.                                 #endif
  989.  
  990.                                 myBot.sendMessage(msg, TelegramSwitchRelay(2).c_str());   // wyślij pogodę
  991.                             }
  992.  
  993.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  994.                            
  995.                             if(tgReply.equalsIgnoreCase("Relay 4"))                              
  996.                             {
  997.                                 #if SERIAL
  998.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  999.                                 #endif
  1000.  
  1001.                                 myBot.sendMessage(msg, TelegramSwitchRelay(3).c_str());   // wyślij pogodę
  1002.                             }
  1003.  
  1004.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  1005.                            
  1006.                             if(tgReply.equalsIgnoreCase("Relay 5"))                              
  1007.                             {
  1008.                                 #if SERIAL
  1009.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  1010.                                 #endif
  1011.  
  1012.                                 myBot.sendMessage(msg, TelegramSwitchRelay(4).c_str());   // wyślij pogodę
  1013.                             }
  1014.  
  1015.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  1016.                            
  1017.                             if(tgReply.equalsIgnoreCase("Relay 6"))                              
  1018.                             {
  1019.                                 #if SERIAL
  1020.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  1021.                                 #endif
  1022.  
  1023.                                 myBot.sendMessage(msg, TelegramSwitchRelay(5).c_str());   // wyślij pogodę
  1024.                             }
  1025.  
  1026.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  1027.                            
  1028.                             if(tgReply.equalsIgnoreCase("Relay 7"))                              
  1029.                             {
  1030.                                 #if SERIAL
  1031.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  1032.                                 #endif
  1033.  
  1034.                                 myBot.sendMessage(msg, TelegramSwitchRelay(6).c_str());   // wyślij pogodę
  1035.                             }
  1036.  
  1037.                             // --- jeśli w apce Telegram wciśnięto przycisk "Przekaznik numer" -------------- //
  1038.                            
  1039.                             if(tgReply.equalsIgnoreCase("Relay 8"))                              
  1040.                             {
  1041.                                 #if SERIAL
  1042.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  1043.                                 #endif
  1044.  
  1045.                                 myBot.sendMessage(msg, TelegramSwitchRelay(7).c_str());   // wyślij pogodę
  1046.                             }
  1047.                            
  1048.                             // --- jeśli w apce Telegram wciśnięto przycisk "Pogoda" ----------------------- //
  1049.                            
  1050.                             if(tgReply.equalsIgnoreCase("Pogoda"))                              
  1051.                             {
  1052.                                 #if SERIAL
  1053.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij pogode");
  1054.                                 #endif
  1055.  
  1056.                                 myBot.sendMessage(msg, TelegramPogoda().c_str());   // wyślij pogodę
  1057.                             }
  1058.  
  1059.                             // --- jeśli w apce Telegram wcisnieto przycisk "Data i Czas" ------------------ //
  1060.  
  1061.                             else if(tgReply.equalsIgnoreCase("Time"))
  1062.                             {
  1063.                                 #if SERIAL
  1064.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij datę i czas");
  1065.                                 #endif
  1066.  
  1067.                                 myBot.sendMessage(msg, TelegramNTP().c_str());      // wyślij datę i czas
  1068.                             }
  1069.                        
  1070.                             // --- jeśli w apce Telegram wcisnieto przycisk "Wolny RAM --------------------- //
  1071.                            
  1072.                             else if(tgReply.equalsIgnoreCase("System"))
  1073.                             {
  1074.                                 #if SERIAL
  1075.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyślij dane o systemie");
  1076.                                 #endif
  1077.                                
  1078.                                 myBot.sendMessage(msg, TelegramSYSTEM().c_str());
  1079.                             }
  1080.                            
  1081.                             // --- jeśli w apce Telegram wcisnieto przycisk Astronomia --------------------- //
  1082.                            
  1083.                             else if(tgReply.equalsIgnoreCase("Astro"))              // wyślij astronomię
  1084.                             {
  1085.                                 #if SERIAL
  1086.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij astronomie");
  1087.                                 #endif
  1088.  
  1089.                                 myBot.sendMessage(msg, TelegramASTRO().c_str());
  1090.                             }
  1091.  
  1092.                             // --- jeśli w apce Telegram wcisnieto przycisk Air ---------------------------- //
  1093.                            
  1094.                             else if(tgReply.equalsIgnoreCase("Air"))                // wyślij powietrze
  1095.                             {
  1096.                                 #if SERIAL
  1097.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij powietrze");
  1098.                                 #endif
  1099.  
  1100.                                 myBot.sendMessage(msg, TelegramAIR().c_str());
  1101.                             }
  1102.  
  1103.                             // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //
  1104.                            
  1105.                             else if(tgReply.equalsIgnoreCase("R Status"))                // stan przekaźników
  1106.                             {
  1107.                                 #if SERIAL
  1108.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
  1109.                                 #endif
  1110.  
  1111.                                 myBot.sendMessage(msg, TelegramRELAY().c_str());
  1112.                             }
  1113.  
  1114.                             // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //
  1115.                            
  1116.                             else if(tgReply.equalsIgnoreCase("R All ON"))                // wszystkie włącz
  1117.                             {
  1118.                                 #if SERIAL
  1119.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
  1120.                                 #endif
  1121.  
  1122.                                 myBot.sendMessage(msg, TelegramRELAY_ALL_ON().c_str());
  1123.                             }
  1124.  
  1125.                             // --- jeśli w apce Telegram wcisnieto przycisk Relay ---------------------------- //                            
  1126.                            
  1127.                             else if(tgReply.equalsIgnoreCase("R All OFF"))                // wszystkie wyłącz
  1128.                             {
  1129.                                 #if SERIAL
  1130.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> wyslij stan przekaźników");
  1131.                                 #endif
  1132.  
  1133.                                 myBot.sendMessage(msg, TelegramRELAY_ALL_OFF().c_str());
  1134.                             }
  1135.  
  1136.                             // --- jeśli w apce Telegram wcisnieto przycisk EXIT ---------------------------- //
  1137.                            
  1138.                             else if(tgReply.equalsIgnoreCase("Exit"))                // wyślij powietrze
  1139.                             {
  1140.                                 #if SERIAL
  1141.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Zamknij Panel Dolny");
  1142.                                 #endif
  1143.                                
  1144.                                 isKeyboardActive = false;
  1145.                                 myBot.sendMessage(msg, "/przekazniki\n/system\n/panel\n/relay\n");
  1146.                                 myBot.removeReplyKeyboard(msg, "Ukryto klawiature");                                
  1147.                                
  1148.                             }
  1149.  
  1150.                             // --- jeśli w apce Telegram wcisnieto przycisk EXIT ---------------------------- //
  1151.                            
  1152.                             else if(tgReply.equalsIgnoreCase("Help"))                // wyślij powietrze
  1153.                             {
  1154.                                 #if SERIAL
  1155.                                     Serial.printf("\n[TELEGRAM] [Nadeszlo żądanie] -> Zamknij Panel Dolny");
  1156.                                 #endif
  1157.                                
  1158.                                 myBot.sendMessage(msg, "/przekazniki\n/system\n/panel\n/relay\n");                                
  1159.                             }
  1160.  
  1161.                             // ----------------------------------------------------------------------------- //
  1162.  
  1163.                             else if (tgReply.equalsIgnoreCase("/system"))       // pokaż panel systemowy (DOLNY)
  1164.                             {
  1165.                                 myBot.sendMessage(msg, "PANEL SYSTEMOWY", myReplyKbd);
  1166.                                 isKeyboardActive = true;
  1167.                             }
  1168.  
  1169.                             // ----------------------------------------------------------------------------- //
  1170.  
  1171.                             else if (tgReply.equalsIgnoreCase("/przekazniki"))  // pokaż panel przekaźników (DOLNY)
  1172.                             {
  1173.                                 myBot.sendMessage(msg, "PANEL PRZEKAZNIKOW", myReplyKbd2);
  1174.                                 isKeyboardActive = true;
  1175.                             }
  1176.  
  1177.                             // ----------------------------------------------------------------------------- //
  1178.  
  1179.                             else if (tgReply.equalsIgnoreCase("/panel"))
  1180.                             {
  1181.                                 myBot.sendMessage(msg, "To jest inline keyboard:", myInlineKbd);          
  1182.                             }
  1183.  
  1184.                             // ----------------------------------------------------------------------------- //
  1185.                            
  1186.                             else if (tgReply.equalsIgnoreCase("/relay"))
  1187.                             {
  1188.                                 myBot.sendMessage(msg, "To jest inline keyboard:", myInlineKbd2);          
  1189.                             }
  1190.  
  1191.                             // ----------------------------------------------------------------------------- //
  1192.  
  1193.                             if (isKeyboardActive)
  1194.                             {
  1195.                                 if (tgReply.equalsIgnoreCase("EXIT"))
  1196.                                 {
  1197.                                     myBot.removeReplyKeyboard(msg, "Ukryto klawiature");
  1198.                                     isKeyboardActive = false;
  1199.                                 }
  1200.                                 else
  1201.                                 {
  1202.                                     myBot.sendMessage(msg, msg.text);
  1203.                                 }
  1204.                             }
  1205.  
  1206.                             // ----------------------------------------------------------------------------- //
  1207.  
  1208.                             else if(tgReply.equalsIgnoreCase("/start"))
  1209.                             {          
  1210.                                 myBot.sendMessage(msg, "/przekazniki\n/system\n/panel\n/relay\n");
  1211.                             }
  1212.                             break;
  1213.  
  1214.                             // ----------------------------------------------------------------------------- //
  1215.  
  1216.           case MessageQuery:      // wiadomosc dla CallBacka
  1217.        
  1218.                             tgReply = msg.callbackQueryData;
  1219.                             Serial.print("\nCallback, odebrano wiadomosc: ");
  1220.                             Serial.println(tgReply);
  1221.        
  1222.                             if (tgReply.equalsIgnoreCase(RELAY1_CALLBACK))
  1223.                             {
  1224.                                 Serial.println("\nPrzekaznik 1");
  1225.                                 myBot.endQuery(msg, "Przekaznik 1", true);
  1226.                             }
  1227.                             else
  1228.                             if (tgReply.equalsIgnoreCase(RELAY2_CALLBACK))
  1229.                             {
  1230.                                 Serial.println("\nPrzekaznik 2");
  1231.                                 myBot.endQuery(msg, "Przekaznik 2", true);
  1232.                             }
  1233.                             else
  1234.                             if (tgReply.equalsIgnoreCase(RELAY3_CALLBACK))
  1235.                             {
  1236.                                 Serial.println("\nPrzekaznik 3");
  1237.                                 myBot.endQuery(msg, "Przekaznik 3", true);
  1238.                             }
  1239.                             else
  1240.                             if (tgReply.equalsIgnoreCase(RELAY4_CALLBACK))
  1241.                             {
  1242.                                 Serial.println("\nPrzekaznik 4");
  1243.                                 myBot.endQuery(msg, "Przekaznik 4", true);
  1244.                             }
  1245.                             else
  1246.                             if (tgReply.equalsIgnoreCase(RELAY5_CALLBACK))
  1247.                             {
  1248.                                 Serial.println("\nPrzekaznik 5");
  1249.                                 myBot.endQuery(msg, "Przekaznik 5", true);
  1250.                             }
  1251.                             else
  1252.                             if (tgReply.equalsIgnoreCase(RELAY6_CALLBACK))
  1253.                             {
  1254.                                 Serial.println("\nPrzekaznik 5");
  1255.                                 myBot.endQuery(msg, "Przekaznik 5", true);
  1256.                             }
  1257.                                                        
  1258.                            
  1259.                             break;
  1260.  
  1261.           case MessageLocation:  
  1262.                             char bufL[200];
  1263.                             snprintf(bufL, sizeof(bufL), "Dlugosc geograficzna: %f\nSzerokosc geograficzna: %f\n", msg.location.longitude, msg.location.latitude) ;
  1264.                             myBot.sendMessage(msg, bufL);
  1265.                             Serial.println(bufL);
  1266.                             break;
  1267.  
  1268.           case MessageContact:
  1269.                             char bufC[50];
  1270.                             snprintf(bufC, sizeof(bufC), "Otrzymano kontakt: %s - %s\n", msg.contact.firstName, msg.contact.phoneNumber ) ;                            
  1271.                             myBot.sendMessage(msg, bufC);
  1272.                             Serial.println(bufC);
  1273.                             break;
  1274.           default:          break;
  1275.     }
  1276.   }
  1277. }
  1278.  
  1279. //
  1280. // ------------------------------------------------------------------------------------------------------------ //
  1281. // --- S E T U P ---------------------------------------------------------------------------------------------- //
  1282. // ------------------------------------------------------------------------------------------------------------ //
  1283. //
  1284. void setup()
  1285. {
  1286.    #if SERIAL
  1287.         Serial.begin(SPEED);                // ustaw prędkość terminala SERIAL
  1288.     #endif
  1289.      
  1290.     WiFi.onEvent(WiFiEvent);                // funkcja zdarzenie Event
  1291.     WiFi.setAutoConnect(true);              // auto-reconnect
  1292.     WiFi.begin(SSID, PASSWORD);             // WiFi start
  1293.     WiFi.mode(WIFI_STA);                    // tryb pracy WiFi
  1294.    
  1295.     while ( WiFi.status() != WL_CONNECTED )                                                    
  1296.     {                                                                                          
  1297.         Serial.print(".");
  1298.         delay(50);                                                                    
  1299.     }            
  1300.    
  1301.     timeClient.begin();                           // włącz klienta NTP (pobieranie czasu z internetu)
  1302.  
  1303.     // --- CPU_Core_0 ----------------------------------------------------------------------------------
  1304.                                                                                                        
  1305.     xTaskCreatePinnedToCore(Core0_Task1, "CPU_Core_0", 5000, NULL, 1, &CPU_Core_0, 0);                
  1306.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                              
  1307.                                                                                                        
  1308.     xTaskCreatePinnedToCore(Core0_Task2, "CPU_Core_0", 5000, NULL, 1, &CPU_Core_0, 0);                
  1309.     vTaskDelay(500 / portTICK_PERIOD_MS);  
  1310.    
  1311.     // --- CPU_Core_1 ----------------------------------------------------------------------------------
  1312.                                                                                                          
  1313.     xTaskCreatePinnedToCore(Core1_Task1, "CPU_Core_1", 5000, NULL, 1, &CPU_Core_1, 1);                
  1314.     vTaskDelay(500 / portTICK_PERIOD_MS);                                                                
  1315.                                                                                                          
  1316.     xTaskCreatePinnedToCore(Core1_Task2, "CPU_Core_1", 5000, NULL, 1, &CPU_Core_1, 1);                
  1317.     vTaskDelay(500 / portTICK_PERIOD_MS);
  1318.  
  1319.     // --- MATRYCA -------------------------------------------------------------------------------------
  1320.  
  1321.     P.begin();                                // włącz matrycę
  1322.     P.setIntensity(1);                        // ustaw jasność wyświetlacza
  1323.     M.Setup();                                // skonfiguruj matrycę  
  1324.     TelegramInit();                           // start Telegram
  1325.  
  1326.     // resetuj przekaźniki (aczkowilek domyślnie do tego ESP nie będą podłączone)
  1327.     // dane będą zczytywany z innego ESP który będzie je obsługiwał
  1328.     // tu tylko sterowanie na tym ESP i wyświetlanie będzie
  1329.  
  1330.     for(byte i = 0; i < 8; i ++ )
  1331.     {
  1332.         przekaznik[i].relayID = i;
  1333.         przekaznik[i].relaySTATUS = false;
  1334.         przekaznik[i].relayOPIS = "off";
  1335.     }
  1336. }
  1337.  
  1338. //
  1339. // ------------------------------------------------------------------------------------------------------------ //
  1340. // --- L O O P ------------------------------------------------------------------------------------------------ //
  1341. // ------------------------------------------------------------------------------------------------------------ //
  1342. //
  1343.  
  1344. void loop()
  1345. {
  1346.     MyTask();  
  1347.     Telegram();
  1348. }
  1349.  
  1350. //
  1351. // ------------------------------------------------------------------------------------------------------------ //
  1352. // --- E N D  ------------------------------------------------------------------------------------------------- //
  1353. // ------------------------------------------------------------------------------------------------------------ //
  1354. //
  1355. //
  1356. //
  1357. //
  1358. //
  1359. //
  1360. //
  1361. // ----------------------------------------------------------------------------------------------------------- //
  1362. // --- T O O L S --------------------------------------------------------------------------------------------- //
  1363. // ----------------------------------------------------------------------------------------------------------- //
  1364. // --- drukuje poziomą linię o zadanej długości -------------------------------------------------------------- //
  1365. // ----------------------------------------------------------------------------------------------------------- //
  1366. //
  1367.  
  1368. void PrintLine(byte lenght)
  1369. {
  1370.     Serial.printf("\n");  
  1371.     for(byte start = 0; start < lenght; start ++ ) Serial.write("-");
  1372. }
  1373.  
  1374. //
  1375. // ----------------------------------------------------------------------------------------------------------- //
  1376. // --- pokazuje wiadomosc (na wejsciu 3 x char) -------------------------------------------------------------- //
  1377. // ----------------------------------------------------------------------------------------------------------- //
  1378. //
  1379.  
  1380. void PrintMSG(const char * wiadomosc_1, const char * wiadomosc_2, const char * wiadomosc_3)    
  1381. {                                                                                                              
  1382.     Serial.printf("\n[%s] [%s] %s", wiadomosc_1, wiadomosc_2, wiadomosc_3);                                    
  1383. }
  1384.  
  1385. //
  1386. // ----------------------------------------------------------------------------------------------------------- //
  1387. // --- drukuje znak końca linii  ----------------------------------------------------------------------------- //
  1388. // ----------------------------------------------------------------------------------------------------------- //
  1389. //
  1390.  
  1391. void PrintEND()    
  1392. {                                                                                                              
  1393.     Serial.printf("\n");
  1394. }
  1395.  
  1396. //
  1397. // ----------------------------------------------------------------------------------------------------------- //
  1398.  
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!