ESP32 Power Monitor

#include <Arduino.h>
#include <WiFi.h>
#include <PubSubClient.h>
#include <ModbusMaster.h>

// Network and MQTT settings supplied for this installation.

// Forward declarations
void beforeModbusTransmission();
void afterModbusTransmission();
bool readFloatInput(uint16_t oneBasedRegister, float &value);
void publishText(const char* topic, const char* payload, bool retained);
void ensureWiFi();
void ensureMqtt();
void pollAndPublish();

const char* WIFI_SSID = "DIRIS_MONITOR";
const char* WIFI_PASSWORD = "JUSTMONITOR";
const char* MQTT_HOST = "192.168.100.101";
const uint16_t MQTT_PORT = 8106;
const char* MQTT_USER = "root";
const char* MQTT_PASSWORD = "gadamonTE";

// ESP32 UART2 to the 3.3 V MAX3485 module.
const int RS485_RX_PIN = 16;  // MAX3485 RO
const int RS485_TX_PIN = 17;  // MAX3485 DI
const int RS485_DE_PIN = 25;  // MAX3485 DE, HIGH while transmitting
const int RS485_RE_PIN = 26;  // MAX3485 RE, LOW enables the receiver
const uint8_t DIRIS_SLAVE_ID = 1;
const uint32_t DIRIS_BAUD = 19200;

// DIRIS A20 measurement table: these are one-based Modbus input-register
// numbers. ModbusMaster uses zero-based addresses, hence the -1 below.
const uint16_t REG_VOLTAGE_L1 = 50514;
const uint16_t REG_VOLTAGE_L2 = 50516;
const uint16_t REG_VOLTAGE_L3 = 50518;
const uint16_t REG_CURRENT_L1 = 50520;
const uint16_t REG_CURRENT_L2 = 50522;
const uint16_t REG_CURRENT_L3 = 50524;
const uint16_t REG_ACTIVE_POWER_TOTAL = 50550;

HardwareSerial meterSerial(2);
ModbusMaster diris;
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);

unsigned long lastPollMs = 0;
unsigned long lastWiFiAttemptMs = 0;
unsigned long lastMqttAttemptMs = 0;
const unsigned long POLL_INTERVAL_MS = 5000;

void beforeModbusTransmission() {
  digitalWrite(RS485_RE_PIN, HIGH);  // turn off receiver while sending
  digitalWrite(RS485_DE_PIN, HIGH);  // enable RS485 driver
  delayMicroseconds(200);
}

void afterModbusTransmission() {
  meterSerial.flush();
  delayMicroseconds(200);
  digitalWrite(RS485_DE_PIN, LOW);  // release the shared RS485 pair
  digitalWrite(RS485_RE_PIN, LOW);  // listen for the meter reply
}

bool readFloatInput(uint16_t oneBasedRegister, float &value) {
  uint8_t result = diris.readInputRegisters(oneBasedRegister - 1, 2);
  if (result != diris.ku8MBSuccess) {
    Serial.printf("Modbus read %u failed: 0x%02X\n", oneBasedRegister, result);
    return false;
  }

  // DIRIS values are IEEE-754 float32 values, high 16-bit word first.
  uint32_t raw = (static_cast<uint32_t>(diris.getResponseBuffer(0)) << 16) |
                 diris.getResponseBuffer(1);
  memcpy(&value, &raw, sizeof(value));
  return isfinite(value);
}

void publishText(const char* topic, const char* payload, bool retained = false) {
  if (mqtt.connected()) {
    mqtt.publish(topic, payload, retained);
  }
}

void ensureWiFi() {
  if (WiFi.status() == WL_CONNECTED) return;
  if (millis() - lastWiFiAttemptMs < 10000) return;

  lastWiFiAttemptMs = millis();
  Serial.printf("Connecting to Wi-Fi %s\n", WIFI_SSID);
  WiFi.disconnect();
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}

void ensureMqtt() {
  if (WiFi.status() != WL_CONNECTED || mqtt.connected()) return;
  if (millis() - lastMqttAttemptMs < 5000) return;

  lastMqttAttemptMs = millis();
  String clientId = "diris-a20-" + String(static_cast<uint32_t>(ESP.getEfuseMac()), HEX);
  if (mqtt.connect(clientId.c_str(), MQTT_USER, MQTT_PASSWORD,
                   "diris_a20/status", 0, true, "offline")) {
    publishText("diris_a20/status", "online", true);
    Serial.println("MQTT connected");
  } else {
    Serial.printf("MQTT connection failed, state %d\n", mqtt.state());
  }
}

void pollAndPublish() {
  float v1, v2, v3, i1, i2, i3, power;
  bool ok = readFloatInput(REG_VOLTAGE_L1, v1) &&
            readFloatInput(REG_VOLTAGE_L2, v2) &&
            readFloatInput(REG_VOLTAGE_L3, v3) &&
            readFloatInput(REG_CURRENT_L1, i1) &&
            readFloatInput(REG_CURRENT_L2, i2) &&
            readFloatInput(REG_CURRENT_L3, i3) &&
            readFloatInput(REG_ACTIVE_POWER_TOTAL, power);

  if (!ok) {
    publishText("diris_a20/status", "modbus_read_error", true);
    return;
  }

  char payload[256];
  snprintf(payload, sizeof(payload),
           "{\"voltage_l1_v\":%.2f,\"voltage_l2_v\":%.2f,\"voltage_l3_v\":%.2f,"
           "\"current_l1_a\":%.3f,\"current_l2_a\":%.3f,\"current_l3_a\":%.3f,"
           "\"active_power_total_w\":%.2f}",
           v1, v2, v3, i1, i2, i3, power);
  publishText("diris_a20/telemetry", payload);
  publishText("diris_a20/status", "online", true);
  Serial.printf("Published: %s\n", payload);
}

void setup() {
  Serial.begin(115200);
  pinMode(RS485_DE_PIN, OUTPUT);
  pinMode(RS485_RE_PIN, OUTPUT);
  digitalWrite(RS485_DE_PIN, LOW);
  digitalWrite(RS485_RE_PIN, LOW);

  meterSerial.begin(DIRIS_BAUD, SERIAL_8N1, RS485_RX_PIN, RS485_TX_PIN);
  diris.begin(DIRIS_SLAVE_ID, meterSerial);
  diris.preTransmission(beforeModbusTransmission);
  diris.postTransmission(afterModbusTransmission);

  WiFi.mode(WIFI_STA);
  mqtt.setServer(MQTT_HOST, MQTT_PORT);
  ensureWiFi();
}

void loop() {
  ensureWiFi();
  ensureMqtt();
  if (mqtt.connected()) mqtt.loop();

  if (millis() - lastPollMs >= POLL_INTERVAL_MS) {
    lastPollMs = millis();
    if (mqtt.connected()) pollAndPublish();
  }
}