arduino-sketches – Diff between revs 13 and 21

Subversion Repositories:

?pathlinks?

Rev 13 – Details – Blame – Last modification – View Log

 // "manual mode". From the manual, that seems to be setting the load     //
 // setting for the first timer to 117 and the second should display 2, n //
 // and then the load can be toggled using this sketch.                   //
 ///////////////////////////////////////////////////////////////////////////
-#include <ModbusMaster.h>
-#if defined(ARDUINO_ARCH_ESP8266)
-#include <ESP8266WiFi.h>
-#include <ESP8266mDNS.h>
-#elif defined(ARDUINO_ARCH_ESP32)
-#include <WiFi.h>
-#include <ESPmDNS.h>
-#endif
-#include <PubSubClient.h>
-#include <ArduinoJson.h>
-#include <ArduinoOTA.h>
-#if defined(ARDUINO_ARCH_ESP8266)
-#include <ESP_EEPROM.h>
-#elif defined(ARDUINO_ARCH_ESP32)
-#include <EEPROM.h>
-#endif
 ///////////////////////////////////////////////////////////////////////////
 //                           configuration                               //
+///////////////////////////////////////////////////////////////////////////
+// Whether to send data over the serial port.
-///////////////////////////////////////////////////////////////////////////
+#define SERIAL_DATA 1
 // RS-485 module pin DE maps to D2 GPIO on ESP.
 #define MAX485_DE D2
 // RS-485 module pin RE maps to D1 GPIO on ESP.
 #define MAX485_RE D1
-const char* STA_SSID = "";
+#define STA_SSID ""
-const char* STA_PASSWORD = "";
+#define STA_PASSWORD ""
-const char* MQTT_SERVER = "";
+#define MQTT_SERVER ""
-const int MQTT_PORT = 1883;
+#define MQTT_PORT 1883
-const char* MQTT_CLIENT_ID = "EpEver Solar Monitor";
+#define MQTT_CLIENT_ID "EpEver Solar Monitor"
-const char* MQTT_TOPIC_PUB = "epever-40a/talk";
+#define MQTT_TOPIC_PUB "epever-40a/talk"
-const char* MQTT_TOPIC_SUB = "epever-40a/hear";
+#define MQTT_TOPIC_SUB "epever-40a/hear"
-// seconds to wait for MQTT message to be delivered and processed
+// Seconds to wait for MQTT message to be delivered and processed.
-const int MQTT_SUBSCRIBE_WAIT = 10;
+#define MQTT_SUBSCRIBE_WAIT 10
 // The OTA hostname.
-const char* OTA_HOSTNAME = "";
+//#define OTA_HOSTNAME
 // The OTA port on which updates take place.
-const unsigned int OTA_PORT = 8266;
+//#define OTA_PORT 8266
 // The authentication password to use for OTA updates.
 // This should be set to the unsalted MD5 hash of the plaintext password.
-const char* OTA_PASSWORD_HASH = "";
+//#define OTA_PASSWORD_HASH
 // Whether to use deep sleep or not (requires hardware modifications).
-const bool USE_DEEP_SLEEP = true;
+//#define USE_DEEP_SLEEP 1
 // the minimal amount that the ESP should sleep for.
+#define MIN_SLEEP_SECONDS 60
+///////////////////////////////////////////////////////////////////////////
+//           general variable declarations and libraries                 //
+///////////////////////////////////////////////////////////////////////////
+#include <ModbusMaster.h>
+#if defined(ARDUINO_ARCH_ESP8266)
+#include <ESP8266WiFi.h>
+#include <ESP8266mDNS.h>
+#elif defined(ARDUINO_ARCH_ESP32)
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#endif
+#include <PubSubClient.h>
+#include <ArduinoJson.h>
+#include <ArduinoOTA.h>
+#if defined(ARDUINO_ARCH_ESP8266)
-const int MIN_SLEEP_SECONDS = 60;
+#include <ESP_EEPROM.h>
 #elif defined(ARDUINO_ARCH_ESP32)
-///////////////////////////////////////////////////////////////////////////
+#include <EEPROM.h>
-//                   general variable declarations                       //
+#endif
 ///////////////////////////////////////////////////////////////////////////
   // Loop until we're reconnected
   Serial.println("Checking MQT connection...");
   while (!mqtt_client.connected()) {
     Serial.print("MQTT Reconnecting: ");
-    // Create a client ID
-    String clientId = MQTT_CLIENT_ID;
     // Attempt to connect
-    if (mqtt_client.connect(clientId.c_str())) {
+    if (mqtt_client.connect(MQTT_CLIENT_ID)) {
       Serial.println("success");
       Serial.print("Subscribing MQTT: ");
     epeverControlPayload.clear();
     return;
+  }
+}
-//////////////////////////
-/////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////
 //                           Arduino functions                           //
 ///////////////////////////////////////////////////////////////////////////
 void setup() {
   Serial.begin(115200);  // DO NOT CHANGE!
   node.postTransmission(postTransmission);
   // EPEver Device ID 1
   node.begin(1, Serial);
   // Connect D0 to RST to wake up
-  if (USE_DEEP_SLEEP) {
+#ifdef USE_DEEP_SLEEP
-    pinMode(D0, WAKEUP_PULLUP);
+  pinMode(D0, WAKEUP_PULLUP);
 #endif
   // variable handling
   EEPROM.begin(16);
+}
 void loop() {
   uint8_t i, result;
-  // flash the led
-  for (i = 0; i < 3; i++) {
-    digitalWrite(LED_BUILTIN, LOW);
-    delay(200);
-    digitalWrite(LED_BUILTIN, HIGH);
-    delay(200);
+  // Turn on LED
-  }
   digitalWrite(LED_BUILTIN, HIGH);
   // clear old data
-  //
+  // Clear old data
   memset(rtc.buf, 0, sizeof(rtc.buf));
-  memset(live.buf, 0, sizeof(live.buf));
-  memset(stats.buf, 0, sizeof(stats.buf));
+  memset(live.buf, 0, sizeof(live.buf));
   memset(stats.buf, 0, sizeof(stats.buf));
   // Read registers for clock
-  //
+  // Read registers for clock
   node.clearResponseBuffer();
   } else {
     Serial.print("Miss read rtc-data, ret val:");
     Serial.println(result, HEX);
+  }
-  // read LIVE-Data
-  //
+  // Read LIVE-Data
   node.clearResponseBuffer();
   result = node.readInputRegisters(LIVE_DATA, LIVE_DATA_CNT);
     Serial.print("Miss read liva-data, ret val:");
     Serial.println(result, HEX);
+  }
-  // Statistical Data
-  //
+  // Statistical Data
   node.clearResponseBuffer();
   result = node.readInputRegisters(STATISTICS, STATISTICS_CNT);
-  if (result == node.ku8MBSuccess) {
+  if (result == node.ku8MBSuccess) {
+    for (i = 0; i < STATISTICS_CNT; i++) {
-    for (i = 0; i < STATISTICS_CNT; i++) stats.buf[i] = node.getResponseBuffer(i);
+      stats.buf[i] = node.getResponseBuffer(i);
+    }
   } else {
     Serial.print("Miss read statistics, ret val:");
     Serial.println(result, HEX);
+  }
   // Battery SOC
-  //
+  // Battery SOC
   node.clearResponseBuffer();
-  result = node.readInputRegisters(BATTERY_SOC, 1);
-  if (result == node.ku8MBSuccess) {
+  result = node.readInputRegisters(BATTERY_SOC, 1);
-    batterySOC = node.getResponseBuffer(0);
+  if (result == node.ku8MBSuccess) {
     batterySOC = node.getResponseBuffer(0);
   } else {
     Serial.print("Miss read batterySOC, ret val:");
     Serial.println(result, HEX);
-  }
+  }
   // Battery Net Current = Icharge - Iload
-  //
+  // Battery Net Current = Icharge - Iload
-  node.clearResponseBuffer();
-  result = node.readInputRegisters(BATTERY_CURRENT_L, 2);
+  node.clearResponseBuffer();
-  if (result == node.ku8MBSuccess) {
+  result = node.readInputRegisters(BATTERY_CURRENT_L, 2);
-    batteryCurrent = node.getResponseBuffer(0);
+  if (result == node.ku8MBSuccess) {
-    batteryCurrent |= node.getResponseBuffer(1) << 16;
+    batteryCurrent = node.getResponseBuffer(0);
     batteryCurrent |= node.getResponseBuffer(1) << 16;
   } else {
     Serial.print("Miss read batteryCurrent, ret val:");
-    Serial.println(result, HEX);
     Serial.println(result, HEX);
+  }
   // State of the Load Switch
-  //
-  node.clearResponseBuffer();
+  // State of the Load Switch
-  result = node.readCoils(LOAD_STATE, 1);
-  if (result == node.ku8MBSuccess) {
+  node.clearResponseBuffer();
   result = node.readCoils(LOAD_STATE, 1);
-    loadState = node.getResponseBuffer(0);
+  if (result == node.ku8MBSuccess) {
     loadState = node.getResponseBuffer(0);
   } else {
-    Serial.print("Miss read loadState, ret val:");
-    Serial.println(result, HEX);
+    Serial.print("Miss read loadState, ret val:");
     Serial.println(result, HEX);
+  }
-  // Read Status Flags
   //
-  node.clearResponseBuffer();
+  // Read Status Flags
-  result = node.readInputRegisters(0x3200, 2);
+  node.clearResponseBuffer();
-  if (result == node.ku8MBSuccess) {
+  result = node.readInputRegisters(0x3200, 2);
   if (result == node.ku8MBSuccess) {
     uint16_t temp = node.getResponseBuffer(0);
     Serial.print("Batt Flags : ");
-    Serial.println(temp);
     Serial.println(temp);
     status_batt.volt = temp & 0b1111;
-    status_batt.temp = (temp >> 4) & 0b1111;
+    status_batt.volt = temp & 0b1111;
-    status_batt.resistance = (temp >> 8) & 0b1;
+    status_batt.temp = (temp >> 4) & 0b1111;
     //Serial.print( "charger_input : "); Serial.println( charger_input );
     Serial.print("charger_mode  : ");
     Serial.println(charger_mode);
     //Serial.print( "charger_oper  : "); Serial.println( charger_operation );
     //Serial.print( "charger_state : "); Serial.println( charger_state );
   } else {
     Serial.print("Miss read ChargeState, ret val:");
     Serial.println(result, HEX);
+  }
   // Print out to serial
-  //
+#ifdef SERIAL_DATA
   Serial.printf("\n\nTime:  20%02d-%02d-%02d   %02d:%02d:%02d   \n", rtc.r.y, rtc.r.M, rtc.r.d, rtc.r.h, rtc.r.m, rtc.r.s);
   Serial.print("\nLive-Data:           Volt        Amp       Watt  ");
   Serial.printf("\n  Panel:            %7.3f    %7.3f    %7.3f ", live.l.pV / 100.f, live.l.pI / 100.f, live.l.pP / 100.0f);
   Serial.printf("\n  Batt:             %7.3f    %7.3f    %7.3f ", live.l.bV / 100.f, live.l.bI / 100.f, live.l.bP / 100.0f);
   Serial.printf("\n    batt.volt:         %s   ", batt_volt_status[status_batt.volt]);
   Serial.printf("\n    batt.temp:         %s   ", batt_temp_status[status_batt.temp]);
   Serial.printf("\n    charger.charging:  %s   ", charger_charging_status[charger_mode]);
   Serial.println();
   Serial.println();
+#endif
-  // Go Online to publish via mqtt
-  //
-  // get wifi going
+  // Start WiFi connection.
   digitalWrite(LED_BUILTIN, LOW);
   WiFi.mode(WIFI_STA);
   WiFi.begin(STA_SSID, STA_PASSWORD);
   if (WiFi.waitForConnectResult() != WL_CONNECTED) {
   Serial.println("WiFi connected");
   Serial.println("IP address: ");
   Serial.println(WiFi.localIP());
+  // Port defaults to 8266
-  // Port defaults to 8266
+#ifdef OTA_PORT
+  ArduinoOTA.setPort(OTA_PORT);
-  ArduinoOTA.setPort(OTA_PORT);
+#endif
   // Hostname defaults to esp8266-[ChipID]
-  // Hostname defaults to esp8266-[ChipID]
+#ifdef OTA_HOSTNAME
   if (strlen(OTA_HOSTNAME) != 0) {
+    ArduinoOTA.setHostname(OTA_HOSTNAME);
     ArduinoOTA.setHostname(OTA_HOSTNAME);
+#endif
   // No authentication by default
-  // No authentication by default
+#ifdef OTA_PASSWORD_HASH
+  if (strlen(OTA_PASSWORD_HASH) != 0) {
-  if (strlen(OTA_PASSWORD_HASH) != 0) {
+    ArduinoOTA.setPasswordHash(OTA_PASSWORD_HASH);
     ArduinoOTA.setPasswordHash(OTA_PASSWORD_HASH);
 #endif
       Serial.println("End Failed");
+    }
   });
   ArduinoOTA.begin();
-  // establish/keep mqtt connection
-  //
+  // Establish/keep mqtt connection
   mqtt_client.setServer(MQTT_SERVER, MQTT_PORT);
   mqtt_client.setCallback(mqtt_callback);
   mqtt_reconnect();
   controllerStatusPayload["solar"]["monitor"]["status"] = "waiting";
   serializeJson(controllerStatusPayload, tmpJsonPayloadBuffer);
   controllerStatusPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "status").c_str(), tmpJsonPayloadBuffer);
-  // wait for MQTT subscription processing
+  // Wait for MQTT subscription processing
   Serial.println("Waiting for MQTT and OTA events.");
   unsigned int now = millis();
   while (millis() - now < MQTT_SUBSCRIBE_WAIT * 1000) {
     // Loop for MQTT.
     ArduinoOTA.handle();
     delay(100);
+  }
   Serial.println("Done waiting for MQTT and OTA events.");
-  // publish via mqtt
-  //
+  // Publish to MQTT
   Serial.print("Publishing to MQTT: ");
   // panel
-  //
+  // Panel
   epeverMetricsPayload["solar"]["panel"]["V"] = String(live.l.pV / 100.f, 2);
   epeverMetricsPayload["solar"]["panel"]["I"] = String(live.l.pI / 100.f, 2);
   epeverMetricsPayload["solar"]["panel"]["P"] = String(live.l.pP / 100.f, 2);
   epeverMetricsPayload["solar"]["panel"]["minV"] = String(stats.s.pVmin / 100.f, 3);
   epeverMetricsPayload["solar"]["panel"]["maxV"] = String(stats.s.pVmax / 100.f, 3);
   serializeJson(epeverMetricsPayload, tmpJsonPayloadBuffer);
-  epeverMetricsPayload.clear();
-  mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "panel").c_str(), tmpJsonPayloadBuffer);
+  epeverMetricsPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "panel").c_str(), tmpJsonPayloadBuffer);
   // battery
-  //
+  // Battery
   epeverMetricsPayload["solar"]["battery"]["V"] = String(live.l.bV / 100.f, 2);
   serializeJson(epeverMetricsPayload, tmpJsonPayloadBuffer);
   epeverMetricsPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "battery").c_str(), tmpJsonPayloadBuffer);
   // load
-  //
+  // Load
   epeverMetricsPayload["solar"]["load"]["V"] = String(live.l.lV / 100.f, 2);
   epeverMetricsPayload["solar"]["load"]["I"] = String(live.l.lI / 100.f, 2);
   epeverMetricsPayload["solar"]["load"]["P"] = String(live.l.lP / 100.f, 2);
   serializeJson(epeverMetricsPayload, tmpJsonPayloadBuffer);
   epeverMetricsPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "load").c_str(), tmpJsonPayloadBuffer);
   // energy
-  //
+  // Energy
   epeverMetricsPayload["solar"]["energy"]["consumed_day"] = String(stats.s.consEnerDay / 100.f, 3);
   epeverMetricsPayload["solar"]["energy"]["consumed_all"] = String(stats.s.consEnerTotal / 100.f, 3);
   epeverMetricsPayload["solar"]["energy"]["generated_day"] = String(stats.s.genEnerDay / 100.f, 3);
   epeverMetricsPayload["solar"]["energy"]["generated_all"] = String(stats.s.genEnerTotal / 100.f, 3);
   serializeJson(epeverMetricsPayload, tmpJsonPayloadBuffer);
-  epeverMetricsPayload.clear();
-  mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "energy").c_str(), tmpJsonPayloadBuffer);
+  epeverMetricsPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "energy").c_str(), tmpJsonPayloadBuffer);
   // extra
-  //
+  // Extra
   epeverMetricsPayload["solar"]["extra"]["CO2"]["t"] = String(stats.s.c02Reduction / 100.f, 2);
   serializeJson(epeverMetricsPayload, tmpJsonPayloadBuffer);
   epeverMetricsPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "extra").c_str(), tmpJsonPayloadBuffer);
   // settings
-  //
+  // Settings
   epeverMetricsPayload["solar"]["monitor"]["settings"]["sleep"].set(sleepSeconds);
   controllerStatusPayload["solar"]["monitor"]["status"] = "offline";
   serializeJson(controllerStatusPayload, tmpJsonPayloadBuffer);
   controllerStatusPayload.clear();
   mqtt_client.publish((String(MQTT_TOPIC_PUB) + "/" + "status").c_str(), tmpJsonPayloadBuffer);
-  // ensure all messages are sent
+  // Ensure all messages are sent
   mqtt_client.unsubscribe(MQTT_TOPIC_SUB);
   mqtt_client.disconnect();
   while (mqtt_client.state() != -1) {
     delay(100);
   // power down MAX485_DE
   // low active
   digitalWrite(MAX485_RE, 0);
   digitalWrite(MAX485_DE, 0);
-  // DeepSleep n microseconds
-  //
+  // Sleep
-  Serial.print("\nDeepSleep for ");
+  Serial.print("\nSleep for ");
   Serial.print(sleepSeconds);
+  Serial.println(" Seconds");
+  digitalWrite(LED_BUILTIN, LOW);
-  Serial.println(" Seconds");
+#ifdef USE_DEEP_SLEEP
   if (USE_DEEP_SLEEP) {
     ESP.deepSleep(sleepSeconds * 1000000);
   } else {
     delay(sleepSeconds * 1000);
+  }
+#else
+  delay(sleepSeconds * 1000);
 #endif
+}