Делаем секционные гаражные ворота более удобными

#include "button_control.h"
#include "config.h"
#include "load_control.h"
#include "network.h"
#include "state.h"

ADC_MODE(ADC_VCC);

Config CFG;
State ST;
LoadsControl LC;
ButtonControl BC;
NetManager NM;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// init
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void setup() {
  // init state
  ST.init();
  // read config from EEPROM
  CFG.get();
  // init loads
  LC.init();
  // init buttons
  BC.init();
  // init network
  NM.init();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main loop
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  // update time
  ST.updateClock();
  // loads control
  LC.control();
  // reaction fo change buttons state
  BC.logic();
  // controlling change state buttons
  BC.check();
  // network control
  NM.control();
}

#ifndef CONFIG_H
#define CONFIG_H

#include <Arduino.h>

// Config
class Config {
 public:
  char host[32];
  char user[16];
  char pass[16];
  bool wifimode;
  char ssid[16];
  char ssidpass[16];
  bool ipmode;
  char ip[16];
  char gateway[16];
  char subnet[16];
  char primaryDNS[16];
  char secondaryDNS[16];
  uint32_t maxon;

  // read config from EEPROM, if this is the first start, then write
  void get();
  // write config to EEPROM
  void put();
};

extern Config CFG;

#endif  // CONFIG_H

#include "config.h"
#include <EEPROM.h>

#define INIT_EEPROM_ADDR 0
#define INIT_EEPROM_KEY 1
#define SAVE_EEPROM_ADDR 1
#define EEPROM_MAX_SIZE 512

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// read config from EEPROM, if this is the first start, then write the value in
// EEPROM
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Config::get() {
  EEPROM.begin(EEPROM_MAX_SIZE);
  if (EEPROM.read(INIT_EEPROM_ADDR) != INIT_EEPROM_KEY) {  // first start
    EEPROM.write(INIT_EEPROM_ADDR, INIT_EEPROM_KEY);       // write key
    // set default values
    strcpy(host, "WIFI-RELAY");
    strcpy(user, "user");
    strcpy(pass, "pass");
    wifimode = 1;
    strcpy(ssid, "xxx");
    strcpy(ssidpass, "xxxxxxx");
    ipmode = 1;
    strcpy(ip, "192.168.1.189");
    strcpy(gateway, "192.168.1.1");
    strcpy(subnet, "255.255.255.0");
    strcpy(primaryDNS, "192.168.1.1");
    strcpy(secondaryDNS, "8.8.8.8");
    maxon = 2000;
    // save
    put();
  }
  EEPROM.get(SAVE_EEPROM_ADDR, CFG);
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// write config to EEPROM
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Config::put() {
  EEPROM.put(SAVE_EEPROM_ADDR, CFG);
  EEPROM.commit();
}

#ifndef STATE_H
#define STATE_H

#include <Arduino.h>

#include "network.h"

#undef DEBUG
#define DEBUG  // for debug: DPRINT & DPRINTLN
#ifdef DEBUG
#define DPRINT(...) Serial.print(__VA_ARGS__)      // debug print
#define DPRINTLN(...) Serial.println(__VA_ARGS__)  // debug print with new line
#define DPRINTF(...) Serial.printf(__VA_ARGS__)    // debug printf
#else
#define DPRINT(...)    // blank line
#define DPRINTLN(...)  // blank line
#define DPRINTF(...)   // blank line
#endif

// return amount object
template <typename T, size_t n>
inline size_t arraySize(const T (&arr)[n]) {
  return n;
}

class State {
 public:
  // set start state
  void init();

  // get safe mode
  inline bool isSafeMode() { return FLAGS.safeMode; }

  // get safe mode text
  inline String getSafeModeText() { return FLAGS.safeMode ? "ON" : "OFF"; }

  // set open gate by num
  inline void open(uint8_t num) {
    extern NetManager NM;
    if (num == 0)
      FLAGS.firstState = true;
    else if (num == 1)
      FLAGS.secondState = true;
    NM.sendEvents(getData(num), "change");
  }

  // set close gate by num
  inline void close(uint8_t num) {
    extern NetManager NM;
    if (num == 0)
      FLAGS.firstState = false;
    else if (num == 1)
      FLAGS.secondState = false;
    NM.sendEvents(getData(num), "change");
  }

  // get state gate by num
  inline char* getData(uint8_t num) {
    static char _return[24];
    sprintf(_return, "{\"num\":%d,\"state\":%d}", (num + 1),
            (uint8_t)getState(num));
    return _return;
  }

  // get state gate by num
  inline bool getState(uint8_t num) {
    if (num == 0)
      return FLAGS.firstState;
    else if (num == 1)
      return FLAGS.secondState;
    return false;
  }
  
  // get state gate Text by num
  inline String getStateText(uint8_t num) {
    bool flag = FLAGS.firstState;
    if (num == 1) flag = FLAGS.secondState;
    return flag ? "ОТКРЫТО" : "ЗАКРЫТО";
  }

  // get color gate by num
  inline String getColor(uint8_t num) {
    bool flag = FLAGS.firstState;
    if (num == 1) flag = FLAGS.secondState;
    return flag ? "#F08080" : "#98FB98";
  }

  // on flag wifi connect
  inline void setConnect() { FLAGS.connectWIFI = true; }

  // off flag wifi connect
  inline void setDisconnect() { FLAGS.connectWIFI = false; }

  // get flag wifi connect
  inline bool isConnect() { return FLAGS.connectWIFI; }

  // fill current time
  void updateClock();

  // get low part current time
  inline uint32_t getTime() { return lowPartCurrentTime; }

  // get full current time
  inline uint64_t getFullTime() {
    return (uint64_t)highPartCurrentTime << 32 | lowPartCurrentTime;
  }

  // get uptime string
  char *getUptimeText();

 private:
  // low part uptime
  uint32_t lowPartCurrentTime;
  // high part uptime
  uint32_t highPartCurrentTime;
  // flags state
  struct {
    bool safeMode : 1;     // run without password in AP mode
    bool firstState : 1;   // state near gate
    bool secondState : 1;  // state far gate
    bool connectWIFI : 1;  // is connect to WIFI
  } FLAGS;
};

extern State ST;
#endif  // STATE_H

#include "state.h"

#define SERIAL_SPEED 115200
#define SERIAL_DATA 45
#define SERIAL_TIME_SLEEP 1000
#define SERIAL_TIME_WAIT 10

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// first init state
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void State::init() {
  Serial.begin(SERIAL_SPEED);
#ifdef DEBUG
  // Serial.setDebugOutput(true);
  delay(SERIAL_TIME_SLEEP);
#endif
  DPRINTLN(F("start"));
  Serial.write(SERIAL_DATA);
  delay(SERIAL_TIME_WAIT);
  uint8_t incomingByte = 0;
  if (Serial.available() > 0) {
    incomingByte = Serial.read();
    if (SERIAL_DATA == incomingByte)
      FLAGS.safeMode = true;
    else
      FLAGS.safeMode = false;
  }
  updateClock();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// set current time
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void State::updateClock() {
  uint32_t newCurrentTime = millis();
  if (newCurrentTime < lowPartCurrentTime) highPartCurrentTime++;
  lowPartCurrentTime = newCurrentTime;
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// get string uptime
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
char* State::getUptimeText() {
  uint64_t mills = getFullTime();
  static char _return[32];
  uint32_t secs = mills / 1000;
  uint32_t mins = secs / 60;
  uint16_t hours = mins / 60;
  uint16_t days = hours / 24;
  mills -= secs * 1000;
  secs -= mins * 60;
  mins -= hours * 60;
  hours -= days * 24;
  sprintf(_return, "%d days %2.2d:%2.2d:%2.2d %3.3d", (uint8_t)days,
          (uint8_t)hours, (uint8_t)mins, (uint8_t)secs, (uint16_t)mills);
  return _return;
}

#ifndef NETWORK_H
#define NETWORK_H

#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>

class NetManager {
 private:
  static String processor(const String &var);
  void connect();
  void setAnsvers();

 public:
  void init();
  void control();
  void sendEvents(const char *data, const char *tag);
  void postProcessing(AsyncWebServerRequest *request);
};

#endif  // NETWORK_H

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// setting ansvers for network requests
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void NetManager::setAnsvers() {
  // Route for root / web page
  server.on("/", HTTP_GET, [](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    request->send(LittleFS, "/index.html", String(), false, processor);
  });

  // Route for /set web page
  server.on("/set", HTTP_ANY, [this](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    if (request->method() == HTTP_POST) {
      postProcessing(request);
    }
    request->send(LittleFS, "/settings.html", String(), false, processor);
  });

  // Route for /reset web page
  server.on("/reset", HTTP_GET, [](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    request->send(LittleFS, "/settings.html", String(), false, processor);
    ESP.restart();
  });

  // Button 1 control
  server.on("/button1", HTTP_GET, [](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    LC.on(L_NEAR);
    request->send(200, "application/json", "{'ok':1}");
  });

  // Button 2 control
  server.on("/button2", HTTP_GET, [](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    LC.on(L_FAR);
    request->send(200, "application/json", "{'ok':1}");
  });

  // api
  server.on("/sensors", HTTP_GET, [](AsyncWebServerRequest* request) {
    if (!request->authenticate(CFG.user, CFG.pass) && !ST.isSafeMode())
      return request->requestAuthentication();
    String answer = "hostname:" + String(CFG.host);
    answer += ";GATE1:" + String(ST.getState(0));
    answer += ";GATE2:" + String(ST.getState(1));
    answer += ";";
    request->send(200, "text/html", answer);
  });

  // route roe all static files
  server.serveStatic("/", LittleFS, "/").setCacheControl("max-age:6000000");

  // if page not found
  server.onNotFound([](AsyncWebServerRequest* request) {
    request->send(404, "404: Not found");
  });
}

#ifndef LOAD_CONTROL_H
#define LOAD_CONTROL_H

#include <Arduino.h>

class LoadsControl {
 public:
  // init load control
  void init();

  // set on
  void on(uint8_t num);

  // set off
  void off(uint8_t num);

  // check
  void control();

  // get state load
  inline bool isOn(uint8_t num) { return L[num].flag.state; }

 private:
  // one load
  struct Load {
    uint8_t pin;     // pin load
    uint32_t start;  // start time
    // flags for load
    struct LoadFlag_t {
      bool state : 1;
      bool autoOff : 1;
    } flag;  // load's flags
  };

  // array loads
  static Load L[];

  // amount loads
  uint8_t countL = 0;
};

extern LoadsControl LC;

enum loadNum_t {
  L_NEAR,  // 0
  L_FAR,   // 1
  L_LED,   // 2
};

#endif  // LOAD_CONTROL_H

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// control loads
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void LoadsControl::control() {
  // auto off relay
  for (uint8_t i = 0; i < countL; i++) {
    if (L[i].flag.state && L[i].flag.autoOff && CFG.maxon &&
        ((ST.getTime() - L[i].start) > CFG.maxon)) {
      off(i);
    }
  }

  // switching the connection led
  if (ST.isConnect() && !L[L_LED].flag.state) {
    on(L_LED);
  } else if (!ST.isConnect() && L[L_LED].flag.state) {
    off(L_LED);
  }
}

#ifndef BUTTON_CONTROL_H
#define BUTTON_CONTROL_H

#include <Arduino.h>

struct Button {
  uint8_t pin;
  bool state;            // current state
  uint32_t startChange;  // time begin change
  uint32_t timeProtect;  // bounce protect timer
  bool change;
};

class ButtonControl {
 private:
  uint8_t countB;
  static Button B[];

 public:
  void init();
  void check();
  void logic();
  
  inline uint8_t getCount() { return countB; }

  inline bool isChangeDown(uint8_t num) {
    return B[num].change && !B[num].state;
  }
  inline bool isChangeUp(uint8_t num) {
    return B[num].change && B[num].state;
  }
};

enum buttonNum_t {
  BT_FIRST,       // 0
  BT_SECOND,      // 1
  BT_FIRST_SENS,  // 2
  BT_SECOND_SENS, // 3
};

#endif  // BUTTON_CONTROL_H

<!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8">
  <title>Управление воротами</title>
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <link rel="stylesheet" type="text/css" href="style.css" />
  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
  <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
  <link rel="manifest" href="/site.webmanifest">
</head>

<body>
  <div class="pure-menu pure-menu-horizontal">
    <ul class="pure-menu-list">
      <li class="pure-menu-item pure-menu-selected">
        <a href="/" class="pure-menu-link">Управление</a>
      </li>
      <li class="pure-menu-item">
        <a href="/set" class="pure-menu-link">Настройки</a>
      </li>
    </ul>
  </div>

  <div class="pure-g">
    <div class="pure-u-2-3">
      <div>

        <h1>СОСТОЯНИЕ ВОРОТ</h1>
        <table class="pure-table pure-table-bordered">
          <tbody>
            <tr>
              <td>УЛИЦА</td>
              <td id="gate1" style="background-color:%BGCOLOR1%;">%GATE1%</td>
            </tr>
            <tr>
              <td>ГАРАЖ</td>
              <td id="gate2" style="background-color:%BGCOLOR2%;">%GATE2%</td>
            </tr>
          </tbody>
        </table>

        <h1>УПРАВЛЕНИЕ ВОРОТАМИ</h1>
        <p>
          <button name="button1" class="pure-button pure-button-primary button-xlarge">УЛИЦА</button>
        </p>
        <p>
          <button name="button2" class="pure-button pure-button-primary button-xlarge">ГАРАЖ</button>
        </p>
      </div>
    </div>
  </div>
</body>
<script>
  const buttons = document.querySelectorAll(".pure-button");
  buttons.forEach(function (bt) {
    bt.addEventListener('click', function (event) {
      bt.classList.remove("pure-button-primary");
      fetch('/' + bt.name).then(function (response) {
        if (response.status == 200) {
          setTimeout(() => {
            bt.classList.add("pure-button-primary");
          }, 800);
        } else {
          alert("Error HTTP: " + response.status);
        }
      })
        .catch(function (err) {
          alert("Error network: " + err);
        });
    })
  })
  if (!!window.EventSource) {
    var source = new EventSource('/events');
    source.addEventListener('open', (e) => {
      console.log("Events Connected");
    }, false);
    source.addEventListener('error', (e) => {
      if (e.target.readyState != EventSource.OPEN) {
        console.log("Events Disconnected");
      }
    }, false);
    source.addEventListener('change', (e) => {
      console.log(e.data);
      const data = JSON.parse(e.data);
      const { num, state } = data;
      const id = 'gate' + num;
      document.getElementById(id).innerHTML = state ? 'ОТКРЫТО' : 'ЗАКРЫТО';
      document.getElementById(id).style.backgroundColor = state ? '#F08080' : '#98FB98';
    }, false);

  }
</script>
</html>

<!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8">
  <title>Управление воротами</title>
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <link rel="stylesheet" type="text/css" href="style.css" />
  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png">
  <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32x32.png">
  <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16x16.png">
  <link rel="manifest" href="/site.webmanifest">
</head>

<body>
  <div class="pure-menu pure-menu-horizontal">
    <ul class="pure-menu-list">
      <li class="pure-menu-item">
        <a href="/" class="pure-menu-link">Управление</a>
      </li>
      <li class="pure-menu-item pure-menu-selected">
        <a href="/set" class="pure-menu-link">Настройки</a>
      </li>
    </ul>
  </div>

  <div class="pure-g">
    <div class="pure-u-2-3">
      <div>

        <h1>STATE</h1>
        <table class="pure-table pure-table-bordered">
          <tbody>
            <tr>
              <td>Safe mode</td>
              <td>%SAFEMODE%</td>
            </tr>
            <tr>
              <td>RSSI</td>
              <td>%RSSI% dBm</td>
            </tr>
            <tr>
              <td>Free memory</td>
              <td>%MEM% B</td>
            </tr>
            <tr>
              <td>Voltage</td>
              <td>%VOLTAGE% mV</td>
            </tr>
            <tr>
              <td>Uptime</td>
              <td>%UPTIME%</td>
            </tr>
          </tbody>
        </table>


        <h1>SETTINGS</h1>
        <form class="pure-form pure-form-aligned" method="post" action="/set" onsubmit="return validate()">
          <fieldset>

            <legend>Base</legend>
            <div class="pure-control-group">
              <label for="host">Host</label>
              <input name="host" type="text" id="host" placeholder="Host name" value="%HOST%">
            </div>

            <legend>HTTP basic authentication</legend>
            <div class="pure-control-group">
              <label for="name">Username</label>
              <input name="name" type="text" id="name" placeholder="Username" value="%USER%">
            </div>
            <div class="pure-control-group">
              <label for="password">Password</label>
              <input name="password" type="password" id="password" placeholder="Password" value="%PASSWORD%">
              <button class="pure-button toggle-button" type="button">show</button>
            </div>

            <legend>WIFI settings</legend>
            <div class="pure-control-group">
              <label for="wifimode">WIFI mode</label>
              <select name="wifimode" id="wifimode">
                <option %APSELECTED% value="ap">AP</option>
                <option %STSELECTED% value="station">STATION</option>
              </select>
            </div>
            <div class="pure-control-group">
              <label for="ssid">SSID</label>
              <input name="ssid" type="text" id="ssid" placeholder="SSID" value="%SSID%">
            </div>
            <div class="pure-control-group">
              <label for="ssidpass">WIFI-Password</label>
              <input name="ssidpass" type="password" id="ssidpass" placeholder="WIFI password" value="%SSIDPASS%">
              <button class="pure-button toggle-button" type="button">show</button>
            </div>
            <div class="pure-control-group">
              <label for="ipmode">IP mode</label>
              <select name="ipmode" id="ipmode">
                <option %DHCPSELECTED% value="dhcp">DHCP</option>
                <option %FIXSELECTED% value="static">STATIC</option>
              </select>
            </div>
            <div class="pure-control-group">
              <label for="ip">IP</label>
              <input name="ip" type="text" id="ip" placeholder="xxx.xxx.xxx.xxx" value="%IP%" class="ipaddress">
            </div>
            <div class="pure-control-group">
              <label for="gateway">Gateway</label>
              <input name="gateway" type="text" id="gateway" placeholder="xxx.xxx.xxx.xxx" value="%GATEWAY%"
                class="ipaddress">
            </div>
            <div class="pure-control-group">
              <label for="subnet">Subnet</label>
              <input name="subnet" type="text" id="subnet" placeholder="xxx.xxx.xxx.xxx" value="%SUBNET%"
                class="ipaddress">
            </div>
            <div class="pure-control-group">
              <label for="primaryDNS">Primary DNS</label>
              <input name="primaryDNS" type="text" id="primaryDNS" placeholder="xxx.xxx.xxx.xxx" value="%PRIMARYDNS%"
                class="ipaddress">
            </div>
            <div class="pure-control-group">
              <label for="secondaryDNS">Secondary DNS</label>
              <input name="secondaryDNS" type="text" id="secondaryDNS" placeholder="xxx.xxx.xxx.xxx"
                value="%SECONDARYDNS%" class="ipaddress">
            </div>

            <legend>Device settings</legend>
            <div class="pure-control-group">
              <label for="maxon">On time</label>
              <input name="maxon" type="text" id="maxon" placeholder="On time" value="%MAXON%">
            </div>

            <div class="pure-controls">
              <button type="submit" class="pure-button pure-button-primary">Save</button>
            </div>

          </fieldset>
        </form>
      </div>
      <p>
       <a href="/reset">reset</a>
      </p>
    </div>
  </div>

  <script>
    const toggleButtons = document.querySelectorAll(".toggle-button");
    toggleButtons.forEach(function (tb) {
      tb.addEventListener('click', function () {
        if (this.previousElementSibling.type === 'password') {
          this.previousElementSibling.type = 'text';
          this.textContent = 'hide';
        } else if (tb.previousElementSibling.type === 'text') {
          this.previousElementSibling.type = 'password';
          this.textContent = 'show';
        }
      })
    })

    function validate() {
      const ips = document.querySelectorAll(".ipaddress");
      const ipformat = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
      let retval = true;
      ips.forEach(function (ip) {
        if (!ip.value.match(ipformat)) {
          ip.classList.add("invalid");
          retval = false;
          ip.onfocus = function () {
            if (this.classList.contains('invalid')) {
              this.classList.remove('invalid');
            }
          }
        }
      })
      return retval;
    }
  </script>
</body>
</html>