API tools faq
paste
PowerTGS440

StationROOT_v0.12

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