ESP32_powerMC/firmware/firmware.ino

// This project is written for aESP32 WROOM-32 module (AZ Delivery ESP32 Dev Kit C v4)

#include <WiFi.h>
#include <ESP32httpUpdate.h>
#include <WebServer.h>
#include <ArduinoJson.h>
#include <WiFiManager.h>
#include <esp_task_wdt.h>
#include <EEPROM.h>
#include <Wire.h>
#include <INA226.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "error.h"
#include "config_user.h" // includes preprocessor defines
#include "constants.h"

#ifndef DEBUG_NO_I2C
INA226 ina226(INA226_I2C_ADDRESS);
Adafruit_SSD1306 display(OLED_SCREEN_WIDTH, OLED_SCREEN_HEIGHT, &Wire, OLED_RESET_PIN);
Adafruit_BME280 bme;
#endif

// WiFiManager initialisieren
WiFiManager wifiManager;
WebServer server(80);

// Struktur für die gespeicherte Energie mit Prüfsumme
struct EnergyData {
  float energy;
  uint16_t checksum;
};

struct ConfigData {
  float temp_min;
  float temp_max;
  float humi_min;
  float humi_max;
  float current_min;
  float current_max;
  float shunt_voltage_drop;
  float shunt_max_current;
  float max_capacity;
  float time_ina226_refresh;
  float current_fact;
  uint16_t checksum;
};

// demo modes
bool demoMode1       = false;
bool demo1Increasing = false;
bool demoMode2       = false;
bool demoMode3       = false;

// Globale Variable für den Anzeigemodus
bool    displayEnergyVoltageMode          = false;
uint8_t displayEnergyVoltageModeChangeCnt = 0;

// Globale Variablen für INA226-Werte
float globalBusVoltage   = 0.0;
float globalShuntVoltage = 0.0;
float globalCurrent      = 0.0;
float globalPower        = 0.0;
float globalShuntValue   = 0.0;
// Globale Variable für die Energiemenge in Wattstunden
float globalEnergy   = 0.0;
float globalTemp     = 0.0;
float globalHumidity = 0.0;

// global error code
uint16_t globalErrorCode = ERROR_NONE;

uint16_t ina226Status = 0x0000;

unsigned long lastINA226CheckTime  = 0;
unsigned long lastWiFiCheckTime    = 0;
unsigned long lastHandleClientTime = 0;
unsigned long lastLoopDisplayTime  = 0;

String updateStatus;
bool fwUpdate_isRunning = false;

ConfigData globalConfigData;

void setup() {
  Serial.begin(115200);

  Serial.println(cs_readCapacityFromEEPROM);
  EEPROM.begin(EEPROM_SIZE);
  // Versuche, die gespeicherte Energiemenge aus dem EEPROM zu laden
  globalEnergy = readGlobalEnergyFromEEPROM();

  Serial.println(cs_readConfigFromEEPROM);
  readConfigFromEEPROM();
  printConfigData(globalConfigData);

  // Timeout für die Konfiguration auf 120s setzen
  wifiManager.setConfigPortalTimeout(120);

  // Versuche, eine Verbindung herzustellen, und wenn nicht erfolgreich, starte den Konfigurationsportal
  if (!wifiManager.autoConnect(cs_configPortalSSID.c_str())) {
    Serial.println(cs_connectionError);
    delay(10000);
    // Resete und versuche es erneut
    ESP.restart();
  }

  Serial.println(cs_connectedToWiFi);

  // Initialisiere die I2C-Kommunikation
  Wire.begin();

#ifndef DEBUG_NO_I2C
  Serial.println(cs_ssd1306Init);
  // SSD1306_SWITCHCAPVCC = generate display voltage from 3.3V internally
  if(!display.begin(SSD1306_SWITCHCAPVCC, OLED_I2C_ADDRESS)) {
    Serial.println(cs_ssd1306NotFound);
    delay(10000); // Warte 10 Sekunden
    ESP.restart(); // Neu starten
  }
  // Clear the buffer
  display.clearDisplay();

  Serial.println(cs_ina226Init);
  if (!ina226.begin()) {
    Serial.println(cs_ina226ChipNotFound);
    delay(10000); // Warte 10 Sekunden
    ESP.restart(); // Neu starten
  }

  configureIna226();

  Serial.println(cs_bme280Init);
  if (!bme.begin(BME280_I2C_ADDRESS)) {
    Serial.println(cs_bme280NotFound);
    delay(10000); // Warte 10 Sekunden
    ESP.restart(); // Neu starten
  }
#endif // no sensor debug

  Serial.println(cs_webserverInit);
  server.on(cs_rootPath,                     HTTP_GET, handleRoot);
  server.on(cs_jsonPath,                     HTTP_GET, handleJson);
  server.on(cs_configPath,                   HTTP_GET, handleConfig);
  server.on(cs_saveConfigPath,               HTTP_PUT, handleSaveConfig);
  server.on(cs_demoMode1Path,                HTTP_GET, handleDemoMode1);
  server.on(cs_demoMode2Path,                HTTP_GET, handleDemoMode2);
  server.on(cs_demoMode3Path,                HTTP_GET, handleDemoMode3);
  server.on(cs_resetESPPath,                 HTTP_GET, handleResetESP);
  server.on(cs_resetWifiPath,                HTTP_GET, handleResetWifi);
  server.on(cs_checkUpdatePath,              HTTP_GET, handleUpdateFirmware);
  server.on(cs_updateFirmwareActionPath,     HTTP_GET, handleUpdateFirmwareAction);
  server.on(cs_readUpdateFirmwareStatusPath, HTTP_GET, handleReadUpdateFirmwareStatus);
  server.on(cs_handleCSSPath,                HTTP_GET, handleCSS);
  server.begin();

  enableWatchdog();

  Serial.println(cs_initializationComplete);

  checkError();

#ifndef DEBUG_NO_I2C
  //delay(1000);
  displayData();
#endif
}

void loop() {
  static unsigned long lastLoopTime = 0;

  bool demoMode = (demoMode1 || demoMode2 || demoMode3);

  // Führe den Code nur alle xx Sekunden aus
  if (millis() - lastLoopTime >= ((demoMode == false) ? (globalConfigData.time_ina226_refresh * 1000) : LOOP_INA226READ_DEMO_DELAY_MS)) {
    lastLoopTime = millis();

    if (demoMode1 == true)
    {
      simulateUpDownSensorValues();

    } else if (demoMode2 == true) {
      simulateChrgFull();

    } else if (demoMode3 == true) {
      simulateDischrgEmpty();

    } else {
#ifndef DEBUG_NO_I2C
      // INA226-Werte aktualisieren
      globalBusVoltage   = ina226.getBusVoltage();
      globalShuntVoltage = ina226.getShuntVoltage();
      globalCurrent      = ina226.getCurrent() * (globalConfigData.current_fact / 100);
      globalPower        = ina226.getPower();
#endif
    }

#ifndef DEBUG_NO_SERIAL_MSG
    Serial.println(cs_separatorLine);
#endif

    // Berechne den Energieverbrauch und aktualisiere die globale Energiemenge
    updateEnergy(globalCurrent, globalPower);

#ifndef DEBUG_NO_I2C
    globalTemp     = bme.readTemperature();
    globalHumidity = bme.readHumidity();
#endif

    checkError();

#ifndef DEBUG_NO_SERIAL_MSG
    // Debug-Ausgabe der aktualisierten Werte
    Serial.print(cs_busVoltageLabel);
    Serial.println(globalBusVoltage);
    Serial.print(cs_shuntVoltageLabel);
    Serial.println(globalShuntVoltage);
    Serial.print(cs_currentLabel);
    Serial.println(globalCurrent);
    Serial.print(cs_powerLabel);
    Serial.println(globalPower);
    Serial.print(cs_energyLabel);
    Serial.println(globalEnergy);
    Serial.print(cs_temperatureLabel);
    Serial.println(globalTemp);
    Serial.print(cs_humidityLabel);
    Serial.println(globalHumidity);
#endif

  }

  if (millis() - lastLoopDisplayTime >= ((demoMode == false) ? LOOP_DISPLAY_DELAY_MS : LOOP_DISPLAY_DEMO_DELAY_MS)) {
    lastLoopDisplayTime = millis();
    // Display aktualisieren
#ifndef DEBUG_NO_I2C
    displayData();
#endif
  }

  if (millis() - lastHandleClientTime >= LOOP_HANDLE_CLIENT_DELAY_MS) {
    lastHandleClientTime = millis();
    server.handleClient();
  }

  // Überprüfe, ob es Zeit ist, die Anwesenheit des INA226-Chip erneut zu überprüfen
  if (millis() - lastINA226CheckTime >= LOOP_INA226CHECK_DELAY_MS) { // 10 Minuten = 600000 Millisekunden
    lastINA226CheckTime = millis();

#ifndef DEBUG_NO_I2C
    if (!ina226.begin()) {
      Serial.println(cs_ina226ChipNotFoundRestart);
      delay(5000);
      ESP.restart();
    }
#endif
  }

  // Überprüfe, ob WLAN-Verbindung getrennt wurde
  if (WiFi.status() == WL_DISCONNECTED && millis() - lastWiFiCheckTime >= LOOP_WLAN_CHECK_DELAY_MS) { // 1 Minute = 60000 Millisekunden
    lastWiFiCheckTime = millis();
    Serial.println(cs_wifiDisconnectedRestart);
    delay(5000);
    ESP.restart();
  }

  // Füttere den Watchdog-Timer, um einen Reset zu vermeiden
  esp_task_wdt_reset();

  // Blockiere die loop() Funktion maximal 100ms
  delay(100);

}

#ifndef DEBUG_NO_I2C
void displayData() {
  display.clearDisplay();

  // Zeige den Stromwert an
  display.setTextSize(OLED_TEST_SIZE);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 0);
  display.print(globalCurrent, 2); // Zwei Dezimalstellen anzeigen
  display.setCursor(100, 0);
  display.print(cs_ampereUnit);

  // Zeige die Leistung an
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 17);
  display.print(globalPower, 2); // Zwei Dezimalstellen anzeigen
  display.setCursor(100, 17);
  display.print(cs_wattUnit);

  //display.setTextSize(1);

  // Zeige den Stromwert oder die Bus-Spannung basierend auf dem Anzeigemodus an
  if (displayEnergyVoltageMode) {
    // Zeige die verfügbare Energiemenge an
    display.setTextSize(OLED_TEST_SIZE);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 34);
    display.print(globalEnergy, 2); // Zwei Dezimalstellen anzeigen
    display.setCursor(100, 34);
    display.print(cs_wattHourUnit);
  } else {
    // Zeige die Bus-Spannung an
    display.setTextSize(OLED_TEST_SIZE);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 34);
    display.print(globalBusVoltage, 2); // Zwei Dezimalstellen anzeigen
    display.setCursor(100, 34);
    display.print(cs_voltageUnit);
  }

  // Wechsle den Anzeigemodus für das nächste Mal
  if (displayEnergyVoltageModeChangeCnt >= DISPLAY_SWITCH_SHOWN_VALUE_COUNT)
  {
    displayEnergyVoltageMode = !displayEnergyVoltageMode;
    displayEnergyVoltageModeChangeCnt = 0;
  } else {
    displayEnergyVoltageModeChangeCnt++;
  }

  // Zeige die maximale Kapazität an
  display.setCursor(0, 51);
  display.print(cs_stateOfChargeLabel);
  display.setCursor(50, 51);
  float batteryCapacityPercentage = (globalEnergy / globalConfigData.max_capacity) * 100.0;
  batteryCapacityPercentage = max(0.0f, min(batteryCapacityPercentage, 100.0f));
  display.print(batteryCapacityPercentage, 1); // Zwei Dezimalstellen anzeigen
  display.setCursor(115, 51);
  display.print(cs_percentageUnit);

  // Zeige den Pfeil an
  if (globalCurrent > 0) {
    display.drawLine(120, 10, 116, 5, SSD1306_WHITE);
    display.drawLine(120, 10, 124, 5, SSD1306_WHITE);
  } else if (globalCurrent < 0) {
    display.drawLine(120, 5, 116, 10, SSD1306_WHITE);
    display.drawLine(120, 5, 124, 10, SSD1306_WHITE);
  }

  display.display();
}
#endif

void updateEnergy(float current, float power) {
  static unsigned long lastUpdateTime = 0;
  static unsigned long lastDailyUpdateCheck = 0;

  // Berechne die vergangene Zeit seit dem letzten Update
  unsigned long currentTime = millis();
  float timeInterval = (currentTime - lastUpdateTime) / 1000.0; // Zeitintervall in Sekunden

  // Aktualisiere die globale Energiemenge basierend auf der Leistung und vergangener Zeit
  float energyChange = (power * timeInterval) / 3600.0; // Energieänderung in Wattstunden
  if (current > 0)
  {
    globalEnergy += energyChange;
  } else {
    globalEnergy -= energyChange;
  }


  // Begrenze den Wert auf das Minimum (0) und den maximalen Wert
  globalEnergy = max(0.0f, min(globalEnergy, globalConfigData.max_capacity));

  if (demoMode1 == false && demoMode2 == false && demoMode3 == false)
  {
    // Speichere die globale Energiemenge im EEPROM
    saveGlobalEnergyToEEPROM();
  }

  // Aktualisiere die Zeit des letzten Updates
  lastUpdateTime = currentTime;
}

void checkError()
{
  globalErrorCode = ERROR_NONE;

  if (globalTemp >= globalConfigData.temp_max) {
    globalErrorCode |= ERROR_MAX_TEMP_EXCEEDED;
  } else if (globalTemp <= globalConfigData.temp_min) {
    globalErrorCode |= ERROR_TEMP_BELOW_MIN;
  }
  if (globalCurrent > globalConfigData.current_max) {
    globalErrorCode |= ERROR_MAX_CURRENT_EXCEEDED;
  } else if (globalCurrent < globalConfigData.current_min) {
    globalErrorCode |= ERROR_CURRENT_BELOW_MIN;
  }
  if (globalHumidity >= globalConfigData.humi_max) {
    globalErrorCode |= ERROR_MAX_HUMI_EXCEEDED;
  } else if (globalHumidity <= globalConfigData.humi_min) {
    globalErrorCode |= ERROR_HUMI_BELOW_MIN;
  }
  if (ina226.isCalibrated() == false)
  {
    globalErrorCode |= ERROR_INA226_UNCONFIGURED;
  }

#ifndef DEBUG_NO_SERIAL_MSG
  Serial.print(cs_errorCode);
  for (int i = 15; i >= 0; i--) {
    Serial.print((globalErrorCode >> i) & 1);
  }
  Serial.println();
#endif
}


void printConfigData(ConfigData c) {
#ifndef DEBUG_NO_SERIAL_MSG
  Serial.println(cs_configDataLabel);
  Serial.print(cs_tempMinLabel);
  Serial.println(c.temp_min);
  Serial.print(cs_tempMaxLabel;
  Serial.println(c.temp_max);
  Serial.print(cs_humiMinLabel);
  Serial.println(c.humi_min);
  Serial.print(cs_humiMaxLabel);
  Serial.println(c.humi_max);
  Serial.print(cs_currentMinLabel);
  Serial.println(c.current_min);
  Serial.print(cs_currentMaxLabel);
  Serial.println(c.current_max);
  Serial.print(cs_shuntVoltageDropLabel);
  Serial.println(c.shunt_voltage_drop);
  Serial.print(cs_shuntMaxCurrentLabel);
  Serial.println(c.shunt_max_current);
  Serial.print(cs_timeIna226RefreshLabel);
  Serial.println(c.time_ina226_refresh);
  Serial.print(cs_checksumLabel);
  Serial.println(c.checksum);
  Serial.println(cs_separator2);
#endif
}

void enableWatchdog()
{
  Serial.println(cs_enableWatchdog);
  // Initialisiere den Watchdog-Timer mit einer Timeout-Zeit von 5 Sekunden
  esp_task_wdt_init(WATCHDOG_TIMEOUT_S, true);
  // Aktiviere den Watchdog-Timer für den Hauptprozess
  esp_task_wdt_add(NULL);
}

void disableWatchdog()
{
    Serial.println(cs_disablingWatchdog);
    esp_task_wdt_deinit();
    esp_task_wdt_delete(NULL);
}

void configureIna226()
{
  ina226.setMinimalShunt(0.0001); // overwrite INA226_ERR_SHUNT_LOW

  globalShuntValue = (globalConfigData.shunt_voltage_drop / 1000.0) / globalConfigData.shunt_max_current;
  Serial.println("Ina226 target shunt size (Ohm): " + String(globalShuntValue));

  // normalization to 3 floatingpoint accuracy
  ina226Status = ina226.setMaxCurrentShunt(globalConfigData.shunt_max_current / 1000.0,
                                           globalShuntValue, true);
  if (0x0000 != ina226Status)
  {
    Serial.print("Ina226 error, invalid configuration: ");
    Serial.println(ina226Status, HEX);
  }
  ina226.setAverage(2); // 2=16 samples will be used to build an average value
  Serial.println("Ina226 mode: "+String(ina226.getMode()));
  Serial.println("Ina226 shunt ohm: "+String(ina226.getShunt()));
  Serial.println("Ina226 is calibrated: "+String(ina226.isCalibrated()));
}