My wall socket remote managment

[NHN]

I glad to show my first project, this is just a first step, I plan to 3 more steps. This is my wall socket control by Blynk and Nodemcu, I can toggle on/off socket by Blynk button, can set timer to turn On / off each socket on demand time like timer widget, but easier to control and don’t depend on Blynk server, I can toggle on off the Timer of each socket, I can get Wan IP to update new ip to no-ip, this ip need to view camera system via internet; I can choose some task from menu, after choose task from menu, I need to type comand in Terminal to send to hardware; monitor temp, humidity, MQ2 sensor like eveyone else, MQ2 I need to monitor socket, if some strange smell or smoke, MQ2 push notify, email, twitter, to alert me.
I install the tablet in my technical room of my small “room for rent” department, in this room, there is an electric control center, a fingerprint door access control center, 16ch camera system, a pc, one ups 3kva to backup power to access control system, one modem to internet, one lan switch, 2 wifi routers direct connect to modem, get power from here and I can set timer to toggle modem, wifi router, camera system, power on the pc. Next step I setup a another control center to control this tablet or maybe some more tablets, and one more controler to collect data, watching everything is working, maybe I need a local Raspberry Blynk server to make sure everything in control. At my home, I setup a control center connect to department control to monitor everything easier, on the wall with light, LCD TV, speaker,…
Sorry about my bla bla…

This is my very first version tablet, I used UNO R3, Ethernet shield, 12v power supply, DC - DC 12v - 5v convertor, this time that’s all I have and connect them all…

This is the shield to protect from high voltage AC

Here first version using NodeMCU, smaller tablet, smaller MCU

update version

…on the wall…

and my blynk app

[Pavel]

whoa! that’s a lot of connected stuff!

Really cool!

[cptnslick]

Looks great. Where can I find the plastic board and enclosures you used? I like how they look.

[Pavel]

Yeah, enclosure is great. I need one too.

[NHN]

thanks for your like, I don’t know that enclosures called in English, sorry, but it use in Medical equipment, it used to put the medicin into hole, like “pen”, hope you can imagine out. The plastic board in my local is very easy to buy, go out, find any electric store, it cost about 0.7 usd

[madis]

wow, cool project… mind sharing arduino code?

[NHN]

updated

[Lichtsignaal]

It’s probably for test tubes and such. You can probably get that at a wholesales shop for school stuff. They use it in science classes too.

[NHN]

Hi, I post my code, hope someone help me improve my code, thks

#include "FS.h"
#define BLYNK_PRINT Serial
#define BLYNK_DEBUG
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SimpleTimer.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>
#include <ESP8266httpUpdate.h>
#include <ESP8266Ping.h>

#include <Wire.h>
#include "RTClib.h"
#include <DHT.h>

char auth[] = "xxx";

SimpleTimer timer;
byte timer_readDHT11_ID;
byte timer_readMQ2_ID;

RTC_DS3231 rtc;
WidgetTerminal terminal1(V10);

const byte VP_String[] = {V30 , V31 , V27 , V20};
String HW_String[] = {"", "", "http://192.168.0.222/update.bin", "NodeMCU_4.0.3.FS"};
//currentIP, oldIP, http update address, Version

const byte VP_data[] = {V32, V33, V35, V34, V45, V47};
int data[] = {30, 30, 42, 300, 1, 1};
//interval MQ2 alarm, interval Temp alarm, temp alarm, MQ2 alarm, Temp alarm, MQ2 Alarm

const byte ON_pins[] = {2, 14, 12};
const byte OFF_pins[] = {13};
const byte ON_VPpins[] = {V1, V2, V3};
const byte OFF_VPpins[] = {V4};
const byte clocker_ON_VP_start[] = {V11, V12, V13};
const byte clocker_ON_VP_stop[] = {V21, V22, V23};
const byte clocker_OFF_VP_start[] = {V14};
const byte clocker_OFF_VP_stop[] = {V24};
const byte VP_func[] = {V36, V39, V50, V53, V37, V48, V51, V38, V49, V52, V42, V40, V41, V43, V54};

const int sizeON_pins = (sizeof(ON_pins) / sizeof(byte));
const int sizeOFF_pins = (sizeof(OFF_pins) / sizeof(byte));
const int sizedata = (sizeof(VP_data) / sizeof(byte));
const int sizeString = (sizeof(VP_String) / sizeof(byte));
const int sizeVP_func = (sizeof(VP_func) / sizeof(byte));

byte ON_VPstate[sizeON_pins];
byte OFF_VPstate[sizeOFF_pins];
int clocker_ON_start[sizeON_pins];
int clocker_ON_stop[sizeON_pins];
int clocker_OFF_start[sizeOFF_pins];
int clocker_OFF_stop[sizeOFF_pins];

boolean isFirstConnect;
boolean compareIP_Alarm;

byte task = 0;
String VPstate_SPIFFS = "";
String ON_clocker_SPIFFS = "";
String OFF_clocker_SPIFFS = "";

//String currentIP = HW_String[0];
//String oldIP = HW_String[1];
//String httpUpdateAddress = HW_String[2];
//String Version = HW_String[3];

//const byte currentIP_VP = VP_String[0];
//const byte oldIP_VP = VP_String[1];
//const byte httpUpdateAddress_VP = VP_String[2];
//const byte Version_VP = VP_String[3];

String currentTime;
String currentDay;
String WifiLocal;

DHT dht(16, DHT11);
unsigned long t_temp_count = 0;
unsigned long t_MQ2_count = 0;
byte h;
byte t;
String h_push;
String t_push;

#define MQ2_Pin A0
int MQ2;
String MQ2_push;

void get_VPstate_SPIFFS()
{
  String ON_VPstate_SPIFFS;
  String OFF_VPstate_SPIFFS;
  for (byte i = 0; i < sizeON_pins; i++)
  {
    ON_VPstate_SPIFFS += String (ON_VPstate[i]);
    delay(10);
  }
  Serial.println("ON_VPstate_SPIFFS :" + ON_VPstate_SPIFFS);
  delay(10);
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    OFF_VPstate_SPIFFS += String (OFF_VPstate[i]);
    delay(10);
  }
  Serial.println("OFF_VPstate_SPIFFS :" + OFF_VPstate_SPIFFS);
  delay(10);
  VPstate_SPIFFS = ON_VPstate_SPIFFS + OFF_VPstate_SPIFFS;
  terminal1.println("get VPstate_SPIFFS :" + VPstate_SPIFFS);
  terminal1.flush();
}

void get_ON_clocker_SPIFFS()
{
  String ON_clocker_start_SPIFFS;
  String ON_clocker_stop_SPIFFS;
  for (byte i = 0; i < sizeON_pins; i++)
  {
    ON_clocker_start_SPIFFS += String (clocker_ON_start[i]) + ",";
    ON_clocker_stop_SPIFFS += String (clocker_ON_stop[i]) + ",";
    delay(10);
  }
  Serial.println("get ON_clocker_start_SPIFFS :" + ON_clocker_start_SPIFFS);
  Serial.println("get ON_clocker_stop_SPIFFS :" + ON_clocker_stop_SPIFFS);
  ON_clocker_SPIFFS = ON_clocker_start_SPIFFS + ON_clocker_stop_SPIFFS;
  Serial.println("get ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
  terminal1.println("get ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
  terminal1.flush();
}

void get_OFF_clocker_SPIFFS()
{
  String OFF_clocker_start_SPIFFS;
  String OFF_clocker_stop_SPIFFS;
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    OFF_clocker_start_SPIFFS += String (clocker_OFF_start[i]) + ",";
    OFF_clocker_stop_SPIFFS += String (clocker_OFF_stop[i]) + ",";
    delay(10);
  }
  Serial.println("get OFF_clocker_start_SPIFFS :" + OFF_clocker_start_SPIFFS);
  Serial.println("get OFF_clocker_stop_SPIFFS :" + OFF_clocker_stop_SPIFFS);
  OFF_clocker_SPIFFS = OFF_clocker_start_SPIFFS + OFF_clocker_stop_SPIFFS;
  Serial.println("get OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
  terminal1.println("get OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
  terminal1.flush();
}

void formatSPIFFS()
{
  SPIFFS.format();
}

void read_VPstate_SPIFFS()
{
  String line = "";
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/VP_state.txt"))
    {
      Serial.println("reading VP_state file");
      File VP_state_file = SPIFFS.open("/VP_state.txt", "r");
      if (VP_state_file) 
      {
        while(VP_state_file.available())
        {
          line = VP_state_file.readStringUntil('\n');
          Serial.println("read_VPstate_SPIFFS line: " + line);
        }
      }
      else
      {
        Serial.println("failed to load VP_state.txt");
        terminal1.println("failed to load VP_state.txt");
      }
    }
    else
    {
      Serial.println("VP_state.txt not exist");
      terminal1.println("VP_state.txt not exist");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
    terminal1.println("failed to mount FS");
  }
  
  String ON_VPstate_SPIFFS;
  String OFF_VPstate_SPIFFS;
  
  for (byte i = 0; i < sizeON_pins; i++)
  {
    ON_VPstate[i] = line.substring(i, i+1).toInt();
    ON_VPstate_SPIFFS += String (ON_VPstate[i]);
    delay(10);
  }
  
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    int j = sizeON_pins + i;
    OFF_VPstate[i] = line.substring(j, j+1).toInt();
    OFF_VPstate_SPIFFS += String (OFF_VPstate[i]);
    delay(10);
  }
  
  VPstate_SPIFFS = ON_VPstate_SPIFFS + OFF_VPstate_SPIFFS;
  String anbc = String(ON_VPstate[0]) + ON_VPstate[1] + ON_VPstate[2] + OFF_VPstate[0];
  terminal1.println("read VPstate_SPIFFS :" + anbc);
  terminal1.flush();
}

void read_ON_clocker_SPIFFS()
{
  String line = "";
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/ON_clocker.txt"))
    {
      //file exists, reading and loading
      Serial.println("reading ON_clocker file");
      File ON_clocker_file = SPIFFS.open("/ON_clocker.txt", "r");
      if (ON_clocker_file) 
      {
        while(ON_clocker_file.available())
        {
          line = ON_clocker_file.readStringUntil('\n');
          Serial.println("read ON_clocker_file line: " + line);
        }
      }
      else
      {
        Serial.println("failed to load ON_clocker.txt");
      }
    }
    else
    {
      Serial.println("ON_clocker.txt not exist");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
  }
  
  String ON_clocker_start_SPIFFS;
  String ON_clocker_stop_SPIFFS;
  int m = 0;
  int n = 0;
  for (byte i = 0; i < sizeON_pins; i++)
  {
    m = line.indexOf(',', n);
    clocker_ON_start[i] = line.substring(n, m).toInt();
    n = m + 1;
    ON_clocker_start_SPIFFS += String (clocker_ON_start[i]) + ",";
    delay(10);
  }
  for (byte i = 0; i < sizeON_pins; i++)
  {
    m = line.indexOf(',', n);
    clocker_ON_stop[i] = line.substring(n, m).toInt();
    n = m + 1;
    ON_clocker_stop_SPIFFS += String (clocker_ON_stop[i]) + ",";
    delay(10);
  }
  Serial.println("read ON_clocker_start_SPIFFS :" + ON_clocker_start_SPIFFS);
  Serial.println("read ON_clocker_stop_SPIFFS :" + ON_clocker_stop_SPIFFS);
  ON_clocker_SPIFFS = ON_clocker_start_SPIFFS + ON_clocker_stop_SPIFFS;
  Serial.println("read ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
  terminal1.println("read ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
  terminal1.flush();
}

void read_OFF_clocker_SPIFFS()
{
  String line = "";
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/OFF_clocker.txt"))
    {
      //file exists, reading and loading
      Serial.println("reading OFF_clocker file");
      File OFF_clocker_file = SPIFFS.open("/OFF_clocker.txt", "r");
      if (OFF_clocker_file) 
      {
        while(OFF_clocker_file.available())
        {
          line = OFF_clocker_file.readStringUntil('\n');
          Serial.println("read OFF_clocker_file line: " + line);
        }
      }
      else
      {
        Serial.println("failed to load OFF_clocker.txt");
      }
    }
    else
    {
      Serial.println("OFF_clocker not exist.txt");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
  }
  
  String OFF_clocker_start_SPIFFS;
  String OFF_clocker_stop_SPIFFS;
  int m = 0;
  int n = 0;
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    m = line.indexOf(',', n);
    clocker_OFF_start[i] = line.substring(n, m).toInt();
    n = m + 1;
    OFF_clocker_start_SPIFFS += String (clocker_OFF_start[i]) + ",";
    delay(10);
  }
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    m = line.indexOf(',', n);
    clocker_OFF_stop[i] = line.substring(n, m).toInt();
    n = m + 1;
    OFF_clocker_stop_SPIFFS += String (clocker_OFF_stop[i]) + ",";
    delay(10);
  }
  Serial.println("read OFF_clocker_start_SPIFFS :" + OFF_clocker_start_SPIFFS);
  delay(10);
  Serial.println("read OFF_clocker_stop_SPIFFS :" + OFF_clocker_stop_SPIFFS);
  delay(10);
  OFF_clocker_SPIFFS = OFF_clocker_start_SPIFFS + OFF_clocker_stop_SPIFFS;
  Serial.println("read OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
  delay(10);
  terminal1.println("read OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
  terminal1.flush();
}

void write_VPstate_SPIFFS()
{
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/VP_state.txt"))
    {
      Serial.println("reading VP_state file");
      File VP_state_file = SPIFFS.open("/VP_state.txt", "w");
      if (!VP_state_file)
      {
        Serial.println("VP_state.txt open failed");
        terminal1.println("VP_state.txt open failed");
      }
      VP_state_file.println(VPstate_SPIFFS);
      terminal1.println("write VPstate_SPIFFS :" + VPstate_SPIFFS);
      VPstate_SPIFFS = "";
    }
    else
    {
      Serial.println("VP_state.txt doesn't exist yet");
      terminal1.println("VP_state.txt doesn't exist yet");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
    terminal1.println("failed to mount FS");
  }
  terminal1.flush();
}

void write_ON_clocker_SPIFFS()
{
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/ON_clocker.txt"))
    {
      Serial.println("reading ON_clocker file");
      
      File ON_clocker_file = SPIFFS.open("/ON_clocker.txt", "w");
      if (!ON_clocker_file)
      {
        Serial.println("ON_clocker.txt open failed");
        terminal1.println("ON_clocker.txt open failed");
      }
      ON_clocker_file.println(ON_clocker_SPIFFS);
      delay(10);
      Serial.println("Write ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
      terminal1.println("Write ON_clocker_SPIFFS :" + ON_clocker_SPIFFS);
      ON_clocker_SPIFFS = "";
    }
    else
    {
      Serial.println("ON_clocker.txt doesn't exist yet");
      terminal1.println("ON_clocker.txt doesn't exist yet");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
    terminal1.println("failed to mount FS");
  }
  terminal1.flush();
}

void write_OFF_clocker_SPIFFS()
{
  if (SPIFFS.begin())
  {
    Serial.println("mounted file system");
    if (SPIFFS.exists("/OFF_clocker.txt"))
    {
      Serial.println("reading OFF_clocker file");
      
      File OFF_clocker_file = SPIFFS.open("/OFF_clocker.txt", "w");
      if (!OFF_clocker_file)
      {
        Serial.println("OFF_clocker.txt open failed");
        terminal1.println("OFF_clocker.txt open failed");
      }
      OFF_clocker_file.println(OFF_clocker_SPIFFS);
      delay(10);
      Serial.println("Write OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
      terminal1.println("Write OFF_clocker_SPIFFS :" + OFF_clocker_SPIFFS);
      OFF_clocker_SPIFFS = "";
    }
    else
    {
      Serial.println("OFF_clocker.txt doesn't exist yet");
      terminal1.println("OFF_clocker.txt doesn't exist yet");
    }
  }
  else
  {
    Serial.println("failed to mount FS");
    terminal1.println("failed to mount FS");
  }
  terminal1.flush();
}

void getlocalWifi()
{
  char myIpChar[24];
  IPAddress myIp = WiFi.localIP();
  sprintf(myIpChar, "%d.%d.%d.%d", myIp[0], myIp[1], myIp[2], myIp[3]);
  String WifiLocalIP = String(myIpChar);
  WifiLocal = "SSID: " + WiFi.SSID() + " - IP: " + WifiLocalIP;
  Serial.println(WifiLocal);
  Serial.println();
  Blynk.virtualWrite(V18, WifiLocal);
}

void checkWifi()
{
  if (!Blynk.connected())
  {
    if (WiFi.status() != WL_CONNECTED)
    {
      ESP8266WiFiMulti wifiMulti;
      wifiMulti.addAP("xxx", "xxx");
      wifiMulti.addAP("xxx", "xxx");
      wifiMulti.addAP("xxx", "xxx");
      wifiMulti.addAP("xxx", "xxx");
      wifiMulti.addAP("xxx", "xxx");
      if (wifiMulti.run() == WL_CONNECTED)
      {
        Serial.println("Success");
        if (Ping.ping("www.google.com.vn", 1))
        {
          Serial.println("Success connect to internet");
          if (Ping.ping("blynk-cloud.com", 1))
          {
            Serial.println("Success ping to blynk");
          }
          else
          {
            Serial.println("Fail ping to blynk");
          }
        }
        else
        {
          Serial.println("Fail ping to Google");
        }
      }
      else
      {
        Serial.println("Fail");
      }
    }
  }
}

void syncBlynk()
{
  Blynk.syncAll();
}

void updateON_clocker()
{
  for (byte i = 0; i <sizeON_pins; i++)
  {
    String ON_start = String(clocker_ON_start[i]);
    String ON_start_push = ON_start.substring(0,2) + "h" + ON_start.substring(2,4);
    Blynk.virtualWrite(clocker_ON_VP_start[i], ON_start_push);
    delay(10);
    String ON_stop = String(clocker_ON_stop[i]);
    String ON_stop_push = ON_stop.substring(0,2) + "h" + ON_stop.substring(2,4);
    Blynk.virtualWrite(clocker_ON_VP_stop[i], ON_stop_push);
    delay(10);
  }
}

void updateOFF_clocker()
{
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    String OFF_start = String(clocker_OFF_start[i]);
    String OFF_start_push = OFF_start.substring(0,2) + "h" + OFF_start.substring(2,4);
    Blynk.virtualWrite(clocker_OFF_VP_start[i], OFF_start_push);
    delay(10);
    String OFF_stop = String(clocker_OFF_stop[i]);
    String OFF_stop_push = OFF_stop.substring(0,2) + "h" + OFF_stop.substring(2,4);
    Blynk.virtualWrite(clocker_OFF_VP_stop[i], OFF_stop_push);
    delay(10);
  }
}

void updateState()
{
  for (byte i = 0; i < sizeON_pins; i++)
  {
    byte t = digitalRead(ON_pins[i]);
    Serial.println(String("ON_VPstate: ") + i + " " + ON_VPstate[i]);
    Serial.println(String("t ON: ") + i + " " + t);
    if (t != ON_VPstate[i])
    {
      Blynk.virtualWrite(ON_VPpins[i], t);
      ON_VPstate[i] = t;
      Serial.println(String("ON_VPstate khac: ") + i + " " + ON_VPstate[i]);
      get_VPstate_SPIFFS();
      delay(10);
      write_VPstate_SPIFFS();
      delay(10);
    }
    delay(10);
  }
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    byte t = digitalRead(OFF_pins[i]);
    Serial.println(String("OFF_VPstate: ") + i + " " + OFF_VPstate[i]);
    Serial.println(String("t OFF: ") +i + t);
    if (t == OFF_VPstate[i])
    {
      Blynk.virtualWrite(OFF_VPpins[i], 1 - t);
      OFF_VPstate[i] = 1 - t;
      Serial.println(String("OFF_VPstate khac: ") + i + " " + OFF_VPstate[i]);
      get_VPstate_SPIFFS();
      delay(10);
      write_VPstate_SPIFFS();
      delay(10);
    }
    delay(10);
  }
  delay(10);
  getlocalWifi();
  delay(10);
  Blynk.virtualWrite(V26,MQ2_push);
  delay(10);
  Blynk.virtualWrite(V28,h_push);
  delay(10);
  Blynk.virtualWrite(V29,t_push);
  delay(10);
  updateOFF_clocker();
  delay(10);
  updateON_clocker();
  delay(10);
  terminal1.print("State updated");
  terminal1.println();
  terminal1.flush();
}

void readDHT11()
{
  h = dht.readHumidity();
  t = dht.readTemperature();
  t_push = String (t) + " ℃";
  h_push = String (h) + " %";
  if (t > data[2] && t < 70)
  {
    if ((millis() - t_temp_count) >= (data[1] * 1000L) && data[4] == 1)
    {
      t_temp_count = millis();
      String alarm_str = String("Temp is HIGH: ") + t_push + " > " + data[2];
      Blynk.notify(alarm_str);
      Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
    }
  }
  else
  {
    t_temp_count = 0;
  }
}

void readMQ2()
{
  MQ2 = (analogRead(MQ2_Pin));
  MQ2_push = MQ2;
  if (MQ2 > data[3])
  {
    if ((millis() - t_MQ2_count) >= (data[0] * 1000L) && data[5] == 1)
    {
      t_MQ2_count = millis();
      String alarm_str = String("MQ2 is HIGH: ") + MQ2_push + " > " + data[3];
      Blynk.notify(alarm_str);
      Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
    }
  }
  else
  {
    t_MQ2_count = 0;
  }
}

void compareIP()
{
  if (HW_String[0].length() > 0 && HW_String[1].length() > 0)
  {
    if (HW_String[0] != HW_String[1])
    {
      if (compareIP_Alarm)
      {
        Blynk.notify("IP has changed");
        Blynk.email("xxx@gmail.com", "IP has changed", "IP has changed");
        compareIP_Alarm = false;
      }
    }
    else
    {
      compareIP_Alarm = true;
    }
  }
}

void clocker()
{
  DateTime Time = rtc.now();
  currentTime = String(Time.hour()) + ":" + Time.minute() + ":" + Time.second();
  currentDay = String(Time.day()) + "-" + Time.month() + "-" + Time.year();
  int t = Time.hour() * 100 + Time.minute();
  for (byte k = 0; k < sizeON_pins; k++) 
  {
    if (clocker_ON_start[k] == 0 && clocker_ON_stop[k] == 0) 
    {
      continue;
    }
    else if (t >= clocker_ON_start[k] && t < clocker_ON_stop[k])
    {
      if (digitalRead(ON_pins[k]) == 1) 
      {
        digitalWrite(ON_pins[k], 0); 
        Serial.println(String("ON_VPstate: ") + k + " " + ON_VPstate[k]);
        if (Blynk.connected()); 
        {
          Blynk.virtualWrite(ON_VPpins[k], 0);
          ON_VPstate[k] = 0;
          String alarm_str = String("ON pin ") + k+1 + " OFF by Clocker at: " + currentTime + " " + currentTime;
          terminal1.print(alarm_str);
          terminal1.println();
          terminal1.flush();
          Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
          delay (10);
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
      }
    }
    else 
    {
      if (digitalRead(ON_pins[k]) == 0) 
      {
        digitalWrite(ON_pins[k], 1);
        Serial.println(String("ON_VPstate: ") + k + " " + ON_VPstate[k]);
        if (Blynk.connected());
        {
          Blynk.virtualWrite(ON_VPpins[k], 1);
          ON_VPstate[k] = 1;
          String alarm_str = String("ON pin ") + k+1 + " ON by Clocker at: " + currentTime + " " + currentTime;
          terminal1.print(alarm_str);
          terminal1.println();
          terminal1.flush();
          Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
          delay (10);
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
      }
    }
  }

  for (byte j = 0; j < sizeOFF_pins; j++)
  {
    if (clocker_OFF_start[j] == 0 && clocker_OFF_stop[j] == 0)
    {
      continue;
    }
    else if (t >= clocker_OFF_start[j] && t < clocker_OFF_stop[j])
    {
      if (digitalRead(OFF_pins[j]) == 1)
      {
        digitalWrite(OFF_pins[j], 0);
        Serial.println(String("OFF_VPstate: ") + j + " " + OFF_VPstate[j]);
        if (Blynk.connected()); 
        {
          Blynk.virtualWrite(OFF_VPpins[j], 1);
          OFF_VPstate[j] = 1;
          String alarm_str = String("OFF pin ") + j+1 + " ON by Clocker at: " + currentTime + " " + currentTime;
          terminal1.print(alarm_str);
          terminal1.println();
          terminal1.flush();
          Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
          delay (10);
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
      }
    }
    else 
    {
      if (digitalRead(OFF_pins[j]) == 0)
      {
        digitalWrite(OFF_pins[j], 1);  
        Serial.println(String("OFF_VPstate: ") + j + " " + OFF_VPstate[j]);
        if (Blynk.connected());
        {
          Blynk.virtualWrite(OFF_VPpins[j], 0);
          OFF_VPstate[j] = 0; 
          String alarm_str = String("OFF pin ") + j+1 + " OFF by Clocker at: " + currentTime + " " + currentTime;
          terminal1.print(alarm_str);
          terminal1.println();
          terminal1.flush();
          Blynk.email("xxx@gmail.com", alarm_str, alarm_str);
          delay (10);
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
      }
    }
    delay (10);
  }
}

void getIP()
{
  String readString;
  WiFiClient client;
  if (client.connect("api.ipify.org", 80))
  {
    client.println(String("GET / HTTP/1.0\r\n") +
                   "Host: api.ipify.org\r\n" +
                   "Connection: close\r\n\r\n");

    //Waiting response
    unsigned long timeout = millis() + 5000;
    while (client.available() == 0)
    {
      if (timeout - millis() < 0)
      {
        Serial.println(">>> Client Timeout !");
        terminal1.println(">>> Client Timeout !");
        terminal1.println();
        terminal1.flush();
        client.stop();
        return;
      }
    }
    while (client.available())
    {
      char c = client.read(); 
      readString += c;
    }
    client.stop(); //stop client
    Serial.print(readString);
    int strangeChar = readString.indexOf((char) - 1);
    HW_String[0] = readString.substring(153, strangeChar);
    readString = "";
    terminal1.print("Current IP: ");
    Blynk.virtualWrite(VP_String[0], HW_String[0]);
    terminal1.println(HW_String[0]);
    terminal1.println();
    terminal1.flush();
  }
  else
  {
    Serial.println("connection failed");
    Serial.println();
    terminal1.println("connection failed");
    terminal1.println();
  }
}

void updateIP1()
{
  WiFiClient client1;
  if (HW_String[0].length() > 0)
  {
    if (client1.connect("dynupdate.no-ip.com", 80))
    {
      client1.println(String("GET /nic/update?hostname=xxx.ddns.net&myip=") + HW_String[0] + " HTTP/1.0\r\n"
                      + "Host: dynupdate.no-ip.com\r\n"
                      + "Authorization: Basic bmdvaHV1bmFtOmd5Z2FieXRl\r\n"
                      + "User-Agent: Arduino_update_client/1.0 xxx@gmail.com\r\n\r\n");
      terminal1.print("Updated Ip xxx.ddns.net to " + HW_String[0]);
      terminal1.println();
    }
    else
    {
      terminal1.println("connection to update.no-ip.com failed");
      terminal1.println();
    }
    client1.stop();
  }
  else
  {
    terminal1.println("Need New IP First");
    terminal1.println();
  }
  terminal1.flush();
}

void updateIP2()
{
  WiFiClient client2;
  if (HW_String[0].length() > 0)
  {
    if (client2.connect("dynupdate.no-ip.com", 80))
    {
      client2.println(String ("GET /nic/update?hostname=xxx.ddns.net,xxx.ddns.net,xxx.ddns.net,&myip=") + HW_String[0] + " HTTP/1.0\r\n"
                      + "Host: dynupdate.no-ip.com\r\n"
                      + "Authorization: Basic aHV1bmFtODI6Z3lnYWJ5dGU=\r\n"
                      + "User-Agent: Arduino_update_client/1.0 xxx@gmail.com\r\n\r\n");
      terminal1.print("Updated Ip xxx.ddns.net to " + HW_String[0]);
      terminal1.println();
    }
    else
    {
      terminal1.println("connection to update.no-ip.com failed");
      terminal1.println();
    }
    client2.stop();
  }
  else
  {
    terminal1.println("Need New IP First");
    terminal1.println();
  }
  terminal1.flush();
}

void updateIPall()
{
  updateIP2();
  timer.setTimeout(5000L, updateIP1);
  Blynk.virtualWrite(VP_String[1], HW_String[0]);
}

void http_update()
{
  ESPhttpUpdate.update(HW_String[2]);
}

//VP_func[] = {V36, V39, V50, V53, V37, V48, V51, V38, V49, V52, V42, V40, V41, V43, V54};
typedef void (* myFunction)();
extern myFunction FunctionArray[];
myFunction FunctionArray[] = {formatSPIFFS, get_VPstate_SPIFFS, get_ON_clocker_SPIFFS,
                              get_OFF_clocker_SPIFFS, read_VPstate_SPIFFS, read_ON_clocker_SPIFFS,
                              read_OFF_clocker_SPIFFS, write_VPstate_SPIFFS,
                              write_ON_clocker_SPIFFS, write_OFF_clocker_SPIFFS, updateState,
                              getIP, updateIPall, http_update, syncBlynk};
volatile int foo = sizeVP_func;

void setup()
{
  Serial.begin(115200);
  read_VPstate_SPIFFS();
  delay(3000);
  read_ON_clocker_SPIFFS();
  delay(3000);
  read_OFF_clocker_SPIFFS();
  delay(3000);
  //Blynk.begin(auth, "xxx", "xxx");
  Blynk.config(auth);
  for (byte i = 0; i < sizeON_pins; i++)
  {
    pinMode(ON_pins[i], OUTPUT);
    digitalWrite(ON_pins[i], HIGH);
    delay (10);
  }
  for (byte i = 0; i < sizeOFF_pins; i++)
  {
    pinMode(OFF_pins[i], OUTPUT);
    digitalWrite(OFF_pins[i], HIGH);
    delay (10);
  }
  pinMode(MQ2_Pin, INPUT);
  dht.begin();
  Wire.begin();
  timer.setInterval(100, clocker);
  timer.setInterval(1000, compareIP);
  timer_readDHT11_ID = timer.setInterval(1000, readDHT11);
  timer.disable(timer_readDHT11_ID);
  h_push = "OFF";
  t_push = "OFF";
  timer_readMQ2_ID = timer.setInterval(1000, readMQ2);
  timer.disable(timer_readMQ2_ID);
  MQ2_push = "OFF";
  timer.setInterval(1000, checkWifi);
  isFirstConnect = true;
  compareIP_Alarm = true;
  task = 0;
  Serial.print("Setup done");
  Serial.println();
}

void loop()
{
  Blynk.run();
  timer.run();
}

BLYNK_CONNECTED()
{
  getlocalWifi();
  task = 0;
  //updateState();
  /*if (isFirstConnect)
  {
    Blynk.syncAll();
    Blynk.virtualWrite(VP_String[3], HW_String[3]);
    isFirstConnect = false;
  }*/
  Blynk.syncAll();
  Blynk.virtualWrite(VP_String[3], HW_String[3]);
  getIP;
}

BLYNK_READ(V9)
{
  Blynk.virtualWrite(V9, currentTime);
}

BLYNK_READ(V26) 
{
  Blynk.virtualWrite(V26, MQ2_push);
}

BLYNK_READ(V29)
{
  Blynk.virtualWrite(V29, t_push);
}

BLYNK_READ(V28) 
{
  Blynk.virtualWrite(V28, h_push);
}

[NHN]

reach maximum character, have to post one more post

BLYNK_WRITE_DEFAULT()
{
  int pin = request.pin;
  int value_int = param.asInt();
  String value_str = param.asStr();

  if (pin == 44) 
  {
    switch (value_int)
    {
      case 0:
        timer.disable(timer_readDHT11_ID);
        h_push = "OFF";
        t_push = "OFF";
        break;
      case 1:
        timer.enable(timer_readDHT11_ID);
        break;
    }
  }

  else if (pin == 46) 
  {
    switch (value_int)
    {
      case 0:
        timer.disable(timer_readMQ2_ID);
        MQ2_push = "OFF";
        break;
      case 1:
        timer.enable(timer_readMQ2_ID);
        break;
    }
  }
 
  else
  {
    for (byte i = 0; i < sizeVP_func ; i++)
    {
      if (pin == VP_func[i])
      {
        if (value_int == 1)
        {
          FunctionArray[i]();
        }
        break;
      }
    }
      
    for (byte i = 0; i < sizeString ; i++) 
    {
      if (pin == VP_String[i])
      {
        HW_String[i] = value_str;
        Serial.println(value_str);
        break;
      }
    }

    for (byte i = 0; i < sizedata ; i++)
    {
      if (pin == VP_data[i]) 
      {
        data[i] = value_int;   
        Serial.println(value_int);
        break;
      }
    }

    for (byte i = 0; i < sizeON_pins ; i++) 
    {
      if (pin == ON_VPpins[i])
      {
        byte n = digitalRead(ON_pins[i]);
        if (n == ON_VPstate[i])
        {
          digitalWrite(ON_pins[i], value_int);
          ON_VPstate[i] = value_int; 
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
        else
        {
          Blynk.virtualWrite(ON_VPpins[i], n);
          ON_VPstate[i] = n;
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
        break;
      }
    }
    
    for (byte i = 0; i < sizeON_pins ; i++)
    {
      if (pin == clocker_ON_VP_start[i]) 
      {
        String abc = value_str.substring(0,2) + value_str.substring(3,5);
        if (abc.toInt() != clocker_ON_start[i])
        {
          String ON_start = String(clocker_ON_start[i]);
          String ON_start_push = ON_start.substring(0,2) + "h" + ON_start.substring(2,4);
          Blynk.virtualWrite(clocker_ON_VP_start[i], ON_start_push);
          delay(10);
        }
        break;
      }
    }
    
    for (byte i = 0; i < sizeON_pins ; i++)
    {
      if (pin == clocker_ON_VP_stop[i])
      {
        String abc = value_str.substring(0,2) + value_str.substring(3,5);
        if (abc.toInt() != clocker_ON_stop[i])
        {
          String ON_stop = String(clocker_ON_stop[i]);
          String ON_stop_push = ON_stop.substring(0,2) + "h" + ON_stop.substring(2,4);
          Blynk.virtualWrite(clocker_ON_VP_stop[i], ON_stop_push);
          delay(10);
        }
        break;
      }
    }

    for (byte i = 0; i < sizeOFF_pins ; i++) 
    {
      if (pin == OFF_VPpins[i])
      {
        byte m = digitalRead(OFF_pins[i]);
        byte p = 1 - OFF_VPstate[i];
        if (m == p)
        {
          digitalWrite(OFF_pins[i], 1 - value_int);
          OFF_VPstate[i] = value_int;
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
        else
        {
          Blynk.virtualWrite(OFF_VPpins[i], 1 - m);
          OFF_VPstate[i] = 1 - m;
          get_VPstate_SPIFFS();
          delay(10);
          write_VPstate_SPIFFS();
          delay(10);
        }
        break;
      }
    }
    
    for (byte i = 0; i < sizeOFF_pins ; i++)
    {
      if (pin == clocker_OFF_VP_start[i])
      {
        String abc = value_str.substring(0,2) + value_str.substring(3,5);
        if (abc.toInt() != clocker_OFF_start[i])
        {
          String OFF_start = String(clocker_OFF_start[i]);
          String OFF_start_push = OFF_start.substring(0,2) + "h" + OFF_start.substring(2,4);
          Blynk.virtualWrite(clocker_OFF_VP_start[i], OFF_start_push);
          delay(10);
        }
        break;
      }
    }
    
    for (byte i = 0; i < sizeOFF_pins ; i++)
    {
      if (pin == clocker_OFF_VP_stop[i]) 
      {
        String abc = value_str.substring(0,2) + value_str.substring(3,5);
        if (abc.toInt() != clocker_OFF_stop[i])
        {
          String OFF_stop = String(clocker_OFF_stop[i]);
          String OFF_stop_push = OFF_stop.substring(0,2) + "h" + OFF_stop.substring(2,4);
          Blynk.virtualWrite(clocker_OFF_VP_stop[i], OFF_stop_push);
          delay(10);
        }
        break;
      }
    }
  }
}

BLYNK_WRITE(V10)
{
  String input = param.asStr();
  if (task == 0)
  {
    terminal1.print("no task");
    terminal1.println();
  }
  
  else if (task > 0 && task < 4)
  {
    byte i = task - 1;
    clocker_ON_start[i] = input.substring(0, 4).toInt(); 
    clocker_ON_stop[i] = input.substring(5, 9).toInt();  
    if (clocker_ON_start[i] == 0 && clocker_ON_stop[i] == 0) 
    {
      Blynk.virtualWrite(clocker_ON_VP_start[i], "OFF");
      Blynk.virtualWrite(clocker_ON_VP_stop[i], "OFF"); 
      delay(10);
      get_ON_clocker_SPIFFS();
      delay(10);
      write_ON_clocker_SPIFFS();
      delay(10);
    }
    else
    {
      String value = String("Clocker ON ") + task + ": " + input.substring(0, 2) + "h" + input.substring(2, 4) + " -> " + input.substring(5, 7) + "h" + input.substring(7, 9);
      String value_start = input.substring(0, 2) + "h" + input.substring(2, 4);
      String value_stop = input.substring(5, 7) + "h" + input.substring(7, 9);
      terminal1.print(value);
      terminal1.println();
      Blynk.virtualWrite(clocker_ON_VP_start[i], value_start);
      Blynk.virtualWrite(clocker_ON_VP_stop[i], value_stop);
      delay(10);
      get_ON_clocker_SPIFFS();
      delay(10);
      write_ON_clocker_SPIFFS();
      delay(10);
    }
    task = 0;
  }
  else if (task > 3 && task < 5)
  {
    byte i = task - 4;
    clocker_OFF_start[i] = input.substring(0, 4).toInt();
    clocker_OFF_stop[i] = input.substring(5, 9).toInt();
    if (clocker_OFF_start[i] == 0 && clocker_OFF_stop[i] == 0)
    {
      Blynk.virtualWrite(clocker_OFF_VP_start[i], "OFF");
      Blynk.virtualWrite(clocker_OFF_VP_stop[i], "OFF");
      delay(10);
      get_OFF_clocker_SPIFFS();
      delay(10);
      write_OFF_clocker_SPIFFS();
      delay(10);
    }
    else
    {
      String value = String("Clocker OFF ") + task + ": " + input.substring(0, 2) + "h" + input.substring(2, 4) + " -> " + input.substring(5, 7) + "h" + input.substring(7, 9);
      String value_start = input.substring(0, 2) + "h" + input.substring(2, 4);
      String value_stop = input.substring(5, 7) + "h" + input.substring(7, 9);
      terminal1.print(value);
      terminal1.println();
      Blynk.virtualWrite(clocker_OFF_VP_start[i], value_start);
      Blynk.virtualWrite(clocker_OFF_VP_stop[i], value_stop);
      delay(10);
      get_OFF_clocker_SPIFFS();
      delay(10);
      write_OFF_clocker_SPIFFS();
      delay(10);
    }
    task = 0;
  }
  else if (task == 6)
  {
    byte i = input.toInt();
    switch (i)
    {
      case 1:
        updateIP1();
        task = 0;
        break;

      case 2:
        updateIP2();
        task = 0;
        break;

      case 3:
        updateIP2();
        timer.setTimeout(5000, updateIP1);
        //updateIP1();
        task = 0;
        break;

      default:
        terminal1.print("Wrong code");
        terminal1.println();
        task = 0;
        break;
    }
  }
  else if (task == 7)
  {
    HW_String[0] = input.substring(2);
    byte i = input.substring(0, 1).toInt();
    switch (i)
    {
      case 1:
        updateIP1();
        task = 0;
        break;

      case 2:
        updateIP2();
        task = 0;
        break;

      case 3:
        updateIP1();
        timer.setTimeout(5000, updateIP2);
        //updateIP2();
        task = 0;
        break;

      default:
        terminal1.print("Wrong code");
        terminal1.println();
        task = 0;
        break;
    }
  }
  else if (task == 8)
  {
    byte nam = input.substring(0, 2).toInt();
    byte thang = input.substring(3, 5).toInt();
    byte ngay = input.substring(6, 8).toInt();
    byte gio = input.substring(9, 11).toInt();
    byte phut = input.substring(12, 14).toInt();
    byte giay = input.substring(15, 17).toInt();
    rtc.adjust(DateTime(nam, thang, ngay, gio, phut, giay));
    String datetime = String(gio) + "h" + phut + "m" + giay + "s" + " - " + ngay + "." + thang + ".20" + nam;
    terminal1.println(datetime);
    terminal1.println();
    task = 0;
  }
  else if (task == 9)
  {
    data[3] = input.toInt();
    Blynk.virtualWrite(VP_data[3], input);
    terminal1.print("MQ2 value alarm change to: " + input);
    terminal1.println();
    task = 0;
  }
  else if (task == 10)
  {
    data[2] = input.toInt();
    Blynk.virtualWrite(VP_data[2], input + " ℃");
    terminal1.print("Temp value alarm change to: " + input + " ℃");
    terminal1.println();
    task = 0;
  }
  else if (task == 11)
  {
    data[0] = input.toInt();
    Blynk.virtualWrite(VP_data[0], input + "s");
    terminal1.print("MQ2 alarm interval change to: " + input + "s");
    terminal1.println();
    task = 0;
  }
  else if (task == 12) 
  {
    data[1] = input.toInt();
    Blynk.virtualWrite(VP_data[1], input + "s");
    terminal1.print("Temp alarm interval change to: " + input + "s");
    terminal1.println();
    task = 0;
  }
  else if (task == 13)
  {
    HW_String[2] = input;
    Blynk.virtualWrite(VP_String[2], input);
    terminal1.print("http aupdate address change to: " + input);
    terminal1.println();
    task = 0;
  }
  terminal1.flush();
}

BLYNK_WRITE(V19) 
{
  task = param.asInt();
  if (task > 0 && task < 5)
  {
    terminal1.print("Set Start_Stop Clocker ");
    terminal1.print(task);
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 5) 
  {
    for (byte i = 0; i < sizeON_pins ; i++)
    {
      terminal1.print("Clocker ON ");
      terminal1.print(i);
      terminal1.print(": ");
      terminal1.print(clocker_ON_start[i]);
      terminal1.print(" -> ");
      terminal1.print(clocker_ON_stop[i]);
      terminal1.println();
      delay(10);
    }
    for (byte i = 0; i < sizeOFF_pins ; i++) 
    {
      terminal1.print("Clocker OFF ");
      terminal1.print(i);
      terminal1.print(": ");
      terminal1.print(clocker_OFF_start[i]);
      terminal1.print(" -> ");
      terminal1.print(clocker_OFF_stop[i]);
      terminal1.println();
      delay(10);
    }
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 6)
  {
    getIP();
    terminal1.print("type 1 to update modem, 2 to update door, cam, pc, 3 to update all");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 7)
  {
    terminal1.print("Manual update Ip No-IP.com");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 8)
  {
    terminal1.print("Input Date Time to adjust");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 9)
  {
    terminal1.print("Input MQ2 alarm value");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 10)
  {
    terminal1.print("Input Temp alarm value");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 11)
  {
    terminal1.print("Input MQ2 alarm interval");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 12)
  {
    terminal1.print("Input Temp alarm interval");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  else if (task == 13)
  {
    terminal1.print("Input http update address, include bin file name");
    terminal1.println();
    Blynk.virtualWrite(V19, 0);
  }
  terminal1.flush();
}

[madis]

i have been looking at ur code and i have to say, bit messy

but i can’t get to work MultiWifi system you have… it is new to me but i can’t figure out why it does not work. it just wont connect to wifi. after changing from blynk.begin to blynk.config it works. but if i disconnect router, it wont connect to any other i have in list or the same. even after reset or config reload…

[speed57]

wow, great project
I wish I could do same project as you are.

[KAUSTUBHAGARWAL]

cool project. I will try to replicate the project