API tools faq
paste
Advertisement
PowerTGS440

Blynk-Relay-Expander Starter v1.0

PowerTGS440
Aug 2nd, 2021
419
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 43.77 KB | None | 0 0
raw download clone embed print report
  1. /****************************************************************************************************************************
  2.  
  3.   WiFi + NTP + EXPANDER + RELAY + BLYNK
  4.  
  5.   Starter v1.0 by Tomasz Majcher
  6.   Licencja : Free
  7.  
  8. *****************************************************************************************************************************/
  9. //
  10. // 2 WIRE !!!
  11. //
  12. // ------------------------------------------------------------------------------------------------------------------- //
  13. // --- WiFi Setup ---------------------------------------------------------------------------------------------------- //
  14. // ------------------------------------------------------------------------------------------------------------------- //
  15.  
  16. #include <ESP8266WiFi.h>                // Library for WiFi Network (biblioteka do obsługi sieci WiFi)
  17. #include <WiFiUdp.h>                    // Library for NTP Server (biblioteka do obsługi serwera NTP)
  18.  
  19. char ssid[] = "XXXXXX";                 // your network SSID (nazwa twojej sieci WiFi)
  20. char pass[] = "XXXXXXXXXXX";            // your network password (hasło dostępu do sieci WiFi)
  21.  
  22. WiFiUDP ntpUDP;
  23.  
  24. unsigned long previousMillis = 0;       // for WiFiReconect
  25. unsigned long interval = 30000;         // for WiFiReconect
  26.  
  27. // ------------------------------------------------------------------------------------------------------------------- //
  28. // --- NTP server ---------------------------------------------------------------------------------------------------- //
  29. // ------------------------------------------------------------------------------------------------------------------- //
  30.  
  31. #define NTP_DBG_PORT                Serial                            // where Debug NTP ---> Serial
  32. #define _NTP_LOGLEVEL_              0                                 // 0 = no NTP debug
  33.  
  34. #include <NTPClient_Generic.h>                                        // Library for NTP Server
  35.  
  36. char timeServer[] = "pl.pool.ntp.org";                                // Time Server (Europe/Poland)
  37.  
  38. #define TIME_ZONE_OFFSET_HRS            (2)                           // Time Zone (Europe/Warsaw)
  39. #define NTP_UPDATE_INTERVAL_MS          60000L                        // Ntp Update (60 seconds)
  40.  
  41. NTPClient timeClient(ntpUDP, timeServer, (3600 * TIME_ZONE_OFFSET_HRS), NTP_UPDATE_INTERVAL_MS);
  42.  
  43. // ------------------------------------------------------------------------------------------------------------------- //
  44. // --- B L Y N K ----------------------------------------------------------------------------------------------------- //
  45. // ------------------------------------------------------------------------------------------------------------------- //
  46.  
  47. #include <BlynkSimpleEsp8266.h>  
  48.  
  49. #define VPIN_BUTTON_1  V1  
  50. #define VPIN_BUTTON_2  V2  
  51. #define VPIN_BUTTON_3  V3  
  52. #define VPIN_BUTTON_4  V4  
  53. #define VPIN_BUTTON_5  V5  
  54. #define VPIN_BUTTON_6  V6  
  55. #define VPIN_BUTTON_7  V7  
  56. #define VPIN_BUTTON_8  V8
  57.  
  58. #define AUTH "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"    // You should get Auth Token in the Blynk App.  
  59.  
  60. BlynkTimer timer;  
  61.  
  62. int toggleState_1 = 1; //Define integer to remember the toggle state for relay 1  
  63. int toggleState_2 = 1; //Define integer to remember the toggle state for relay 2  
  64. int toggleState_3 = 1; //Define integer to remember the toggle state for relay 3  
  65. int toggleState_4 = 1; //Define integer to remember the toggle state for relay 4  
  66. int toggleState_5 = 1; //Define integer to remember the toggle state for relay 5  
  67. int toggleState_6 = 1; //Define integer to remember the toggle state for relay 6  
  68. int toggleState_7 = 1; //Define integer to remember the toggle state for relay 7  
  69. int toggleState_8 = 1; //Define integer to remember the toggle state for relay 8  
  70.  
  71. // ------------------------------------------------------------------------------------------------------------------- //
  72. // --- E X P A N D E R  ---------------------------------------------------------------------------------------------- //
  73. // ------------------------------------------------------------------------------------------------------------------- //
  74.  
  75. #include <pcf8574_esp.h>
  76. #include <Wire.h>
  77.  
  78. /*  
  79.     Wire.h already defines "Wire" which the PCF8574-class would use by default,
  80.     but for the sakes of an example let's define our own instance of it and use that instead!
  81.  
  82.     Also, since I2C is emulated on the ESP8266 let's redefine what pins to use as SDA and SCL
  83.     and instead swap them around!
  84.     DO NOT FORGET TO WIRE ACCORDINGLY, SDA GOES TO GPIO5, SCL TO GPIO4 (ON NODEMCU GPIO5 IS D1 AND GPIO4 IS D2)
  85. */
  86.  
  87. TwoWire rWire;                               // wire SCL D2 (GPIO4), SCA D1 (GPIO5)
  88. PCF857x expander(0x20, &rWire);              // expander on 0x20
  89.  
  90. // ------------------------------------------------------------------------------------------------------------------- //
  91. // --- R E L A Y S  -------------------------------------------------------------------------------------------------- //
  92. // ------------------------------------------------------------------------------------------------------------------- //
  93.  
  94. #define RELAY0    0                             // reserved (to manage from 1 to 8)
  95. #define RELAY1    0                             // RELAY 1 on pin 0 (EXPANDER)
  96. #define RELAY2    1                             // RELAY 2 on pin 1 (EXPANDER)
  97. #define RELAY3    2                             // RELAY 3 on pin 2 (EXPANDER)
  98. #define RELAY4    3                             // RELAY 4 on pin 3 (EXPANDER)
  99. #define RELAY5    4                             // RELAY 5 on pin 4 (EXPANDER)
  100. #define RELAY6    5                             // RELAY 6 on pin 5 (EXPANDER)
  101. #define RELAY7    6                             // RELAY 7 on pin 6 (EXPANDER)
  102. #define RELAY8    7                             // RELAY 8 on pin 7 (EXPANDER)
  103.  
  104. #define RelayMin    1                           // define first RELAY (to debug)
  105. #define RelayMax    8                           // define last RELAY (to debug)
  106.  
  107. const byte RELAY[9] = { RELAY0, RELAY1, RELAY2, RELAY3, RELAY4, RELAY5, RELAY6, RELAY7, RELAY8 };
  108.  
  109. /*
  110.     How to use ?
  111.  
  112.     RelayOn(0);    turn on all relay (set to LOW)    
  113.     RelayOff(0);   turn off all relay (set to HIGH)    
  114.     RelayOn(1);    turn on relay nr. 1 (set to LOW)
  115.     RelayOn(3);    turn on relay nr. 3 (set to LOW)    
  116.     RelayOff(3);   turn off relay nr. 1 (set to HIGH)    
  117.     RelayOff(1);   turn off relay nr. 3 (set to HIGH)
  118. */
  119.  
  120. // ------------------------------------------------------------------------------------------------------------------- //
  121. // --- T A S K ------------------------------------------------------------------------------------------------------- //
  122. // ------------------------------------------------------------------------------------------------------------------- //
  123.  
  124. #include <TaskScheduler.h>                                       // scheluder
  125.  
  126. // ------------------------------------------------------------------------------------------------------------------- //
  127. // --- P R O T O T Y P Y --------------------------------------------------------------------------------------------- //
  128. // ------------------------------------------------------------------------------------------------------------------- //
  129.  
  130. void Task0Callback();                                                     // funkcja dla task_0    
  131. void Task1Callback();                                                     // funkcja dla task_1    
  132. void Task2Callback();                                                     // funkcja dla task_2    
  133. void Task3Callback();                                                     // funkcja dla task_3    
  134.  
  135. // ------------------------------------------------------------------------------------------------------------------- //
  136. // --- Z A D A N I A   S C H E L U D E R ' A ------------------------------------------------------------------------- //
  137. // ------------------------------------------------------------------------------------------------------------------- //
  138.                                                                                                    
  139. Task task_0( 3600000, TASK_FOREVER, &Task0Callback);                       // task_0 - co 1 godzinę  
  140. Task task_1(   60000,  TASK_FOREVER, &Task1Callback);                      // task_1 - co 1 minutę  
  141. Task task_2(    1000,  TASK_FOREVER, &Task2Callback);                      // task_2 - co 1 sekundę  
  142. Task task_3(   90000,  TASK_FOREVER, &Task3Callback);                      // task_3 - co 90 sekund
  143.                                                                                                    
  144. Scheduler runner;    
  145.  
  146. // ------------------------------------------------------------------------------------------------------------------- //
  147. // --- L A N G U A G E   S E T U P ----------------------------------------------------------------------------------- //
  148. // ------------------------------------------------------------------------------------------------------------------- //
  149.  
  150. #define LANGUAGE 0                                            // 0 (Polish), 1 (English)
  151.                                                                
  152. #if LANGUAGE == 0                                             // if POLISH Language                                            
  153.     #define POLISH 1
  154.     #define ENGLISH 0
  155. #endif
  156.    
  157. #if LANGUAGE == 1                                             // if ENGLISH Language
  158.     #define POLISH 0                                        
  159.     #define ENGLISH 1    
  160. #endif
  161.  
  162. // ------------------------------------------------------------------------------------------------------------------- //
  163. // --- S E R I A L   S E T U P --------------------------------------------------------------------------------------- //
  164. // ------------------------------------------------------------------------------------------------------------------- //
  165.  
  166. #define SERIAL true
  167. #define SerialSpeed 57600
  168.  
  169. // ------------------------------------------------------------------------------------------------------------------- //
  170. //                             *** STRUKTURA DNI TYGODNIA / STRUCT DAY OF WEEK ***                                     //
  171. // ------------------------------------------------------------------------------------------------------------------- //
  172.  
  173. const char PL_Day_0 [] = "Fake";
  174. const char PL_Day_1 [] = "Niedziela";
  175. const char PL_Day_2 [] = "Poniedzialek";
  176. const char PL_Day_3 [] = "Wtorek";
  177. const char PL_Day_4 [] = "Sroda";
  178. const char PL_Day_5 [] = "Czwartek";
  179. const char PL_Day_6 [] = "Piatek";
  180. const char PL_Day_7 [] = "Sobota";
  181.  
  182. const char EN_Day_0 [] = "Fake";
  183. const char EN_Day_1 [] = "Sunday";
  184. const char EN_Day_2 [] = "Monday";
  185. const char EN_Day_3 [] = "Tuesday";
  186. const char EN_Day_4 [] = "Wednesday";
  187. const char EN_Day_5 [] = "Thursday";
  188. const char EN_Day_6 [] = "Friday";
  189. const char EN_Day_7 [] = "Saturday";
  190.  
  191. const char * const PL_DAY[] = { PL_Day_0, PL_Day_1, PL_Day_2, PL_Day_3, PL_Day_4, PL_Day_5, PL_Day_6, PL_Day_7 };   // in POLISH
  192. const char * const EN_DAY[] = { EN_Day_0, EN_Day_1, EN_Day_2, EN_Day_3, EN_Day_4, EN_Day_5, EN_Day_6, EN_Day_7 };   // in ENGLISH
  193.  
  194. // ------------------------------------------------------------------------------------------------------------------- //
  195. //                                     *** STRUKTURA MIESIĄCE / STRUCT MONTH ***                                       //
  196. // ------------------------------------------------------------------------------------------------------------------- //
  197.  
  198. const char PL_MONTH_00  [] = "Fake";
  199. const char PL_MONTH_01  [] = "Styczen";
  200. const char PL_MONTH_02  [] = "Luty";
  201. const char PL_MONTH_03  [] = "Marzec";
  202. const char PL_MONTH_04  [] = "Kwiecien";
  203. const char PL_MONTH_05  [] = "Maj";
  204. const char PL_MONTH_06  [] = "Czerwiec";
  205. const char PL_MONTH_07  [] = "Lipiec";
  206. const char PL_MONTH_08  [] = "Sierpien";
  207. const char PL_MONTH_09  [] = "Wrzesien";
  208. const char PL_MONTH_10  [] = "Pazdziernik";
  209. const char PL_MONTH_11  [] = "Listopad";
  210. const char PL_MONTH_12  [] = "Grudzien";
  211.  
  212. const char EN_MONTH_00  [] = "Fake";
  213. const char EN_MONTH_01  [] = "January";
  214. const char EN_MONTH_02  [] = "February";
  215. const char EN_MONTH_03  [] = "March";
  216. const char EN_MONTH_04  [] = "April";
  217. const char EN_MONTH_05  [] = "May";
  218. const char EN_MONTH_06  [] = "June";
  219. const char EN_MONTH_07  [] = "July";
  220. const char EN_MONTH_08  [] = "August";
  221. const char EN_MONTH_09  [] = "September";
  222. const char EN_MONTH_10  [] = "October";
  223. const char EN_MONTH_11  [] = "November";
  224. const char EN_MONTH_12  [] = "December";
  225.  
  226. const char * const PL_MONTH[] = { PL_MONTH_00,
  227.                                   PL_MONTH_01, PL_MONTH_02, PL_MONTH_03,
  228.                                   PL_MONTH_04, PL_MONTH_05, PL_MONTH_06,
  229.                                   PL_MONTH_07, PL_MONTH_08, PL_MONTH_09,
  230.                                   PL_MONTH_10, PL_MONTH_11, PL_MONTH_12
  231.                                  };
  232.  
  233. const char * const EN_MONTH[] = { EN_MONTH_00,
  234.                                   EN_MONTH_01, EN_MONTH_02, EN_MONTH_03,
  235.                                   EN_MONTH_04, EN_MONTH_05, EN_MONTH_06,
  236.                                   EN_MONTH_07, EN_MONTH_08, EN_MONTH_09,
  237.                                   EN_MONTH_10, EN_MONTH_11, EN_MONTH_12
  238.                                 };
  239.  
  240. // ------------------------------------------------------------------------------------------------------------------- //
  241. // --- M Y N T P   S T R U C T --------------------------------------------------------------------------------------- //
  242. // ------------------------------------------------------------------------------------------------------------------- //
  243.  
  244. struct TIMEDATA
  245. {
  246.     // *** U T C   T I M E   &   D A T A *** ///
  247.    
  248.     int       iUTCYear;                                     // year UTC integer
  249.     int       iUTCMonth;                                    // month UTC integer
  250.     String    sUTCMonth;                                    // month UTC string
  251.     String    sUTCDoW;                                      // day of week UTC string
  252.     int       iUTCDay;                                      // day UTC integer
  253.     int       iUTCHours;                                    // hour UTC integer
  254.     String    sUTCHours;                                    // hour UTC string
  255.     int       iUTCMinutes;                                  // minutes UTC integer
  256.     String    sUTCMinutes;                                  // minutes UTC string
  257.     int       iUTCSeconds;                                  // seconds UTC integer
  258.     String    sUTCSeconds;                                  // seconds UTC string
  259.  
  260.     // *** L O C   T I M E   &   D A T A *** ///
  261.  
  262.     int       iLOCYear;
  263.     String    sLOCMonth;
  264.     int       iLOCMonth;
  265.     String    sLOCWeekDay;
  266.     int       iLOCWeekDay;                                  // Day of week (need re-build library by Tomasz Majcher)
  267.     int       iLOCDay;
  268.     int       iLOCHours;
  269.     String    sLOCHours;
  270.     int       iLOCMinutes;
  271.     String    sLOCMinutes;
  272.     int       iLOCSeconds;
  273.     String    sLOCSeconds;
  274.  
  275.     // *** E X T R A   S T R I N G   *** ///
  276.  
  277.     //String    sPL_DayOfWeek;                                // Day of week (need re-build library by Tomasz Majcher)
  278.     //String    sEN_DayOfWeek;                                // Day of week (need re-build library by Tomasz Majcher)
  279.     String    sPL_Month;
  280.     String    sEN_Month;
  281.    
  282. }
  283. MyNTP;
  284.  
  285. // ------------------------------------------------------------------------------------------------------------------- //
  286. // --- S E R I A L    I N I T ---------------------------------------------------------------------------------------- //
  287. // ------------------------------------------------------------------------------------------------------------------- //
  288.  
  289. void SerialInit()
  290. {
  291.     #if SERIAL
  292.         Serial.begin(SerialSpeed);                            // init Serial and set speed
  293.         while (!Serial);                                      // wait if not ready
  294.         Serial.printf("\n\n");                                // next line please
  295.     #endif    
  296. }
  297.  
  298. // ------------------------------------------------------------------------------------------------------------------- //
  299. // --- D R A W   L I N E --------------------------------------------------------------------------------------------- //
  300. // ------------------------------------------------------------------------------------------------------------------- //
  301.  
  302. void DrawLine(byte l, char s)
  303. {
  304.     #if SERIAL
  305.         Serial.printf("\n");
  306.         for (byte i=0; i<l; i++) Serial.print(s);        
  307.     #endif
  308. }
  309.  
  310. // ------------------------------------------------------------------------------------------------------------------- //
  311. // --- W i F i   I N I T --------------------------------------------------------------------------------------------- //
  312. // ------------------------------------------------------------------------------------------------------------------- //
  313.  
  314. void WiFiInit()
  315. {
  316.     WiFi.mode(WIFI_STA);
  317.     WiFi.begin(ssid, pass);
  318.  
  319.     #if SERIAL    
  320.         #if ENGLISH
  321.             Serial.printf("\n[ESP] [WiFI] Connecting to WiFi ..");
  322.         #endif
  323.         #if POLISH
  324.             Serial.printf("\n[ESP] [WiFI] Łącze z siecią WiFi ..");
  325.         #endif        
  326.     #endif
  327.      
  328.     while (WiFi.status() != WL_CONNECTED)
  329.     {
  330.         Serial.print('.');
  331.         delay(200);
  332.     }
  333.  
  334.     //statWiFi();
  335.          
  336.     WiFi.setAutoReconnect(true);
  337.     WiFi.persistent(true);
  338. }
  339.  
  340. // ------------------------------------------------------------------------------------------------------------------- //
  341. // --- WiFiStat ------------------------------------------------------------------------------------------------------ //
  342. // ------------------------------------------------------------------------------------------------------------------- //
  343.  
  344. void WiFiStat()
  345. {
  346.     switch (WiFi.status())
  347.     {
  348.         case WL_NO_SSID_AVAIL:
  349.                               #if SERIAL
  350.                                   #if ENGLISH
  351.                                       Serial.printf("\n[ESP] [WiFI] Configured SSID cannot be reached");
  352.                                   #endif
  353.                                   #if POLISH
  354.                                       Serial.printf("\n[ESP] [WiFI] Nie można osiągnąć skonfigurowanego identyfikatora SSID");
  355.                                   #endif                                  
  356.                               #endif        
  357.                               break;
  358.                              
  359.         case WL_CONNECTED:
  360.                               #if SERIAL
  361.                                   #if ENGLISH
  362.                                       Serial.printf("\n[ESP] [WiFI] Connection successfully established");
  363.                                       Serial.printf("\n[ESP] [WiFI] Your IP : %s", WiFi.localIP().toString().c_str());
  364.                                       Serial.printf("\n[ESP] [WiFI] Received Signal Strength Indication : %d", WiFi.RSSI());
  365.                                   #endif
  366.                                   #if POLISH
  367.                                       Serial.printf("\n[ESP] [WiFI] Pomyślnie nawiązano połączenie");
  368.                                       Serial.printf("\n[ESP] [WiFI] Twój adres IP : %s", WiFi.localIP().toString().c_str());
  369.                                       Serial.printf("\n[ESP] [WiFI] Wskazanie siły odbieranego sygnału : %d", WiFi.RSSI());
  370.                                   #endif                                
  371.                               #endif
  372.                               break;
  373.                              
  374.         case WL_CONNECT_FAILED:
  375.                               #if SERIAL
  376.                                   #if ENGLISH
  377.                                       Serial.printf("\n[ESP] [WiFI] Connection failed");
  378.                                   #endif
  379.                                   #if POLISH
  380.                                       Serial.printf("\n[ESP] [WiFI] Połączenie nieudane");
  381.                                   #endif                                  
  382.                               #endif
  383.                               break;
  384.       }      
  385. }
  386.  
  387. // ------------------------------------------------------------------------------------------------------------------- //
  388. // --- reconect Wi-Fi ------------------------------------------------------------------------------------------------ //
  389. // ------------------------------------------------------------------------------------------------------------------- //
  390.  
  391. void WiFiReconect()
  392. {
  393.     unsigned long currentMillis = millis();
  394.      
  395.     if ((WiFi.status() != WL_CONNECTED) && (currentMillis - previousMillis >=interval))     // if no WiFi connect now
  396.     {
  397.         #if SERIAL
  398.             #if ENGLISH
  399.                 Serial.printf("\n[ESP] [WiFI] Reconnecting to WiFi...");
  400.             #endif
  401.             #if POLISH
  402.                 Serial.printf("\n[ESP] [WiFI] Ponowne łączenie z Wi-Fi...");
  403.             #endif
  404.         #endif
  405.          
  406.         WiFi.disconnect();
  407.         WiFi.begin(ssid, pass);
  408.          
  409.         WiFiStat();                                       // show WiFi Status
  410.          
  411.         previousMillis = currentMillis;
  412.     }
  413. }
  414.  
  415. // ------------------------------------------------------------------------------------------------------------------- //
  416. // ---N T P   I N I T ------------------------------------------------------------------------------------------------ //
  417. // ------------------------------------------------------------------------------------------------------------------- //
  418.  
  419. int NTPInit()
  420. {
  421.     timeClient.update();
  422.  
  423.     if (timeClient.updated())
  424.     {
  425.         #if SERIAL
  426.             DrawLine(60,'*');
  427.             #if ENGLISH
  428.                 Serial.printf("\n[ESP] [NTP] Time Update :-)");
  429.                 Serial.printf("\n[ESP] [NTP] Using NTP Server : %s", timeClient.getPoolServerName().c_str());
  430.             #endif
  431.             #if POLISH
  432.                 Serial.printf("\n[ESP] [NTP] Czas został zaktualizowany :-)");
  433.                 Serial.printf("\n[ESP] [NTP] Używasz Serwera NTP : %s", timeClient.getPoolServerName().c_str());
  434.             #endif
  435.         #endif
  436.  
  437.         return 1;                     // return 1 if time is update
  438.     }
  439.     else
  440.     {
  441.         #if SERIAL
  442.             #if ENGLISH
  443.                 Serial.printf("\n[ESP] [NTP] Time in not Update !!!");
  444.             #endif
  445.             #if POLISH
  446.                 Serial.printf("\n[ESP] [NTP] Czas nie został zaktualizowany !!!");
  447.             #endif
  448.         #endif
  449.  
  450.         return 0;                     // return 0 if time is not update
  451.     }
  452. }
  453.  
  454. // ------------------------------------------------------------------------------------------------------------------- //
  455. // --- S H O W   N T P ----------------------------------------------------------------------------------------------- //
  456. // ------------------------------------------------------------------------------------------------------------------- //
  457.  
  458. void Show_NTP()
  459. {
  460.     #if SERIAL
  461.         DrawLine(60,'*');
  462.         #if POLISH
  463.             Serial.printf("\n[ESP] [TIME] UTC Czas : %s", timeClient.getFormattedUTCTime().c_str());
  464.             Serial.printf("\n[ESP] [TIME] UTC Data : %d/%d/%d", timeClient.getUTCDay(),timeClient.getUTCMonth(),timeClient.getUTCYear());
  465.             Serial.printf("\n[ESP] [TIME] LOC Czas : %s", timeClient.getFormattedTime().c_str());
  466.             Serial.printf("\n[ESP] [TIME] LOC Data : %d/%d/%d", timeClient.getDay(),timeClient.getMonth(),timeClient.getYear());
  467.             //Serial.printf("\n[ESP] [TIME] EXT Data : %s %d %s %d", MyNTP.sPL_DayOfWeek, timeClient.getDay(), MyNTP.sPL_Month, timeClient.getYear());
  468.         #endif
  469.         #if ENGLISH
  470.             Serial.printf("\n[ESP] [TIME] UTC Time : %s", timeClient.getFormattedUTCTime().c_str());
  471.             Serial.printf("\n[ESP] [TIME] UTC Data : %d/%d/%d", timeClient.getUTCDay(),timeClient.getUTCMonth(),timeClient.getUTCYear());
  472.             Serial.printf("\n[ESP] [TIME] LOC Time : %s", timeClient.getFormattedTime().c_str());
  473.             Serial.printf("\n[ESP] [TIME] LOC Data : %d/%d/%d", timeClient.getDay(),timeClient.getMonth(),timeClient.getYear());
  474.             //Serial.printf("\n[ESP] [TIME] EXT Data : %s %d %s %d", MyNTP.sEN_DayOfWeek, timeClient.getDay(), MyNTP.sEN_Month, timeClient.getYear());
  475.         #endif
  476.     #endif
  477. }
  478.  
  479. // ------------------------------------------------------------------------------------------------------------------- //
  480. // --- U P D A T E   M Y N T P   S T R U C T U R E ------------------------------------------------------------------- //
  481. // ------------------------------------------------------------------------------------------------------------------- //
  482.  
  483. void MyNTP_Update()
  484. {
  485.     timeClient.update();
  486.    
  487.     // *** U T C   T I M E   &   D A T A *** ///
  488.    
  489.     MyNTP.iUTCYear      = timeClient.getUTCYear();                                    
  490.     MyNTP.iUTCMonth     = timeClient.getUTCMonth();                                    
  491.     MyNTP.sUTCMonth     = timeClient.getUTCMonthStr();
  492.     MyNTP.sUTCDoW       = timeClient.getUTCDoW();
  493.     MyNTP.iUTCDay       = timeClient.getUTCDay();
  494.     MyNTP.iUTCHours     = timeClient.getUTCHours();
  495.     MyNTP.sUTCHours     = timeClient.getUTCStrHours();
  496.     MyNTP.iUTCMinutes   = timeClient.getUTCMinutes();
  497.     MyNTP.sUTCMinutes   = timeClient.getUTCStrMinutes();
  498.     MyNTP.iUTCSeconds   = timeClient.getUTCSeconds();
  499.     MyNTP.sUTCSeconds   = timeClient.getUTCStrSeconds();
  500.  
  501.     // *** L O C   T I M E   &   D A T A *** ///
  502.  
  503.     MyNTP.iLOCYear      = timeClient.getYear();
  504.     MyNTP.sLOCMonth     = timeClient.getMonthStr();
  505.     MyNTP.iLOCMonth     = timeClient.getMonth();
  506.     MyNTP.sLOCWeekDay   = timeClient.getDoW();
  507.     //MyNTP.iLOCWeekDay   = timeClient.getWeek();
  508.     MyNTP.iLOCDay       = timeClient.getDay();
  509.     MyNTP.iLOCHours     = timeClient.getHours();
  510.     MyNTP.sLOCHours     = timeClient.getStrHours();
  511.     MyNTP.iLOCMinutes   = timeClient.getMinutes();
  512.     MyNTP.sLOCMinutes   = timeClient.getStrMinutes();
  513.     MyNTP.iLOCSeconds   = timeClient.getSeconds();
  514.     MyNTP.sLOCSeconds   = timeClient.getStrSeconds();
  515.  
  516.     // *** E X T R A   S T R I N G   *** ///
  517.  
  518.  
  519.     //MyNTP.sPL_DayOfWeek       = PL_DAY[MyNTP.iLOCWeekDay];      // day of week (dzień tygodnia) POLISH (need Re-Build Library NTP by Tomasz Majcher)
  520.     //MyNTP.sEN_DayOfWeek       = EN_DAY[MyNTP.iLOCWeekDay];      // day of week (dzień tygodnia) ENGLISH(need Re-Build Library NTP by Tomasz Majcher)
  521.     MyNTP.sPL_Month           = PL_MONTH[MyNTP.iLOCMonth];      // month (miesiąc) in POLISH
  522.     MyNTP.sEN_Month           = EN_MONTH[MyNTP.iLOCMonth];      // month (miesiąć) in ENGLISH
  523. }
  524.  
  525. // ------------------------------------------------------------------------------------------------------------------- //
  526. // --- T A S K   S E T U P ------------------------------------------------------------------------------------------- //
  527. // ------------------------------------------------------------------------------------------------------------------- //
  528.  
  529. void TaskInit()
  530. {
  531.     runner.init();                                       // inicjalizuj scheluder
  532.                                                                                  
  533.     runner.addTask(task_0);                              // dodaj zadanie do scheluder
  534.     task_0.enable();                                     // włącz zadanie do scheluder
  535.     runner.addTask(task_1);                              // dodaj zadanie do scheluder
  536.     task_1.enable();                                     // włącz zadanie do scheluder
  537.     runner.addTask(task_2);                              // dodaj zadanie do scheluder
  538.     task_2.enable();                                     // włącz zadanie do scheluder
  539.     runner.addTask(task_3);                              // dodaj zadanie do scheluder
  540.     task_3.enable();                                     // włącz zadanie do scheluder
  541. }
  542.  
  543. // ------------------------------------------------------------------------------------------------------------------- //
  544. // --- T A S K   C A L L B A C K ------------------------------------------------------------------------------------- //
  545. // ------------------------------------------------------------------------------------------------------------------- //
  546.  
  547. void Task0Callback()    // run with interval 60 minutes
  548. {
  549.  
  550. }
  551.  
  552. // ------------------------------------------------------------------------------------------------------------------- //
  553. // --- T A S K   C A L L B A C K ------------------------------------------------------------------------------------- //
  554. // ------------------------------------------------------------------------------------------------------------------- //
  555.  
  556. void Task1Callback()    // run with interval 60 seconds
  557. {
  558.     #if SERIAL
  559.         Serial.printf("\n\n[ESP] [TASK1] Inside Task1Callback() ");
  560.         DrawLine(60,'*');
  561.         Serial.printf("\n[ESP] [TASK1] [Memory Free]     : %u [kB]", ESP.getFreeHeap());      
  562.         Serial.printf("\n[ESP] [TASK1] [CPU frequency]   : %u [MHz]",ESP.getCpuFreqMHz());  
  563.         Serial.printf("\n[ESP] [TASK1] [WiFi IP]         : "); Serial.print(WiFi.localIP() );
  564.     #endif  
  565. }
  566.  
  567. // ------------------------------------------------------------------------------------------------------------------- //
  568. // --- T A S K   C A L L B A C K ------------------------------------------------------------------------------------- //
  569. // ------------------------------------------------------------------------------------------------------------------- //
  570.  
  571. void Task2Callback()    // run with interval 1 seconds
  572. {
  573.  
  574. }
  575.  
  576. // ------------------------------------------------------------------------------------------------------------------- //
  577. // --- T A S K   C A L L B A C K ------------------------------------------------------------------------------------- //
  578. // ------------------------------------------------------------------------------------------------------------------- //
  579.  
  580. void Task3Callback()    // run with interval 90 seconds
  581. {
  582.     #if SERIAL
  583.         Serial.printf("\n\n[ESP] [TASK3] Inside Task3Callback() ");
  584.         MyNTP_Update();                                               // copy Time & Data to structure MyNTP
  585.         Show_NTP();                                                   // show NTP time & datarunner.execute();  
  586.     #endif
  587. }
  588.  
  589. // ------------------------------------------------------------------------------------------------------------------- //
  590. // --- E X P A N D E R   I N I T ------------------------------------------------------------------------------------- //
  591. // ------------------------------------------------------------------------------------------------------------------- //
  592.  
  593. void ExpanderInit()
  594. {
  595.     rWire.begin(5, 4);
  596.     rWire.setClock(100000L);
  597.     expander.begin();
  598.     RelayOff(0);                               //  all Relay OFF (send 0)
  599. }
  600.  
  601. // ------------------------------------------------------------------------------------------------------------------- //
  602. // --- M A I N   S E T U P ------------------------------------------------------------------------------------------- //
  603. // ------------------------------------------------------------------------------------------------------------------- //
  604.  
  605. void setup()
  606. {
  607.     SerialInit();                                         // check and init serial monitor
  608.     WiFiInit();                                           // start WiFi Connection
  609.     WiFiStat();                                           // show WiFi Status
  610.     WiFiReconect();                                       // check WiFi Connection and conect if loss !!!
  611.  
  612.     timeClient.begin();                                   // start timeClient
  613.  
  614.     DrawLine(60,'*');                                     // Draw 60x separator *
  615.    
  616.     if ( WiFi.status() == WL_CONNECTED )                  // if WiFi is OK
  617.     {
  618.         while(!NTPInit());                                // init NTP server                        
  619.         MyNTP_Update();                                   // copy Time & Data to structure MyNTP
  620.         Show_NTP();                                       // show NTP time & data
  621.     }
  622.  
  623.     ExpanderInit();                                       // ExpanderInit
  624.    
  625.     TaskInit();                                           // Init Task Scheluder
  626.  
  627.     /*
  628.     RelayOn(1);
  629.     RelayOn(10);
  630.     delay(2000);
  631.     RelayOff(1);
  632.     RelayOff(10);
  633.     delay(2000);
  634.     RelayOn(0);
  635.     delay(2000);
  636.     RelayOff(0);
  637.     */
  638.  
  639.     timer.setInterval(3000L, checkBlynkStatus); // check if Blynk server is connected every 3 seconds  
  640.     Blynk.config(AUTH);
  641. }
  642.  
  643. // ------------------------------------------------------------------------------------------------------------------- //
  644. // --- M A I N   L O O P --------------------------------------------------------------------------------------------- //
  645. // ------------------------------------------------------------------------------------------------------------------- //
  646.  
  647. void loop()
  648. {
  649.     runner.execute();                                     // scheluder        
  650.     Blynk.run();
  651. }
  652.  
  653. // ------------------------------------------------------------------------------------------------------------------- //
  654. //
  655. //
  656. //    ***   R E L A Y S   ***
  657. //
  658. //
  659. // ------------------------------------------------------------------------------------------------------------------- //
  660. // --- Relay to OFF -------------------------------------------------------------------------------------------------- //
  661. // ------------------------------------------------------------------------------------------------------------------- //
  662.  
  663. void RelayOff(byte nr)
  664. {
  665.     if (!nr)     // if nr = 0 all relay set to OFF (RelayMin, RelayMax)
  666.     {
  667.         for (byte i = RelayMin; i <= RelayMax; i++) expander.write(RELAY[i], HIGH);      
  668.  
  669.         #if SERIAL
  670.             DrawLine(60,'-');                                                      // draw line
  671.             #if POLISH
  672.                 Serial.printf("\n[ESP] [RELAY] Wyłączono wszystkie przekaźniki");
  673.             #endif                
  674.             #if ENGLISH
  675.                 Serial.printf("\n[ESP] [RELAY] Turn off all relay");
  676.             #endif
  677.         #endif
  678.     }
  679.     else
  680.     {
  681.         if ( nr >= RelayMin && nr <= RelayMax )                                   // only value (1-8)
  682.         {
  683.             if ( !expander.read(RELAY[nr]) )                                      // if Relay is ON
  684.             {
  685.                 expander.write(RELAY[nr], HIGH);                                  // turn off Relay
  686.                
  687.                 #if SERIAL
  688.                     DrawLine(60,'-');                                             // draw line
  689.                     #if POLISH
  690.                         Serial.printf("\n[ESP] [RELAY] Wyłączono przekaźnik nr. %d", nr);
  691.                     #endif                        
  692.                     #if ENGLISH
  693.                         Serial.printf("\n[ESP] [RELAY] Turn off relay no. %d", nr);
  694.                     #endif
  695.                 #endif
  696.             }
  697.             else                                                                  // relay is off, re-off
  698.             {
  699.                 #if SERIAL
  700.                     DrawLine(60,'-');
  701.                     #if POLISH
  702.                         Serial.printf("\n[ESP] [RELAY] Wykryto próbę ponownego wyłączenia przekaźnika nr. %d", nr);
  703.                     #endif
  704.                     #if ENGLISH
  705.                         Serial.printf("\n[ESP] [RELAY] An attempt to re-engage the relay has been detected no. %d", nr);
  706.                     #endif
  707.                 #endif
  708.             }
  709.         }
  710.         else                    // ERROR !!! Relay does not exist (jeśli taki przekaźnik nie istnieje)
  711.         {
  712.             #if SERIAL
  713.                 DrawLine(60,'-');                                                
  714.                 #if POLISH
  715.                     Serial.printf("\n[ESP] [RELAY] Nie ma takiego przekaźnika, nr. %d", nr);
  716.                 #endif                
  717.                 #if ENGLISH
  718.                     Serial.printf("\n[ESP] [RELAY] There is no such relay, no. %d", nr);
  719.                 #endif
  720.             #endif
  721.         }
  722.     }
  723. }
  724.  
  725. // ------------------------------------------------------------------------------------------------------------------- //
  726. // --- Relay to OFF -------------------------------------------------------------------------------------------------- //
  727. // ------------------------------------------------------------------------------------------------------------------- //
  728.  
  729. void RelayOn(byte nr)
  730. {
  731.     if (!nr)     // if nr = 0 all relay set to ON (RelayMin, RelayMax)
  732.     {
  733.         for (byte i = RelayMin; i <= RelayMax; i++) expander.write(RELAY[i], LOW);    
  734.  
  735.         #if SERIAL
  736.             DrawLine(60,'-');                                                      // draw line
  737.             #if POLISH
  738.                 Serial.printf("\n[ESP] [RELAY] Włączono wszystkie przekaźniki");
  739.             #endif                
  740.             #if ENGLISH
  741.                 Serial.printf("\n[ESP] [RELAY] Turn on all relay");
  742.             #endif
  743.          #endif
  744.     }
  745.     else
  746.     {
  747.         if ( nr >= RelayMin && nr <= RelayMax )                                   // only value (1-8)
  748.         {
  749.             if ( expander.read(RELAY[nr]) )                                       // if Relay is OFF
  750.             {
  751.                 expander.write(RELAY[nr], LOW);                                   // turn on Relay
  752.                
  753.                 #if SERIAL
  754.                     DrawLine(60,'-');                                             // draw line
  755.                     #if POLISH
  756.                         Serial.printf("\n[ESP] [RELAY] Włączono przekaźnik nr. %d", nr);
  757.                     #endif                        
  758.                     #if ENGLISH
  759.                         Serial.printf("\n[ESP] [RELAY] Turn on relay no. %d", nr);
  760.                     #endif
  761.                 #endif
  762.             }
  763.             else                                                                  // relay is on, re-on
  764.             {
  765.                 #if SERIAL
  766.                     DrawLine(60,'-');
  767.                     #if POLISH
  768.                         Serial.printf("\n[ESP] [RELAY] Wykryto próbę ponownego włączenia przekaźnika nr. %d", nr);
  769.                     #endif
  770.                     #if ENGLISH
  771.                         Serial.printf("\n[ESP] [RELAY] An attempt to re-engage the relay has been detected no. %d", nr);
  772.                     #endif
  773.                 #endif
  774.             }
  775.         }
  776.         else
  777.         {
  778.             #if SERIAL
  779.                 DrawLine(60,'-');                                                      // draw line
  780.                 #if POLISH
  781.                     Serial.printf("\n[ESP] [RELAY] Nie ma takiego przekaźnika, nr. %d", nr);
  782.                 #endif                
  783.                 #if ENGLISH
  784.                     Serial.printf("\n[ESP] [RELAY] There is no such relay, no. %d", nr);
  785.                 #endif  
  786.             #endif
  787.         }
  788.     }
  789. }
  790.  
  791. // ------------------------------------------------------------------------------------------------------------------- //
  792. //
  793. //
  794. // B L Y N K   S E C T I O N
  795. //
  796. //
  797. // ------------------------------------------------------------------------------------------------------------------- //
  798. // BLYNK_CONNECTED
  799. // ------------------------------------------------------------------------------------------------------------------- //
  800.  
  801. BLYNK_CONNECTED()
  802. {  
  803.     Blynk.syncVirtual(VPIN_BUTTON_1);  
  804.     Blynk.syncVirtual(VPIN_BUTTON_2);  
  805.     Blynk.syncVirtual(VPIN_BUTTON_3);  
  806.     Blynk.syncVirtual(VPIN_BUTTON_4);  
  807.     Blynk.syncVirtual(VPIN_BUTTON_5);  
  808.     Blynk.syncVirtual(VPIN_BUTTON_6);  
  809.     Blynk.syncVirtual(VPIN_BUTTON_7);  
  810.     Blynk.syncVirtual(VPIN_BUTTON_8);
  811. }  
  812.  
  813. // ------------------------------------------------------------------------------------------------------------------- //
  814. // BLYNK BUTTON 1
  815. // ------------------------------------------------------------------------------------------------------------------- //
  816.  
  817. BLYNK_WRITE(VPIN_BUTTON_1)
  818. {    
  819.   toggleState_1 = param.asInt();  
  820.  
  821.   if(toggleState_1)
  822.   {
  823.       RelayOn(1);
  824.   }
  825.   else
  826.   {
  827.       RelayOff(1);
  828.   }
  829. }  
  830.  
  831. // ------------------------------------------------------------------------------------------------------------------- //
  832. // BLYNK BUTTON 2
  833. // ------------------------------------------------------------------------------------------------------------------- //
  834.  
  835. BLYNK_WRITE(VPIN_BUTTON_2)
  836. {  
  837.   toggleState_2 = param.asInt();
  838.    
  839.   if(toggleState_2)
  840.   {
  841.       RelayOn(2);
  842.   }
  843.   else
  844.   {
  845.       RelayOff(2);
  846.   }
  847. }
  848.  
  849. // ------------------------------------------------------------------------------------------------------------------- //
  850. // BLYNK BUTTON 3
  851. // ------------------------------------------------------------------------------------------------------------------- //
  852.  
  853. BLYNK_WRITE(VPIN_BUTTON_3)
  854. {  
  855.   toggleState_3 = param.asInt();
  856.    
  857.   if(toggleState_3)
  858.   {
  859.       RelayOn(3);
  860.   }
  861.   else
  862.   {
  863.       RelayOff(3);
  864.   }
  865. }  
  866.  
  867. // ------------------------------------------------------------------------------------------------------------------- //
  868. // BLYNK BUTTON 4
  869. // ------------------------------------------------------------------------------------------------------------------- //
  870.  
  871. BLYNK_WRITE(VPIN_BUTTON_4)
  872. {  
  873.   toggleState_4 = param.asInt();
  874.    
  875.   if(toggleState_4)
  876.   {
  877.       RelayOn(4);
  878.   }
  879.   else
  880.   {
  881.       RelayOff(4);
  882.   }
  883. }  
  884.  
  885. // ------------------------------------------------------------------------------------------------------------------- //
  886. // BLYNK BUTTON 5
  887. // ------------------------------------------------------------------------------------------------------------------- //
  888.  
  889. BLYNK_WRITE(VPIN_BUTTON_5)
  890. {  
  891.   toggleState_5 = param.asInt();
  892.  
  893.   if(toggleState_5)
  894.   {
  895.       RelayOn(5);
  896.   }
  897.   else
  898.   {
  899.       RelayOff(5);
  900.   }
  901. }  
  902.  
  903. // ------------------------------------------------------------------------------------------------------------------- //
  904. // BLYNK BUTTON 6
  905. // ------------------------------------------------------------------------------------------------------------------- //
  906.  
  907. BLYNK_WRITE(VPIN_BUTTON_6)
  908. {  
  909.   toggleState_6 = param.asInt();
  910.  
  911.   if(toggleState_6)
  912.   {
  913.       RelayOn(6);
  914.   }
  915.   else
  916.   {
  917.       RelayOff(6);
  918.   }
  919. }  
  920.  
  921. // ------------------------------------------------------------------------------------------------------------------- //
  922. // BLYNK BUTTON 7
  923. // ------------------------------------------------------------------------------------------------------------------- //
  924. BLYNK_WRITE(VPIN_BUTTON_7)
  925. {  
  926.   toggleState_7 = param.asInt();
  927.  
  928.   if(toggleState_7)
  929.   {
  930.       RelayOn(7);
  931.   }
  932.   else
  933.   {
  934.       RelayOff(7);
  935.   }
  936. }  
  937.  
  938. // ------------------------------------------------------------------------------------------------------------------- //
  939. // BLYNK BUTTON 8
  940. // ------------------------------------------------------------------------------------------------------------------- //
  941.  
  942. BLYNK_WRITE(VPIN_BUTTON_8)
  943. {  
  944.   toggleState_8 = param.asInt();
  945.    
  946.   if(toggleState_8)
  947.   {
  948.       RelayOn(8);
  949.   }
  950.   else
  951.   {
  952.       RelayOff(8);
  953.   }
  954. }  
  955.  
  956. // ------------------------------------------------------------------------------------------------------------------- //
  957. // CHECK BLYNK
  958. // ------------------------------------------------------------------------------------------------------------------- //
  959.  
  960. void checkBlynkStatus()
  961. {
  962.     // no yet available
  963. }  
  964.  
  965. // ------------------------------------------------------------------------------------------------------------------- //
  966. // E N D
  967. // ------------------------------------------------------------------------------------------------------------------- //
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!