API tools faq
paste
PowerTGS440

StationROOT_v0.16

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