API tools faq
paste
PowerTGS440

StationROOT_v0.47

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