Initial commit with action

src/main.cpp

@@ -0,0 +1,388 @@
+#include <Arduino.h>
+#include "SPIFFS.h"
+#include <WiFi.h>
+#include <AsyncTCP.h>
+#include <ESPAsyncWebServer.h>
+#include <ETH.h>
+
+#include <ArduinoJson.h>
+#include <ArduinoLog.h>
+#include "AsyncJson.h"
+
+#include <ArduinoOTA.h>
+
+#include "INA226.h"
+#include "Wire.h"
+
+#include <Preferences.h>
+
+#define LED_1 4
+#define LED_2 2
+#define LED_3 15
+#define LED_4 13
+#define LED_5 12
+#define LED_RED 14
+
+// Define keys to prevent typos
+#define ssid_key "ssid"
+#define wifi_password_key "wifi_password"
+
+//Calibration variables
+float zero_value = 0.03; //Measured shunt voltage with nothing connected, used to fix measuring offset
+float max_water_level_cm = 200;
+float min_water_level_cm = 0;
+float sensor_range = 2.0;
+
+bool voltage_high = false;
+bool voltage_low = false;
+bool current_high = false;
+bool current_low = false;
+
+float rssi;
+uint32_t ip_address;
+uint8_t failed_connection_attempts = 0;
+
+struct SensorData {
+  int percentage;
+  float voltage;
+  float current;
+  float water_height;
+};
+
+SensorData current_data = SensorData{-1, -1, -1, -1};
+
+int64_t mac_address = ESP.getEfuseMac();
+
+INA226 ina_sensor(0x40);
+
+Preferences prefs;
+
+AsyncWebServer server(80);
+#define FORMAT_LITTLEFS_IF_FAILED true
+
+
+void display_percentage(int percentage){
+  digitalWrite(LED_RED, 0);
+  
+  if (percentage > 20){
+    digitalWrite(LED_1, 1);
+  } else {
+    digitalWrite(LED_1, 0);
+  }
+  if (percentage > 40){
+    digitalWrite(LED_2, 1);
+  } else {
+    digitalWrite(LED_2, 0);
+  }
+  if (percentage > 60){
+    digitalWrite(LED_3, 1);
+  } else {
+    digitalWrite(LED_3, 0);
+  }
+  if (percentage > 80){
+    digitalWrite(LED_4, 1);
+  } else {
+    digitalWrite(LED_4, 0);
+  }
+  if (percentage > 95){
+    digitalWrite(LED_5, 1);
+  } else {
+    digitalWrite(LED_5, 0);
+  }
+}
+
+void display_error_code(byte err_code) {
+  digitalWrite(LED_RED, 1);
+  digitalWrite(LED_1, bitRead(err_code, 0));
+  digitalWrite(LED_2, bitRead(err_code, 1));
+  digitalWrite(LED_3, bitRead(err_code, 2));
+  digitalWrite(LED_4, bitRead(err_code, 3));
+  digitalWrite(LED_5, bitRead(err_code, 4));
+
+}
+
+bool is_error(){
+  return voltage_high || voltage_low || current_high || current_low;
+}
+
+void printSuffix(Print* _logOutput, int logLevel) {
+  _logOutput->print(CR);
+}
+
+void print_prefix(Print* _logOutput, int logLevel) {
+    _logOutput->print("WATERMETER - C");
+    _logOutput->print(xPortGetCoreID());
+    _logOutput->print(" - ");
+    _logOutput->print(pcTaskGetName(xTaskGetCurrentTaskHandle()));
+    _logOutput->print(" - ");
+}
+
+void display_task(void * parameter ){
+  while (true) {
+    if (!is_error()){
+      // We have no error, refresh status display and wait half a second
+      display_percentage(current_data.percentage);
+      delay(1000);
+    } else {
+      Log.verbose("Error detected");
+      // We have an error, display error code for 3 seconds and then water level for 3 seconds
+      if (voltage_low) {
+        display_error_code(1);
+      } else if (voltage_high){
+        display_error_code(2);
+      } else if (current_low) {
+        display_error_code(3);
+      } else if (current_high){
+        display_error_code(4);
+      }
+      delay(3000);
+      display_percentage(current_data.percentage);
+      delay(3000);
+    }
+  }
+
+}
+
+void wifi_task(void * parameter ){
+  Log.verbose("Starting WiFi Task");
+  while (true) {
+    if (prefs.getString(ssid_key, "") == "" || failed_connection_attempts > 5 ) {
+      if (failed_connection_attempts > 5) {
+        Log.verbose("Failed to connecto to currently saved SSID, starting SoftAP");
+      } else {
+        Log.verbose("No SSID saved, starting SoftAP");
+      }
+      
+
+      String ap_ssid = "Watermeter-" + String(mac_address);
+      WiFi.softAP(ap_ssid, "");
+
+      Log.verbose("[WIFI_TASK] Waiting for SSID now...");
+
+      String old_ssid = prefs.getString(ssid_key, "xxx");
+      while(prefs.getString(ssid_key, "") == "" || prefs.getString(ssid_key, "") == old_ssid) {
+        delay(1000);
+      }
+      
+
+      failed_connection_attempts = 0;
+    } else {
+      if (WiFi.isConnected() && WiFi.SSID() == prefs.getString(ssid_key, "")) {
+        failed_connection_attempts = 0;
+        rssi = WiFi.RSSI();
+        ip_address = WiFi.localIP();
+
+        
+
+        Log.verbose("RSSI: %F, IP Address, %p, SSID: %s", rssi, WiFi.localIP(), prefs.getString(ssid_key, "NOSSID"));
+        delay(5000);
+      } else {
+        Log.verbose("Connecting to %s using password %s", prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
+        WiFi.mode(WIFI_STA);
+        WiFi.begin(prefs.getString(ssid_key, ""), prefs.getString(wifi_password_key, ""));
+        failed_connection_attempts++;
+        delay(5000);
+      }
+    }
+  }
+
+}
+
+void ethernet_task(void * parameter ){
+  while (true) {
+
+  }
+
+}
+
+void setup() {
+  prefs.begin("waterlevel", false);
+  Serial.begin(115200);
+
+  Log.begin(LOG_LEVEL_VERBOSE, &Serial);
+  Log.setSuffix(printSuffix);
+  Log.setPrefix(print_prefix);
+
+  Log.verbose("Starting WiFi Task now (external)");
+  xTaskCreate(wifi_task, "WiFiTask", 10000, NULL, 1, NULL);
+
+  Log.verbose("Init LEDs");
+  pinMode(LED_1, OUTPUT);
+  pinMode(LED_2, OUTPUT);
+  pinMode(LED_3, OUTPUT);
+  pinMode(LED_4, OUTPUT);
+  pinMode(LED_5, OUTPUT);
+  pinMode(LED_RED, OUTPUT);
+  display_error_code(17);
+
+  Log.verbose("Beginning SPIFFS");
+  SPIFFS.begin(true);
+  Log.verbose("SPIFFS initialized");
+  display_error_code(19);
+
+  Log.verbose("Begin INA");
+  ina_sensor.begin(33, 32);
+  display_error_code(20);
+  ina_sensor.setMaxCurrentShunt(0.02, 4, false);
+  ina_sensor.setBusVoltageConversionTime(7);
+  ina_sensor.setShuntVoltageConversionTime(7);
+  ina_sensor.setAverage(4);
+  display_error_code(21);
+
+  Log.verbose("Connecting Ethernet");
+  ETH.begin(0, 17, 23, 18);
+  Log.verbose(ETH.getHostname());
+  display_error_code(22);
+
+  /////////////////////////////// ROUTES ///////////////////////////////
+  Log.verbose("Route Setup");
+  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
+    request->send(SPIFFS, "/status.html", "text/html", false);
+  });
+
+  server.on("/settings", HTTP_GET, [](AsyncWebServerRequest *request){
+    request->send(SPIFFS, "/settings.html", "text/html", false);
+  });
+
+  server.on("/export", HTTP_GET, [](AsyncWebServerRequest *request){
+    request->send(SPIFFS, "/data_export.html", "text/html", false);
+  });
+
+  server.on("/update_wifi_credentials", HTTP_POST, [](AsyncWebServerRequest *request){
+    int params = request->params();
+    
+    // Log.verbose(request->hasParam(ssid_key));
+    // Log.verbose(request->hasParam(wifi_password_key));
+
+    if (request->hasParam(ssid_key, true) && request->hasParam(wifi_password_key, true)){
+      Log.verbose("Updating SSID config");
+      AsyncWebParameter* ssid_param = request->getParam(ssid_key, true);
+      AsyncWebParameter* password_param = request->getParam(wifi_password_key, true);
+      prefs.putString(ssid_key, ssid_param->value().c_str());
+      prefs.putString(wifi_password_key, password_param->value().c_str());
+    } else {
+      for(int i=0;i<params;i++){
+        AsyncWebParameter* p = request->getParam(i);
+        if(p->isFile()){ //p->isPost() is also true
+            Log.verbose("POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+        } else if(p->isPost()){
+            Log.verbose("POST[%s]: %s\n", p->name().c_str(), p->value().c_str());
+        } else {
+            Log.verbose("GET[%s]: %s\n", p->name().c_str(), p->value().c_str());
+        }
+    }
+      request->send(400, "text/plain", "Missing parameters"); //TODO add proper error messages
+    }
+    request->send(SPIFFS, "/settings.html", "text/html", false); //TODO add proper return templating
+  });
+  
+  server.on("/sensor_data", HTTP_GET, [](AsyncWebServerRequest *request){
+    StaticJsonDocument<128> doc;
+    doc["percentage"] = current_data.percentage;
+    doc["voltage"] = current_data.voltage;
+    doc["current"] = current_data.current;
+    doc["water_height"] = current_data.water_height;
+
+    String output;
+    serializeJson(doc, output);
+    request->send(200, "application/json", output);
+    });
+
+  server.on("/chota.css", HTTP_GET, [](AsyncWebServerRequest *request){
+      request->send(SPIFFS, "/chota.css", "text/css", false);
+  });
+  
+  display_error_code(23);
+
+  Log.verbose("Starting webserver");
+  server.begin();
+  display_error_code(24);
+
+  Log.verbose("OTA Setup");
+  ArduinoOTA
+    .onStart([]() {
+      String type;
+      if (ArduinoOTA.getCommand() == U_FLASH)
+        type = "sketch";
+      else // U_SPIFFS
+        type = "filesystem";
+
+      // NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
+      Log.verbose("Start updating %s", type);
+    })
+    .onEnd([]() {
+      Log.verbose("\nEnd");
+    })
+    .onProgress([](unsigned int progress, unsigned int total) {
+      Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
+    })
+    .onError([](ota_error_t error) {
+      Serial.printf("Error[%u]: ", error);
+      if (error == OTA_AUTH_ERROR) Log.verbose("Auth Failed");
+      else if (error == OTA_BEGIN_ERROR) Log.verbose("Begin Failed");
+      else if (error == OTA_CONNECT_ERROR) Log.verbose("Connect Failed");
+      else if (error == OTA_RECEIVE_ERROR) Log.verbose("Receive Failed");
+      else if (error == OTA_END_ERROR) Log.verbose("End Failed");
+    });
+  display_error_code(25);
+  ArduinoOTA.begin();
+  display_error_code(26);
+  digitalWrite(LED_RED, 0);
+  Log.verbose(ETH.localIP());
+
+  xTaskCreate(display_task, "DisplayTask", 10000, NULL, 1, NULL);
+}
+
+
+/**
+ * Updates the global variables from the current ina sensor data
+ * All other parts just read these variables to prevent incositencies
+*/
+void update_sensor_data(){
+  float bus_voltage = ina_sensor.getBusVoltage();
+  float shunt_voltage = ina_sensor.getShuntVoltage_mV() - zero_value;
+  float shunt_current = shunt_voltage / 4 ;
+
+
+  float mA_per_cm = (20 - 4)/ (sensor_range*100);
+
+
+  float min_water_level_mA_over_zero = (min_water_level_cm * mA_per_cm);
+  float max_water_level_mA_over_zero = (max_water_level_cm * mA_per_cm);
+
+  float min_water_level_mA = 4 + min_water_level_mA_over_zero;
+  float max_water_level_mA = 4 + max_water_level_mA_over_zero;
+
+  // Over Zero always revers to zero water level
+  float shunt_current_over_zero = shunt_current - min_water_level_mA;
+
+  int percentage = round(( shunt_current_over_zero / max_water_level_mA_over_zero) * 100);
+
+
+  current_low = shunt_current < 3.5;
+  current_high = shunt_current > 20.5;
+  voltage_low = bus_voltage < 23;
+  voltage_high = bus_voltage > 25;
+  Log.verbose("==========");
+  Log.verbose("Shunt current: %F", shunt_current);
+  Log.verbose("Shunt voltage: %F", shunt_voltage);
+  Log.verbose("Value percentage: %F", percentage);
+
+
+  current_data = SensorData{percentage, bus_voltage, shunt_current, shunt_current_over_zero};
+
+
+
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  
+  
+  update_sensor_data();
+  // Log.verbose(WiFi.softAPIP());
+  // Log.verbose(ETH.localIP());
+  delay(5000);
+}
+
+