API tools faq
paste
PowerTGS440

simpleESP8266ClockLQ v1.6 BETA

PowerTGS440
Jun 9th, 2021 (edited)
482
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 58.27 KB | None | 0 0
raw download clone embed print report
  1. // ------------------------------------------------------------------------------------------------------------------- //
  2. // Simple ESP8266 CLOCK by TOMASZ MAJCHER (TRANSLINE GROUP POLSKA)                                                     //
  3. // e-mail  : [email protected]                                                                               //
  4. // licence : DonationWare                                                                                              //
  5. // ------------------------------------------------------------------------------------------------------------------- //
  6. //
  7. // v1.7 (09.06.2021) - update : show humidity method in class LCD
  8. // v1.6 (05.06.2021) - update : show temperature method in class LCD
  9. // v1.5 (03.06.2021) - update : show percentage (sing)
  10. // v1.4 (02.06.2021) - update : show C (sing)
  11. // v1.3 (30.05.2021) - update : add TypeWriter Public Method in class LCD
  12. // v1.2 (30.05.2021) - update : MultiLanguage (Day of Week) and (Month) in Germany
  13. // v1.1 (30.05.2021) - update : MultiLanguage (Day of Week) and (Month) in English
  14. // v1.0 (30.05.2021) - update : FINAL FREE VERSION
  15. // v0.9 (30.05.2021) - update : dodano formatowanie LongDate do długości 20 znaków
  16. // v0.8 (30.05.2021) - update : switch ShortData / LongData
  17. // v0.7 (30.05.2021) - update : formatowanie dat LONG / SHORT
  18. // v0.6 (29.05.2021) - update : DNI TYGODNIA / NAZWY MIESIĘCY
  19. // v0.5 (28.05.2021) - update : aktualizacja daty (Task0) co 1 godzinę
  20. // v0.4 (28.05.2021) - update : aktualizacja Timeu (Task1) co 1 minutę
  21. // v0.3 (27.05.2021) - FULL BETA :-)
  22. // v0.2 (26.05.2021) - budowa klasy LCD
  23. // v0.1 (26.05.2021) - budowa projektu
  24. //
  25. // ------------------------------------------------------------------------------------------------------------------- //
  26. //
  27. // GND   <---> GND
  28. // VCC   <---> Vin
  29. // SDA   <---> D2 (NodeMCU) GPIO 4
  30. // SCL   <---> D1 (NodeMCU) GPIO 5
  31. //
  32. // ------------------------------------------------------------------------------------------------------------------- //
  33. // --- L A N G U A G E   S E T U P ----------------------------------------------------------------------------------- //
  34. // ------------------------------------------------------------------------------------------------------------------- //
  35.  
  36. #define LANGUAGE 0                                            // 0 (Polish), 1 (English), 2 (Germany)
  37.                                                              
  38. #if LANGUAGE == 0                                                
  39.     #define POLISH 1
  40.     #define ENGLISH 0
  41.     #define GERMANY 0                                          
  42. #endif
  43.  
  44. #if LANGUAGE == 1                                                      
  45.     #define POLISH 0                                        
  46.     #define ENGLISH 1
  47.     #define GERMANY 0
  48. #endif
  49.  
  50. #if LANGUAGE == 2
  51.     #define POLISH 0
  52.     #define ENGLISH 0
  53.     #define GERMANY 1
  54. #endif      
  55.  
  56. // ------------------------------------------------------------------------------------------------------------------- //
  57. // --- M A C R O   D E F I N E --------------------------------------------------------------------------------------- //
  58. // ------------------------------------------------------------------------------------------------------------------- //
  59.  
  60. #define ARRAY_SIZE(a)   (sizeof(a) / sizeof((a)[0]))
  61.  
  62. const char *ssid     = "DIABLO";                                       // network wifi ssid  
  63. const char *password = "xxxxxxxxxx";                                  // network wifi password
  64.  
  65. // ------------------------------------------------------------------------------------------------------------------- //
  66. // --- I N C L U D E   L I B R A R Y --------------------------------------------------------------------------------- //
  67. // ------------------------------------------------------------------------------------------------------------------- //
  68.  
  69. extern "C" char* sbrk(int incr);
  70.  
  71. #include "LiquidCrystal_I2C.h" // get from https://circuits4you.com/wp-content/uploads/2019/03/I2C-LCD-ESP8266-Library.zip
  72.  
  73. #include <ESP8266WiFi.h>                                         // biblioteka Wi-Fi
  74. #include <NTPClient.h>                                           // NTP klient (Time)
  75. #include <WiFiUdp.h>                                             // UDP dla NTP (Time)
  76. #include <TaskScheduler.h>                                       // scheluder
  77. #include <TimeLib.h>    
  78. #include <Arduino.h>
  79.  
  80. LiquidCrystal_I2C lcd(0x27,20,4);  
  81.  
  82. #define SERIAL true
  83. #define SerialSpeed 57600
  84.  
  85. // ------------------------------------------------------------------------------------------------------------------- //
  86. // --- P R O T O T Y P Y --------------------------------------------------------------------------------------------- //
  87. // ------------------------------------------------------------------------------------------------------------------- //
  88.  
  89. void Task0Callback();                                                     // funkcja dla task_0    
  90. void Task1Callback();                                                     // funkcja dla task_1    
  91. void Task2Callback();                                                     // funkcja dla task_2    
  92.  
  93. // ------------------------------------------------------------------------------------------------------------------- //
  94. // --- Z A D A N I A   S C H E L U D E R ' A ------------------------------------------------------------------------- //
  95. // ------------------------------------------------------------------------------------------------------------------- //
  96.                                                                                                    
  97. Task task_0( 3600000, TASK_FOREVER, &Task0Callback);                      // task_0 - co 1 godzinę  
  98. Task task_1(  60000,  TASK_FOREVER, &Task1Callback);                      // task_2 - co 1 minutę  
  99. Task task_2(   1000,  TASK_FOREVER, &Task2Callback);                      // task_3 - co 1 sekundę  
  100.                                                                                                    
  101. Scheduler runner;    
  102.  
  103. // ------------------------------------------------------------------------------------------------------------------- //
  104. //                                              *** DHT11/22 ***                                                       //
  105. // ------------------------------------------------------------------------------------------------------------------- //
  106.  
  107. float temperature = 20.0;   // default - domyślna wartość (test only)
  108. float humidity    = 50.0;   // default - domyślna wartość (test only)
  109.  
  110. // ------------------------------------------------------------------------------------------------------------------- //
  111. //                                              *** STRUKTURA Time ***                                                 //
  112. // ------------------------------------------------------------------------------------------------------------------- //
  113.  
  114. struct TIME_DATA
  115. {
  116.     int Hour = 0;
  117.     int Minute  = 0;
  118.     int Second = 0;
  119.     String FormatedData  = "NULL";
  120.     String ShortData = "NULL";
  121.     String LongData = "NULL";
  122.     int DayOfTheWeek = 0;
  123.     int DayOfTheMonth = 0;
  124.     int Month = 0;
  125.     int Year = 0;
  126. }
  127. Time;
  128.  
  129. bool DisplayTime = true;
  130. bool DisplayTemperature = false;
  131. bool DisplayHumidity = false;
  132.  
  133. // ------------------------------------------------------------------------------------------------------------------- //
  134. //                                              *** STRUKTURA DZIEN ***                                                //
  135. // ------------------------------------------------------------------------------------------------------------------- //
  136.  
  137. #if POLISH
  138.     const char Day_0 [] = "Niedziela";
  139.     const char Day_1 [] = "Poniedzialek";
  140.     const char Day_2 [] = "Wtorek";
  141.     const char Day_3 [] = "Sroda";
  142.     const char Day_4 [] = "Czwartek";
  143.     const char Day_5 [] = "Piatek";
  144.     const char Day_6 [] = "Sobota";
  145. #endif
  146.  
  147. #if ENGLISH
  148.     const char Day_0 [] = "Sunday";
  149.     const char Day_1 [] = "Monday";
  150.     const char Day_2 [] = "Tuesday";
  151.     const char Day_3 [] = "Wednesday";
  152.     const char Day_4 [] = "Thursday";
  153.     const char Day_5 [] = "Friday";
  154.     const char Day_6 [] = "Saturday";
  155. #endif
  156.  
  157. #if GERMANY
  158.     const char Day_0 [] = "Sonntag";
  159.     const char Day_1 [] = "Montag";
  160.     const char Day_2 [] = "Dienstag";
  161.     const char Day_3 [] = "Mittwoch";
  162.     const char Day_4 [] = "Donnerstag";
  163.     const char Day_5 [] = "Freitag";
  164.     const char Day_6 [] = "Samstag";
  165. #endif
  166.  
  167. const char * const DAY[] = { Day_0, Day_1, Day_2, Day_3, Day_4, Day_5, Day_6 }; // dni tygodnia [0..6]
  168.  
  169. // ------------------------------------------------------------------------------------------------------------------- //
  170. //                                              *** STRUKTURA MONTH ***                                                //
  171. // ------------------------------------------------------------------------------------------------------------------- //
  172.  
  173. #if POLISH
  174.     const char MONTH_0  [] = "NULL";
  175.     const char MONTH_1  [] = "Styczen";
  176.     const char MONTH_2  [] = "Luty";
  177.     const char MONTH_3  [] = "Marzec";
  178.     const char MONTH_4  [] = "Kwiecien";
  179.     const char MONTH_5  [] = "Maj";
  180.     const char MONTH_6  [] = "Czerwiec";
  181.     const char MONTH_7  [] = "Lipiec";
  182.     const char MONTH_8  [] = "Sierpien";
  183.     const char MONTH_9  [] = "Wrzesien";
  184.     const char MONTH_10 [] = "Pazdziernik";
  185.     const char MONTH_11 [] = "Listopad";
  186.     const char MONTH_12 [] = "Grudzien";
  187. #endif
  188.  
  189. #if ENGLISH
  190.     const char MONTH_0  [] = "NULL";
  191.     const char MONTH_1  [] = "January";
  192.     const char MONTH_2  [] = "February";
  193.     const char MONTH_3  [] = "March";
  194.     const char MONTH_4  [] = "April";
  195.     const char MONTH_5  [] = "May";
  196.     const char MONTH_6  [] = "June";
  197.     const char MONTH_7  [] = "July";
  198.     const char MONTH_8  [] = "August";
  199.     const char MONTH_9  [] = "September";
  200.     const char MONTH_10 [] = "October";
  201.     const char MONTH_11 [] = "November";
  202.     const char MONTH_12 [] = "December";
  203. #endif
  204.  
  205. #if GERMANY
  206.     const char MONTH_0  [] = "NULL";
  207.     const char MONTH_1  [] = "Januar";
  208.     const char MONTH_2  [] = "Februar";
  209.     const char MONTH_3  [] = "März";
  210.     const char MONTH_4  [] = "April";
  211.     const char MONTH_5  [] = "Mai";
  212.     const char MONTH_6  [] = "Juni";
  213.     const char MONTH_7  [] = "Juli";
  214.     const char MONTH_8  [] = "August";
  215.     const char MONTH_9  [] = "September";
  216.     const char MONTH_10 [] = "Oktober";
  217.     const char MONTH_11 [] = "November";
  218.     const char MONTH_12 [] = "Dezember";
  219. #endif
  220.    
  221.     const char * const MONTH[] = { MONTH_0, MONTH_1, MONTH_2, MONTH_3, MONTH_4, MONTH_5, MONTH_6,
  222.                                    MONTH_7, MONTH_8, MONTH_9, MONTH_10, MONTH_11, MONTH_12 };
  223.  
  224. // ------------------------------------------------------------------------------------------------------------------- //
  225. //                            *** KLASA LCD *** by Tomasz Majcher (TLG) v1.00 Lite ***                                 //
  226. // ------------------------------------------------------------------------------------------------------------------- //
  227.  
  228. class LCD
  229. {
  230.     private :
  231.  
  232.         // --- ZMIENNE PRYWATNE -------------------------------------------------------------------------------------- //
  233.  
  234.         byte LGc[8]  = { B00111, B01111, B11111, B11111, B11111, B11111, B11111, B11111 };         // lewy górny ----- //
  235.         byte LDc[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B01111, B00111 };         // lewy dolny ----- //
  236.         byte PGc[8]  = { B11100, B11110, B11111, B11111, B11111, B11111, B11111, B11111 };         // prawy górny ---- //
  237.         byte PDc[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B11110, B11100 };         // prawy dolny ---- //
  238.         byte UDb[8]  = { B11111, B11111, B11111, B11111, B11111, B00000, B00000, B00000 };         // górny 1/2 ------ //
  239.         byte DDb[8]  = { B00000, B00000, B00000, B11111, B11111, B11111, B11111, B11111 };         // dolny 1/2 ------ //
  240.         byte blk[8]  = { B11111, B11111, B11111, B11111, B11111, B11111, B11111, B11111 };         // blok pełny ----- //
  241.         byte emp[8]  = { B00000, B00000, B00000, B00000, B00000, B00000, B00000, B00000 };         // blok pusty ----- //
  242.         byte procent[8] = { B00000, B01110, B10001, B10001, B10001, B01110, B00000, B00000 };      // procent -------- //
  243.  
  244.         // --- ZMIENNE PRYWATNE -------------------------------------------------------------------------------------- //
  245.  
  246.         LiquidCrystal_I2C & MyLCD;
  247.  
  248.         void ShowDot(int x, int y);
  249.         void ShowColon(int x, int y);
  250.         void Digit0(int x, int y);
  251.         void Digit1(int x, int y);
  252.         void Digit2(int x, int y);
  253.         void Digit3(int x, int y);
  254.         void Digit4(int x, int y);
  255.         void Digit5(int x, int y);
  256.         void Digit6(int x, int y);
  257.         void Digit7(int x, int y);
  258.         void Digit8(int x, int y);
  259.         void Digit9(int x, int y);
  260.             void ShowC (int x, int y);
  261.         void ShowPercentage(int x, int y);
  262.         void ShowDigit(int x, int y, int numer);
  263.         void ClearLine(int x);        
  264.  
  265.         // ---------------------------------------------------------------------------------------- //  
  266.         // --- METODY PRYWATNE -------------------------------------------------------------------- //
  267.         // ---------------------------------------------------------------------------------------- //
  268.  
  269.        
  270.         // ---------------------------------------------------------------------------------------- //
  271.        
  272.     public  :
  273.  
  274.         // ---------------------------------------------------------------------------------------- //
  275.         // --- KONSTRUKTOR KLACY LCD -------------------------------------------------------------- //
  276.         // ---------------------------------------------------------------------------------------- //
  277.        
  278.         LCD (LiquidCrystal_I2C &adres_lc) : MyLCD(adres_lc)
  279.         {
  280.             LcdRegister();  
  281.         }
  282.        
  283.         // ---------------------------------------------------------------------------------------- //
  284.         //  --- METODY PUBLICZNE KLASY LCD -------------------------------------------------------- //
  285.         // ---------------------------------------------------------------------------------------- //
  286.  
  287.         void ShowTime();  // wyswietl zegar  
  288.         void ShowDate();  // wyswietl datę
  289.         void LcdRegister();   // zarejestruj nowy zestaw znaków specjalnych  
  290.         void TypeWriter(const String & message, unsigned int wait, unsigned int x, unsigned int y);
  291.         void ShowTemperature();
  292.         void ShowHumidity();                                                                                        
  293. };
  294.  
  295. // ------------------------------------------------------------------------------------------------------------------- //
  296. //          *** METODY PRYWATNE *** WYCZYSC LINIE X***                                                                 //
  297. // ------------------------------------------------------------------------------------------------------------------- //
  298.  
  299. void LCD :: ClearLine(int y)
  300. {
  301.     MyLCD.setCursor(0,y);
  302.     MyLCD.print(F("                    "));            
  303. }
  304.  
  305. // ------------------------------------------------------------------------------------------------------------------- //
  306. //          *** METODY PRYWATNE *** ZAREJESTRUJ NOWY ZESTAW ZNAKÓW SPECJALNYCH DLA WYŚWIETLACZA 20x4 ***               //
  307. // ------------------------------------------------------------------------------------------------------------------- //
  308.  
  309. void LCD :: LcdRegister()                                                                                        
  310. {                                                                                                                
  311.           MyLCD.createChar(0,LGc);                                   // 0 -> lewy górny narożnik ------------ //
  312.           MyLCD.createChar(1,LDc);                                   // 1 -> lewy dolny narożnik ------------ //
  313.           MyLCD.createChar(2,PGc);                                   // 2 -> prawy górny narożnik ----------- //
  314.           MyLCD.createChar(3,PDc);                                   // 3 -> prawy dolny narożnik ----------- //
  315.           MyLCD.createChar(4,UDb);                                   // 4 -> górny pół-blok ----------------- //
  316.           MyLCD.createChar(5,DDb);                                   // 5 -> dolny pół-blok ----------------- //
  317.           MyLCD.createChar(6,blk);                                   // 6 -> pełny blok --------------------- //
  318.               MyLCD.createChar(7,procent);                               // 7 -> kolko gora --------------------- //  
  319. }
  320.  
  321. // ------------------------------------------------------------------------------------------------------------------- //
  322. // --- Duża Digit 0 -------------------------------------------------------------------------------------------------- //
  323. // ------------------------------------------------------------------------------------------------------------------- //
  324.  
  325. void LCD :: Digit0(int x, int y)                                  
  326. {                                                                                                                  //          
  327.           MyLCD.setCursor(x,y);                                     // ustaw kursor ------------------------ //
  328.           MyLCD.write(0);                                           // lewy górny narożnk ------------------ //          
  329.           MyLCD.write(4);                                           // kropa górna ------------------------- //
  330.           MyLCD.write(2);                                           // prawy górny narożnik ---------------- //
  331.           MyLCD.setCursor(x,y+1);                                   // ustaw kursor ------------------------ //
  332.           MyLCD.write(6);                                           // pełny 5x8 --------------------------- //
  333.           MyLCD.print(F(" "));                                      // pusty blok -------------------------- //          
  334.           MyLCD.write(6);                                           // pełny 5x8 --------------------------- //
  335.           MyLCD.setCursor(x,y+2);                                   // ustaw kursor ------------------------ //
  336.           MyLCD.write(1);                                           // lewy dolny narożnik ----------------- //
  337.           MyLCD.write(5);                                           // kropa dolna ------------------------- //
  338.           MyLCD.write(3);                                           // prawy dolny narożnik ---------------- //
  339. }                                                                    
  340.  
  341. // ------------------------------------------------------------------------------------------------------------------- //
  342. // --- Duża Digit 1 -------------------------------------------------------------------------------------------------- //
  343. // ------------------------------------------------------------------------------------------------------------------- //
  344.  
  345. void LCD :: Digit1(int x, int y)  
  346. {                                                                                                          
  347.           MyLCD.setCursor(x,y);                                      // ustaw kursor ----------------------- //
  348.           MyLCD.write(4);                                            // górna kropa ------------------------ //
  349.           MyLCD.write(2);                                            // prawy górny narożnik --------------- //          
  350.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //          
  351.           MyLCD.setCursor(x,y+1);                                    // ustaw kursor ----------------------- //
  352.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //                    
  353.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  354.           MyLCD.print(F(" "));                                       // pusty blok ------------------------- //                    
  355.           MyLCD.setCursor(x,y+2);                                    // ustaw kursor ----------------------- //
  356.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  357.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //
  358.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  359. }    
  360.                                                                    
  361. // ------------------------------------------------------------------------------------------------------------------- //
  362. // --- Duża Digit 2 -------------------------------------------------------------------------------------------------- //
  363. // ------------------------------------------------------------------------------------------------------------------- //
  364.  
  365. void LCD :: Digit2(int x, int y)                                                                    
  366. {                                                                                                                
  367.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  368.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  369.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  370.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  371.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  372.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  373.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  374.           MyLCD.write(4);                                           // kropa górna ------------------------ //          
  375.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //
  376.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //  
  377.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  378.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  379. }                                                                      
  380.  
  381. // ------------------------------------------------------------------------------------------------------------------- //
  382. // --- Duża Digit 3 -------------------------------------------------------------------------------------=------------ //
  383. // ------------------------------------------------------------------------------------------------------------------- //
  384.  
  385. void LCD :: Digit3(int x, int y)                
  386. {                                                      
  387.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  388.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  389.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  390.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  391.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  392.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  393.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  394.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  395.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  396.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  397.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  398.           MyLCD.write(3);                                           // prawy dolny narożnik --------------- //
  399. }                                              
  400.  
  401. // ------------------------------------------------------------------------------------------------------------------- //
  402. // --- Duża Digit 4 ------------------------------------------------------------------------------------=------------- //
  403. // ------------------------------------------------------------------------------------------------------------------- //
  404.  
  405. void LCD :: Digit4(int x, int y)    
  406. {                                                    
  407.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  408.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  409.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //                    
  410.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //                    
  411.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  412.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //          
  413.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  414.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  415.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  416.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  417.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  418.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  419. }                                                                                                              
  420.  
  421. // ------------------------------------------------------------------------------------------------------------------- //
  422. // --- Duża Digit 5 -----------------------------------------------------------------------------------=-------------- //
  423. // ------------------------------------------------------------------------------------------------------------------- //
  424.    
  425. void LCD :: Digit5(int x, int y)                            
  426. {                                                                            
  427.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  428.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //  
  429.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  430.           MyLCD.write(4);                                           // kropa górna ------------------------ //                    
  431.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  432.           MyLCD.write(4);                                           // kropa górna ------------------------ //        
  433.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  434.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  435.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  436.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //
  437.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  438.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  439. }                                                                                                                
  440.  
  441. // ------------------------------------------------------------------------------------------------------------------- //
  442. // --- Duża Digit 6 ---------------------------------------------------------------------------------------=---------- //
  443. // ------------------------------------------------------------------------------------------------------------------- //
  444.    
  445. void LCD :: Digit6(int x, int y)                                                                  
  446. {                                                                                                              
  447.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  448.           MyLCD.write(0);                                           // lewy górny narożnk ----------------- //          
  449.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  450.           MyLCD.write(4);                                           // kropa górna ------------------------ //                    
  451.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  452.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  453.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  454.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //          
  455.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  456.           MyLCD.write(1);                                           // lewy dolny narożnik ---------------- //
  457.           MyLCD.write(5);                                           // kropa dolna ------------------------ //
  458.           MyLCD.write(3);                                           // prawy dolny narożnik --------------- //
  459. }                                                                                                                  
  460.  
  461. // ------------------------------------------------------------------------------------------------------------------- //
  462. // --- Duża Digit 7 -----------------------------------------------------------------------------------------=-------- //
  463. // ------------------------------------------------------------------------------------------------------------------- //
  464.  
  465. void LCD :: Digit7(int x, int y)      
  466. {                                                      
  467.           MyLCD.setCursor(x,y);                                     // ustaw kursor ----------------------- //
  468.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  469.           MyLCD.write(4);                                           // kropa górna ------------------------ //
  470.           MyLCD.write(2);                                           // prawy górny narożnik --------------- //                    
  471.           MyLCD.setCursor(x, y+1);                                  // ustaw kursor ----------------------- //
  472.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //                    
  473.           MyLCD.print(F(" "));                                      // pusty blok ------------------------- //          
  474.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //          
  475.           MyLCD.setCursor(x, y+2);                                  // ustaw kursor ----------------------- //          
  476.           MyLCD.print(F("  "));                                     // pusty blok ------------------------- //                    
  477.           MyLCD.write(6);                                           // pełny 5x8 -------------------------- //
  478. }                                                                                                      
  479.  
  480. // ------------------------------------------------------------------------------------------------------------------- //
  481. // --- Duża Digit 8 -----------------------------------------------------------------------------------------=-------- //
  482. // ------------------------------------------------------------------------------------------------------------------- //
  483.  
  484. void LCD :: Digit8(int x, int y)  
  485. {                                                  
  486.           MyLCD.setCursor(x,y);                                      // ustaw kursor ----------------------- //
  487.           MyLCD.write(0);                                            // lewy górny narożnk ----------------- //          
  488.           MyLCD.write(4);                                            // kropa górna ------------------------ //
  489.           MyLCD.write(2);                                            // prawy górny narożnik --------------- //                    
  490.           MyLCD.setCursor(x, y+1);                                   // ustaw kursor ----------------------- //
  491.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  492.           MyLCD.write(4);                                            // kropa górna ------------------------ //
  493.           MyLCD.write(6);                                            // pełny 5x8 -------------------------- //          
  494.           MyLCD.setCursor(x, y+2);                                   // ustaw kursor ----------------------- //          
  495.           MyLCD.write(1);                                            // lewy dolny narożnik ---------------- //
  496.           MyLCD.write(5);                                            // kropa dolna ------------------------ //
  497.           MyLCD.write(3);                                            // prawy dolny narożnik --------------- //
  498. }                                                                                                                
  499.  
  500. // ------------------------------------------------------------------------------------------------------------------- //
  501. // --- Duża Digit 9 -------------------------------------------------------------------------------------------=------ //
  502. // ------------------------------------------------------------------------------------------------------------------- //
  503.  
  504. void LCD :: Digit9(int x, int y)                                                        
  505. {                                                                                                        
  506.           MyLCD.setCursor(x,y);                                       // ustaw kursor ----------------------- //
  507.           MyLCD.write(0);                                             // lewy górny narożnk ----------------- //  
  508.           MyLCD.write(4);                                             // kropa górna ------------------------ //
  509.           MyLCD.write(2);                                             // prawy górny narożnik --------------- //                    
  510.           MyLCD.setCursor(x, y+1);                                    // ustaw kursor ----------------------- //
  511.           MyLCD.write(1);                                             // lewy dolny narożnik ---------------- //          
  512.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  513.           MyLCD.write(6);                                             // pełny 5x8 -------------------------- //          
  514.           MyLCD.setCursor(x, y+2);                                    // ustaw kursor ----------------------- //          
  515.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  516.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  517.           MyLCD.write(3);                                             // prawy dolny narożnik --------------- //
  518. }  
  519.                                                                                                                
  520. // ------------------------------------------------------------------------------------------------------------------- //
  521. // --- Duża Digit 9 ----------------------------------------------------------------------------------------=--------- //
  522. // ------------------------------------------------------------------------------------------------------------------- //
  523.  
  524. void LCD :: ShowColon(int x, int y)          
  525. {                                                            
  526.           MyLCD.setCursor(x,y);                                       // ustaw kursor ----------------------- //
  527.           MyLCD.print(F(" "));                                        // pusty blok ------------------------- //          
  528.           MyLCD.setCursor(x,y+1);                                     // ustaw kursor ----------------------- //
  529.           MyLCD.write(4);                                             // kropa górna ------------------------ //
  530.           MyLCD.setCursor(x,y+2);                                     // ustaw kursor ----------------------- //
  531.           MyLCD.write(5);                                             // kropa dolna ------------------------ //
  532. }
  533.  
  534. // ------------------------------------------------------------------------------------------------------------------- //
  535. // --- KROPA --------------------------------------------------------------------------------------------------------- //
  536. // ------------------------------------------------------------------------------------------------------------------- //
  537.  
  538. void LCD :: ShowDot(int x, int y)
  539. {                                              
  540.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  541.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  542.           MyLCD.setCursor(x,y+1);                                      // ustaw kursor ----------------------- //
  543.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  544.           MyLCD.setCursor(x,y+2);                                      // ustaw kursor ----------------------- //
  545.           MyLCD.print(F(" "));                                         // pusty blok ------------------------- //          
  546. }          
  547.  
  548. // --------------------------------------------------------------------------------------------------------------- //
  549.  
  550. void LCD :: ShowC (int x, int y)                                                                    
  551. {
  552.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  553.           MyLCD.write(0);                                              // lewy górny narożnk ----------------- //          
  554.           MyLCD.write(4);                                              // kropa górna ------------------------ //
  555.           MyLCD.write(4);                                              // kropa górna ------------------------ //
  556.           MyLCD.setCursor(x, y+1);                                     // ustaw kursor ----------------------- //
  557.           MyLCD.write(6);                                              // pełny 5x8 -------------------------- //          
  558.           MyLCD.print(F("  "));                                        // pusty blok ------------------------- //          
  559.           MyLCD.setCursor(x, y+2);                                     // ustaw kursor ----------------------- //          
  560.           MyLCD.write(1);                                              // lewy dolny narożnik ---------------- //
  561.           MyLCD.write(5);                                              // kropa dolna ------------------------ //
  562.           MyLCD.write(5);                                              // kropa dolna ------------------------ //
  563. }                                                                                                            
  564.  
  565. // --------------------------------------------------------------------------------------------------------------- //
  566. void LCD :: ShowPercentage(int x, int y)    
  567. {                                                                          
  568.           MyLCD.setCursor(x,y);                                        // ustaw kursor ----------------------- //
  569.           MyLCD.write(7);                                              // lewy górny narożnk ----------------- //          
  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.           MyLCD.write(7);                                              // lewy górny narożnk ----------------- //
  576. }                                                                          
  577.  
  578. // ------------------------------------------------------------------------------------------------------------------- //
  579. // --- WYSWIETL CYFRE ------------------------------------------------------------------------------------------------ //
  580. // ------------------------------------------------------------------------------------------------------------------- //
  581.  
  582. void LCD :: ShowDigit(int x, int y, int numer)
  583. {                                      
  584.     // --------------------------------------------------------------------------------------------------------- //
  585.                                                      // K O N T R O L A   B Ł Ę D U                              //
  586.     if(x > 17) x = 17;                               // jesli pozycja x większa niż 17, ustaw maksymalną ------- //
  587.     if(y >  1) y =  1;                               // jesli pozycja y wieksza niz 1 , ustaw maksymalna ------- //
  588.                                                                                                                  //
  589.     // --------------------------------------------------------------------------------------------------------- //
  590.              
  591.     switch (numer)                                                                                              
  592.     {                                                                                                          
  593.         case  0:  Digit0(x,y); break;                                                                          
  594.         case  1:  Digit1(x,y); break;                                                                          
  595.         case  2:  Digit2(x,y); break;                                                                          
  596.         case  3:  Digit3(x,y); break;                                                                          
  597.         case  4:  Digit4(x,y); break;                                                                          
  598.         case  5:  Digit5(x,y); break;                                                                          
  599.         case  6:  Digit6(x,y); break;                                                                          
  600.         case  7:  Digit7(x,y); break;                                                                          
  601.         case  8:  Digit8(x,y); break;                                                                          
  602.         case  9:  Digit9(x,y); break;                                                                          
  603.     }                                                                                                          
  604. }        
  605.  
  606. // ------------------------------------------------------------------------------------------------------------------- //
  607. //          *** METODY PUBLICZNE *** WYSWIETL Time ***                                                                 //
  608. // ------------------------------------------------------------------------------------------------------------------- //
  609.  
  610. void LCD :: ShowTime()
  611. {
  612.     static bool F_sec = false;
  613.     static int  O_min = 0;              // optymalizacja (no flickering)
  614.     static int  O_hrs = 0;              // optymalizacja (no flickering)
  615.  
  616.     if (O_min != Time.Minute)  
  617.     {
  618.         ShowDigit(0,  0, Time.Hour / 10);
  619.         ShowDigit(4,  0, Time.Hour % 10);
  620.         ShowDigit(10, 0, Time.Minute / 10);
  621.         ShowDigit(14, 0, Time.Minute % 10);
  622.         O_min = Time.Minute;
  623.     }
  624.  
  625.     switch (F_sec)                
  626.     {                            
  627.         case 0 :  ShowColon(8,0); F_sec = true;  break;
  628.         case 1 :  ShowDot(8,0); F_sec = false; break;
  629.         default: break;          
  630.     }  
  631.  
  632.     MyLCD.setCursor(18,2);                     // ustaw pozycję SEKUNDNIKA
  633.     MyLCD.print(Time.Second / 10);             // wyswietl dziesiątki sekundnika
  634.     MyLCD.print(Time.Second % 10);             // wyswietl jednosci sekundnika
  635.  
  636.    
  637.     if (O_hrs != Time.Hour)
  638.     {
  639.         MyLCD.setCursor(18,0);                  // ustaw pozycję AM/PM
  640.        
  641.         if (Time.Hour < 12) MyLCD.print(F("AM"));
  642.         else                MyLCD.print(F("PM"));
  643.          
  644.         O_hrs = Time.Hour;  
  645.     }
  646. }
  647.  
  648. // ------------------------------------------------------------------------------------------------------------------- //
  649. //          *** METODY PUBLICZNE *** WYSWIETL Temperaturę ***                                                          //
  650. // ------------------------------------------------------------------------------------------------------------------- //
  651.  
  652. void LCD :: ShowTemperature()                                                                                        
  653. {
  654.     int temp1 = int(temperature) / 10;                     // 1x
  655.     int temp2 = int(temperature) % 10;                     // x1
  656.     MyLCD.setCursor(4,0);
  657.  
  658.     #if POLISH
  659.         MyLCD.print(F("TEMPERATURA"));
  660.     #endif
  661.  
  662.     #if ENGLISH
  663.         MyLCD.print(F("TEMPERATURE"));
  664.     #endif
  665.  
  666.     #if GERMANY
  667.         MyLCD.print(F("TEMPERATUR"));
  668.     #endif
  669.    
  670.     ShowDigit(3,  1, temp1);
  671.     ShowDigit(7,  1, temp2);
  672.     MyLCD.setCursor(11,1);  
  673.     MyLCD.write(7);
  674.     ShowC(13,1);
  675. }                                                                                                                  
  676.  
  677.  
  678. // ------------------------------------------------------------------------------------------------------------------- //
  679. //          *** METODY PUBLICZNE *** WYSWIETL Wilgotnosc ***                                                           //
  680. // ------------------------------------------------------------------------------------------------------------------- //
  681.  
  682. void LCD :: ShowHumidity()                                                                                        
  683. {          
  684.     int humi1 = int(humidity) / 10;
  685.     int humi2 = int(humidity) % 10;
  686.     MyLCD.setCursor(5,0);    
  687.  
  688.     #if POLISH
  689.         MyLCD.print(F("WILGOTNOSC"));
  690.     #endif
  691.  
  692.     #if ENGLISH
  693.         MyLCD.print(F("HUMIDITY"));
  694.     #endif
  695.  
  696.     #if GERMANY
  697.         MyLCD.print(F("Feuchtigkeit"));
  698.     #endif    
  699.        
  700.     ShowDigit(4,  1,  humi1);
  701.     ShowDigit(8,  1,  humi2);
  702.     ShowPercentage(13,1);  
  703. }                          
  704.  
  705. // ------------------------------------------------------------------------------------------------------------------- //
  706. //          *** METODY PUBLICZNE *** WYSWIETL DATE ***                                                                 //
  707. // ------------------------------------------------------------------------------------------------------------------- //
  708.  
  709. void LCD :: ShowDate()
  710. {
  711.     static bool switcher = true;
  712.     ClearLine(3);
  713.     MyLCD.setCursor(0,3);
  714.  
  715.     if ( switcher )
  716.     {
  717.         MyLCD.print(Time.ShortData);
  718.         switcher = false;
  719.     }
  720.     else
  721.     if ( !switcher )
  722.     {
  723.         MyLCD.print(Time.LongData);
  724.         switcher = true;
  725.     }
  726. }
  727.  
  728. // ------------------------------------------------------------------------------------------------------------------- //
  729. //          *** METODY PUBLICZNE *** T Y P E W R I T E R ***                                                           //
  730. // ------------------------------------------------------------------------------------------------------------------- //
  731.  
  732. void LCD :: TypeWriter(const String & message, unsigned int wait, unsigned int x, unsigned int y)
  733. {
  734.     MyLCD.setCursor(x,y);
  735.     for(const char c : message)
  736.     {
  737.         MyLCD.print(c);    
  738.         delay(wait);  
  739.     }
  740. }
  741.    
  742. // ------------------------------------------------------------------------------------------------------------------- //
  743. //                            *** KLASA LCD *** by Tomasz Majcher (TLG) v1.00 Lite ***                                 //
  744. // ------------------------------------------------------------------------------------------------------------------- //
  745. //                                    * * * K O N I E C   K L A S Y   L C D ***                                        //
  746. // ------------------------------------------------------------------------------------------------------------------- //
  747.  
  748.  
  749. // ------------------------------------------------------------------------------------------------------------------- //
  750. // --- O B I E K T Y  ------------------------------------------------------------------------------------------------ //
  751. // ------------------------------------------------------------------------------------------------------------------- //
  752.  
  753. LCD myLCD(lcd);
  754.  
  755. WiFiUDP ntpUDP;                                                
  756. NTPClient timeClient(ntpUDP, "pool.ntp.org", 3600);  
  757.  
  758. // ------------------------------------------------------------------------------------------------------------------- //
  759. // --- Task0Callback() ----------------------------------------------------------------------------------------------- //
  760. // ------------------------------------------------------------------------------------------------------------------- //
  761.  
  762. void Task0Callback()
  763. {
  764.     timeClient.update();                                                                              
  765.    
  766.     unsigned long epochTime = timeClient.getEpochTime();                                              
  767.     struct tm *ptm = gmtime ( (time_t *) &epochTime );                                          
  768.                                                                                                
  769.     Time.DayOfTheWeek      =   timeClient.getDay();                                          
  770.     Time.DayOfTheMonth     =   ptm->tm_mday;                                                
  771.     Time.Month             =   ptm->tm_mon+1;                                                
  772.     Time.Year              =   ptm->tm_year+1900;
  773.  
  774.     Time.FormatedData  
  775.                    =   String(DAY[Time.DayOfTheWeek])
  776.                    +   ", "
  777.                    +   String(Time.DayOfTheMonth)
  778.                    +   " "
  779.                    +   String(MONTH[Time.Month])
  780.                    +   " "
  781.                    +   String(Time.Year);    
  782.  
  783.     Time.ShortData = String(Time.DayOfTheMonth)
  784.                    +   " "
  785.                    +   String(MONTH[Time.Month])
  786.                    +   " "
  787.                    +   String(Time.Year);  
  788.  
  789.     Time.LongData  =   String(DAY[Time.DayOfTheWeek])
  790.                    +   " "
  791.                    +   String(Time.DayOfTheMonth)
  792.                    +   "/"
  793.                    +   String(Time.Month);
  794.  
  795.     // --- formatowanie długości wyświetlanej daty ---
  796.  
  797.     if ( strlen(Time.LongData.c_str()) < 15 ) // jesli uda sie dokleci /RRRR
  798.     {
  799.         Time.LongData += "/" +   String(Time.Year);
  800.     }
  801.     else
  802.     if ( strlen(Time.LongData.c_str()) < 18 ) // jesli nie uda się dokleić /RRRR doklej /RR
  803.     {
  804.       Time.LongData += "/" +   String(Time.Year % 100);
  805.     }
  806.     else
  807.     if ( strlen(Time.LongData.c_str()) < 17 ) // jesli nie uda sie dokleic /RR
  808.     {
  809.       // nie rób nic :-)
  810.     }
  811.  
  812.     // -----------------------------------------------                  
  813.  
  814.     #if SERIAL                                                                                  
  815.         Serial.printf("\n\n[ESP] [TASK0] Data NTP  \t: %s ", Time.FormatedData.c_str());        
  816.     #endif          
  817. }
  818.  
  819. // ------------------------------------------------------------------------------------------------------------------- //
  820. // --- Task1Callback() ----------------------------------------------------------------------------------------------- //
  821. // ------------------------------------------------------------------------------------------------------------------- //
  822.  
  823. void Task1Callback()
  824. {
  825.     #if SERIAL
  826.         String bufor;
  827.        
  828.         if (Time.Hour < 10)
  829.         {
  830.             bufor =  "0";
  831.             bufor += String(Time.Hour);
  832.         }
  833.         else
  834.         {
  835.             bufor = String(Time.Hour);
  836.         }
  837.  
  838.         bufor += ":";
  839.  
  840.         if (Time.Minute < 10)
  841.         {
  842.             bufor +=  "0";
  843.             bufor += String(Time.Minute);
  844.         }
  845.         else
  846.         {
  847.             bufor += String(Time.Minute);
  848.         }
  849.  
  850.         if (Time.Hour < 12) bufor += " AM";
  851.         else                   bufor += " PM";
  852.        
  853.         Serial.printf("\n\n[ESP] [TASK1] [Time NTP] \t: %s", bufor.c_str());
  854.         Serial.printf("\n[ESP] [TASK1] [Memory Free]     : %u [kB]", ESP.getFreeHeap());      
  855.         Serial.printf("\n[ESP] [TASK1] [CPU frequency]   : %u [MHz]",ESP.getCpuFreqMHz());  
  856.         Serial.printf("\n[ESP] [TASK1] [WiFi IP]         : "); Serial.print(WiFi.localIP() );
  857.         Serial.printf("\n[ESP] [TASK1] [LongData]  \t: %s ", Time.LongData.c_str());
  858.         Serial.printf("\n[ESP] [TASK1] [ShortData] \t: %s ", Time.ShortData.c_str());
  859.        
  860.     #endif  
  861.  
  862.     if(DisplayTime) myLCD.ShowDate();     // only if DisplayTime is TRUE --- jesli DisplayTime jest TRUE
  863. }
  864.  
  865. // ------------------------------------------------------------------------------------------------------------------- //
  866. // --- Task2Callback() ----------------------------------------------------------------------------------------------- //
  867. // ------------------------------------------------------------------------------------------------------------------- //
  868.  
  869. void Task2Callback()
  870. {
  871.     timeClient.update();                                                            
  872.                                                                                    
  873.     Time.Hour    =  timeClient.getHours()+1;             // zapisz godzinę z serwera
  874.     Time.Minute  =  timeClient.getMinutes();             // zapisz minutę z serwera
  875.     Time.Second  =  timeClient.getSeconds();             // zapisz sekundę z serwera
  876.  
  877.     if(DisplayTime) myLCD.ShowTime();                   // only if DisplayTime is TRUE --- jesli DisplayTime jest TRUE
  878.     else
  879.     if(DisplayTemperature) myLCD.ShowTemperature();    
  880.     else
  881.     if(DisplayHumidity) myLCD.ShowHumidity();                                                                                        
  882.    
  883. }
  884.  
  885. // ------------------------------------------------------------------------------------------------------------------- //
  886. // --- S E T U P ----------------------------------------------------------------------------------------------------- //
  887. // ------------------------------------------------------------------------------------------------------------------- //
  888.  
  889. void setup()
  890. {
  891.     #if SERIAL
  892.         Serial.begin(SerialSpeed);
  893.     #endif
  894.  
  895.     lcd.init();                      
  896.     lcd.backlight();    
  897.     lcd.clear();
  898.    
  899.     myLCD.LcdRegister();            // register new chars
  900.  
  901.     myLCD.TypeWriter("simple ESP8266 Clock", 150, 0, 0);    
  902.     myLCD.TypeWriter("v1.70b by: T.Majcher", 150, 0, 1);    
  903.  
  904.     WiFi.begin(ssid, password);
  905.  
  906.     while ( WiFi.status() != WL_CONNECTED )                              // czekaj na połączenie
  907.     {                                                                    // wait for connect    
  908.         #if SERIAL
  909.             delay ( 200 );                                              
  910.             Serial.print ( "." );                                      
  911.         #endif
  912.     }
  913.  
  914.    char buf[21];
  915.    strcpy (buf, "IP : ");
  916.    strcat (buf, WiFi.localIP().toString().c_str() );
  917.    
  918.    myLCD.TypeWriter(buf, 150, 0, 2);    
  919.    myLCD.TypeWriter("Wait ..............", 150, 0, 3);
  920.    
  921.    delay(2000);
  922.    lcd.clear();  
  923.  
  924.    runner.init();                                       // inicjalizuj scheluder
  925.                                                                                  
  926.    runner.addTask(task_0);                              // dodaj zadanie do scheluder
  927.    task_0.enable();                                     // włącz zadanie do scheluder
  928.    runner.addTask(task_1);                              // dodaj zadanie do scheluder
  929.    task_1.enable();                                     // włącz zadanie do scheluder
  930.    runner.addTask(task_2);                              // dodaj zadanie do scheluder
  931.    task_2.enable();                                     // włącz zadanie do scheluder
  932.  
  933.    // --- WYWOŁAJ TERAZ --------------------- //
  934.  
  935.    Task0Callback();
  936.    Task1Callback();
  937.    Task2Callback();
  938.  
  939.    // --------------------------------------- //
  940.  
  941. }
  942.  
  943. // ------------------------------------------------------------------------------------------------------------------- //
  944. // --- L O O P ------------------------------------------------------------------------------------------------------- //
  945. // ------------------------------------------------------------------------------------------------------------------- //
  946.  
  947. void loop()
  948. {
  949.     runner.execute();    
  950. }
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!