API tools faq
paste
PowerTGS440

simpleESP8266ClockLQ v2.4 PRO

PowerTGS440
Jun 13th, 2021
718
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 71.93 KB | None | 0 0
raw download clone embed print report
  1. // ------------------------------------------------------------------------------------------------------------------- //
  2. //                                                                                                                     //
  3. // Simple ESP8266 CLOCK by TOMASZ MAJCHER (TRANSLINE GROUP POAND)                                                      //
  4. //                                                                                                                     //
  5. // e-mail  : [email protected]                                                                               //
  6. // licence : DonationWare                                                                                              //
  7. // paypal  : @TomaszMajcher                                                                                            //
  8. // www     : https://esp32dev.blogspot.com/                                                                            //
  9. //                                                                                                                     //
  10. // ------------------------------------------------------------------------------------------------------------------- //
  11. //
  12. // v2.4 (12.06.2021) - update : multi-switch (clock, temperature, humidity)
  13. // v2.3 (12.06.2021) - update : move temperature and humidity value to struct MyDHT
  14. // v2.2 (12.06.2021) - update : add Task3Callback (DHT11/DHT22) sensor reader (multilanguage)
  15. // v2.1 (11.06.2021) - update : add DHTesp library (DHT11/DHT22 support)
  16. // v2.0 (11.06.2021) - update : add function -> reconectWiFi (multilanguage)
  17. // v1.9 (10.06.2021) - update : add function -> statWiFi (multilanguage)
  18. // v1.8 (09.06.2021) - update : add function -> initWiFi (multilanguage)
  19. // v1.7 (xx.06.2021) - update : show humidity method in class LCD
  20. // v1.6 (xx.06.2021) - update : show temperature method in class LCD
  21. // v1.5 (xx.06.2021) - update : show percentage (sing)
  22. // v1.4 (xx.06.2021) - update : show C (sing)
  23. // v1.3 (30.05.2021) - update : add TypeWriter Public Method in class LCD
  24. // v1.2 (30.05.2021) - update : MultiLanguage (Day of Week) and (Month) in Germany
  25. // v1.1 (30.05.2021) - update : MultiLanguage (Day of Week) and (Month) in English
  26. // v1.0 (30.05.2021) - update : FINAL FREE VERSION
  27. // v0.9 (30.05.2021) - update : dodano formatowanie LongDate do długości 20 znaków
  28. // v0.8 (30.05.2021) - update : switch ShortData / LongData
  29. // v0.7 (30.05.2021) - update : formatowanie dat LONG / SHORT
  30. // v0.6 (29.05.2021) - update : DNI TYGODNIA / NAZWY MIESIĘCY
  31. // v0.5 (28.05.2021) - update : aktualizacja daty (Task0) co 1 godzinę
  32. // v0.4 (28.05.2021) - update : aktualizacja Timeu (Task1) co 1 minutę
  33. // v0.3 (27.05.2021) - FULL BETA :-)
  34. // v0.2 (26.05.2021) - budowa klasy LCD
  35. // v0.1 (26.05.2021) - budowa projektu
  36. //
  37. // ------------------------------------------------------------------------------------------------------------------- //
  38. //
  39. // GND   <---> GND
  40. // VCC   <---> Vin
  41. // SDA   <---> D2 (NodeMCU) GPIO 4
  42. // SCL   <---> D1 (NodeMCU) GPIO 5
  43. //
  44. // ------------------------------------------------------------------------------------------------------------------- //
  45. // --- L A N G U A G E   S E T U P ----------------------------------------------------------------------------------- //
  46. // ------------------------------------------------------------------------------------------------------------------- //
  47.  
  48. #define LANGUAGE 0                                            // 0 (Polish), 1 (English), 2 (Germany)
  49.                                                              
  50. #if LANGUAGE == 0                                                
  51.     #define POLISH 1
  52.     #define ENGLISH 0
  53.     #define GERMANY 0                                          
  54. #endif
  55.  
  56. #if LANGUAGE == 1                                                      
  57.     #define POLISH 0                                        
  58.     #define ENGLISH 1
  59.     #define GERMANY 0
  60. #endif
  61.  
  62. #if LANGUAGE == 2
  63.     #define POLISH 0
  64.     #define ENGLISH 0
  65.     #define GERMANY 1
  66. #endif      
  67.  
  68. // ------------------------------------------------------------------------------------------------------------------- //
  69. // --- M A C R O   D E F I N E --------------------------------------------------------------------------------------- //
  70. // ------------------------------------------------------------------------------------------------------------------- //
  71.  
  72. #define ARRAY_SIZE(a)   (sizeof(a) / sizeof((a)[0]))
  73.  
  74. const char *ssid     = "xxxxxxxx";                                  // network wifi ssid  
  75. const char *password = "xxxxxxxx";                                  // network wifi password
  76.  
  77. // ------------------------------------------------------------------------------------------------------------------- //
  78. // --- I N C L U D E   L I B R A R Y --------------------------------------------------------------------------------- //
  79. // ------------------------------------------------------------------------------------------------------------------- //
  80.  
  81. extern "C" char* sbrk(int incr);
  82.  
  83. #include "LiquidCrystal_I2C.h" // get from https://circuits4you.com/wp-content/uploads/2019/03/I2C-LCD-ESP8266-Library.zip
  84.  
  85. #include <ESP8266WiFi.h>                                         // biblioteka Wi-Fi
  86. #include <NTPClient.h>                                           // NTP klient (Time)
  87. #include <WiFiUdp.h>                                             // UDP dla NTP (Time)
  88. #include <TaskScheduler.h>                                       // scheluder
  89. #include <TimeLib.h>
  90. #include "DHTesp.h"    
  91. #include <Arduino.h>
  92.  
  93. LiquidCrystal_I2C lcd(0x27,20,4);  
  94.  
  95. #define SERIAL true
  96. #define SerialSpeed 57600
  97.  
  98. #define DHTpin D3                                                 // czujnik temp i wilgotności
  99. DHTesp dht;                                                       // obiekt modułu
  100.  
  101. // ------------------------------------------------------------------------------------------------------------------- //
  102. // --- P R O T O T Y P Y --------------------------------------------------------------------------------------------- //
  103. // ------------------------------------------------------------------------------------------------------------------- //
  104.  
  105. void Task0Callback();                                                     // funkcja dla task_0    
  106. void Task1Callback();                                                     // funkcja dla task_1    
  107. void Task2Callback();                                                     // funkcja dla task_2    
  108. void Task3Callback();                                                     // funkcja dla task_3    
  109.  
  110. // ------------------------------------------------------------------------------------------------------------------- //
  111. // --- Z A D A N I A   S C H E L U D E R ' A ------------------------------------------------------------------------- //
  112. // ------------------------------------------------------------------------------------------------------------------- //
  113.                                                                                                    
  114. Task task_0( 3600000, TASK_FOREVER, &Task0Callback);                      // task_0 - co 1 godzinę  
  115. Task task_1(  60000,  TASK_FOREVER, &Task1Callback);                      // task_1 - co 1 minutę  
  116. Task task_2(   1000,  TASK_FOREVER, &Task2Callback);                      // task_2 - co 1 sekundę  
  117. Task task_3(  90000,  TASK_FOREVER, &Task3Callback);                      // task_3 - co 90 sekund -- dla DHT11/DHT22
  118.                                                                                                    
  119. Scheduler runner;    
  120.  
  121. // ------------------------------------------------------------------------------------------------------------------- //
  122. //                                              *** DHT11/22 ***                                                       //
  123. // ------------------------------------------------------------------------------------------------------------------- //
  124.  
  125. struct MyDHT
  126. {
  127.     float temperature = 20.0;   // default - DHT11/DHT22
  128.     float humidity    = 50.0;   // default - DHT11/DHT22
  129. }
  130. myDHT;
  131.  
  132. // ------------------------------------------------------------------------------------------------------------------- //
  133. //                                              *** WiFi Reconect ***                                                  //
  134. // ------------------------------------------------------------------------------------------------------------------- //
  135.  
  136. unsigned long previousMillis = 0;
  137. unsigned long interval = 30000;
  138.  
  139. // ------------------------------------------------------------------------------------------------------------------- //
  140. //                                              *** STRUKTURA Time ***                                                 //
  141. // ------------------------------------------------------------------------------------------------------------------- //
  142.  
  143. struct TIME_DATA
  144. {
  145.     int Hour = 0;
  146.     int Minute  = 0;
  147.     int Second = 0;
  148.     String FormatedData  = "NULL";
  149.     String ShortData = "NULL";
  150.     String LongData = "NULL";
  151.     int DayOfTheWeek = 0;
  152.     int DayOfTheMonth = 0;
  153.     int Month = 0;
  154.     int Year = 0;
  155. }
  156. Time;
  157.  
  158. bool DisplayTime = true;
  159. bool DisplayTemperature = false;
  160. bool DisplayHumidity = false;
  161.  
  162. // ------------------------------------------------------------------------------------------------------------------- //
  163. //                                              *** STRUKTURA DZIEN ***                                                //
  164. // ------------------------------------------------------------------------------------------------------------------- //
  165.  
  166. #if POLISH
  167.     const char Day_0 [] = "Niedziela";
  168.     const char Day_1 [] = "Poniedzialek";
  169.     const char Day_2 [] = "Wtorek";
  170.     const char Day_3 [] = "Sroda";
  171.     const char Day_4 [] = "Czwartek";
  172.     const char Day_5 [] = "Piatek";
  173.     const char Day_6 [] = "Sobota";
  174. #endif
  175.  
  176. #if ENGLISH
  177.     const char Day_0 [] = "Sunday";
  178.     const char Day_1 [] = "Monday";
  179.     const char Day_2 [] = "Tuesday";
  180.     const char Day_3 [] = "Wednesday";
  181.     const char Day_4 [] = "Thursday";
  182.     const char Day_5 [] = "Friday";
  183.     const char Day_6 [] = "Saturday";
  184. #endif
  185.  
  186. #if GERMANY
  187.     const char Day_0 [] = "Sonntag";
  188.     const char Day_1 [] = "Montag";
  189.     const char Day_2 [] = "Dienstag";
  190.     const char Day_3 [] = "Mittwoch";
  191.     const char Day_4 [] = "Donnerstag";
  192.     const char Day_5 [] = "Freitag";
  193.     const char Day_6 [] = "Samstag";
  194. #endif
  195.  
  196. const char * const DAY[] = { Day_0, Day_1, Day_2, Day_3, Day_4, Day_5, Day_6 }; // dni tygodnia [0..6]
  197.  
  198. // ------------------------------------------------------------------------------------------------------------------- //
  199. //                                              *** STRUKTURA MONTH ***                                                //
  200. // ------------------------------------------------------------------------------------------------------------------- //
  201.  
  202. #if POLISH
  203.     const char MONTH_0  [] = "NULL";
  204.     const char MONTH_1  [] = "Styczen";
  205.     const char MONTH_2  [] = "Luty";
  206.     const char MONTH_3  [] = "Marzec";
  207.     const char MONTH_4  [] = "Kwiecien";
  208.     const char MONTH_5  [] = "Maj";
  209.     const char MONTH_6  [] = "Czerwiec";
  210.     const char MONTH_7  [] = "Lipiec";
  211.     const char MONTH_8  [] = "Sierpien";
  212.     const char MONTH_9  [] = "Wrzesien";
  213.     const char MONTH_10 [] = "Pazdziernik";
  214.     const char MONTH_11 [] = "Listopad";
  215.     const char MONTH_12 [] = "Grudzien";
  216. #endif
  217.  
  218. #if ENGLISH
  219.     const char MONTH_0  [] = "NULL";
  220.     const char MONTH_1  [] = "January";
  221.     const char MONTH_2  [] = "February";
  222.     const char MONTH_3  [] = "March";
  223.     const char MONTH_4  [] = "April";
  224.     const char MONTH_5  [] = "May";
  225.     const char MONTH_6  [] = "June";
  226.     const char MONTH_7  [] = "July";
  227.     const char MONTH_8  [] = "August";
  228.     const char MONTH_9  [] = "September";
  229.     const char MONTH_10 [] = "October";
  230.     const char MONTH_11 [] = "November";
  231.     const char MONTH_12 [] = "December";
  232. #endif
  233.  
  234. #if GERMANY
  235.     const char MONTH_0  [] = "NULL";
  236.     const char MONTH_1  [] = "Januar";
  237.     const char MONTH_2  [] = "Februar";
  238.     const char MONTH_3  [] = "März";
  239.     const char MONTH_4  [] = "April";
  240.     const char MONTH_5  [] = "Mai";
  241.     const char MONTH_6  [] = "Juni";
  242.     const char MONTH_7  [] = "Juli";
  243.     const char MONTH_8  [] = "August";
  244.     const char MONTH_9  [] = "September";
  245.     const char MONTH_10 [] = "Oktober";
  246.     const char MONTH_11 [] = "November";
  247.     const char MONTH_12 [] = "Dezember";
  248. #endif
  249.    
  250.     const char * const MONTH[] = { MONTH_0, MONTH_1, MONTH_2, MONTH_3, MONTH_4, MONTH_5, MONTH_6,
  251.                                    MONTH_7, MONTH_8, MONTH_9, MONTH_10, MONTH_11, MONTH_12 };
  252.  
  253. // ------------------------------------------------------------------------------------------------------------------- //
  254. //                            *** KLASA LCD *** by Tomasz Majcher (TLG) v1.00 Lite ***                                 //
  255. // ------------------------------------------------------------------------------------------------------------------- //
  256.  
  257. class LCD
  258. {
  259.     private :
  260.  
  261.         // --- ZMIENNE PRYWATNE -------------------------------------------------------------------------------------- //
  262.  
  263.         byte LGc[8]  = { B00111, B01111, B11111, B11111, B11111, B11111, B11111, B11111 };         // lewy górny ----- //
  264.         byte LDc[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B01111, B00111 };         // lewy dolny ----- //
  265.         byte PGc[8]  = { B11100, B11110, B11111, B11111, B11111, B11111, B11111, B11111 };         // prawy górny ---- //
  266.         byte PDc[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B11110, B11100 };         // prawy dolny ---- //
  267.         byte UDb[8]  = { B11111, B11111, B11111, B11111, B11111, B00000, B00000, B00000 };         // górny 1/2 ------ //
  268.         byte DDb[8]  = { B00000, B00000, B00000, B11111, B11111, B11111, B11111, B11111 };         // dolny 1/2 ------ //
  269.         byte blk[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 };         // blok pełny ----- //
  270.         byte emp[8]  = { B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000 };         // blok pusty ----- //
  271.             byte procent[8] = { B00000, B01110, B10001, B10001, B10001, B01110, B00000, B00000 };      // procent -------- //
  272.  
  273.         // --- ZMIENNE PRYWATNE -------------------------------------------------------------------------------------- //
  274.  
  275.         LiquidCrystal_I2C & MyLCD;
  276.  
  277.         void ShowDot(int x, int y);
  278.         void ShowColon(int x, int y);
  279.         void Digit0(int x, int y);
  280.         void Digit1(int x, int y);
  281.         void Digit2(int x, int y);
  282.         void Digit3(int x, int y);
  283.         void Digit4(int x, int y);
  284.         void Digit5(int x, int y);
  285.         void Digit6(int x, int y);
  286.         void Digit7(int x, int y);
  287.         void Digit8(int x, int y);
  288.         void Digit9(int x, int y);
  289.             void ShowC (int x, int y);
  290.         void ShowPercentage(int x, int y);
  291.         void ShowDigit(int x, int y, int numer);
  292.         void ClearLine(int x);        
  293.  
  294.         // ---------------------------------------------------------------------------------------- //  
  295.         // --- METODY PRYWATNE -------------------------------------------------------------------- //
  296.         // ---------------------------------------------------------------------------------------- //
  297.  
  298.        
  299.         // ---------------------------------------------------------------------------------------- //
  300.        
  301.     public  :
  302.  
  303.         // ---------------------------------------------------------------------------------------- //
  304.         // --- KONSTRUKTOR KLACY LCD -------------------------------------------------------------- //
  305.         // ---------------------------------------------------------------------------------------- //
  306.        
  307.         LCD (LiquidCrystal_I2C &adres_lc) : MyLCD(adres_lc)
  308.         {
  309.             LcdRegister();  
  310.         }
  311.        
  312.         // ---------------------------------------------------------------------------------------- //
  313.         //  --- METODY PUBLICZNE KLASY LCD -------------------------------------------------------- //
  314.         // ---------------------------------------------------------------------------------------- //
  315.  
  316.         void ShowTime();  // wyswietl zegar  
  317.         void ShowDate();  // wyswietl datę
  318.         void LcdRegister();   // zarejestruj nowy zestaw znaków specjalnych  
  319.         void TypeWriter(const String & message, unsigned int wait, unsigned int x, unsigned int y);
  320.         void ShowTemperature();
  321.         void ShowHumidity();                                                                                        
  322. };
  323.  
  324. // ------------------------------------------------------------------------------------------------------------------- //
  325. //          *** METODY PRYWATNE *** WYCZYSC LINIE X***                                                                 //
  326. // ------------------------------------------------------------------------------------------------------------------- //
  327.  
  328. void LCD :: ClearLine(int y)
  329. {
  330.     MyLCD.setCursor(0,y);
  331.     MyLCD.print(F("                    "));            
  332. }
  333.  
  334. // ------------------------------------------------------------------------------------------------------------------- //
  335. //          *** METODY PRYWATNE *** ZAREJESTRUJ NOWY ZESTAW ZNAKÓW SPECJALNYCH DLA WYŚWIETLACZA 20x4 ***               //
  336. // ------------------------------------------------------------------------------------------------------------------- //
  337.  
  338. void LCD :: LcdRegister()                                                                                        
  339. {                                                                                                                
  340.           MyLCD.createChar(0,LGc);                                   // 0 -> lewy górny narożnik ------------ //
  341.           MyLCD.createChar(1,LDc);                                   // 1 -> lewy dolny narożnik ------------ //
  342.           MyLCD.createChar(2,PGc);                                   // 2 -> prawy górny narożnik ----------- //
  343.           MyLCD.createChar(3,PDc);                                   // 3 -> prawy dolny narożnik ----------- //
  344.           MyLCD.createChar(4,UDb);                                   // 4 -> górny pół-blok ----------------- //
  345.           MyLCD.createChar(5,DDb);                                   // 5 -> dolny pół-blok ----------------- //
  346.           MyLCD.createChar(6,blk);                                   // 6 -> pełny blok --------------------- //
  347.               MyLCD.createChar(7,procent);                               // 7 -> kolko gora --------------------- //  
  348. }
  349.  
  350. // ------------------------------------------------------------------------------------------------------------------- //
  351. // --- Duża Digit 0 -------------------------------------------------------------------------------------------------- //
  352. // ------------------------------------------------------------------------------------------------------------------- //
  353.  
  354. void LCD :: Digit0(int x, int y)                                  
  355. {                                                                                                                  //          
  356.           MyLCD.setCursor(x,y);                                     // ustaw kursor ------------------------ //
  357.           MyLCD.write(0);                                           // lewy górny narożnk ------------------ //          
  358.           MyLCD.write(4);                                           // kropa górna ------------------------- //
  359.           MyLCD.write(2);                                           // prawy górny narożnik ---------------- //
  360.           MyLCD.setCursor(x,y+1);                                   // ustaw kursor ------------------------ //
  361.           MyLCD.write(6);                                           // pełny 5x8 --------------------------- //
  362.           MyLCD.print(F(" "));                                      // pusty blok -------------------------- //          
  363.           MyLCD.write(6);                                           // pełny 5x8 --------------------------- //
  364.           MyLCD.setCursor(x,y+2);                                   // ustaw kursor ------------------------ //
  365.           MyLCD.write(1);                                           // lewy dolny narożnik ----------------- //
  366.           MyLCD.write(5);                                           // kropa dolna ------------------------- //
  367.           MyLCD.write(3);                                           // prawy dolny narożnik ---------------- //
  368. }                                                                    
  369.  
  370. // ------------------------------------------------------------------------------------------------------------------- //
  371. // --- Duża Digit 1 -------------------------------------------------------------------------------------------------- //
  372. // ------------------------------------------------------------------------------------------------------------------- //
  373.  
  374. void LCD :: Digit1(int x, int y)  
  375. {                                                                                                          
  376.           MyLCD.setCursor(x,y);                                      // ustaw kursor ----------------------- //
  377.           MyLCD.write(4);                                            // górna kropa ------------------------ //
  378.           MyLCD.write(2);                                            // prawy górny narożnik --------------- //          
  379.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //          
  380.           MyLCD.setCursor(x,y+1);                                    // ustaw kursor ----------------------- //
  381.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //                    
  382.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  383.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //                    
  384.           MyLCD.setCursor(x,y+2);                                    // ustaw kursor ----------------------- //
  385.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  386.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //
  387.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  388. }    
  389.                                                                    
  390. // ------------------------------------------------------------------------------------------------------------------- //
  391. // --- Duża Digit 2 -------------------------------------------------------------------------------------------------- //
  392. // ------------------------------------------------------------------------------------------------------------------- //
  393.  
  394. void LCD :: Digit2(int x, int y)                                                                    
  395. {                                                                                                                
  396.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  397.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  398.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  399.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  400.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  401.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  402.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  403.           MyLCD.write(4);                                           // kropa górna ------------------------ //          
  404.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //
  405.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //  
  406.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  407.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  408. }                                                                      
  409.  
  410. // ------------------------------------------------------------------------------------------------------------------- //
  411. // --- Duża Digit 3 -------------------------------------------------------------------------------------=------------ //
  412. // ------------------------------------------------------------------------------------------------------------------- //
  413.  
  414. void LCD :: Digit3(int x, int y)                
  415. {                                                      
  416.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  417.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  418.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  419.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  420.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  421.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  422.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  423.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  424.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  425.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  426.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  427.           MyLCD.write(3);                                           // prawy dolny narożnik --------------- //
  428. }                                              
  429.  
  430. // ------------------------------------------------------------------------------------------------------------------- //
  431. // --- Duża Digit 4 ------------------------------------------------------------------------------------=------------- //
  432. // ------------------------------------------------------------------------------------------------------------------- //
  433.  
  434. void LCD :: Digit4(int x, int y)    
  435. {                                                    
  436.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  437.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  438.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //                    
  439.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //                    
  440.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  441.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //          
  442.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  443.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  444.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  445.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  446.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  447.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  448. }                                                                                                              
  449.  
  450. // ------------------------------------------------------------------------------------------------------------------- //
  451. // --- Duża Digit 5 -----------------------------------------------------------------------------------=-------------- //
  452. // ------------------------------------------------------------------------------------------------------------------- //
  453.    
  454. void LCD :: Digit5(int x, int y)                            
  455. {                                                                            
  456.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  457.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //  
  458.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  459.           MyLCD.write(4);                                           // kropa górna ------------------------ //                    
  460.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  461.           MyLCD.write(4);                                           // kropa górna ------------------------ //        
  462.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  463.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  464.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  465.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //
  466.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  467.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  468. }                                                                                                                
  469.  
  470. // ------------------------------------------------------------------------------------------------------------------- //
  471. // --- Duża Digit 6 ---------------------------------------------------------------------------------------=---------- //
  472. // ------------------------------------------------------------------------------------------------------------------- //
  473.    
  474. void LCD :: Digit6(int x, int y)                                                                  
  475. {                                                                                                              
  476.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  477.           MyLCD.write(0);                                           // lewy górny narożnk ----------------- //          
  478.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  479.           MyLCD.write(4);                                           // kropa górna ------------------------ //                    
  480.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  481.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  482.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  483.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  484.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  485.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //
  486.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  487.           MyLCD.write(3);                                           // prawy dolny narożnik --------------- //
  488. }                                                                                                                  
  489.  
  490. // ------------------------------------------------------------------------------------------------------------------- //
  491. // --- Duża Digit 7 -----------------------------------------------------------------------------------------=-------- //
  492. // ------------------------------------------------------------------------------------------------------------------- //
  493.  
  494. void LCD :: Digit7(int x, int y)      
  495. {                                                      
  496.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  497.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  498.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  499.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //                    
  500.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  501.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //                    
  502.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  503.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  504.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  505.           MyLCD.print(F("  "));                                     // pusty blok ------------------------- //                    
  506.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  507. }                                                                                                      
  508.  
  509. // ------------------------------------------------------------------------------------------------------------------- //
  510. // --- Duża Digit 8 -----------------------------------------------------------------------------------------=-------- //
  511. // ------------------------------------------------------------------------------------------------------------------- //
  512.  
  513. void LCD :: Digit8(int x, int y)  
  514. {                                                  
  515.           MyLCD.setCursor(x,y);                                      // ustaw kursor ----------------------- //
  516.           MyLCD.write(0);                                            // lewy górny narożnk ----------------- //          
  517.           MyLCD.write(4);                                            // kropa górna ------------------------ //
  518.           MyLCD.write(2);                                            // prawy górny narożnik --------------- //                    
  519.           MyLCD.setCursor(x, y+1);                                   // ustaw kursor ----------------------- //
  520.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  521.           MyLCD.write(4);                                            // kropa górna ------------------------ //
  522.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  523.           MyLCD.setCursor(x, y+2);                                   // ustaw kursor ----------------------- //          
  524.           MyLCD.write(1);                                            // lewy dolny narożnik ---------------- //
  525.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  526.           MyLCD.write(3);                                            // prawy dolny narożnik --------------- //
  527. }                                                                                                                
  528.  
  529. // ------------------------------------------------------------------------------------------------------------------- //
  530. // --- Duża Digit 9 -------------------------------------------------------------------------------------------=------ //
  531. // ------------------------------------------------------------------------------------------------------------------- //
  532.  
  533. void LCD :: Digit9(int x, int y)                                                        
  534. {                                                                                                        
  535.           MyLCD.setCursor(x,y);                                       // ustaw kursor ----------------------- //
  536.           MyLCD.write(0);                                             // lewy górny narożnk ----------------- //  
  537.           MyLCD.write(4);                                             // kropa górna ------------------------ //
  538.           MyLCD.write(2);                                             // prawy górny narożnik --------------- //                    
  539.           MyLCD.setCursor(x, y+1);                                    // ustaw kursor ----------------------- //
  540.           MyLCD.write(1);                                             // lewy dolny narożnik ---------------- //          
  541.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  542.           MyLCD.write(6);                                             // pełny 5x8 -------------------------- //          
  543.           MyLCD.setCursor(x, y+2);                                    // ustaw kursor ----------------------- //          
  544.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  545.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  546.           MyLCD.write(3);                                             // prawy dolny narożnik --------------- //
  547. }  
  548.                                                                                                                
  549. // ------------------------------------------------------------------------------------------------------------------- //
  550. // --- Duża Digit 9 ----------------------------------------------------------------------------------------=--------- //
  551. // ------------------------------------------------------------------------------------------------------------------- //
  552.  
  553. void LCD :: ShowColon(int x, int y)          
  554. {                                                            
  555.           MyLCD.setCursor(x,y);                                       // ustaw kursor ----------------------- //
  556.           MyLCD.print(F(" "));                                        // pusty blok ------------------------- //          
  557.           MyLCD.setCursor(x,y+1);                                     // ustaw kursor ----------------------- //
  558.           MyLCD.write(4);                                             // kropa górna ------------------------ //
  559.           MyLCD.setCursor(x,y+2);                                     // ustaw kursor ----------------------- //
  560.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  561. }
  562.  
  563. // ------------------------------------------------------------------------------------------------------------------- //
  564. // --- KROPA --------------------------------------------------------------------------------------------------------- //
  565. // ------------------------------------------------------------------------------------------------------------------- //
  566.  
  567. void LCD :: ShowDot(int x, int y)
  568. {                                              
  569.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  570.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  571.           MyLCD.setCursor(x,y+1);                                      // ustaw kursor ----------------------- //
  572.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  573.           MyLCD.setCursor(x,y+2);                                      // ustaw kursor ----------------------- //
  574.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  575. }          
  576.  
  577. // --------------------------------------------------------------------------------------------------------------- //
  578.  
  579. void LCD :: ShowC (int x, int y)                                                                    
  580. {
  581.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  582.           MyLCD.write(0);                                              // lewy górny narożnk ----------------- //          
  583.           MyLCD.write(4);                                              // kropa górna ------------------------ //
  584.           MyLCD.write(4);                                              // kropa górna ------------------------ //
  585.           MyLCD.setCursor(x, y+1);                                     // ustaw kursor ----------------------- //
  586.           MyLCD.write(6);                                              // pełny 5x8 -------------------------- //          
  587.           MyLCD.print(F("  "));                                        // pusty blok ------------------------- //          
  588.           MyLCD.setCursor(x, y+2);                                     // ustaw kursor ----------------------- //          
  589.           MyLCD.write(1);                                              // lewy dolny narożnik ---------------- //
  590.           MyLCD.write(5);                                              // kropa dolna ------------------------ //
  591.           MyLCD.write(5);                                              // kropa dolna ------------------------ //
  592. }                                                                                                            
  593.  
  594. // --------------------------------------------------------------------------------------------------------------- //
  595. void LCD :: ShowPercentage(int x, int y)    
  596. {                                                                          
  597.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  598.           MyLCD.write(7);                                              // lewy górny narożnk ----------------- //          
  599.           MyLCD.print(F(" /"));                                        // pusty blok ------------------------- //          
  600.           MyLCD.setCursor(x, y+1);                                     // ustaw kursor ----------------------- //
  601.           MyLCD.print(F(" / "));                                       // pusty blok ------------------------- //                    
  602.           MyLCD.setCursor(x, y+2);                                     // ustaw kursor ----------------------- //                    
  603.           MyLCD.print(F("/ "));                                        // pusty blok ------------------------- //
  604.           MyLCD.write(7);                                              // lewy górny narożnk ----------------- //
  605. }                                                                          
  606.  
  607. // ------------------------------------------------------------------------------------------------------------------- //
  608. // --- WYSWIETL CYFRE ------------------------------------------------------------------------------------------------ //
  609. // ------------------------------------------------------------------------------------------------------------------- //
  610.  
  611. void LCD :: ShowDigit(int x, int y, int numer)
  612. {                                      
  613.     // --------------------------------------------------------------------------------------------------------- //
  614.                                                      // K O N T R O L A   B Ł Ę D U                              //
  615.     if(x > 17) x = 17;                               // jesli pozycja x większa niż 17, ustaw maksymalną ------- //
  616.     if(y >  1) y =  1;                               // jesli pozycja y wieksza niz 1 , ustaw maksymalna ------- //
  617.                                                                                                                  //
  618.     // --------------------------------------------------------------------------------------------------------- //
  619.              
  620.     switch (numer)                                                                                              
  621.     {                                                                                                          
  622.         case  0:  Digit0(x,y); break;                                                                          
  623.         case  1:  Digit1(x,y); break;                                                                          
  624.         case  2:  Digit2(x,y); break;                                                                          
  625.         case  3:  Digit3(x,y); break;                                                                          
  626.         case  4:  Digit4(x,y); break;                                                                          
  627.         case  5:  Digit5(x,y); break;                                                                          
  628.         case  6:  Digit6(x,y); break;                                                                          
  629.         case  7:  Digit7(x,y); break;                                                                          
  630.         case  8:  Digit8(x,y); break;                                                                          
  631.         case  9:  Digit9(x,y); break;                                                                          
  632.     }                                                                                                          
  633. }        
  634.  
  635. // ------------------------------------------------------------------------------------------------------------------- //
  636. //          *** METODY PUBLICZNE *** WYSWIETL Time ***                                                                 //
  637. // ------------------------------------------------------------------------------------------------------------------- //
  638.  
  639. void LCD :: ShowTime()
  640. {
  641.     static bool F_sec = false;
  642.     static int  O_min = 0;              // optymalizacja (no flickering)
  643.     static int  O_hrs = 0;              // optymalizacja (no flickering)
  644.  
  645.     if (O_min != Time.Minute)  
  646.     {
  647.         ShowDigit(0,  0, Time.Hour / 10);
  648.         ShowDigit(4,  0, Time.Hour % 10);
  649.         ShowDigit(10, 0, Time.Minute / 10);
  650.         ShowDigit(14, 0, Time.Minute % 10);
  651.         O_min = Time.Minute;
  652.     }
  653.  
  654.     switch (F_sec)                
  655.     {                            
  656.         case 0 :  ShowColon(8,0); F_sec = true;  break;
  657.         case 1 :  ShowDot(8,0); F_sec = false; break;
  658.         default: break;          
  659.     }  
  660.  
  661.     MyLCD.setCursor(18,2);                     // ustaw pozycję SEKUNDNIKA
  662.     MyLCD.print(Time.Second / 10);             // wyswietl dziesiątki sekundnika
  663.     MyLCD.print(Time.Second % 10);             // wyswietl jednosci sekundnika
  664.     MyLCD.setCursor(18,0);                     // ustaw pozycję AM/PM
  665.     if (Time.Hour < 12) MyLCD.print(F("AM"));
  666.     else                MyLCD.print(F("PM"));
  667.  
  668. }
  669.  
  670. // ------------------------------------------------------------------------------------------------------------------- //
  671. //          *** METODY PUBLICZNE *** WYSWIETL Temperaturę ***                                                          //
  672. // ------------------------------------------------------------------------------------------------------------------- //
  673.  
  674. void LCD :: ShowTemperature()                                                                                        
  675. {
  676.     int temp1 = int(myDHT.temperature) / 10;                     // 1x
  677.     int temp2 = int(myDHT.temperature) % 10;                     // x1
  678.     MyLCD.setCursor(4,0);
  679.  
  680.     #if POLISH
  681.         MyLCD.print(F("TEMPERATURA"));
  682.     #endif
  683.  
  684.     #if ENGLISH
  685.         MyLCD.print(F("TEMPERATURE"));
  686.     #endif
  687.  
  688.     #if GERMANY
  689.         MyLCD.print(F("TEMPERATUR"));
  690.     #endif
  691.    
  692.     ShowDigit(3,  1, temp1);
  693.     ShowDigit(7,  1, temp2);
  694.     MyLCD.setCursor(11,1);  
  695.     MyLCD.write(7);
  696.     ShowC(13,1);
  697. }                                                                                                                  
  698.  
  699.  
  700. // ------------------------------------------------------------------------------------------------------------------- //
  701. //          *** METODY PUBLICZNE *** WYSWIETL Wilgotnosc ***                                                           //
  702. // ------------------------------------------------------------------------------------------------------------------- //
  703.  
  704. void LCD :: ShowHumidity()                                                                                        
  705. {          
  706.     int humi1 = int(myDHT.humidity) / 10;
  707.     int humi2 = int(myDHT.humidity) % 10;
  708.     MyLCD.setCursor(5,0);    
  709.  
  710.     #if POLISH
  711.         MyLCD.print(F("WILGOTNOSC"));
  712.     #endif
  713.  
  714.     #if ENGLISH
  715.         MyLCD.print(F("HUMIDITY"));
  716.     #endif
  717.  
  718.     #if GERMANY
  719.         MyLCD.print(F("Feuchtigkeit"));
  720.     #endif    
  721.        
  722.     ShowDigit(4,  1,  humi1);
  723.     ShowDigit(8,  1,  humi2);
  724.     ShowPercentage(13,1);  
  725. }                          
  726.  
  727. // ------------------------------------------------------------------------------------------------------------------- //
  728. //          *** METODY PUBLICZNE *** WYSWIETL DATE ***                                                                 //
  729. // ------------------------------------------------------------------------------------------------------------------- //
  730.  
  731. void LCD :: ShowDate()
  732. {
  733.     static bool switcher = true;
  734.     ClearLine(3);
  735.     MyLCD.setCursor(0,3);
  736.  
  737.     if ( switcher )
  738.     {
  739.         MyLCD.print(Time.ShortData);
  740.         switcher = false;
  741.     }
  742.     else
  743.     if ( !switcher )
  744.     {
  745.         MyLCD.print(Time.LongData);
  746.         switcher = true;
  747.     }
  748. }
  749.  
  750. // ------------------------------------------------------------------------------------------------------------------- //
  751. //          *** METODY PUBLICZNE *** T Y P E W R I T E R ***                                                           //
  752. // ------------------------------------------------------------------------------------------------------------------- //
  753.  
  754. void LCD :: TypeWriter(const String & message, unsigned int wait, unsigned int x, unsigned int y)
  755. {
  756.     MyLCD.setCursor(x,y);
  757.     for(const char c : message)
  758.     {
  759.         MyLCD.print(c);    
  760.         delay(wait);  
  761.     }
  762. }
  763.    
  764. // ------------------------------------------------------------------------------------------------------------------- //
  765. //                            *** KLASA LCD *** by Tomasz Majcher (TLG) v2.00 Lite ***                                 //
  766. // ------------------------------------------------------------------------------------------------------------------- //
  767. //                                    * * * K O N I E C   K L A S Y   L C D ***                                        //
  768. // ------------------------------------------------------------------------------------------------------------------- //
  769.  
  770.  
  771. // ------------------------------------------------------------------------------------------------------------------- //
  772. // --- O B I E K T Y  ------------------------------------------------------------------------------------------------ //
  773. // ------------------------------------------------------------------------------------------------------------------- //
  774.  
  775. LCD myLCD(lcd);
  776.  
  777. WiFiUDP ntpUDP;                                                
  778. NTPClient timeClient(ntpUDP, "pool.ntp.org", 3600);  
  779.  
  780. // ------------------------------------------------------------------------------------------------------------------- //
  781. // --- Task0Callback() ----------------------------------------------------------------------------------------------- //
  782. // ------------------------------------------------------------------------------------------------------------------- //
  783.  
  784. void Task0Callback()
  785. {
  786.     timeClient.update();                                                                              
  787.    
  788.     unsigned long epochTime = timeClient.getEpochTime();                                              
  789.     struct tm *ptm = gmtime ( (time_t *) &epochTime );                                          
  790.                                                                                                
  791.     Time.DayOfTheWeek      =   timeClient.getDay();                                          
  792.     Time.DayOfTheMonth     =   ptm->tm_mday;                                                
  793.     Time.Month             =   ptm->tm_mon+1;                                                
  794.     Time.Year              =   ptm->tm_year+1900;
  795.  
  796.     Time.FormatedData  
  797.                    =   String(DAY[Time.DayOfTheWeek])
  798.                    +   ", "
  799.                    +   String(Time.DayOfTheMonth)
  800.                    +   " "
  801.                    +   String(MONTH[Time.Month])
  802.                    +   " "
  803.                    +   String(Time.Year);    
  804.  
  805.     Time.ShortData = String(Time.DayOfTheMonth)
  806.                    +   " "
  807.                    +   String(MONTH[Time.Month])
  808.                    +   " "
  809.                    +   String(Time.Year);  
  810.  
  811.     Time.LongData  =   String(DAY[Time.DayOfTheWeek])
  812.                    +   " "
  813.                    +   String(Time.DayOfTheMonth)
  814.                    +   "/"
  815.                    +   String(Time.Month);
  816.  
  817.     // --- formatowanie długości wyświetlanej daty ---
  818.  
  819.     if ( strlen(Time.LongData.c_str()) < 15 ) // jesli uda sie dokleci /RRRR
  820.     {
  821.         Time.LongData += "/" +   String(Time.Year);
  822.     }
  823.     else
  824.     if ( strlen(Time.LongData.c_str()) < 18 ) // jesli nie uda się dokleić /RRRR doklej /RR
  825.     {
  826.       Time.LongData += "/" +   String(Time.Year % 100);
  827.     }
  828.     else
  829.     if ( strlen(Time.LongData.c_str()) < 17 ) // jesli nie uda sie dokleic /RR
  830.     {
  831.       // nie rób nic :-)
  832.     }
  833.  
  834.     // -----------------------------------------------                  
  835.  
  836.     #if SERIAL                                                                                  
  837.         Serial.printf("\n\n[ESP] [TASK0] Data NTP  \t: %s ", Time.FormatedData.c_str());        
  838.     #endif          
  839. }
  840.  
  841. // ------------------------------------------------------------------------------------------------------------------- //
  842. // --- Task1Callback() ----------------------------------------------------------------------------------------------- //
  843. // ------------------------------------------------------------------------------------------------------------------- //
  844.  
  845. void Task1Callback()
  846. {
  847.     #if SERIAL
  848.         String bufor;
  849.        
  850.         if (Time.Hour < 10)
  851.         {
  852.             bufor =  "0";
  853.             bufor += String(Time.Hour);
  854.         }
  855.         else
  856.         {
  857.             bufor = String(Time.Hour);
  858.         }
  859.  
  860.         bufor += ":";
  861.  
  862.         if (Time.Minute < 10)
  863.         {
  864.             bufor +=  "0";
  865.             bufor += String(Time.Minute);
  866.         }
  867.         else
  868.         {
  869.             bufor += String(Time.Minute);
  870.         }
  871.  
  872.         if (Time.Hour < 12) bufor += " AM";
  873.         else                bufor += " PM";
  874.        
  875.         Serial.printf("\n\n[ESP] [TASK1] [Time NTP] \t: %s", bufor.c_str());
  876.         Serial.printf("\n[ESP] [TASK1] [Memory Free]     : %u [kB]", ESP.getFreeHeap());      
  877.         Serial.printf("\n[ESP] [TASK1] [CPU frequency]   : %u [MHz]",ESP.getCpuFreqMHz());  
  878.         Serial.printf("\n[ESP] [TASK1] [WiFi IP]         : "); Serial.print(WiFi.localIP() );
  879.         Serial.printf("\n[ESP] [TASK1] [LongData]  \t: %s ", Time.LongData.c_str());
  880.         Serial.printf("\n[ESP] [TASK1] [ShortData] \t: %s ", Time.ShortData.c_str());
  881.        
  882.     #endif    
  883.  
  884.     switch(Time.Minute % 10)
  885.     {
  886.         case  0 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  887.         case  1 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  888.         case  2 : DisplayTime = false; DisplayTemperature = true; DisplayHumidity = false; break;
  889.         case  3 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  890.         case  4 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  891.         case  5 : DisplayTime = false; DisplayTemperature = false; DisplayHumidity = true; break;
  892.         case  6 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  893.         case  7 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  894.         case  8 : DisplayTime = false; DisplayTemperature = true; DisplayHumidity = false; break;
  895.         case  9 : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;
  896.         default : DisplayTime = true; DisplayTemperature = false; DisplayHumidity = false; break;      
  897.     }  
  898.  
  899.     if(DisplayTime)
  900.     {
  901.         lcd.clear();
  902.         myLCD.ShowDate();  
  903.     }
  904.     if(DisplayTemperature)
  905.     {
  906.         lcd.clear();
  907.         myLCD.ShowTemperature();    
  908.     }
  909.     else
  910.     if(DisplayHumidity)
  911.     {
  912.         lcd.clear();
  913.         myLCD.ShowHumidity();                                                                                        
  914.     }
  915.        
  916. }
  917.  
  918. // ------------------------------------------------------------------------------------------------------------------- //
  919. // --- Task2Callback() ----------------------------------------------------------------------------------------------- //
  920. // ------------------------------------------------------------------------------------------------------------------- //
  921.  
  922. void Task2Callback()
  923. {
  924.     timeClient.update();                                                            
  925.                                                                                    
  926.     Time.Hour    =  timeClient.getHours()+1;             // zapisz godzinę z serwera
  927.     Time.Minute  =  timeClient.getMinutes();             // zapisz minutę z serwera
  928.     Time.Second  =  timeClient.getSeconds();             // zapisz sekundę z serwera      
  929.    
  930.     if(DisplayTime)
  931.     {
  932.         myLCD.ShowTime();                  
  933.     }
  934. }
  935.  
  936. // ------------------------------------------------------------------------------------------------------------------- //
  937. // --- Task3Callback() ----------------------------------------------------------------------------------------------- //
  938. // ------------------------------------------------------------------------------------------------------------------- //
  939.  
  940. void Task3Callback()
  941. {
  942.     TempAndHumidity sensor = dht.getTempAndHumidity();
  943.  
  944.     float t_temp = myDHT.temperature;                     // zapamiętaj wartość poprzednią
  945.     float t_humi = myDHT.humidity;                        // zapamiętaj wartość poprzednią
  946.  
  947.     myDHT.temperature = sensor.temperature;
  948.     myDHT.humidity  = sensor.humidity;
  949.  
  950.     if(myDHT.temperature < 1)      // jeśli bład odczytu      
  951.     {
  952.         myDHT.temperature = 0;  
  953.     }
  954.  
  955.     if(myDHT.humidity < 1)         // jeśli bład odczytu
  956.     {
  957.         myDHT.humidity = 0;  
  958.     }
  959.  
  960.     #if SERIAL
  961.        
  962.         #if POLISH
  963.             // ------------------------------------------------------------------------------------------------------ //
  964.             Serial.printf("\n\n[TASK3] [DHT INFO] Temperatura w pokoju :  %2.2f [st.C]", myDHT.temperature);
  965.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  966.             if (myDHT.temperature - t_temp >= 0)            
  967.                 Serial.printf("\t [Wartosc Poprzednia] %2.2f [Zmiana] +%2.2f", t_temp, myDHT.temperature - t_temp);
  968.             else
  969.                 Serial.printf("\t [Wartosc Poprzednia] %2.2f [Zmiana] %2.2f", t_temp, myDHT.temperature - t_temp);            
  970.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //            
  971.             Serial.printf("\n[TASK3] [DHT INFO] Wilgotność w pokoju  :  %2.2f [%% rH]", myDHT.humidity);
  972.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  973.             if (myDHT.humidity - t_humi >= 0)
  974.                 Serial.printf("\t [Wartosc Poprzednia] %2.2f [zmiana] +%2.2f", t_humi, myDHT.humidity - t_humi);
  975.             else
  976.                 Serial.printf("\t [Wartosc Poprzednia] %2.2f [zmiana] %2.2f", t_humi, myDHT.humidity - t_humi);            
  977.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //          
  978.         #endif
  979.  
  980.         #if GERMANY
  981.             // ------------------------------------------------------------------------------------------------------ //
  982.             Serial.printf("\n\n[TASK3] [DHT INFO] Temperatur im Zimmer     : %2.2f [st.C]", myDHT.temperature);
  983.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  984.             if (myDHT.temperature - t_temp >= 0)            
  985.                 Serial.printf("\t [vorheriger Wert] %2.2f [Veränderung] +%2.2f", t_temp, myDHT.temperature - t_temp);
  986.             else
  987.                 Serial.printf("\t [vorheriger Wert] %2.2f [Veränderung] %2.2f", t_temp, myDHT.temperature - t_temp);            
  988.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //            
  989.             Serial.printf("\n[TASK3] [DHT INFO] Feuchtigkeit im Zimmer   : %2.2f [%% rH]", myDHT.humidity);
  990.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  991.             if (myDHT.humidity - t_humi >= 0)
  992.                 Serial.printf("\t [vorheriger Wert] %2.2f [Veränderung] +%2.2f", t_humi, myDHT.humidity - t_humi);
  993.             else
  994.                 Serial.printf("\t [vorheriger Wert] %2.2f [Veränderung] %2.2f", t_humi, myDHT.humidity - t_humi);            
  995.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //
  996.         #endif
  997.  
  998.         #if ENGLISH
  999.             // ------------------------------------------------------------------------------------------------------ //
  1000.             Serial.printf("\n\n[TASK3] [DHT INFO] Room temperature :  %2.2f [st.C]", myDHT.temperature);
  1001.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  1002.             if (myDHT.temperature - t_temp >= 0)            
  1003.                 Serial.printf("\t [previous value] %2.2f [change +%2.2f", t_temp, myDHT.temperature - t_temp);
  1004.             else
  1005.                 Serial.printf("\t [previous value] %2.2f [change] %2.2f", t_temp, myDHT.temperature - t_temp);            
  1006.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //            
  1007.             Serial.printf("\n[TASK3] [DHT INFO] Room humidity :     %2.2f [%% rH]", myDHT.humidity);
  1008.             // --- tylko formatowanie znaku + (minus wyświetlany jest automatycznie) -------------------------------- //            
  1009.             if (myDHT.humidity - t_humi >= 0)
  1010.                 Serial.printf("\t [previous value] %2.2f [change] +%2.2f", t_humi, myDHT.humidity - t_humi);
  1011.             else
  1012.                 Serial.printf("\t [previous value] %2.2f [change] %2.2f", t_humi, myDHT.humidity - t_humi);            
  1013.             // --- koniec formatowania znaku + ---------------------------------------------------------------------- //
  1014.         #endif
  1015.        
  1016.     #endif
  1017. }
  1018.  
  1019. // ------------------------------------------------------------------------------------------------------------------- //
  1020. // --- stat Wi-Fi ---------------------------------------------------------------------------------------------------- //
  1021. // ------------------------------------------------------------------------------------------------------------------- //
  1022.  
  1023. void statWiFi()
  1024. {
  1025.     switch (WiFi.status())
  1026.     {
  1027.         case WL_NO_SSID_AVAIL:
  1028.                             #if SERIAL
  1029.                                 #if ENGLISH
  1030.                                     Serial.printf("\nConfigured SSID cannot be reached");
  1031.                                 #endif
  1032.                                 #if POLISH
  1033.                                     Serial.printf("\nNie można osiągnąć skonfigurowanego identyfikatora SSID");
  1034.                                 #endif
  1035.                                 #if GERMANY
  1036.                                     Serial.printf("\nKonfigurierte SSID ist nicht erreichbar");
  1037.                                 #endif
  1038.                             #endif        
  1039.                             break;
  1040.                            
  1041.         case WL_CONNECTED:
  1042.                             #if SERIAL
  1043.                                 #if ENGLISH
  1044.                                     Serial.printf("\nConnection successfully established");
  1045.                                     Serial.printf("\nYour IP : %s", WiFi.localIP().toString().c_str());
  1046.                                     Serial.printf("\nReceived Signal Strength Indication : %d", WiFi.RSSI());
  1047.                                 #endif
  1048.                                 #if POLISH
  1049.                                     Serial.printf("\nPomyślnie nawiązano połączenie");
  1050.                                     Serial.printf("\nTwój adres IP : %s", WiFi.localIP().toString().c_str());
  1051.                                     Serial.printf("\nWskazanie siły odbieranego sygnału : %d", WiFi.RSSI());
  1052.                                 #endif
  1053.                                 #if GERMANY
  1054.                                     Serial.printf("\nVerbindung erfolgreich hergestellt");
  1055.                                     Serial.printf("\nDeine IP-Adresse : %s", WiFi.localIP().toString().c_str());
  1056.                                     Serial.printf("\nAnzeige der empfangenen Signalstärke : %d", WiFi.RSSI());                                
  1057.                                 #endif
  1058.                             #endif
  1059.                             break;
  1060.                            
  1061.         case WL_CONNECT_FAILED:
  1062.                             #if SERIAL
  1063.                                 #if ENGLISH
  1064.                                     Serial.printf("\nConnection failed");
  1065.                                 #endif
  1066.                                 #if POLISH
  1067.                                     Serial.printf("\nPołączenie nieudane");
  1068.                                 #endif
  1069.                                 #if GERMANY
  1070.                                     Serial.printf("\nVerbindung fehlgeschlagen");
  1071.                                 #endif
  1072.                             #endif
  1073.                             break;
  1074.     }      
  1075. }
  1076.  
  1077. // ------------------------------------------------------------------------------------------------------------------- //
  1078. // --- init Wi-Fi ---------------------------------------------------------------------------------------------------- //
  1079. // ------------------------------------------------------------------------------------------------------------------- //
  1080.  
  1081. void initWiFi()
  1082. {
  1083.     WiFi.mode(WIFI_STA);
  1084.     WiFi.begin(ssid, password);
  1085.  
  1086.     #if SERIAL    
  1087.         #if ENGLISH
  1088.             Serial.printf("\nConnecting to WiFi ..");
  1089.         #endif
  1090.         #if POLISH
  1091.             Serial.printf("\nŁącze z siecią WiFi ..");
  1092.         #endif
  1093.         #if GERMANY
  1094.             Serial.printf("\nNetzwerkverbindung mit WLAN ..");
  1095.         #endif
  1096.     #endif
  1097.    
  1098.     while (WiFi.status() != WL_CONNECTED)
  1099.     {
  1100.         Serial.print('.');
  1101.         delay(200);
  1102.     }
  1103.  
  1104.     statWiFi();
  1105.        
  1106.     WiFi.setAutoReconnect(true);
  1107.     WiFi.persistent(true);
  1108.  
  1109.    
  1110. }
  1111.  
  1112. // ------------------------------------------------------------------------------------------------------------------- //
  1113. // --- reconect Wi-Fi ------------------------------------------------------------------------------------------------ //
  1114. // ------------------------------------------------------------------------------------------------------------------- //
  1115.  
  1116. void reconectWifi()
  1117. {
  1118.     unsigned long currentMillis = millis();
  1119.    
  1120.     if ((WiFi.status() != WL_CONNECTED) && (currentMillis - previousMillis >=interval))
  1121.     {
  1122.         #if SERIAL
  1123.             #if ENGLISH
  1124.                 Serial.println("Reconnecting to WiFi...");
  1125.             #endif
  1126.             #if POLISH
  1127.                 Serial.println("Ponowne łączenie z Wi-Fi...");
  1128.             #endif
  1129.             #if GERMANY
  1130.                 Serial.println("Erneut mit WLAN verbinden...");
  1131.             #endif
  1132.         #endif
  1133.        
  1134.         WiFi.disconnect();
  1135.         WiFi.begin(ssid, password);
  1136.        
  1137.         statWiFi();
  1138.        
  1139.         previousMillis = currentMillis;
  1140.   }
  1141. }
  1142.  
  1143. // ------------------------------------------------------------------------------------------------------------------- //
  1144. // --- S E T U P ----------------------------------------------------------------------------------------------------- //
  1145. // ------------------------------------------------------------------------------------------------------------------- //
  1146.  
  1147. void setup()
  1148. {
  1149.     #if SERIAL
  1150.         Serial.begin(SerialSpeed);
  1151.     #endif
  1152.  
  1153.     lcd.init();                      
  1154.     lcd.backlight();    
  1155.     lcd.clear();
  1156.    
  1157.     myLCD.LcdRegister();            // register new chars
  1158.  
  1159.     myLCD.TypeWriter("simple ESP8266 Clock", 150, 0, 0);    
  1160.     myLCD.TypeWriter("v1.70b by: T.Majcher", 150, 0, 1);        
  1161.  
  1162.    initWiFi();
  1163.    
  1164.    char buf[21];
  1165.    strcpy (buf, "IP : ");
  1166.    strcat (buf, WiFi.localIP().toString().c_str() );
  1167.    
  1168.    myLCD.TypeWriter(buf, 150, 0, 2);    
  1169.    myLCD.TypeWriter("Wait ..............", 150, 0, 3);
  1170.    
  1171.    delay(2000);
  1172.    lcd.clear();  
  1173.    
  1174.  
  1175.    runner.init();                                       // inicjalizuj scheluder
  1176.                                                                                  
  1177.    runner.addTask(task_0);                              // dodaj zadanie do scheluder
  1178.    task_0.enable();                                     // włącz zadanie do scheluder
  1179.    runner.addTask(task_1);                              // dodaj zadanie do scheluder
  1180.    task_1.enable();                                     // włącz zadanie do scheluder
  1181.    runner.addTask(task_2);                              // dodaj zadanie do scheluder
  1182.    task_2.enable();                                     // włącz zadanie do scheluder
  1183.    runner.addTask(task_3);                              // dodaj zadanie do scheluder
  1184.    task_3.enable();                                     // włącz zadanie do scheluder
  1185.  
  1186.  
  1187.    dht.setup(DHTpin, DHTesp::DHT11);        // uruchom czujnik DHT11 - o dziwo ten badziew dziala lepiej niz DHT22
  1188.  
  1189.    // --- WYWOŁAJ TERAZ --------------------- //
  1190.  
  1191.    Task0Callback();
  1192.    Task1Callback();
  1193.    Task2Callback();
  1194.  
  1195.    // --------------------------------------- //
  1196.  
  1197. }
  1198.  
  1199. // ------------------------------------------------------------------------------------------------------------------- //
  1200. // --- L O O P ------------------------------------------------------------------------------------------------------- //
  1201. // ------------------------------------------------------------------------------------------------------------------- //
  1202.  
  1203. void loop()
  1204. {
  1205.     runner.execute();     // scheluder init
  1206.     reconectWifi();       // check Wi-Fi status
  1207. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!