API tools faq
paste
PowerTGS440

StationROOT_v0.48

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