partial rewrite

.gitignore

@@ -0,0 +1,5 @@
+.pio
+.vscode/.browse.c_cpp.db*
+.vscode/c_cpp_properties.json
+.vscode/launch.json
+.vscode/ipch

platformio.ini

@@ -11,6 +11,11 @@
 [env:nodemcuv2]
 platform = espressif8266
 board = nodemcuv2
+board_build.filesystem = littlefs
+; set frequency to 160MHz
+board_build.f_cpu = 160000000L
 framework = arduino
-lib_deps = bblanchon/ArduinoJson@^6.17.2
+lib_deps = 
+	bblanchon/ArduinoJson@^6.17.2
+	me-no-dev/ESP Async WebServer@^1.2.3
 monitor_speed = 115200

src/asyncWebserver.cpp

@@ -0,0 +1,558 @@
+//#include <FS.h>
+#include <LittleFS.h>
+#include <ESP8266WiFi.h>
+#include <ESPAsyncTCP.h>       //https://github.com/me-no-dev/ESPAsyncTCP
+#include <ESPAsyncWebServer.h> //https://github.com/me-no-dev/ESPAsyncWebServer
+#include "AsyncJson.h"
+#include <ArduinoJson.h> //https://arduinojson.org/
+#include "global.h"
+#include "pins.h"
+#include "h1602_eeprom.h"
+#include "timers.h"
+#include "interrupts.h"
+
+AsyncWebServer asyncServer(80);
+
+boolean isAuthenticated(AsyncWebServerRequest *request)
+{
+    //return request->authenticate(getEeprom()->www_username, getEeprom()->www_password);
+
+    if (!request->authenticate(getEeprom()->www_username, getEeprom()->www_password))
+    {
+        request->requestAuthentication();
+        return false;
+    }
+    return true;
+}
+
+//////////////////////// Webserver ////////////////////////////////////////////////
+
+void notFound(AsyncWebServerRequest *request)
+{
+    digitalWrite(LED_RED, LOW);
+    String message = F("File Not Found\n\n");
+    message += F("URI: ");
+    message += request->url();
+    message += F("\nMethod: ");
+    message += (request->method() == HTTP_GET) ? F("GET") : F("POST");
+    message += F("\nArguments: ");
+    message += request->args();
+    message += F("\n");
+    for (uint8_t i = 0; i < request->args(); i++)
+    {
+        message += " " + request->argName(i) + ": " + request->arg(i) + "\n";
+    }
+    request->send(404, F("text/plain"), message);
+    digitalWrite(LED_RED, HIGH);
+}
+
+void sendPlainError(AsyncWebServerRequest *request)
+{
+    request->send(200, "text/plain", "I'm sorry Dave, I'm afraid I can't do that");
+}
+
+//--------------- Index.html -------------------------------
+void LiveInfoGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            AsyncJsonResponse *response = new AsyncJsonResponse();
+            //response->addHeader("Server", "ESP Async Web Server");
+            JsonVariant &jsonObj = response->getRoot();
+            jsonObj["rssi"] = WiFi.RSSI();
+            jsonObj["uptimeDay"] = uptime.Day;
+            jsonObj["uptimeHour"] = uptime.Hour;
+            jsonObj["uptimeMinute"] = uptime.Minute;
+            jsonObj["uptimeSecond"] = uptime.Second;
+            jsonObj["free"] = ESP.getFreeHeap();
+            jsonObj["max"] = ESP.getMaxFreeBlockSize();
+            jsonObj["heap"] = ESP.getHeapFragmentation();
+            response->setLength();
+            request->send(response);
+
+            // AsyncResponseStream *response = request->beginResponseStream("application/json");
+            // const int JSON_MAX_SIZE = 1024;
+            // DynamicJsonDocument doc(JSON_MAX_SIZE);
+            // JsonObject root = doc.to<JsonObject>();
+            // root["rssi"] = WiFi.RSSI();
+            // root["uptimeDay"] = uptime.Day;
+            // root["uptimeHour"] = uptime.Hour;
+            // root["uptimeMinute"] = uptime.Minute;
+            // root["uptimeSecond"] = uptime.Second;
+            // root["free"] = ESP.getFreeHeap();
+            // root["max"] = ESP.getMaxFreeBlockSize();
+            // root["heap"] = ESP.getHeapFragmentation();
+            // serializeJson(root, *response);
+            // request->send(response);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+void InfoGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            AsyncJsonResponse *response = new AsyncJsonResponse();
+            //response->addHeader("Server", "ESP Async Web Server");
+            JsonVariant &jsonObj = response->getRoot();
+            jsonObj["mac"] = MAC_char;
+            jsonObj["chipid"] = String(ESP.getChipId(), DEC);
+            jsonObj["version"] = softwareVersion;
+            jsonObj["sdkversion"] = String(ESP.getFullVersion());
+            String cmp = compileDate;
+            cmp += " , ";
+            cmp += compileTime;
+            jsonObj["compiledate"] = cmp;
+            jsonObj["vcc"] = (ESP.getVcc() / 1024.0f);
+            jsonObj["ipaddress"] = WiFi.localIP().toString();
+            jsonObj["subnet"] = WiFi.subnetMask().toString();
+            jsonObj["gateway"] = WiFi.gatewayIP().toString();
+            jsonObj["dns"] = WiFi.dnsIP().toString();
+            jsonObj["serialnumber"] = getEeprom()->serialnumber;
+            jsonObj["isSerialSet"] = getEeprom()->isSerialSet;
+            response->setLength();
+            request->send(response);
+
+            // AsyncResponseStream *response = request->beginResponseStream("application/json");
+            // const int JSON_MAX_SIZE = 1024;
+            // DynamicJsonDocument doc(JSON_MAX_SIZE);
+            // JsonObject root = doc.to<JsonObject>();
+            // root["mac"] = MAC_char;
+            // root["chipid"] = String(ESP.getChipId(), DEC);
+            // root["version"] = softwareVersion;
+            // root["sdkversion"] = String(ESP.getFullVersion());
+            // String cmp = compileDate;
+            // cmp += " , ";
+            // cmp += compileTime;
+            // root["compiledate"] = cmp;
+            // root["vcc"] = (ESP.getVcc() / 1024.0f);
+            // root["ipaddress"] = WiFi.localIP().toString();
+            // root["subnet"] = WiFi.subnetMask().toString();
+            // root["gateway"] = WiFi.gatewayIP().toString();
+            // root["dns"] = WiFi.dnsIP().toString();
+            // root["serialnumber"] = getEeprom()->serialnumber;
+            // root["isSerialSet"] = getEeprom()->isSerialSet;
+            // serializeJson(root, *response);
+            // request->send(response);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+void SerialNumberPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            request->arg("serialnumber").toCharArray(getEeprom()->serialnumber, sizeof(getEeprom()->serialnumber) - 1);
+            if (strlen(getEeprom()->serialnumber) > 0)
+            {
+                getEeprom()->isSerialSet = true;
+            }
+            saveEeprom();
+        }
+        request->redirect("/index.html");
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Config.html -------------------------------
+void ConfigGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            AsyncJsonResponse *response = new AsyncJsonResponse();
+            JsonVariant &jsonObj = response->getRoot();
+            jsonObj["device"] = getEeprom()->device;
+            jsonObj["useprtg"] = getEeprom()->use_prtg;
+            jsonObj["usenodered"] = getEeprom()->use_nodered;
+            jsonObj["noderedserver"] = getEeprom()->noderedHost;
+            jsonObj["noderedurl"] = getEeprom()->noderedUrl;
+            jsonObj["prtgserver"] = getEeprom()->prtgHost;
+            jsonObj["prtgport"] = getEeprom()->prtgHttpPort;
+            jsonObj["update"] = getEeprom()->updateTime;
+            response->setLength();
+            request->send(response);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+void ConfigPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            request->arg("device").toCharArray(getEeprom()->device, sizeof(getEeprom()->device) - 1);
+            getEeprom()->use_nodered = request->hasArg("usenodered") ? true : false;
+            request->arg("noderedserver").toCharArray(getEeprom()->noderedHost, sizeof(getEeprom()->noderedHost) - 1);
+            request->arg("noderedurl").toCharArray(getEeprom()->noderedUrl, sizeof(getEeprom()->noderedUrl) - 1);
+            getEeprom()->use_prtg = request->hasArg("useprtg") ? true : false;
+            request->arg("prtgserver").toCharArray(getEeprom()->prtgHost, sizeof(getEeprom()->prtgHost) - 1);
+            getEeprom()->prtgHttpPort = request->arg("prtgport").toInt();
+            getEeprom()->updateTime = request->arg("update").toInt();
+
+            startSendTimer();
+            // if (getEeprom()->updateTime == 0)
+            //     detachSendTimer();
+            // else
+            //     attachSendTimer(getEeprom()->updateTime);
+            saveEeprom();
+        }
+        request->redirect("/config.html");
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Access point -------------------------------
+void AccesspointGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            DynamicJsonDocument jsonBuffer(24);
+            jsonBuffer["apMode"] = eepromStruct.apMode;
+            String JSONmessageBuffer;
+            Serial.println(jsonBuffer.memoryUsage());
+            serializeJson(jsonBuffer, JSONmessageBuffer);
+            request->send(200, "application/json", JSONmessageBuffer);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+void AccesspointPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 1)
+        {
+            StaticJsonDocument<32> doc;
+            DeserializationError error = deserializeJson(doc, request->arg("plain"));
+            if (error)
+            {
+                Serial.print(F("deserializeJson() failed: "));
+                Serial.println(error.c_str());
+                return;
+            }
+            getEeprom()->apMode = doc["apMode"];
+            saveEeprom();
+            //request->send(200, "application/json");
+            request->redirect("/accesspoint.html");
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Inputs -------------------------------
+void InputsGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            if (request->hasArg("settings"))
+            {
+                DynamicJsonDocument jsonBuffer(256);
+                jsonBuffer["ch1Enabled"] = getEepromChannel(1)->enable;
+                jsonBuffer["ch1Name"] = getEepromChannel(1)->channel;
+                jsonBuffer["ch2Enabled"] = getEepromChannel(2)->enable;
+                jsonBuffer["ch2Name"] = getEepromChannel(2)->channel;
+                jsonBuffer["ch3Enabled"] = getEepromChannel(3)->enable;
+                jsonBuffer["ch3Name"] = getEepromChannel(3)->channel;
+                jsonBuffer["ch4Enabled"] = getEepromChannel(4)->enable;
+                jsonBuffer["ch4Name"] = getEepromChannel(4)->channel;
+                String JSONmessageBuffer;
+                //Serial.println(jsonBuffer.memoryUsage());
+                serializeJson(jsonBuffer, JSONmessageBuffer);
+                request->send(200, "application/json", JSONmessageBuffer);
+            }
+            else if (request->hasArg("state"))
+            {
+                DynamicJsonDocument jsonBuffer(128);
+                jsonBuffer["in1_state"] = !digitalRead(inputTable[1]);
+                jsonBuffer["in2_state"] = !digitalRead(inputTable[2]);
+                jsonBuffer["in3_state"] = !digitalRead(inputTable[3]);
+                jsonBuffer["in4_state"] = !digitalRead(inputTable[4]);
+                String JSONmessageBuffer;
+                //Serial.println(jsonBuffer.memoryUsage());
+                serializeJson(jsonBuffer, JSONmessageBuffer);
+                request->send(200, "application/json", JSONmessageBuffer);
+            }
+            else
+            {
+                sendPlainError(request);
+            }
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+const char *enableTable[5] = {"", "en1", "en2", "en3", "en4"};
+const char *channelTable[5] = {"", "ch1Name", "ch2Name", "ch3Name", "ch4Name"};
+void InputsPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            //const char *enableTable[5] = {"", "en1", "en2", "en3", "en4"};
+            //const char *channelTable[5] = {"", "ch1Name", "ch2Name", "ch3Name", "ch4Name"};
+
+            for (int i = 1; i < 5; i++)
+            {
+                if (request->hasArg(enableTable[i]))
+                {
+                    getEepromChannel(i)->enable = true;
+                    attachInputInterrupt(i);
+                }
+                else
+                {
+                    getEepromChannel(i)->enable = false;
+                    detachInputInterrupt(i);
+                }
+
+                startSendTimer();
+                // if (!anyChannelEnabled())
+                // {
+                //     detachSendTimer();
+                // }
+                // if (getEepromChannel(1)->enable == false && getEepromChannel(2)->enable == false && getEepromChannel(3)->enable == false && getEepromChannel(4)->enable == false)
+                // {
+                //     detachSendTimer();
+                // }
+                // else
+                // {
+                //     attachSendTimer(getEeprom()->updateTime);
+                // }
+                request->arg(channelTable[i]).toCharArray(getEepromChannel(i)->channel, sizeof(getEepromChannel(i)->channel) - 1);
+            }
+            saveEeprom();
+        }
+        request->redirect("/inputs.html");
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Credentials -------------------------------
+void CredentialsGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            DynamicJsonDocument jsonBuffer(64);
+            jsonBuffer["username"] = eepromStruct.www_username;
+            jsonBuffer["password"] = eepromStruct.www_password;
+            String JSONmessageBuffer;
+            //Serial.println(jsonBuffer.memoryUsage());
+            serializeJson(jsonBuffer, JSONmessageBuffer);
+            request->send(200, "application/json", JSONmessageBuffer);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+void CredentialsPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            request->arg("www_user").toCharArray(getEeprom()->www_username, sizeof(getEeprom()->www_username) - 1);
+            request->arg("www_pass").toCharArray(getEeprom()->www_password, sizeof(getEeprom()->www_password) - 1);
+            saveEeprom();
+        }
+        request->redirect("/credentials.html");
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Wifi -------------------------------
+void WifiGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 0)
+        {
+            DynamicJsonDocument jsonBuffer(128);
+            jsonBuffer["ssid"] = getEeprom()->ssid;
+            jsonBuffer["pass"] = getEeprom()->password;
+            jsonBuffer["ssdp"] = getEeprom()->ssdp;
+            jsonBuffer["mdns"] = getEeprom()->use_mdns;
+            jsonBuffer["llmnr"] = getEeprom()->use_llmnr;
+            String JSONmessageBuffer;
+            //Serial.println(jsonBuffer.memoryUsage());
+            serializeJson(jsonBuffer, JSONmessageBuffer);
+            request->send(200, "application/json", JSONmessageBuffer);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+void WifiPost(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() != 0)
+        {
+            request->arg("ssid").toCharArray(getEeprom()->ssid, sizeof(getEeprom()->ssid) - 1);
+            request->arg("pass").toCharArray(getEeprom()->password, sizeof(getEeprom()->password) - 1);
+            getEeprom()->ssdp = request->hasArg("ssdp") ? true : false;
+
+            getEeprom()->use_mdns = request->hasArg("mdns") ? true : false;
+            getEeprom()->use_llmnr = request->hasArg("llmnr") ? true : false;
+
+            saveEeprom();
+        }
+        request->redirect("/wifi.html");
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+String translateEncryptionType(uint8_t type)
+{
+    switch (type)
+    {
+    case (0):
+        return "Open";
+    case (1):
+        return "WEP";
+    case (2):
+        return "WPA_PSK";
+    case (3):
+        return "WPA2_PSK";
+    case (4):
+        return "WPA_WPA2_PSK";
+    case (5):
+        return "WPA2_ENTERPRISE";
+    default:
+        return "UNKOWN";
+    }
+}
+void WifiScanGet(AsyncWebServerRequest *request)
+{
+    if (isAuthenticated(request))
+    {
+        digitalWrite(LED_RED, LOW);
+        if (request->args() == 1)
+        {
+            bool showHidden = false;
+            if (request->arg("hidden") == "true")
+            {
+                showHidden = true;
+            }
+            DynamicJsonDocument jsonBuffer(4096);
+            JsonArray networks = jsonBuffer.createNestedArray("networks");
+            int n = WiFi.scanNetworks(false, showHidden);
+            if (n != 0)
+            {
+                for (int i = 0; i < n; ++i)
+                {
+                    JsonObject network = networks.createNestedObject();
+                    network["ssid"] = WiFi.SSID(i);
+                    network["rssi"] = WiFi.RSSI(i);
+                    network["chan"] = WiFi.channel(i);
+                    network["encrypt"] = translateEncryptionType(WiFi.encryptionType(i));
+                }
+            }
+            String JSONmessageBuffer;
+            //Serial.println(jsonBuffer.memoryUsage());
+            serializeJson(jsonBuffer, JSONmessageBuffer);
+            request->send(200, "application/json", JSONmessageBuffer);
+        }
+        else
+        {
+            sendPlainError(request);
+        }
+        digitalWrite(LED_RED, HIGH);
+    }
+}
+
+//--------------- Server setup -------------------------------
+void setupAsyncWebserver()
+{
+    //serve all filesystem files
+    asyncServer.serveStatic("/", LittleFS, "/").setDefaultFile("index.html").setAuthentication(getEeprom()->www_username, getEeprom()->www_password);
+
+    asyncServer.on("/liveinfo", HTTP_GET, [](AsyncWebServerRequest *request) { LiveInfoGet(request); });
+    asyncServer.on("/info", HTTP_GET, [](AsyncWebServerRequest *request) { InfoGet(request); });
+    asyncServer.on("/serialnumber", HTTP_POST, [](AsyncWebServerRequest *request) { ConfigPost(request); });
+
+    asyncServer.on("/config", HTTP_GET, [](AsyncWebServerRequest *request) { ConfigGet(request); });
+    asyncServer.on("/config", HTTP_POST, [](AsyncWebServerRequest *request) { ConfigPost(request); });
+
+    asyncServer.on("/accesspoint", HTTP_GET, [](AsyncWebServerRequest *request) { AccesspointGet(request); });
+    asyncServer.on("/accesspoint", HTTP_POST, [](AsyncWebServerRequest *request) { AccesspointPost(request); });
+
+    asyncServer.on("/inputs", HTTP_GET, [](AsyncWebServerRequest *request) { InputsGet(request); });
+    asyncServer.on("/inputs", HTTP_POST, [](AsyncWebServerRequest *request) { InputsPost(request); });
+
+    asyncServer.on("/credentials", HTTP_GET, [](AsyncWebServerRequest *request) { CredentialsGet(request); });
+    asyncServer.on("/credentials", HTTP_POST, [](AsyncWebServerRequest *request) { CredentialsPost(request); });
+
+    asyncServer.on("/wifi", HTTP_GET, [](AsyncWebServerRequest *request) { WifiGet(request); });
+    asyncServer.on("/wifi", HTTP_GET, [](AsyncWebServerRequest *request) { WifiPost(request); });
+    asyncServer.on("/wifiscan", HTTP_POST, [](AsyncWebServerRequest *request) { WifiScanGet(request); });
+    
+    //   server.on("/clear", HTTP_POST, handleClearPost);
+
+    //   server.on("/reboot", HTTP_POST, handleRebootPost);
+
+    asyncServer.onNotFound(notFound);
+
+    asyncServer.begin();
+}

src/asyncWebserver.h

@@ -0,0 +1,6 @@
+#ifndef ASYNCWEBSERVER_H
+#define ASYNCWEBSERVER_H
+
+void setupAsyncWebserver(void);
+
+#endif

src/h1602_eeprom.cpp

@@ -166,3 +166,23 @@ eepromStruct_t *getEeprom()
 {
   return &eepromStruct;
 }
+
+channel_t *getEepromChannel(int channel)
+{
+  return &eepromStruct.channel[channel];
+}
+
+bool anyChannelEnabled()
+{
+  if (eepromStruct.channel[1].enable == true || eepromStruct.channel[2].enable == true || eepromStruct.channel[3].enable == true || eepromStruct.channel[4].enable == true)
+  {
+    return true;
+  }
+  return false;
+}
+
+bool saveEeprom()
+{
+  EEPROM.put(EEPROMSTRUCT_OFFSET, eepromStruct);
+  return EEPROM.commit();
+}

src/h1602_eeprom.h

@@ -37,5 +37,8 @@ typedef struct {
 extern eepromStruct_t eepromStruct;
 
 eepromStruct_t *getEeprom(void);
+channel_t *getEepromChannel(int channel);
+bool anyChannelEnabled(void);
+bool saveEeprom(void);
 
 #endif

src/interrupts.cpp

@@ -27,4 +27,28 @@ void ICACHE_RAM_ATTR pinChangedInput4()
 {
   inputValue[4] = !digitalRead(inputTable[4]);
   inputChangedFlag = true;
-}
+}
+
+void attachInputInterrupt(int pin)
+{
+  switch (pin)
+  {
+  case 1:
+    attachInterrupt(inputTable[pin], pinChangedInput1, CHANGE);
+    break;
+  case 2:
+    attachInterrupt(inputTable[pin], pinChangedInput2, CHANGE);
+    break;
+  case 3:
+    attachInterrupt(inputTable[pin], pinChangedInput3, CHANGE);
+    break;
+  case 4:
+    attachInterrupt(inputTable[pin], pinChangedInput4, CHANGE);
+    break;
+  }
+}
+
+void detachInputInterrupt(int pin)
+{
+  detachInterrupt(inputTable[pin]);
+}

src/interrupts.h

@@ -3,10 +3,13 @@
 
 //#include <ESP8266WiFi.h>
 
-void ICACHE_RAM_ATTR pinChangedInput1();
+//void ICACHE_RAM_ATTR pinChangedInput1();
-void ICACHE_RAM_ATTR pinChangedInput2();
+//void ICACHE_RAM_ATTR pinChangedInput2();
-void ICACHE_RAM_ATTR pinChangedInput3();
+//void ICACHE_RAM_ATTR pinChangedInput3();
-void ICACHE_RAM_ATTR pinChangedInput4();
+//void ICACHE_RAM_ATTR pinChangedInput4();
+
+void attachInputInterrupt(int pin);
+void detachInputInterrupt(int pin);
 
 //volatile boolean inputChangedFlag = false;
 extern volatile boolean inputChangedFlag;

src/main.cpp

@@ -12,8 +12,10 @@
 //#include <ESP8266LLMNR.h>
 //#include <ESP8266mDNS.h>
 #include <ESP8266httpUpdate.h>
+//#include <ESPAsyncTCP.h>       //https://github.com/me-no-dev/ESPAsyncTCP
+//#include <ESPAsyncWebServer.h> //https://github.com/me-no-dev/ESPAsyncWebServer
 #include "h1602_eeprom.h"
-#include "webserver.h"
+//#include "webserver.h"
 #include "nodered.h"
 #include "prtg.h"
 #include "pins.h"
@@ -21,6 +23,7 @@
 #include "interrupts.h"
 #include "timers.h"
 #include "networkDetection.h"
+#include "asyncWebserver.h"
 
 #define DEBUG_MSG
 
@@ -57,7 +60,6 @@ void checkApButton(unsigned int count)
 // Connect to wifi network
 void connectWifi()
 {
-  //ledFlashTimer.detach();
   detachLedFlashTimer();
 
   // We start by connecting to a WiFi network
@@ -72,7 +74,6 @@ void connectWifi()
 #ifdef DEBUG_MSG
     Serial.println("connecting..");
 #endif
-    //WiFi.begin(eepromStruct.ssid, eepromStruct.password);
     WiFi.begin(getEeprom()->ssid, getEeprom()->password);
     // wait 5 seconds for connection:
     delay(5000);
@@ -83,7 +84,6 @@ void connectWifi()
   Serial.print("Connected, IP address: ");
   Serial.println(WiFi.localIP());
 #endif
-  //ledFlashTimer.attach_ms(750, ledFlashChanged);
   attachLedFlashTimer_ms(750);
 }
 
@@ -121,10 +121,15 @@ void setup()
   Serial.begin(115200);
   Serial.println();
 
-  LittleFS.begin();
+  if (!LittleFS.begin())
+  {
+    Serial.println(F("LittleFS mount failed"));
+  }
 
   startEeprom();
-  setupServerPaths();
+  //setupServerPaths();
+  setupAsyncWebserver();
+  //setupAsyncWebserver();
   setupSSDP();
 
   uint8_t MAC_array[6];
@@ -140,27 +145,27 @@ void setup()
   {
     pinMode(inputTable[i], INPUT_PULLUP);
     inputValue[i] = !digitalRead(inputTable[i]);
-    //if (eepromStruct.apMode == false)
     if (getEeprom()->apMode == false)
     {
-      //if (eepromStruct.channel[i].enable == true)
       if (getEeprom()->channel[i].enable == true)
       {
-        switch (i)
+        attachInputInterrupt(i);
-        {
+
-        case 1:
+        // switch (i)
-          attachInterrupt(inputTable[i], pinChangedInput1, CHANGE);
+        // {
-          break;
+        // case 1:
-        case 2:
+        //   attachInterrupt(inputTable[i], pinChangedInput1, CHANGE);
-          attachInterrupt(inputTable[i], pinChangedInput2, CHANGE);
+        //   break;
-          break;
+        // case 2:
-        case 3:
+        //   attachInterrupt(inputTable[i], pinChangedInput2, CHANGE);
-          attachInterrupt(inputTable[i], pinChangedInput3, CHANGE);
+        //   break;
-          break;
+        // case 3:
-        case 4:
+        //   attachInterrupt(inputTable[i], pinChangedInput3, CHANGE);
-          attachInterrupt(inputTable[i], pinChangedInput4, CHANGE);
+        //   break;
-          break;
+        // case 4:
-        }
+        //   attachInterrupt(inputTable[i], pinChangedInput4, CHANGE);
+        //   break;
+        // }
       }
     }
   }
@@ -181,11 +186,11 @@ void setup()
     dnsServer.start(DNS_PORT, "*", apIP);
 
     // replay to all requests with same HTML
-    server.onNotFound([]() {
+    // server.onNotFound([]() {
-      server.send(200, "text/html", responseHTML);
+    //   server.send(200, "text/html", responseHTML);
-      //handleServerRequest("/index.html");
+    //   //handleServerRequest("/index.html");
-    });
+    // });
-    server.begin();
+    // server.begin();
 
     //Deactivate AP mode bool
     storeApMode(false);
@@ -198,7 +203,7 @@ void setup()
     while (1)
     {
       //only config webserver, fast flashing green led
-      server.handleClient();
+      //server.handleClient();
       dnsServer.processNextRequest();
       if (ledCounter == 20000)
       {
@@ -217,25 +222,31 @@ void setup()
 
   //server.onNotFound(handleNotFound);
 
-  //httpUpdater.setup(&server, update_path, eepromStruct.www_username, eepromStruct.www_password);
+  //httpUpdater.setup(&server, update_path, getEeprom()->www_username, getEeprom()->www_password);
-  httpUpdater.setup(&server, update_path, getEeprom()->www_username, getEeprom()->www_password);
+  //server.begin();
-  server.begin();
 
   startLLMNR();
   startMDNS();
   startSSDP();
 
+  startSendTimer();
   //Timer interrupt
-  if (eepromStruct.updateTime != 0)
+  //if (eepromStruct.updateTime != 0)
-  {
+  // if (getEeprom()->updateTime != 0)
-    //sendTimer.attach(eepromStruct.updateTime, tickerChanged);
+  // {
-    attachSendTimer(eepromStruct.updateTime);
+  //   //sendTimer.attach(eepromStruct.updateTime, tickerChanged);
-  }
+  //   attachSendTimer(getEeprom()->updateTime);
+  // }
 
-  if (eepromStruct.channel[1].enable == false && eepromStruct.channel[2].enable == false && eepromStruct.channel[3].enable == false && eepromStruct.channel[4].enable == false)
+  //if (eepromStruct.channel[1].enable == false && eepromStruct.channel[2].enable == false && eepromStruct.channel[3].enable == false && eepromStruct.channel[4].enable == false)
-  {
+  // if (getEepromChannel(1)->enable == false && getEepromChannel(2)->enable == false && getEepromChannel(3)->enable == false && getEepromChannel(4)->enable == false)
-    detachSendTimer();
+  // {
-  }
+  //   detachSendTimer();
+  // }
+  // if (!anyChannelEnabled())
+  // {
+  //   detachSendTimer();
+  // }
 
   //Vertsuur meteen de eerste status
   timerRaisedFlag = true;
@@ -251,7 +262,7 @@ void setup()
 
 void loop()
 {
-  server.handleClient();
+  //server.handleClient();
   uptime_update();
   updateMDNS();
 
@@ -264,7 +275,7 @@ void loop()
     {
       inputChangedFlag = false;
       digitalWrite(LED_RED, LOW);
-      //if (eepromStruct.use_nodered == true)
+
       if (getEeprom()->use_nodered == true)
       {
         noderedServerUpdate();
@@ -282,12 +293,11 @@ void loop()
     {
       timerRaisedFlag = false;
       digitalWrite(LED_RED, LOW);
-      //if (eepromStruct.use_nodered == true)
+
       if (getEeprom()->use_nodered == true)
       {
         noderedServerUpdate();
       }
-      //if (eepromStruct.use_prtg == true)
       if (getEeprom()->use_prtg == true)
       {
         prtgServerUpdate();

src/networkDetection.cpp

@@ -8,7 +8,7 @@
 #include <ESP8266mDNS.h>
 #include "global.h"
 #include "h1602_eeprom.h"
-#include "webserver.h"
+//#include "webserver.h"
 
 void setupSSDP()
 {
@@ -17,9 +17,11 @@ void setupSSDP()
 #ifdef DEBUG_MSG
         Serial.printf("Setting up SSDP...\n");
 #endif
-        server.on("/description.xml", HTTP_GET, []() {
+        // server.on("/description.xml", HTTP_GET, []() {
-            SSDP.schema(server.client());
+        //     SSDP.schema(server.client());
-        });
+        // });
+
+
         //SSDP.setTTL(5);
         //SSDP.setInterval(60);
         SSDP.setDeviceType("upnp:rootdevice");

src/nodered.cpp

@@ -16,17 +16,21 @@ boolean noderedHasError()
 void noderedServerUpdate()
 {
   DynamicJsonDocument jsonBuffer(384);
-  jsonBuffer["device"] = eepromStruct.device;
+  //jsonBuffer["device"] = eepromStruct.device;
+  jsonBuffer["device"] = getEeprom()->device;
   jsonBuffer["ip"] = WiFi.localIP().toString();
   jsonBuffer["version"] = softwareVersion;
-  jsonBuffer["serial"] = eepromStruct.serialnumber;
+  //jsonBuffer["serial"] = eepromStruct.serialnumber;
+  jsonBuffer["serial"] = getEeprom()->serialnumber;
 
   JsonObject channels = jsonBuffer.createNestedObject("channels");
   for (int i = 1; i < 5; i++)
   {
-    if (eepromStruct.channel[i].enable == true)
+    //if (eepromStruct.channel[i].enable == true)
+    if (getEepromChannel(i)->enable == true)
     {
-      channels[eepromStruct.channel[i].channel] = int(inputValue[i]);
+      //channels[eepromStruct.channel[i].channel] = int(inputValue[i]);
+      channels[getEepromChannel(i)->channel] = int(inputValue[i]);
     }
   }
 
@@ -43,7 +47,8 @@ void noderedServerUpdate()
   WiFiClient httpClient;
   HTTPClient http; //Declare object of class HTTPClient
 
-  String url = String(eepromStruct.noderedHost) + "/" + String(eepromStruct.noderedUrl);
+  //String url = String(eepromStruct.noderedHost) + "/" + String(eepromStruct.noderedUrl);
+  String url = String(getEeprom()->noderedHost) + "/" + String(getEeprom()->noderedUrl);
 #ifdef DEBUG_MSG
   Serial.print("server = ");
   Serial.println(url);

src/prtg.cpp

@@ -15,15 +15,17 @@ void prtgServerUpdate()
 {
   // We now create a URI for the request
   String request = "/";
-  request += eepromStruct.device;
+  //request += eepromStruct.device;
+  request += getEeprom()->device;
   request += "?content=<prtg>";
 
   for (int i = 1; i < 5; i++)
   {
-    if (eepromStruct.channel[i].enable == true)
+    //if (eepromStruct.channel[i].enable == true)
+    if (getEepromChannel(i)->enable == true)
     {
       request += "<result><channel>";
-      request += eepromStruct.channel[i].channel;
+      request += getEepromChannel(i)->channel;
       request += "</channel><value>" + String(inputValue[i]) + "</value></result>";
     }
   }
@@ -31,7 +33,8 @@ void prtgServerUpdate()
 
   WiFiClient httpClient;
   HTTPClient http; //Declare object of class HTTPClient
-  String url = String(eepromStruct.prtgHost) + ":" + String(eepromStruct.prtgHttpPort) + request;
+  //String url = String(eepromStruct.prtgHost) + ":" + String(eepromStruct.prtgHttpPort) + request;
+  String url = String(getEeprom()->prtgHost) + ":" + String(getEeprom()->prtgHttpPort) + request;
 
 #ifdef DEBUG_MSG
   Serial.println("-- PRTG --");

src/prtg.h

@@ -1,9 +1,7 @@
 #ifndef PRTG_H
 #define PRTG_H
 
-void prtgServerUpdate();
+void prtgServerUpdate(void);
-boolean prtgHasError();
+boolean prtgHasError(void);
-
-//extern boolean prtgErrorFlag;
 
 #endif

src/timers.cpp

@@ -20,7 +20,8 @@ void ICACHE_RAM_ATTR tickerChanged()
 //Led flash timer
 void ICACHE_RAM_ATTR ledFlashChanged()
 {
-  if (eepromStruct.apMode == true)
+  //if (eepromStruct.apMode == true)
+  if (getEeprom()->apMode == true)
   {
     digitalWrite(LED_GREEN, LOW);
   }
@@ -35,15 +36,29 @@ void ICACHE_RAM_ATTR ledFlashChanged()
   }
 }
 
-void detachSendTimer()
+void startSendTimer()
 {
-  sendTimer.detach();
+  if (getEeprom()->updateTime != 0)
+  {
+    //attachSendTimer(getEeprom()->updateTime);
+    sendTimer.attach(getEeprom()->updateTime, tickerChanged);
+  }
+  if (!anyChannelEnabled())
+  {
+    //detachSendTimer();
+    sendTimer.detach();
+  }
 }
 
-void attachSendTimer(uint32_t time)
+// void detachSendTimer()
-{
+// {
-  sendTimer.attach(time, tickerChanged);
+//   sendTimer.detach();
-}
+// }
+
+// void attachSendTimer(uint32_t time)
+// {
+//   sendTimer.attach(time, tickerChanged);
+// }
 
 void detachLedFlashTimer()
 {

src/timers.h

@@ -1,8 +1,9 @@
 #ifndef TIMERS_H
 #define TIMERS_H
 
-void detachSendTimer();
+void startSendTimer(void);
-void attachSendTimer(uint32_t time);
+//void detachSendTimer();
+//void attachSendTimer(uint32_t time);
 
 void detachLedFlashTimer();
 void attachLedFlashTimer_ms(uint32_t time);

src/webserver.h

@@ -1,11 +1,11 @@
 #ifndef WEBSERVER_H
 #define WEBSERVER_H
 
-#include <ESP8266HTTPUpdateServer.h>
+//#include <ESP8266HTTPUpdateServer.h>
 
-void setupServerPaths();
+//void setupServerPaths();
 
-extern ESP8266WebServer server;
+//extern ESP8266WebServer server;
-extern ESP8266HTTPUpdateServer httpUpdater;
+//extern ESP8266HTTPUpdateServer httpUpdater;
 
 #endif