esp32.cpp

#if MODEM
#include <stdint.h>
#include <stdio.h>
int8_t InitialSoC = -1;                                                     // State of charge of car
int8_t FullSoC = -1;                                                        // SoC car considers itself fully charged
int8_t ComputedSoC = -1;                                                    // Estimated SoC, based on charged kWh
int8_t RemainingSoC = -1;                                                   // Remaining SoC, based on ComputedSoC
int32_t TimeUntilFull = -1;                                                 // Remaining time until car reaches FullSoC, in seconds
int32_t EnergyCapacity = -1;                                                // Car's total battery capacity
int32_t EnergyRequest = -1;                                                 // Requested amount of energy by car
char EVCCID[32];                                                            // Car's EVCCID (EV Communication Controller Identifer)
char RequiredEVCCID[32] = "";                                               // Required EVCCID before allowing charging
#endif

#ifdef SMARTEVSE_VERSION //ESP32

#include <ArduinoJson.h>
#include <SPI.h>
#include <Preferences.h>

#include <FS.h>
#include <LittleFS.h>

#include <WiFi.h>
#include "network_common.h"
#include "esp_ota_ops.h"
#include "mbedtls/md_internal.h"

#include <HTTPClient.h>
#include <ESPmDNS.h>
#include <Update.h>
#include <glcd.h>

#include <Logging.h>
#include <ModbusServerRTU.h>        // Slave/node
#include <ModbusClientRTU.h>        // Master
#include <time.h>

#include <soc/sens_reg.h>
#include <soc/sens_struct.h>
#include <driver/adc.h>
#include <esp_adc_cal.h>
#include <soc/rtc_io_struct.h>

#include "esp32.h"
#include "glcd.h"
#include "utils.h"
#include "OneWire.h"
#include "OneWireESP32.h"
#include "modbus.h"
#include "meter.h"
#include "evse_bridge.h"
#include "solar_debug_json.h"
#include "session_log.h"
#include "diag_sampler.h"
#include "diag_storage.h"
#include "mqtt_parser.h"
#include "mqtt_publish.h"
#include "http_api.h"
#include "capacity_peak.h"

//OCPP includes
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
#include <MicroOcpp.h>
#include <MicroOcppMongooseClient.h>
#include <MicroOcpp/Core/Configuration.h>
#include <MicroOcpp/Core/Context.h>
#include "ocpp_logic.h"
#include "ocpp_telemetry.h"
#endif //ENABLE_OCPP

#if SMARTEVSE_VERSION >= 40
#include <esp_sleep.h>
#include <driver/uart.h>

#include "wchisp.h"
#include "qca.h"

SPIClass QCA_SPI1(FSPI);  // The ESP32-S3 has two usable SPI busses FSPI and HSPI
SPIClass LCD_SPI2(HSPI);

/*    Commands send from ESP32 to CH32V203 over Uart
/    cmd        Name           Answer/data        Comments
/---------------------------------------------------------------------------------------------------------------------------------
/    Ver?    Version           0001              Version of CH32 software
/    Stat?   Status                              State, Amperage, PP pin, SSR outputs, ACT outputs, VCC enable, Lock input, RCM, Temperature, Error
/    Amp:    Set AMP           160               Set Chargecurrent A (*10)
/    Con:    Set Contactors    0-3               0= Both Off, 1= SSR1 ON, 2= SSR2 ON, 3= Both ON
/    Vcc:    Set VCC           0-1               0= VCC Off, 1= VCC ON
/    Sol:    Set Solenoid      0-3               0= Both Off, 1= LOCK_R ON, 2= LOCK_W ON, 3= Both ON (or only lock/unlock?)
/    Led:    Set Led color                       RGB, Fade speed, Blink
/    485:    Modbus data
/
/    Bij wegvallen ZC -> Solenoid unlock (indien locked)

*/


// Power Panic handler
// Shut down ESP to conserve the power we have left. RTC will automatically store powerdown timestamp
// We can store some important data in flash storage or the RTC chip (2 bytes)
//
void PowerPanicESP() {

    _LOG_D("Power Panic!\n");
    ledcWrite(LCD_CHANNEL, 0);                 // LCD Backlight off

    // Stop SPI bus, and set all QCA data lines low
    // TODO: store important information.

    gpio_wakeup_enable(GPIO_NUM_8, GPIO_INTR_LOW_LEVEL);
    esp_sleep_enable_gpio_wakeup();

    esp_light_sleep_start();
    // ESP32 is now in light sleep mode

    // It will re-enable everything as soon it has woken up again.
    // When using USB, you will have to unplug, and replug to re-establish the connection

    _LOG_D("Power Back up!\n");

    ledcWrite(LCD_CHANNEL, 50);                 // LCD Backlight on
}

extern void SendConfigToCH32(void);
#endif //SMARTEVSE_VERSION

#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
// Create a ModbusRTU server, client and bridge instance on Serial1
ModbusServerRTU MBserver(2000, PIN_RS485_DIR);     // TCP timeout set to 2000 ms
ModbusClientRTU MBclient(PIN_RS485_DIR);
static esp_adc_cal_characteristics_t * adc_chars_PP;
static esp_adc_cal_characteristics_t * adc_chars_Temperature;
extern ModbusMessage MBEVMeterResponse(ModbusMessage request);
#endif //SMARTEVSE_VERSION

hw_timer_t * timerA = NULL;
Preferences preferences;

#if DIAG_LOG
volatile uint32_t cpPulseCount = 0;  // Count CP rising edge interrupts
#endif

// delayed write settings - reduces flash wear by combining multiple writes into one
static bool SettingsDirty = false;                      // Flag indicating settings need to be written
static unsigned long LastSettingsWriteTime = 0;         // millis() timestamp of last write

// Cache structure for detecting changed values - only write values that actually changed
struct SettingsCache {
    uint8_t Config, Lock, Mode, AccessStatus;
    uint16_t CardOffset;
    uint32_t DelayedStartTime, DelayedStopTime;
    uint16_t DelayedRepeat;
    uint8_t LoadBl;
    uint16_t MaxMains, MaxSumMains, MaxSumMainsTime, MaxCurrent, MinCurrent, MaxCircuit;
    uint8_t Switch, RCmon;
    uint16_t StartCurrent, StopTime, ImportCurrent;
    uint8_t Grid, SB2_WIFImode, RFIDReader;
    uint8_t MainsMeterType, MainsMeterAddress, EVMeterType, EVMeterAddress, CircuitMeterType, CircuitMeterAddress;
    uint16_t MaxCircuitMains;
    uint8_t EMEndianness, EMIDivisor, EMUDivisor, EMPDivisor, EMEDivisor, EMDataType, EMFunction;
    uint16_t EMIRegister, EMURegister, EMPRegister, EMERegister;
    uint8_t WIFImode;
    uint16_t EnableC2;
#if MODEM
    char RequiredEVCCID[32];
#endif
    uint16_t maxTemp;
    uint8_t PrioStrategy;
    uint16_t RotationInterval;
    uint16_t IdleTimeout;
    uint8_t AutoUpdate, LCDlock, CableLock;
    uint16_t LCDPin;
    bool MQTTSmartServer;
#if MQTT
    bool MQTTChangeOnly;
    uint16_t MQTTHeartbeat;
#endif
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION)
    uint8_t OcppMode;
#endif
    uint16_t CapacityLimit;
    bool valid;  // True once cache is populated from read_settings()
};
static SettingsCache settingsCache = {};

// MQTT change-only publishing cache and settings
#if MQTT
mqtt_cache_t mqtt_cache;
bool MQTTChangeOnly = true;               // Master toggle: true = change-only, false = publish all
uint16_t MQTTHeartbeat = 60;              // Heartbeat interval (seconds) for unchanged values
static uint32_t MQTTMsgCount = 0;         // Count of MQTT messages published since boot
#endif

// Macros to only write if value changed
#define PREFS_PUT_UCHAR_IF_CHANGED(key, value, cacheVar) \
    if (!settingsCache.valid || (value) != settingsCache.cacheVar) { \
        preferences.putUChar(key, value); \
        settingsCache.cacheVar = (value); \
    }

#define PREFS_PUT_USHORT_IF_CHANGED(key, value, cacheVar) \
    if (!settingsCache.valid || (value) != settingsCache.cacheVar) { \
        preferences.putUShort(key, value); \
        settingsCache.cacheVar = (value); \
    }

#define PREFS_PUT_ULONG_IF_CHANGED(key, value, cacheVar) \
    if (!settingsCache.valid || (value) != settingsCache.cacheVar) { \
        preferences.putULong(key, value); \
        settingsCache.cacheVar = (value); \
    }

#define PREFS_PUT_BOOL_IF_CHANGED(key, value, cacheVar) \
    if (!settingsCache.valid || (value) != settingsCache.cacheVar) { \
        preferences.putBool(key, value); \
        settingsCache.cacheVar = (value); \
    }

uint16_t LCDPin = 0;                                                        // PINcode to operate LCD keys from web-interface
uint8_t PIN_SW_IN, PIN_ACTA, PIN_ACTB, PIN_RCM_FAULT, PIN_RS485_RX; //these pins have to be assigned dynamically because of hw version v3.1

extern esp_adc_cal_characteristics_t * adc_chars_CP;
extern void setStatePowerUnavailable(void);
extern char IsCurrentAvailable(void);
extern uint8_t Force_Single_Phase_Charging(void);
extern unsigned char RFID[8];
extern uint8_t pilot;

extern const char StrStateName[15][13];
const char StrStateNameWeb[15][17] = {"Ready to Charge", "Connected to EV", "Charging", "D", "Request State B", "State B OK", "Request State C", "State C OK", "Activate", "Charging Stopped", "Stop Charging", "Modem Setup", "Modem Request", "Modem Done", "Modem Denied"};
const char StrErrorNameWeb[9][20] = {"None", "No Power Available", "Communication Error", "Temperature High", "EV Meter Comm Error", "RCM Tripped", "RCM Test", "Test IO", "Flash Error"};
const char StrMode[3][8] = {"Normal", "Smart", "Solar"};
const char StrRFIDStatusWeb[8][20] = {"Ready to read card","Present", "Card Stored", "Card Deleted", "Card already stored", "Card not in storage", "Card Storage full", "Invalid" };
extern const char StrRFIDReader[7][10] = {"Disabled", "EnableAll", "EnableOne", "Learn", "Delete", "DeleteAll", "Rmt/OCPP"};
bool BuzzerPresent = false;

// The following data will be updated by eeprom/storage data at powerup:
extern uint16_t MaxMains;
extern uint16_t MaxCircuitMains;
extern uint16_t MaxSumMains;
                                                                            // see https://github.com/serkri/SmartEVSE-3/issues/215
                                                                            // 0 means disabled, allowed value 10 - 600 A
extern uint8_t MaxSumMainsTime;
extern uint16_t MaxSumMainsTimer;
extern uint16_t GridRelayMaxSumMains;
                                                                            // Meant to obey par 14a of Energy Industry Act, where the provider can switch a device
                                                                            // down to 4.2kW by a relay connected to the "switch" connectors.
                                                                            // you will have to set the "Switch" setting to "GridRelay",
                                                                            // and connect the relay to the switch terminals
                                                                            // When the relay opens its contacts, power will be reduced to 4.2kW
                                                                            // The relay is only allowed on the Master
extern bool CustomButton;
extern uint16_t CapacityLimit;
extern capacity_state_t CapacityState;
extern uint16_t MaxCurrent;
extern uint16_t MinCurrent;
extern uint8_t Mode;
extern uint32_t CurrentPWM;
extern void SetCurrent(uint16_t current);

extern bool CPDutyOverride;
extern uint8_t Lock;
extern uint16_t MaxCircuit;
extern uint8_t Config;
extern uint8_t Switch;
                                                                            // 3:Smart-Solar B / 4:Smart-Solar S / 5: Grid Relay
                                                                            // 6:Custom B / 7:Custom S)
                                                                            // B=momentary push <B>utton, S=toggle <S>witch
extern uint8_t RCmon;
extern uint8_t AutoUpdate;
extern uint16_t StartCurrent;
extern uint16_t StopTime;
extern uint16_t ImportCurrent;
extern struct DelayedTimeStruct DelayedStopTime;
extern uint8_t DelayedRepeat;
extern uint8_t LCDlock;
extern uint8_t Lock;
extern uint8_t CableLock;
extern EnableC2_t EnableC2;
extern uint8_t RFIDReader;

extern uint16_t maxTemp;
extern uint8_t PrioStrategy;
extern uint16_t RotationInterval;
extern uint16_t IdleTimeout;
extern uint32_t ConnectedTime[];
extern uint8_t ScheduleState[];
extern uint16_t RotationTimer;

extern uint16_t MaxCapacity;                                                       // Cable limit (A) (limited by the wire in the charge cable, set automatically, or manually if Config=Fixed Cable)
extern uint16_t ChargeCurrent;                                                     // Calculated Charge Current (Amps *10)
extern uint16_t OverrideCurrent;

// Load Balance variables
extern int16_t IsetBalanced;
extern uint16_t Balanced[NR_EVSES];
#if SMARTEVSE_VERSION < 40 //v3
extern uint16_t BalancedMax[NR_EVSES];
extern uint8_t BalancedState[NR_EVSES];
extern uint16_t BalancedError[NR_EVSES];
#endif

extern Node_t Node[NR_EVSES];
extern uint16_t BacklightTimer;
extern uint8_t BacklightSet;
extern int8_t TempEVSE;
String PairingPin = "";
SemaphoreHandle_t buttonMutex = xSemaphoreCreateMutex();
uint8_t ButtonStateOverride = 0x07;                                         // Possibility to override the buttons via API
uint32_t LastBtnOverrideTime = 0;                                           // Avoid UI buttons getting stuck
bool LCDPasswordOK = false;                                                 // LCD web control PIN verification state
extern uint8_t ChargeDelay;
extern uint8_t NoCurrent;
extern uint8_t ModbusRequest;
extern uint16_t CardOffset;

extern uint8_t ConfigChanged;

extern uint16_t SolarStopTimer;
extern uint8_t State;
extern uint8_t ErrorFlags;
extern uint8_t LoadBl;
extern AccessStatus_t AccessStatus;
extern uint8_t Nr_Of_Phases_Charging;

extern uint8_t ActivationMode, ActivationTimer;
extern volatile uint16_t adcsample;
extern volatile uint16_t ADCsamples[25];                                           // declared volatile, as they are used in a ISR
extern volatile uint8_t sampleidx;
extern char str[20];

extern int phasesLastUpdate;
extern bool phasesLastUpdateFlag;
extern int16_t IrmsOriginal[3];
extern int16_t homeBatteryCurrent;
extern time_t homeBatteryLastUpdate;
// set by EXTERNAL logic through MQTT/REST to indicate cheap tariffs ahead until unix time indicated
extern uint8_t ColorOff[3] ;
extern uint8_t ColorNormal[3] ;
extern uint8_t ColorSmart[3] ;
extern uint8_t ColorSolar[3] ;
extern uint8_t ColorCustom[3];

#define FW_UPDATE_DELAY 3600                                                    // time between detection of new version and actual update in seconds
extern uint16_t firmwareUpdateTimer;
                                                                                // 0 means timer inactive
                                                                                // 0 < timer < FW_UPDATE_DELAY means we are in countdown for an actual update
                                                                                // FW_UPDATE_DELAY <= timer <= 0xffff means we are in countdown for checking
                                                                                //                                              whether an update is necessary
extern OneWire32& ds();

#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
extern unsigned char OcppRfidUuid [7];
extern size_t OcppRfidUuidLen;
extern unsigned long OcppLastRfidUpdate;
extern unsigned long OcppTrackLastRfidUpdate;

extern bool OcppForcesLock;
extern std::shared_ptr<MicroOcpp::Configuration> OcppUnlockConnectorOnEVSideDisconnect; // OCPP Config for RFID-based transactions: if false, demand same RFID card again to unlock connector
extern std::shared_ptr<MicroOcpp::Transaction> OcppLockingTx; // Transaction which locks connector until same RFID card is presented again

extern bool OcppTrackPermitsCharge;
extern bool OcppTrackAccessBit;
extern uint8_t OcppTrackCPvoltage;
extern MicroOcpp::MOcppMongooseClient *OcppWsClient;

extern float OcppCurrentLimit;
extern bool OcppWasStandalone;
extern ocpp_telemetry_t OcppTelemetry;

extern unsigned long OcppStopReadingSyncTime; // Stop value synchronization: delay StopTransaction by a few seconds so it reports an accurate energy reading

extern bool OcppDefinedTxNotification;
extern MicroOcpp::TxNotification OcppTrackTxNotification;
extern unsigned long OcppLastTxNotification;
#endif //ENABLE_OCPP


#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
// Some low level stuff here to setup the ADC, and perform the conversion.
//
//
uint16_t IRAM_ATTR local_adc1_read(int channel) {
    uint16_t adc_value;

    SENS.sar_read_ctrl.sar1_dig_force = 0;                      // switch SARADC into RTC channel 
    SENS.sar_meas_wait2.force_xpd_sar = SENS_FORCE_XPD_SAR_PU;  // adc_power_on
    RTCIO.hall_sens.xpd_hall = false;                           // disable other peripherals
    
    //adc_ll_amp_disable()  // Close ADC AMP module if don't use it for power save.
    SENS.sar_meas_wait2.force_xpd_amp = SENS_FORCE_XPD_AMP_PD;  // channel is set in the convert function
    // disable FSM, it's only used by the LNA.
    SENS.sar_meas_ctrl.amp_rst_fb_fsm = 0; 
    SENS.sar_meas_ctrl.amp_short_ref_fsm = 0;
    SENS.sar_meas_ctrl.amp_short_ref_gnd_fsm = 0;
    SENS.sar_meas_wait1.sar_amp_wait1 = 1;
    SENS.sar_meas_wait1.sar_amp_wait2 = 1;
    SENS.sar_meas_wait2.sar_amp_wait3 = 1; 

    // adc_hal_set_controller(ADC_NUM_1, ADC_CTRL_RTC);         //Set controller
    // see esp-idf/components/hal/esp32/include/hal/adc_ll.h
    SENS.sar_read_ctrl.sar1_dig_force       = 0;                // 1: Select digital control;       0: Select RTC control.
    SENS.sar_meas_start1.meas1_start_force  = 1;                // 1: SW control RTC ADC start;     0: ULP control RTC ADC start.
    SENS.sar_meas_start1.sar1_en_pad_force  = 1;                // 1: SW control RTC ADC bit map;   0: ULP control RTC ADC bit map;
    SENS.sar_touch_ctrl1.xpd_hall_force     = 1;                // 1: SW control HALL power;        0: ULP FSM control HALL power.
    SENS.sar_touch_ctrl1.hall_phase_force   = 1;                // 1: SW control HALL phase;        0: ULP FSM control HALL phase.

    // adc_hal_convert(ADC_NUM_1, channel, &adc_value);
    // see esp-idf/components/hal/esp32/include/hal/adc_ll.h
    SENS.sar_meas_start1.sar1_en_pad = (1 << channel);          // select ADC channel to sample on
    while (SENS.sar_slave_addr1.meas_status != 0);              // wait for conversion to be idle (blocking)
    SENS.sar_meas_start1.meas1_start_sar = 0;         
    SENS.sar_meas_start1.meas1_start_sar = 1;                   // start ADC conversion
    while (SENS.sar_meas_start1.meas1_done_sar == 0);           // wait (blocking) for conversion to finish
    adc_value = SENS.sar_meas_start1.meas1_data_sar;            // read ADC value from register

    return adc_value;
}



// CP pin low to high transition ISR
//
//
void IRAM_ATTR onCPpulse() {

  // reset timer, these functions are in IRAM !
  timerWrite(timerA, 0);
  timerAlarmEnable(timerA);
#if DIAG_LOG
  cpPulseCount++;
#endif
}



// Timer interrupt handler
// in STATE A this is called every 1ms (autoreload)
// in STATE B/C there is a PWM signal, and the Alarm is set to 5% after the low-> high transition of the PWM signal
void IRAM_ATTR onTimerA() {

  RTC_ENTER_CRITICAL();
  adcsample = local_adc1_read(ADC1_CHANNEL_3);

  RTC_EXIT_CRITICAL();

  ADCsamples[sampleidx++] = adcsample;
  if (sampleidx == 25) sampleidx = 0;
}

#endif //SMARTEVSE_VERSION

// --------------------------- END of ISR's -----------------------------------------------------

#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
// Inverse function of SetCurrent (for monitoring and debugging purposes)
uint16_t GetCurrent() {
    uint32_t DutyCycle = CurrentPWM;

    if (DutyCycle < 102) {
        return 0; //PWM off or ISO15118 modem enabled
    } else if (DutyCycle < 870) {
        return (DutyCycle * 1000 / 1024) * 0.6 + 1; // invert duty cycle formula + fixed rounding error correction
    } else if (DutyCycle <= 983) {
        return ((DutyCycle * 1000 / 1024)- 640) * 2.5 + 3; // invert duty cycle formula + fixed rounding error correction
    } else {
        return 0; //constant +12V
    }
}
#endif //ENABLE_OCPP


#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
// Sample the Temperature sensor.
//
int8_t TemperatureSensor() {
    uint32_t sample, voltage;
    signed char Temperature;

    RTC_ENTER_CRITICAL();
    // Sample Temperature Sensor
    sample = local_adc1_read(ADC1_CHANNEL_0);
    RTC_EXIT_CRITICAL();

    // voltage range is from 0-2200mV 
    voltage = esp_adc_cal_raw_to_voltage(sample, adc_chars_Temperature);

    // The MCP9700A temperature sensor outputs 500mV at 0C, and has a 10mV/C change in output voltage.
    // so 750mV is 25C, 400mV = -10C
    Temperature = (signed int)(voltage - 500)/10;
    //_LOG_A("\nTemp: %i C (%u mV) ", Temperature , voltage);
    
    return Temperature;
}

// Sample the Proximity Pin, and determine the maximum current the cable can handle.
//
uint8_t ProximityPin() {
    uint32_t sample, voltage;
    uint8_t MaxCap = 13;                                               // No resistor, Max cable current = 13A

    RTC_ENTER_CRITICAL();
    // Sample Proximity Pilot (PP)
    sample = local_adc1_read(ADC1_CHANNEL_6);
    RTC_EXIT_CRITICAL();

    voltage = esp_adc_cal_raw_to_voltage(sample, adc_chars_PP);

    if (!Config) {                                                          // Configuration (0:Socket / 1:Fixed Cable)
        //socket
        _LOG_A("PP pin: %u (%u mV)\n", sample, voltage);
    } else {
        //fixed cable
        _LOG_A("PP pin: %u (%u mV) (warning: fixed cable configured so PP probably disconnected, making this reading void)\n", sample, voltage);
    }

    if ((voltage > 1200) && (voltage < 1400)) MaxCap = 16;             // Max cable current = 16A	680R -> should be around 1.3V
    if ((voltage > 500) && (voltage < 700)) MaxCap = 32;               // Max cable current = 32A	220R -> should be around 0.6V
    if ((voltage > 200) && (voltage < 400)) MaxCap = 63;               // Max cable current = 63A	100R -> should be around 0.3V

    if (Config) MaxCap = MaxCurrent;                                   // Override with MaxCurrent when Fixed Cable is used.
    return MaxCap;
}
#endif


/**
 * Get name of a state
 *
 * @param uint8_t State
 * @return uint8_t[] Name
 */
const char * getStateName(uint8_t StateCode) {
    if(StateCode < 15) return StrStateName[StateCode];
    else return "NOSTATE";
}


const char * getStateNameWeb(uint8_t StateCode) {
    if(StateCode < 15) return StrStateNameWeb[StateCode];
    else return "NOSTATE";    
}


uint8_t getErrorId(uint8_t ErrorCode) {
    uint8_t count = 0;
    //find the error bit that is set
    while (ErrorCode) {
        count++;
        ErrorCode = ErrorCode >> 1;
    }    
    return count;
}


const char * getErrorNameWeb(uint8_t ErrorCode) {
    uint8_t count = 0;
    count = getErrorId(ErrorCode);
    if(count < 9) return StrErrorNameWeb[count];
    else return "Multiple Errors";
}


void getButtonState() {
    // Sample the three < o > buttons.
    // As the buttons are shared with the SPI lines going to the LCD,
    // we have to make sure that this does not interfere by write actions to the LCD.
    // Therefore updating the LCD is also done in this task.
    xSemaphoreTake(buttonMutex, portMAX_DELAY);
    if (ButtonStateOverride != 7 && millis() - LastBtnOverrideTime < 4000)
        ButtonState = ButtonStateOverride;
    else {
#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
        pinMatrixOutDetach(PIN_LCD_SDO_B3, false, false);       // disconnect MOSI pin
        pinMode(PIN_LCD_SDO_B3, INPUT);
        pinMode(PIN_LCD_A0_B2, INPUT);

        // sample buttons                                                         < o >
        ButtonState = (digitalRead(PIN_LCD_SDO_B3) ? 4 : 0) |  // > (right)
                      (digitalRead(PIN_LCD_A0_B2)  ? 2 : 0) |  // o (middle)
                      (digitalRead(PIN_IO0_B1)     ? 1 : 0);   // < (left)

        pinMode(PIN_LCD_SDO_B3, OUTPUT);
        pinMatrixOutAttach(PIN_LCD_SDO_B3, VSPID_IN_IDX, false, false); // re-attach MOSI pin
#else
        pinMode(PIN_LCD_A0_B2, INPUT_PULLUP);                  // Switch the shared pin for the middle button to input
        ButtonState = (digitalRead(BUTTON3)        ? 4 : 0) |  // > (right)
                      (digitalRead(PIN_LCD_A0_B2)  ? 2 : 0) |  // o (middle)
                      (digitalRead(BUTTON1)        ? 1 : 0);   // < (left)
#endif
        pinMode(PIN_LCD_A0_B2, OUTPUT);                        // switch pin back to output
    }
    xSemaphoreGive(buttonMutex);
}


String readMqttCaCert() {
    if (!LittleFS.exists("/mqtt_ca.pem")) {
        _LOG_A("No /mqtt_ca.pem found.\n");
        return "";
    }
    File file = LittleFS.open("/mqtt_ca.pem", "r");
    if (!file) {
        _LOG_A("Failed to open /mqtt_ca.pem for reading.\n");
        return "";
    }
    String cert = file.readString();
    file.close();
    return cert;
}

void writeMqttCaCert(const String& cert) {
    if (cert.isEmpty()) {
        LittleFS.remove("/mqtt_ca.pem");
        _LOG_D("Removed /mqtt_ca.pem.\n");
        return;
    }
    File file = LittleFS.open("/mqtt_ca.pem", "w");
    if (!file) {
        _LOG_A("Failed to open /mqtt_ca.pem for writing.\n");
        return;
    }
    file.print(cert);
    file.close();
    _LOG_D("Wrote %d bytes to /mqtt_ca.pem.\n", cert.length());
}

#if MQTT
static void mqttSetSolarDebug(bool enabled);  // forward declaration

void mqtt_receive_callback(const String topic, const String payload) {
    mqtt_command_t cmd;
    if (!mqtt_parse_command(MQTTprefix.c_str(), topic.c_str(), payload.c_str(), &cmd))
        return;

    uint8_t *color_target = NULL; // used by MQTT_CMD_COLOR

    switch (cmd.cmd) {
        case MQTT_CMD_MODE:
            if (cmd.mode == MQTT_MODE_OFF) {
#if SMARTEVSE_VERSION >= 40
                Serial1.printf("@ResetModemTimers\n");
#endif
                setAccess(OFF);
            } else if (cmd.mode == MQTT_MODE_PAUSE) {
                setAccess(PAUSE);
            } else if (cmd.mode == MQTT_MODE_SOLAR) {
                setOverrideCurrent(0);
                setMode(cmd.mode);
            } else {
                setMode(cmd.mode);
            }
            break;

        case MQTT_CMD_CUSTOM_BUTTON:
            CustomButton = cmd.custom_button;
            break;

        case MQTT_CMD_CURRENT_OVERRIDE:
            if (cmd.current_override == 0) {
                setOverrideCurrent(0);
            } else if (LoadBl < 2 && (Mode == MODE_NORMAL || Mode == MODE_SMART)) {
                if (cmd.current_override >= (MinCurrent * 10) && cmd.current_override <= (MaxCurrent * 10)) {
                    setOverrideCurrent(cmd.current_override);
                }
            }
            break;

        case MQTT_CMD_MAX_SUM_MAINS:
            if (LoadBl < 2)
                MaxSumMains = cmd.max_sum_mains;
            break;

        case MQTT_CMD_CP_PWM_OVERRIDE:
            if (cmd.cp_pwm == -1) {
                SetCPDuty(1024);
                PILOT_CONNECTED;
                CPDutyOverride = false;
            } else if (cmd.cp_pwm == 0) {
                SetCPDuty(0);
                PILOT_DISCONNECTED;
                CPDutyOverride = true;
            } else {
                SetCPDuty(cmd.cp_pwm);
                PILOT_CONNECTED;
                CPDutyOverride = true;
            }
            break;

        case MQTT_CMD_MAINS_METER:
            if (MainsMeter.Type != EM_API || LoadBl >= 2)
                return;
#if SMARTEVSE_VERSION < 40
            if (LoadBl < 2) {
                MainsMeter.setTimeout(COMM_TIMEOUT);
                MainsMeter.Irms[0] = cmd.mains_meter.L1;
                MainsMeter.Irms[1] = cmd.mains_meter.L2;
                MainsMeter.Irms[2] = cmd.mains_meter.L3;
                CalcIsum();
            }
#else
            Serial1.printf("@Irms:%03u,%d,%d,%d\n", MainsMeter.Address,
                           (int)cmd.mains_meter.L1, (int)cmd.mains_meter.L2, (int)cmd.mains_meter.L3);
#endif
            break;

        case MQTT_CMD_EV_METER:
            if (EVMeter.Type != EM_API)
                return;
            if ((cmd.ev_meter.L1 > -1 && cmd.ev_meter.L1 < 1000) &&
                (cmd.ev_meter.L2 > -1 && cmd.ev_meter.L2 < 1000) &&
                (cmd.ev_meter.L3 > -1 && cmd.ev_meter.L3 < 1000)) {
#if SMARTEVSE_VERSION < 40
                EVMeter.Irms[0] = cmd.ev_meter.L1;
                EVMeter.Irms[1] = cmd.ev_meter.L2;
                EVMeter.Irms[2] = cmd.ev_meter.L3;
                EVMeter.CalcImeasured();
                EVMeter.Timeout = COMM_EVTIMEOUT;
#else
                Serial1.printf("@Irms:%03u,%d,%d,%d\n", EVMeter.Address,
                               (int)cmd.ev_meter.L1, (int)cmd.ev_meter.L2, (int)cmd.ev_meter.L3);
#endif
            }
            if (cmd.ev_meter.W > -1) {
#if SMARTEVSE_VERSION < 40
                EVMeter.PowerMeasured = cmd.ev_meter.W;
#else
                Serial1.printf("@PowerMeasured:%03u,%d\n", EVMeter.Address, (int)cmd.ev_meter.W);
#endif
            }
            if (cmd.ev_meter.Wh > -1) {
                EVMeter.Import_active_energy = cmd.ev_meter.Wh;
                EVMeter.Export_active_energy = 0;
                EVMeter.UpdateEnergies();
            }
            break;

        case MQTT_CMD_HOME_BATTERY_CURRENT:
            if (LoadBl >= 2)
                return;
            homeBatteryCurrent = cmd.home_battery_current;
            homeBatteryLastUpdate = time(NULL);
#if SMARTEVSE_VERSION >= 40
            SEND_TO_CH32(homeBatteryCurrent);
#endif
            break;

        case MQTT_CMD_REQUIRED_EVCCID:
#if MODEM
            strncpy(RequiredEVCCID, cmd.evccid, sizeof(RequiredEVCCID));
            Serial1.printf("@RequiredEVCCID:%s\n", RequiredEVCCID);
            request_write_settings();
#endif
            break;

        case MQTT_CMD_COLOR:
            switch (cmd.color.index) {
                case MQTT_COLOR_OFF:    color_target = ColorOff;    break;
                case MQTT_COLOR_NORMAL: color_target = ColorNormal; break;
                case MQTT_COLOR_SMART:  color_target = ColorSmart;  break;
                case MQTT_COLOR_SOLAR:  color_target = ColorSolar;  break;
                case MQTT_COLOR_CUSTOM: color_target = ColorCustom; break;
                default: return;
            }
            color_target[0] = cmd.color.r;
            color_target[1] = cmd.color.g;
            color_target[2] = cmd.color.b;
            break;

        case MQTT_CMD_CABLE_LOCK:
            CableLock = cmd.cable_lock;
            request_write_settings();
            break;

        case MQTT_CMD_ENABLE_C2:
            EnableC2 = (EnableC2_t)cmd.enable_c2;
            request_write_settings();
            break;

        case MQTT_CMD_PRIO_STRATEGY:
            if (LoadBl < 2) {
                setItemValue(MENU_PRIO, cmd.prio_strategy);
                request_write_settings();
            }
            break;

        case MQTT_CMD_ROTATION_INTERVAL:
            if (LoadBl < 2) {
                setItemValue(MENU_ROTATION, cmd.rotation_interval);
                request_write_settings();
            }
            break;

        case MQTT_CMD_IDLE_TIMEOUT:
            if (LoadBl < 2) {
                setItemValue(MENU_IDLE_TIMEOUT, cmd.idle_timeout);
                request_write_settings();
            }
            break;

        case MQTT_CMD_MQTT_HEARTBEAT:
            MQTTHeartbeat = cmd.mqtt_heartbeat;
            mqtt_cache.heartbeat_s = MQTTHeartbeat;
            request_write_settings();
            break;

        case MQTT_CMD_MQTT_CHANGE_ONLY:
            MQTTChangeOnly = cmd.mqtt_change_only;
            request_write_settings();
            break;

        case MQTT_CMD_SOLAR_DEBUG:
            mqttSetSolarDebug(cmd.solar_debug);
            break;

        // BEGIN PLAN-06: Diagnostic telemetry
        case MQTT_CMD_DIAG_PROFILE:
            if (cmd.diag_profile == 0)
                diag_stop();
            else
                diag_start((diag_profile_t)cmd.diag_profile);
            break;
        // END PLAN-06

        // BEGIN PLAN-13: Capacity tariff limit
        case MQTT_CMD_CAPACITY_LIMIT:
            CapacityLimit = cmd.capacity_limit;
            capacity_set_limit(&CapacityState, (int32_t)CapacityLimit);
            request_write_settings();
            break;
        // END PLAN-13

        // BEGIN PLAN-09: API staleness timeout
        case MQTT_CMD_MAINS_METER_TIMEOUT:
            // Applied via bridge layer to evse_ctx.api_mains_timeout
            break;
        // END PLAN-09

        // BEGIN PLAN-14: CircuitMeter MQTT commands
        case MQTT_CMD_MAX_CIRCUIT_MAINS:
            if (LoadBl < 2)
                MaxCircuitMains = cmd.max_circuit_mains;
            break;

        case MQTT_CMD_CIRCUIT_METER:
            if (CircuitMeter.Type != EM_API || LoadBl >= 2)
                return;
#if SMARTEVSE_VERSION < 40
            CircuitMeter.setTimeout(COMM_TIMEOUT);
            CircuitMeter.Irms[0] = cmd.circuit_meter.L1;
            CircuitMeter.Irms[1] = cmd.circuit_meter.L2;
            CircuitMeter.Irms[2] = cmd.circuit_meter.L3;
            CircuitMeter.CalcImeasured();
#else
            Serial1.printf("@Irms:%03u,%d,%d,%d\n", CircuitMeter.Address,
                           (int)cmd.circuit_meter.L1, (int)cmd.circuit_meter.L2, (int)cmd.circuit_meter.L3);
#endif
            break;
        // END PLAN-14

        // BEGIN PLAN-09: HomeWizard manual IP fallback
        case MQTT_CMD_HOMEWIZARD_IP:
            homeWizardManualIP = cmd.homewizard_ip;
            // Clear cached mDNS result so next poll uses the new IP
            homeWizardHost = "";
            _LOG_A("HomeWizard manual IP set to '%s'\n", cmd.homewizard_ip);
            break;
        // END PLAN-09

        // BEGIN PLAN-15: SoC MQTT commands
#if MODEM
        case MQTT_CMD_INITIAL_SOC:
            InitialSoC = cmd.initial_soc;
            RecomputeSoC();
            break;
        case MQTT_CMD_FULL_SOC:
            FullSoC = cmd.full_soc;
            RecomputeSoC();
            break;
        case MQTT_CMD_ENERGY_CAPACITY:
            EnergyCapacity = cmd.energy_capacity;
            RecomputeSoC();
            break;
        case MQTT_CMD_ENERGY_REQUEST:
            EnergyRequest = cmd.energy_request;
            RecomputeSoC();
            break;
        case MQTT_CMD_EVCCID_SET:
            strncpy(EVCCID, cmd.evccid, sizeof(EVCCID) - 1);
            EVCCID[sizeof(EVCCID) - 1] = '\0';
            break;
#endif
        // END PLAN-15

        default:
            return;
    }

    // Handle RFID via MQTT (not part of mqtt_parser — uses Arduino String for hex parsing)
    if (topic == MQTTprefix + "/Set/RFID") {
        // Accept RFID card via MQTT to start/stop session
        // Payload should be hex string: 12 or 14 characters for 6 or 7 byte UID
        // Examples: "010203040506" (6 bytes) or "01020304050607" (7 bytes)
        uint8_t RFIDReader = getItemValue(MENU_RFIDREADER);
        if (!RFIDReader) {
            _LOG_A("RFID reader not enabled, ignoring MQTT RFID\n");
        } else {
            String hexString = payload;
            hexString.trim();

            // Check if payload is valid hex and correct length
            bool validHex = true;
            for (size_t i = 0; i < hexString.length(); i++) {
                if (!isxdigit(hexString[i])) {
                    validHex = false;
                    break;
                }
            }

            if (!validHex) {
                _LOG_A("Invalid RFID hex string received via MQTT: %s\n", hexString.c_str());
            } else if (hexString.length() == 12 || hexString.length() == 14) {
                // Parse hex string into RFID array
                memset(RFID, 0, 8);

                if (hexString.length() == 12) {
                    // 6 byte UID (old reader format, starts at RFID[1])
                    RFID[0] = 0x01; // Family code for old reader
                    for (int i = 0; i < 6; i++) {
                        RFID[i + 1] = (uint8_t)strtol(hexString.substring(i * 2, i * 2 + 2).c_str(), NULL, 16);
                    }
                    RFID[7] = crc8((unsigned char *)RFID, 7);
                } else {
                    // 7 byte UID (new reader format)
                    for (int i = 0; i < 7; i++) {
                        RFID[i] = (uint8_t)strtol(hexString.substring(i * 2, i * 2 + 2).c_str(), NULL, 16);
                    }
                    RFID[7] = crc8((unsigned char *)RFID, 7);
                }

                _LOG_A("RFID received via MQTT: %s\n", hexString.c_str());

                // Reset RFIDstatus so CheckRFID processes the card as new
                RFIDstatus = 0;

                // Process RFID using existing logic (whitelist check, OCPP, etc.)
                CheckRFID();
            } else {
                _LOG_A("Invalid RFID length received via MQTT (expected 12 or 14 hex chars): %s\n", hexString.c_str());
            }
        }
    }

    // Make sure MQTT updates directly to prevent debounces
    lastMqttUpdate = 10;
}


//print RFID in hex format
void printRFID(char *buf, size_t bufsize) {
    if (RFID[0] == 0x01) {  // old reader 6 byte UID starts at RFID[1]
        snprintf(buf, bufsize, "%02X%02X%02X%02X%02X%02X", RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
    } else {
        snprintf(buf, bufsize, "%02X%02X%02X%02X%02X%02X%02X", RFID[0], RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
    }
}


void SetupMQTTClient() {
    // Initialize MQTT change-only publish cache
    mqtt_cache_init(&mqtt_cache, MQTTHeartbeat);

    // Set up subscriptions
    MQTTclient.subscribe(MQTTprefix + "/Set/#",1);
    MQTTclient.publish(MQTTprefix+"/connected", "online", true, 0);

    //set the parameters for and announce sensors with device class 'current':
    String optional_payload = MQTTclient.jsna("device_class","current") + MQTTclient.jsna("state_class","measurement") + MQTTclient.jsna("unit_of_measurement","A") + MQTTclient.jsna("value_template", R"({{ value | int / 10 }})");
    MQTTclient.announce("Charge Current", "sensor", optional_payload);
    MQTTclient.announce("Max Current", "sensor", optional_payload);
    if (MainsMeter.Type) {
        MQTTclient.announce("Mains Current L1", "sensor", optional_payload);
        MQTTclient.announce("Mains Current L2", "sensor", optional_payload);
        MQTTclient.announce("Mains Current L3", "sensor", optional_payload);
    }
    if (EVMeter.Type) {
        MQTTclient.announce("EV Current L1", "sensor", optional_payload);
        MQTTclient.announce("EV Current L2", "sensor", optional_payload);
        MQTTclient.announce("EV Current L3", "sensor", optional_payload);
    }
    if (homeBatteryLastUpdate) {
        MQTTclient.announce("Home Battery Current", "sensor", optional_payload);
    }

    //set the parameters for and announce sensors with device class 'power':
    optional_payload = MQTTclient.jsna("device_class","power") + MQTTclient.jsna("state_class","measurement") + MQTTclient.jsna("unit_of_measurement","W");
    if (MainsMeter.Type) {
        MQTTclient.announce("Mains Power L1", "sensor", optional_payload);
        MQTTclient.announce("Mains Power L2", "sensor", optional_payload);
        MQTTclient.announce("Mains Power L3", "sensor", optional_payload);
    }
    if (EVMeter.Type) {
        MQTTclient.announce("EV Power L1", "sensor", optional_payload);
        MQTTclient.announce("EV Power L2", "sensor", optional_payload);
        MQTTclient.announce("EV Power L3", "sensor", optional_payload);
    }

#if MODEM
        //set the parameters for modem/SoC sensor entities:
        optional_payload = MQTTclient.jsna("unit_of_measurement","%") + MQTTclient.jsna("value_template", R"({{ none if (value | int == -1) else (value | int) }})");
        MQTTclient.announce("EV Initial SoC", "sensor", optional_payload);
        MQTTclient.announce("EV Full SoC", "sensor", optional_payload);
        MQTTclient.announce("EV Computed SoC", "sensor", optional_payload);
        MQTTclient.announce("EV Remaining SoC", "sensor", optional_payload);

        optional_payload = MQTTclient.jsna("device_class","duration") + MQTTclient.jsna("unit_of_measurement","m") + MQTTclient.jsna("value_template", R"({{ none if (value | int == -1) else (value | int / 60) | round }})");
        MQTTclient.announce("EV Time Until Full", "sensor", optional_payload);

        optional_payload = MQTTclient.jsna("device_class","energy") + MQTTclient.jsna("unit_of_measurement","Wh") + MQTTclient.jsna("value_template", R"({{ none if (value | int == -1) else (value | int) }})");
        MQTTclient.announce("EV Energy Capacity", "sensor", optional_payload);
        MQTTclient.announce("EV Energy Request", "sensor", optional_payload);

        optional_payload = MQTTclient.jsna("value_template", R"({{ none if (value == '') else value }})");
        MQTTclient.announce("EVCCID", "sensor", optional_payload);
        optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/RequiredEVCCID")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/RequiredEVCCID"));
        MQTTclient.announce("Required EVCCID", "text", optional_payload);
#endif

    optional_payload = MQTTclient.jsna("device_class","energy") + MQTTclient.jsna("unit_of_measurement","Wh") + MQTTclient.jsna("state_class","total_increasing");
    if (MainsMeter.Type) {
        MQTTclient.announce("Mains Import Active Energy", "sensor", optional_payload);
        MQTTclient.announce("Mains Export Active Energy", "sensor", optional_payload);
        MQTTclient.announce("Mains Energy L1", "sensor", optional_payload);
        MQTTclient.announce("Mains Energy L2", "sensor", optional_payload);
        MQTTclient.announce("Mains Energy L3", "sensor", optional_payload);
    }

    if (EVMeter.Type) {
        MQTTclient.announce("EV Import Active Energy", "sensor", optional_payload);
        MQTTclient.announce("EV Export Active Energy", "sensor", optional_payload);
        MQTTclient.announce("EV Energy L1", "sensor", optional_payload);
        MQTTclient.announce("EV Energy L2", "sensor", optional_payload);
        MQTTclient.announce("EV Energy L3", "sensor", optional_payload);
        //set the parameters for and MQTTclient.announce other sensor entities:
        optional_payload = MQTTclient.jsna("device_class","power") + MQTTclient.jsna("unit_of_measurement","W") + MQTTclient.jsna("state_class","measurement");
        MQTTclient.announce("EV Charge Power", "sensor", optional_payload);
        optional_payload = MQTTclient.jsna("device_class","energy") + MQTTclient.jsna("unit_of_measurement","Wh") + MQTTclient.jsna("state_class","total");
        MQTTclient.announce("EV Energy Charged", "sensor", optional_payload);
        optional_payload = MQTTclient.jsna("device_class","energy") + MQTTclient.jsna("unit_of_measurement","Wh") + MQTTclient.jsna("state_class","total_increasing");
        MQTTclient.announce("EV Total Energy Charged", "sensor", optional_payload);
    }

    // BEGIN PLAN-14: CircuitMeter HA discovery
    if (CircuitMeter.Type) {
        // Circuit current sensors
        optional_payload = MQTTclient.jsna("device_class","current") + MQTTclient.jsna("state_class","measurement") + MQTTclient.jsna("unit_of_measurement","A") + MQTTclient.jsna("value_template", R"({{ value | int / 10 }})");
        MQTTclient.announce("Circuit Current L1", "sensor", optional_payload);
        MQTTclient.announce("Circuit Current L2", "sensor", optional_payload);
        MQTTclient.announce("Circuit Current L3", "sensor", optional_payload);

        // Circuit power sensor
        optional_payload = MQTTclient.jsna("device_class","power") + MQTTclient.jsna("state_class","measurement") + MQTTclient.jsna("unit_of_measurement","W");
        MQTTclient.announce("Circuit Power", "sensor", optional_payload);

        // Circuit energy sensors
        optional_payload = MQTTclient.jsna("device_class","energy") + MQTTclient.jsna("unit_of_measurement","Wh") + MQTTclient.jsna("state_class","total_increasing");
        MQTTclient.announce("Circuit Import Energy", "sensor", optional_payload);
        MQTTclient.announce("Circuit Export Energy", "sensor", optional_payload);
    }

    // MaxCircuitMains number entity (always announced, even when CircuitMeter disabled)
    optional_payload = MQTTclient.jsna("device_class","current") + MQTTclient.jsna("unit_of_measurement","A") + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/MaxCircuitMains")) + MQTTclient.jsna("min", "0") + MQTTclient.jsna("max", "600") + MQTTclient.jsna("mode","box");
    MQTTclient.announce("Max Circuit Mains", "number", optional_payload);
    // END PLAN-14

    //set the parameters for and MQTTclient.announce sensor entities without device_class or unit_of_measurement:
    optional_payload = "";
    MQTTclient.announce("EV Plug State", "sensor", optional_payload);
    MQTTclient.announce("Access", "sensor", optional_payload);
    MQTTclient.announce("State", "sensor", optional_payload);
    MQTTclient.announce("RFID", "sensor", optional_payload);
    MQTTclient.announce("RFIDLastRead", "sensor", optional_payload);
    MQTTclient.announce("NrOfPhases", "sensor", optional_payload);

#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
    MQTTclient.announce("OCPP", "sensor", optional_payload);
    MQTTclient.announce("OCPPConnection", "sensor", optional_payload);
#endif //ENABLE_OCPP

    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/LEDColorOff")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/ColorOff"));
    MQTTclient.announce("LED Color Off", "text", optional_payload);
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/LEDColorNormal")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/ColorNormal"));
    MQTTclient.announce("LED Color Normal", "text", optional_payload);
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/LEDColorSmart")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/ColorSmart"));
    MQTTclient.announce("LED Color Smart", "text", optional_payload);
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/LEDColorSolar")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/ColorSolar"));
    MQTTclient.announce("LED Color Solar", "text", optional_payload);
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/LEDColorCustom")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/ColorCustom"));
    MQTTclient.announce("LED Color Custom", "text", optional_payload);
    
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/CustomButton")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CustomButton"));
    optional_payload += String(R"(, "options" : ["On", "Off"])");
    MQTTclient.announce("Custom Button", "select", optional_payload);

    optional_payload = MQTTclient.jsna("device_class","duration") + MQTTclient.jsna("unit_of_measurement","s") + MQTTclient.jsna("state_class","measurement");
    MQTTclient.announce("SolarStopTimer", "sensor", optional_payload);
    //set the parameters for and MQTTclient.announce diagnostic sensor entities:
    optional_payload = MQTTclient.jsna("entity_category","diagnostic");
    MQTTclient.announce("Error", "sensor", optional_payload);
    MQTTclient.announce("WiFi SSID", "sensor", optional_payload);
    MQTTclient.announce("WiFi BSSID", "sensor", optional_payload);
    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("device_class","signal_strength") + MQTTclient.jsna("unit_of_measurement","dBm") + MQTTclient.jsna("state_class","measurement");
    MQTTclient.announce("WiFi RSSI", "sensor", optional_payload);
    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("device_class","temperature") + MQTTclient.jsna("unit_of_measurement","°C") + MQTTclient.jsna("state_class","measurement");
    MQTTclient.announce("ESP Temp", "sensor", optional_payload);
    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("device_class","duration") + MQTTclient.jsna("unit_of_measurement","s") + MQTTclient.jsna("state_class","total_increasing") + MQTTclient.jsna("entity_registry_enabled_default","False");
    MQTTclient.announce("ESP Uptime", "sensor", optional_payload);
    optional_payload = MQTTclient.jsna("entity_category","diagnostic");
    MQTTclient.announce("LoadBl", "sensor", optional_payload);
    MQTTclient.announce("PairingPin", "sensor", optional_payload);
    MQTTclient.announce("Firmware Version", "sensor", optional_payload);
    // BEGIN PLAN-09: Metering diagnostic counters
    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("state_class","total_increasing") + MQTTclient.jsna("entity_registry_enabled_default","False");
    MQTTclient.announce("MeterTimeoutCount", "sensor", optional_payload);
    MQTTclient.announce("MeterRecoveryCount", "sensor", optional_payload);
    MQTTclient.announce("ApiStaleCount", "sensor", optional_payload);
    // END PLAN-09

#if MODEM
        optional_payload = MQTTclient.jsna("unit_of_measurement","%") + MQTTclient.jsna("value_template", R"({{ (value | int / 1024 * 100) | round(0) }})");
        MQTTclient.announce("CP PWM", "sensor", optional_payload);

        optional_payload = MQTTclient.jsna("value_template", R"({{ none if (value | int == -1) else (value | int / 1024 * 100) | round }})");
        optional_payload += MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CPPWMOverride")) + MQTTclient.jsna("min", "-1") + MQTTclient.jsna("max", "100") + MQTTclient.jsna("mode","slider");
        optional_payload += MQTTclient.jsna("command_template", R"({{ (value | int * 1024 / 100) | round }})");
        MQTTclient.announce("CP PWM Override", "number", optional_payload);
#endif
    //set the parameters for and MQTTclient.announce select entities, overriding automatic state_topic:
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/Mode")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/Mode"));
    optional_payload += String(R"(, "options" : ["Off", "Normal", "Smart", "Solar", "Pause"])");
    MQTTclient.announce("Mode", "select", optional_payload);

    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/EnableC2")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/EnableC2"));
    optional_payload += String(R"(, "options" : ["Not present", "Always Off", "Solar Off", "Always On", "Auto"])");
    MQTTclient.announce("EnableC2", "select", optional_payload);

    //set the parameters for and MQTTclient.announce number entities:
    optional_payload = MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CurrentOverride")) + MQTTclient.jsna("min", "0") + MQTTclient.jsna("max", MaxCurrent ) + MQTTclient.jsna("mode","slider");
    optional_payload += MQTTclient.jsna("value_template", R"({{ value | int / 10 if value | is_number else none }})") + MQTTclient.jsna("command_template", R"({{ value | int * 10 }})");
    MQTTclient.announce("Charge Current Override", "number", optional_payload);

    optional_payload = MQTTclient.jsna("device_class","current") + MQTTclient.jsna("unit_of_measurement","A") + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CurrentMaxSumMains")) + MQTTclient.jsna("min", "0") + MQTTclient.jsna("max", "600") + MQTTclient.jsna("mode","box");
    MQTTclient.announce("Current Max Sum Mains", "number", optional_payload);

    //set the parameters for and MQTTclient.announce Cable Lock:
    optional_payload = MQTTclient.jsna("cablelock_topic", String(MQTTprefix + "/CableLock")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CableLock"));
    optional_payload += String(R"(, "options" : ["0", "1"])");
    MQTTclient.announce("Cable Lock", "select", optional_payload);

    //set the parameters for and MQTTclient.announce priority scheduling entities:
    optional_payload = MQTTclient.jsna("state_topic", String(MQTTprefix + "/PrioStrategy")) + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/PrioStrategy"));
    optional_payload += String(R"(, "options" : ["0", "1", "2"])");
    MQTTclient.announce("Priority Strategy", "select", optional_payload);

    optional_payload = MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/RotationInterval")) + MQTTclient.jsna("min", "0") + MQTTclient.jsna("max", "1440") + MQTTclient.jsna("mode","box");
    optional_payload += MQTTclient.jsna("unit_of_measurement", "min");
    MQTTclient.announce("Rotation Interval", "number", optional_payload);

    optional_payload = MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/IdleTimeout")) + MQTTclient.jsna("min", "30") + MQTTclient.jsna("max", "300") + MQTTclient.jsna("mode","box");
    optional_payload += MQTTclient.jsna("unit_of_measurement", "s");
    MQTTclient.announce("Idle Timeout", "number", optional_payload);

    optional_payload = MQTTclient.jsna("entity_category","diagnostic");
    MQTTclient.announce("Rotation Timer", "sensor", optional_payload);

    optional_payload = MQTTclient.jsna("entity_category","diagnostic");
    MQTTclient.announce("Schedule State", "sensor", optional_payload);

    // Diagnostic: free heap and MQTT message counter
    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("unit_of_measurement","B") + MQTTclient.jsna("state_class","measurement") + MQTTclient.jsna("entity_registry_enabled_default","False");
    MQTTclient.announce("Free Heap", "sensor", optional_payload);

    optional_payload = MQTTclient.jsna("entity_category","diagnostic") + MQTTclient.jsna("state_class","total_increasing") + MQTTclient.jsna("entity_registry_enabled_default","False");
    MQTTclient.announce("MQTT Msg Count", "sensor", optional_payload);

    // Capacity tariff: settable number entity for limit, sensor entities for state
    optional_payload = MQTTclient.jsna("device_class","power") + MQTTclient.jsna("unit_of_measurement","W")
        + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/CapacityLimit"))
        + MQTTclient.jsna("min", "0") + MQTTclient.jsna("max", "25000") + MQTTclient.jsna("mode","box");
    MQTTclient.announce("Capacity Limit", "number", optional_payload);

    optional_payload = MQTTclient.jsna("device_class","power") + MQTTclient.jsna("unit_of_measurement","W") + MQTTclient.jsna("state_class","measurement");
    MQTTclient.announce("Capacity Window Avg", "sensor", optional_payload);
    MQTTclient.announce("Capacity Monthly Peak", "sensor", optional_payload);
    MQTTclient.announce("Capacity Headroom", "sensor", optional_payload);

    // MQTT publish settings: change-only toggle and heartbeat interval
    optional_payload = MQTTclient.jsna("entity_category","config")
        + MQTTclient.jsna("state_topic", String(MQTTprefix + "/MQTTChangeOnly"))
        + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/MQTTChangeOnly"))
        + MQTTclient.jsna("payload_on", "1")
        + MQTTclient.jsna("payload_off", "0");
    MQTTclient.announce("MQTT Change Only", "switch", optional_payload);

    optional_payload = MQTTclient.jsna("entity_category","config")
        + MQTTclient.jsna("command_topic", String(MQTTprefix + "/Set/MQTTHeartbeat"))
        + MQTTclient.jsna("min", "10")
        + MQTTclient.jsna("max", "300")
        + MQTTclient.jsna("mode","box")
        + MQTTclient.jsna("unit_of_measurement", "s");
    MQTTclient.announce("MQTT Heartbeat", "number", optional_payload);
}

// Wrapper: publish an integer value only if changed (or change-only is disabled)
static void mqtt_pub_int(mqtt_slot_t slot, const char *suffix, int32_t value,
                         bool retained, uint32_t now_s) {
    if (!MQTTChangeOnly || mqtt_should_publish_int(&mqtt_cache, slot, value, now_s)) {
        MQTTclient.publish(MQTTprefix + suffix, value, retained, 0);
        MQTTMsgCount++;
    }
}

// Wrapper: publish a string value only if changed (or change-only is disabled)
static void mqtt_pub_str(mqtt_slot_t slot, const char *suffix, const char *value,
                         bool retained, uint32_t now_s) {
    if (!MQTTChangeOnly || mqtt_should_publish_str(&mqtt_cache, slot, value, now_s)) {
        MQTTclient.publish(MQTTprefix + suffix, value, retained, 0);
        MQTTMsgCount++;
    }
}

static bool session_publish_pending = false;
void mqttPublishSessionComplete(void);  // forward declaration

void mqttPublishData() {
    // Detect forced publish (lastMqttUpdate set to 10 by external triggers)
    bool forced = (lastMqttUpdate >= 10);
    lastMqttUpdate = 0;
    if (forced)
        mqtt_cache_force_all(&mqtt_cache);
    uint32_t now_s = (uint32_t)(esp_timer_get_time() / 1000000);

        // Retry pending session publish after MQTT reconnect
        if (session_publish_pending) {
            mqttPublishSessionComplete();
        }

        if (MainsMeter.Type) {
            mqtt_pub_int(MQTT_SLOT_MAINS_L1, "/MainsCurrentL1", MainsMeter.Irms[0], false, now_s);
            mqtt_pub_int(MQTT_SLOT_MAINS_L2, "/MainsCurrentL2", MainsMeter.Irms[1], false, now_s);
            mqtt_pub_int(MQTT_SLOT_MAINS_L3, "/MainsCurrentL3", MainsMeter.Irms[2], false, now_s);
            // Zero-value guard: suppress energy publishing when meter has not yet reported valid data
            // Publishing 0 for total_increasing sensors corrupts HA long-term statistics
            if (MainsMeter.Import_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_MAINS_IMPORT_ENERGY, "/MainsImportActiveEnergy", MainsMeter.Import_active_energy, false, now_s);
            if (MainsMeter.Export_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_MAINS_EXPORT_ENERGY, "/MainsExportActiveEnergy", MainsMeter.Export_active_energy, false, now_s);
            mqtt_pub_int(MQTT_SLOT_MAINS_POWER_L1, "/MainsPowerL1", MainsMeter.Power[0], false, now_s);
            mqtt_pub_int(MQTT_SLOT_MAINS_POWER_L2, "/MainsPowerL2", MainsMeter.Power[1], false, now_s);
            mqtt_pub_int(MQTT_SLOT_MAINS_POWER_L3, "/MainsPowerL3", MainsMeter.Power[2], false, now_s);
            // Zero-value guard: suppress per-phase energy when meter hasn't reported it
            if (MainsMeter.EnergyPhase[0] > 0)
                mqtt_pub_int(MQTT_SLOT_MAINS_ENERGY_L1, "/MainsEnergyL1", MainsMeter.EnergyPhase[0], false, now_s);
            if (MainsMeter.EnergyPhase[1] > 0)
                mqtt_pub_int(MQTT_SLOT_MAINS_ENERGY_L2, "/MainsEnergyL2", MainsMeter.EnergyPhase[1], false, now_s);
            if (MainsMeter.EnergyPhase[2] > 0)
                mqtt_pub_int(MQTT_SLOT_MAINS_ENERGY_L3, "/MainsEnergyL3", MainsMeter.EnergyPhase[2], false, now_s);
        }
        if (EVMeter.Type) {
            mqtt_pub_int(MQTT_SLOT_EV_L1, "/EVCurrentL1", EVMeter.Irms[0], false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_L2, "/EVCurrentL2", EVMeter.Irms[1], false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_L3, "/EVCurrentL3", EVMeter.Irms[2], false, now_s);
            // Zero-value guard for EV meter energy values
            if (EVMeter.Import_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_EV_IMPORT_ENERGY, "/EVImportActiveEnergy", EVMeter.Import_active_energy, false, now_s);
            if (EVMeter.Export_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_EV_EXPORT_ENERGY, "/EVExportActiveEnergy", EVMeter.Export_active_energy, false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_POWER_L1, "/EVPowerL1", EVMeter.Power[0], false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_POWER_L2, "/EVPowerL2", EVMeter.Power[1], false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_POWER_L3, "/EVPowerL3", EVMeter.Power[2], false, now_s);
            if (EVMeter.EnergyPhase[0] > 0)
                mqtt_pub_int(MQTT_SLOT_EV_ENERGY_L1, "/EVEnergyL1", EVMeter.EnergyPhase[0], false, now_s);
            if (EVMeter.EnergyPhase[1] > 0)
                mqtt_pub_int(MQTT_SLOT_EV_ENERGY_L2, "/EVEnergyL2", EVMeter.EnergyPhase[1], false, now_s);
            if (EVMeter.EnergyPhase[2] > 0)
                mqtt_pub_int(MQTT_SLOT_EV_ENERGY_L3, "/EVEnergyL3", EVMeter.EnergyPhase[2], false, now_s);
        }
        // BEGIN PLAN-14: CircuitMeter publishing
        if (CircuitMeter.Type) {
            mqtt_pub_int(MQTT_SLOT_CIRCUIT_L1, "/CircuitCurrentL1", CircuitMeter.Irms[0], false, now_s);
            mqtt_pub_int(MQTT_SLOT_CIRCUIT_L2, "/CircuitCurrentL2", CircuitMeter.Irms[1], false, now_s);
            mqtt_pub_int(MQTT_SLOT_CIRCUIT_L3, "/CircuitCurrentL3", CircuitMeter.Irms[2], false, now_s);
            mqtt_pub_int(MQTT_SLOT_CIRCUIT_POWER, "/CircuitPower", CircuitMeter.PowerMeasured, false, now_s);
            if (CircuitMeter.Import_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_CIRCUIT_IMPORT_ENERGY, "/CircuitImportEnergy", CircuitMeter.Import_active_energy, false, now_s);
            if (CircuitMeter.Export_active_energy > 0)
                mqtt_pub_int(MQTT_SLOT_CIRCUIT_EXPORT_ENERGY, "/CircuitExportEnergy", CircuitMeter.Export_active_energy, false, now_s);
        }
        mqtt_pub_int(MQTT_SLOT_MAX_CIRCUIT_MAINS, "/MaxCircuitMains", MaxCircuitMains, true, now_s);
        // END PLAN-14
        mqtt_pub_int(MQTT_SLOT_ESP_TEMP, "/ESPTemp", TempEVSE, false, now_s);
        mqtt_pub_str(MQTT_SLOT_MODE, "/Mode", AccessStatus == OFF ? "Off" : AccessStatus == PAUSE ? "Pause" : Mode > 3 ? "N/A" : StrMode[Mode], true, now_s);
        mqtt_pub_int(MQTT_SLOT_MAX_CURRENT, "/MaxCurrent", MaxCurrent * 10, true, now_s);
        mqtt_pub_str(MQTT_SLOT_CUSTOM_BUTTON, "/CustomButton", CustomButton ? "On" : "Off", false, now_s);
        mqtt_pub_int(MQTT_SLOT_CHARGE_CURRENT, "/ChargeCurrent", Balanced[0], true, now_s);
        mqtt_pub_int(MQTT_SLOT_CHARGE_CURRENT_OVERRIDE, "/ChargeCurrentOverride", OverrideCurrent, true, now_s);
        mqtt_pub_int(MQTT_SLOT_NR_OF_PHASES, "/NrOfPhases", Nr_Of_Phases_Charging, true, now_s);
        mqtt_pub_str(MQTT_SLOT_ACCESS, "/Access", AccessStatus == OFF ? "Deny" : AccessStatus == ON ? "Allow" : AccessStatus == PAUSE ? "Pause" : "N/A", true, now_s);
        mqtt_pub_str(MQTT_SLOT_RFID, "/RFID", !RFIDReader ? "Not Installed" : RFIDstatus >= 8 ? "NOSTATUS" : StrRFIDStatusWeb[RFIDstatus], true, now_s);
        mqtt_pub_str(MQTT_SLOT_ENABLE_C2, "/EnableC2", StrEnableC2[EnableC2], true, now_s);
        if (RFIDReader) {
            char buf[15];
            printRFID(buf, sizeof(buf));
            mqtt_pub_str(MQTT_SLOT_RFID_LAST_READ, "/RFIDLastRead", buf, true, now_s);
        }
        mqtt_pub_str(MQTT_SLOT_STATE, "/State", getStateNameWeb(State), true, now_s);
        mqtt_pub_str(MQTT_SLOT_ERROR, "/Error", getErrorNameWeb(ErrorFlags), true, now_s);
        mqtt_pub_str(MQTT_SLOT_EV_PLUG_STATE, "/EVPlugState", (pilot != PILOT_12V) ? "Connected" : "Disconnected", true, now_s);
        mqtt_pub_str(MQTT_SLOT_WIFI_SSID, "/WiFiSSID", WiFi.SSID().c_str(), true, now_s);
        mqtt_pub_str(MQTT_SLOT_WIFI_BSSID, "/WiFiBSSID", WiFi.BSSIDstr().c_str(), true, now_s);
#if MODEM
        mqtt_pub_int(MQTT_SLOT_CPPWM, "/CPPWM", CurrentPWM, false, now_s);
        { // CPPWMOverride is string-typed: either the PWM value or "-1"
            char cppwm_buf[8];
            if (CPDutyOverride)
                snprintf(cppwm_buf, sizeof(cppwm_buf), "%d", (int)CurrentPWM);
            else
                snprintf(cppwm_buf, sizeof(cppwm_buf), "-1");
            mqtt_pub_str(MQTT_SLOT_CPPWM_OVERRIDE, "/CPPWMOverride", cppwm_buf, true, now_s);
        }
        mqtt_pub_int(MQTT_SLOT_EV_INITIAL_SOC, "/EVInitialSoC", InitialSoC, true, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_FULL_SOC, "/EVFullSoC", FullSoC, true, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_COMPUTED_SOC, "/EVComputedSoC", ComputedSoC, true, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_REMAINING_SOC, "/EVRemainingSoC", RemainingSoC, true, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_TIME_UNTIL_FULL, "/EVTimeUntilFull", TimeUntilFull, false, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_ENERGY_CAPACITY, "/EVEnergyCapacity", EnergyCapacity, true, now_s);
        mqtt_pub_int(MQTT_SLOT_EV_ENERGY_REQUEST, "/EVEnergyRequest", EnergyRequest, true, now_s);
        mqtt_pub_str(MQTT_SLOT_EVCCID, "/EVCCID", EVCCID, true, now_s);
        mqtt_pub_str(MQTT_SLOT_REQUIRED_EVCCID, "/RequiredEVCCID", RequiredEVCCID, true, now_s);
#endif
        if (EVMeter.Type) {
            mqtt_pub_int(MQTT_SLOT_EV_CHARGE_POWER, "/EVChargePower", EVMeter.PowerMeasured, false, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_ENERGY_CHARGED, "/EVEnergyCharged", EVMeter.EnergyCharged, true, now_s);
            mqtt_pub_int(MQTT_SLOT_EV_TOTAL_ENERGY_CHARGED, "/EVTotalEnergyCharged", EVMeter.Energy, false, now_s);
        }
        if (homeBatteryLastUpdate)
            mqtt_pub_int(MQTT_SLOT_HOME_BATTERY_CURRENT, "/HomeBatteryCurrent", homeBatteryCurrent, false, now_s);
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
        mqtt_pub_str(MQTT_SLOT_OCPP, "/OCPP", OcppMode ? "Enabled" : "Disabled", true, now_s);
        mqtt_pub_str(MQTT_SLOT_OCPP_CONNECTION, "/OCPPConnection", (OcppWsClient && OcppWsClient->isConnected()) ? "Connected" : "Disconnected", false, now_s);
        mqtt_pub_str(MQTT_SLOT_OCPP_TX_ACTIVE, "/OCPPTxActive", OcppTelemetry.tx_active ? "true" : "false", false, now_s);
        {
            char ocpp_limit_buf[16];
            if (OcppCurrentLimit >= 0.0f) {
                snprintf(ocpp_limit_buf, sizeof(ocpp_limit_buf), "%.1f", (double)OcppCurrentLimit);
            } else {
                snprintf(ocpp_limit_buf, sizeof(ocpp_limit_buf), "none");
            }
            mqtt_pub_str(MQTT_SLOT_OCPP_CURRENT_LIMIT, "/OCPPCurrentLimit", ocpp_limit_buf, false, now_s);
        }
        mqtt_pub_str(MQTT_SLOT_OCPP_SMART_CHARGING, "/OCPPSmartCharging",
            OcppTelemetry.lb_conflict ? "Conflict" : (!LoadBl ? "Active" : "Inactive"), false, now_s);
#endif //ENABLE_OCPP
        { // LED color topics — build string in buffer
            char color_buf[16];
            snprintf(color_buf, sizeof(color_buf), "%u,%u,%u", ColorOff[0], ColorOff[1], ColorOff[2]);
            mqtt_pub_str(MQTT_SLOT_LED_COLOR_OFF, "/LEDColorOff", color_buf, true, now_s);
            snprintf(color_buf, sizeof(color_buf), "%u,%u,%u", ColorNormal[0], ColorNormal[1], ColorNormal[2]);
            mqtt_pub_str(MQTT_SLOT_LED_COLOR_NORMAL, "/LEDColorNormal", color_buf, true, now_s);
            snprintf(color_buf, sizeof(color_buf), "%u,%u,%u", ColorSmart[0], ColorSmart[1], ColorSmart[2]);
            mqtt_pub_str(MQTT_SLOT_LED_COLOR_SMART, "/LEDColorSmart", color_buf, true, now_s);
            snprintf(color_buf, sizeof(color_buf), "%u,%u,%u", ColorSolar[0], ColorSolar[1], ColorSolar[2]);
            mqtt_pub_str(MQTT_SLOT_LED_COLOR_SOLAR, "/LEDColorSolar", color_buf, true, now_s);
            snprintf(color_buf, sizeof(color_buf), "%u,%u,%u", ColorCustom[0], ColorCustom[1], ColorCustom[2]);
            mqtt_pub_str(MQTT_SLOT_LED_COLOR_CUSTOM, "/LEDColorCustom", color_buf, true, now_s);
        }
        if (Lock != 0) {
            mqtt_pub_int(MQTT_SLOT_CABLE_LOCK, "/CableLock", CableLock, true, now_s);
        }
        mqtt_pub_int(MQTT_SLOT_ESP_UPTIME, "/ESPUptime", (int32_t)(esp_timer_get_time() / 1000000), false, now_s);
        { // WiFiRSSI is an integer but was published as String — use int wrapper
            mqtt_pub_int(MQTT_SLOT_WIFI_RSSI, "/WiFiRSSI", WiFi.RSSI(), false, now_s);
        }
        mqtt_pub_int(MQTT_SLOT_LOAD_BL, "/LoadBl", LoadBl, true, now_s);
        mqtt_pub_str(MQTT_SLOT_PAIRING_PIN, "/PairingPin", PairingPin.c_str(), true, now_s);
        mqtt_pub_str(MQTT_SLOT_FIRMWARE_VERSION, "/FirmwareVersion", VERSION, true, now_s);
        mqtt_pub_int(MQTT_SLOT_SOLAR_STOP_TIMER, "/SolarStopTimer", SolarStopTimer, false, now_s);
        mqtt_pub_int(MQTT_SLOT_CURRENT_MAX_SUM_MAINS, "/CurrentMaxSumMains", MaxSumMains, true, now_s);
        if (LoadBl == 1) {
            static const char *StrPrioStrategy[] = {"ModbusAddr", "FirstConn", "LastConn"};
            mqtt_pub_str(MQTT_SLOT_PRIO_STRATEGY, "/PrioStrategy", PrioStrategy <= 2 ? StrPrioStrategy[PrioStrategy] : "N/A", true, now_s);
            mqtt_pub_int(MQTT_SLOT_ROTATION_INTERVAL, "/RotationInterval", RotationInterval, true, now_s);
            mqtt_pub_int(MQTT_SLOT_IDLE_TIMEOUT, "/IdleTimeout", IdleTimeout, true, now_s);
            mqtt_pub_int(MQTT_SLOT_ROTATION_TIMER, "/RotationTimer", RotationTimer, false, now_s);
            static const char *StrSchedState[] = {"Inactive", "Active", "Paused"};
            String schedStr;
            for (int i = 0; i < NR_EVSES; i++) {
                if (i > 0) schedStr += ",";
                schedStr += (ScheduleState[i] <= 2) ? StrSchedState[ScheduleState[i]] : "N/A";
            }
            mqtt_pub_str(MQTT_SLOT_SCHEDULE_STATE, "/ScheduleState", schedStr.c_str(), false, now_s);
        }
        // Diagnostic: free heap and MQTT message counter
        mqtt_pub_int(MQTT_SLOT_FREE_HEAP, "/FreeHeap", (int32_t)ESP.getFreeHeap(), false, now_s);
        mqtt_pub_int(MQTT_SLOT_MQTT_MSG_COUNT, "/MQTTMsgCount", (int32_t)MQTTMsgCount, false, now_s);
        // BEGIN PLAN-09: Metering diagnostic counters
        mqtt_pub_int(MQTT_SLOT_METER_TIMEOUT_COUNT, "/MeterTimeoutCount", (int32_t)g_evse_ctx.meter_timeout_count, false, now_s);
        mqtt_pub_int(MQTT_SLOT_METER_RECOVERY_COUNT, "/MeterRecoveryCount", (int32_t)g_evse_ctx.meter_recovery_count, false, now_s);
        mqtt_pub_int(MQTT_SLOT_API_STALE_COUNT, "/ApiStaleCount", (int32_t)g_evse_ctx.api_stale_count, false, now_s);
        // END PLAN-09

        // Capacity tariff sensors
        mqtt_pub_int(MQTT_SLOT_CAPACITY_LIMIT, "/CapacityLimit", CapacityLimit, true, now_s);
        mqtt_pub_int(MQTT_SLOT_CAPACITY_WINDOW_AVG, "/CapacityWindowAvg", capacity_get_window_avg_w(&CapacityState), false, now_s);
        mqtt_pub_int(MQTT_SLOT_CAPACITY_MONTHLY_PEAK, "/CapacityMonthlyPeak", capacity_get_monthly_peak_w(&CapacityState), false, now_s);
        mqtt_pub_int(MQTT_SLOT_CAPACITY_HEADROOM, "/CapacityHeadroom", capacity_get_headroom_w(&CapacityState), false, now_s);

        // MQTT config settings — publish for HA switch/number entity state
        MQTTclient.publish(MQTTprefix + "/MQTTChangeOnly", MQTTChangeOnly ? "1" : "0", true, 0);
        MQTTclient.publish(MQTTprefix + "/MQTTHeartbeat", (int)MQTTHeartbeat, true, 0);
}

// SmartEVSE server MQTT client setup - subscribe to Set topics
void SetupMQTTClientSmartEVSE() {
    // MQTTSmartEVSEprefix is initialized in MQTTclientSmartEVSE.connect()
    MQTTclientSmartEVSE.subscribe(MQTTSmartEVSEprefix + "/Set/CurrentOverride", 1);
    MQTTclientSmartEVSE.subscribe(MQTTSmartEVSEprefix + "/Set/Mode", 1);
    MQTTclientSmartEVSE.subscribe(MQTTSmartEVSEprefix + "/App/Status", 1);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/connected", "online", true, 0);
    mqttSmartEVSEPublishData();
}

// SmartEVSE server MQTT publish data
void mqttSmartEVSEPublishData() {
    if (!MQTTclientSmartEVSE.connected) return;
    
    // MQTTSmartEVSEprefix is initialized in MQTTclientSmartEVSE.connect()
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/Version", String(VERSION), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/Access", AccessStatus == OFF ? "Deny" : AccessStatus == ON ? "Allow" : AccessStatus == PAUSE ? "Pause" : "N/A", true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/ChargeCurrent", String(Balanced[0]), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/ChargeCurrentOverride", String(OverrideCurrent), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/Mode", AccessStatus == OFF ? "Off" : AccessStatus == PAUSE ? "Pause" : Mode > 3 ? "N/A" : StrMode[Mode], true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/NrOfPhases", String(Nr_Of_Phases_Charging), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/State", getStateNameWeb(State), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/Error", getErrorNameWeb(ErrorFlags), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/LoadBl", String(LoadBl), true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/SolarStopTimer", String(SolarStopTimer), false, 0);
    if (MainsMeter.Type) {
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/MainsCurrentL1", String(MainsMeter.Irms[0]), false, 0);
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/MainsCurrentL2", String(MainsMeter.Irms[1]), false, 0);
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/MainsCurrentL3", String(MainsMeter.Irms[2]), false, 0);
    }
    if (EVMeter.Type) {
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/EVChargePower", String(EVMeter.PowerMeasured), false, 0);
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/EVEnergyCharged", String(EVMeter.EnergyCharged), true, 0);
        MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/EVImportActiveEnergy", String(EVMeter.Import_active_energy), false, 0);
    }
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/PairingPin", PairingPin, true, 0);
    MQTTclientSmartEVSE.publish(MQTTSmartEVSEprefix + "/MaxCurrent", String(MaxCurrent * 10), true, 0);
}

// Publish completed charge session via MQTT (retained) for ERE/HA integration.
// If MQTT is not connected when session ends, sets a pending flag so the publish
// is retried on the next mqttPublishData() cycle after reconnect.
void mqttPublishSessionComplete(void) {
    if (!MQTTclient.connected) {
        session_publish_pending = true;
        return;
    }
    const session_record_t *last = session_get_last();
    if (!last) return;

    char json[384];
    if (session_to_json(last, json, sizeof(json)) > 0) {
        MQTTclient.publish(MQTTprefix + "/Session/Complete", json, true, 0);
        session_publish_pending = false;
    }
}

// Solar debug MQTT publishing (Issue #66)
// Gated behind SolarDebugEnabled flag — only publishes when enabled.
// Rate-limited: publishes at most once every SOLAR_DEBUG_INTERVAL_MS.
static bool SolarDebugEnabled = false;
static unsigned long SolarDebugLastPublish = 0;
#define SOLAR_DEBUG_INTERVAL_MS 5000

void mqttPublishSolarDebug(void) {
    if (!SolarDebugEnabled) return;
    if (!MQTTclient.connected) return;

    unsigned long now = millis();
    if (SolarDebugLastPublish != 0 && (now - SolarDebugLastPublish) < SOLAR_DEBUG_INTERVAL_MS)
        return;

    evse_solar_debug_t snap;
    evse_get_solar_debug(&snap);

    char json[384];
    if (solar_debug_to_json(&snap, json, sizeof(json)) > 0) {
        MQTTclient.publish(MQTTprefix + "/Debug/Solar", json, false, 0);
        SolarDebugLastPublish = now;
    }
}

static void mqttSetSolarDebug(bool enabled) {
    SolarDebugEnabled = enabled;
    if (!enabled) SolarDebugLastPublish = 0;
}
#endif


/**
 * Validate setting ranges and dependencies
 */
void validate_settings(void) {
    uint8_t i;
    uint16_t value;

    // If value is out of range, reset it to default value
    for (i = MENU_ENTER + 1;i < MENU_EXIT; i++){
        value = getItemValue(i);
    //    _LOG_A("value %s set to %i\n",MenuStr[i].LCD, value );
        if (value > MenuStr[i].Max || value < MenuStr[i].Min) {
            value = MenuStr[i].Default;
    //        _LOG_A("set default value for %s to %i\n",MenuStr[i].LCD, value );
            setItemValue(i, value);
        }
    }

    // Sensorbox v2 has always address 0x0A
    if (MainsMeter.Type == EM_SENSORBOX) MainsMeter.Address = 0x0A;
    
    // Erase all RFID cards from ram + eeprom if set to EraseAll
    if (RFIDReader == 5) {
        DeleteAllRFID();
        setItemValue(MENU_RFIDREADER, 0);                                       // RFID Reader Disabled
    }
    if (LoadBl >= 2 && EnableC2 == AUTO) {                                      // AUTO not supported on slaves
        EnableC2 = NOT_PRESENT;
    }

#if SMARTEVSE_VERSION < 40 //v3
    // Update master node config; for v4 this is taken care of when receiving the EVMeterType/Address
    if (LoadBl < 2) {
        Node[0].EVMeter = EVMeter.Type;
        Node[0].EVAddress = EVMeter.Address;
    }
#endif
    // Default to modbus input registers
    if (EMConfig[EM_CUSTOM].Function != 3) EMConfig[EM_CUSTOM].Function = 4;

    // Backward compatibility < 2.20
    if (EMConfig[EM_CUSTOM].IRegister == 8 || EMConfig[EM_CUSTOM].URegister == 8 || EMConfig[EM_CUSTOM].PRegister == 8 || EMConfig[EM_CUSTOM].ERegister == 8) {
        EMConfig[EM_CUSTOM].DataType = MB_DATATYPE_FLOAT32;
        EMConfig[EM_CUSTOM].IRegister = 0;
        EMConfig[EM_CUSTOM].URegister = 0;
        EMConfig[EM_CUSTOM].PRegister = 0;
        EMConfig[EM_CUSTOM].ERegister = 0;
    }

#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
    // If the address of the MainsMeter or EVmeter on a Node has changed, we must re-register the Modbus workers.
    if (LoadBl > 1) {
        if (EVMeter.Type && EVMeter.Type != EM_API) MBserver.registerWorker(EVMeter.Address, ANY_FUNCTION_CODE, &MBEVMeterResponse);
    }
#endif
    MainsMeter.setTimeout(COMM_TIMEOUT);
    EVMeter.setTimeout(COMM_TIMEOUT);                                             // Short Delay, to clear the error message for ~10 seconds.

}

void read_settings() {
    
    // Open preferences. true = read only,  false = read/write
    // If "settings" does not exist, it will be created, and initialized with the default values
    if (preferences.begin("settings", false) ) {                                
        bool Initialized = preferences.isKey("Config");
        Config = preferences.getUChar("Config", CONFIG); 
        Lock = preferences.getUChar("Lock", LOCK); 
        Mode = preferences.getUChar("Mode", MODE); 
        AccessStatus = (AccessStatus_t) preferences.getUChar("Access", ON);
        if (preferences.isKey("CardOffset")) {
            CardOffset = preferences.getUChar("CardOffset", CARD_OFFSET);
            //write the old 8 bits value to the new 16 bits value
            preferences.putUShort("CardOffs16", CardOffset);
            preferences.remove("CardOffset");
        }
        else
            CardOffset = preferences.getUShort("CardOffs16", CARD_OFFSET);
        LoadBl = preferences.getUChar("LoadBl", LOADBL); 
        MaxMains = preferences.getUShort("MaxMains", MAX_MAINS); 
        MaxSumMains = preferences.getUShort("MaxSumMains", MAX_SUMMAINS);
        MaxSumMainsTime = preferences.getUShort("MaxSumMainsTime", MAX_SUMMAINSTIME);
        MaxCurrent = preferences.getUShort("MaxCurrent", MAX_CURRENT); 
        MinCurrent = preferences.getUShort("MinCurrent", MIN_CURRENT); 
        MaxCircuit = preferences.getUShort("MaxCircuit", MAX_CIRCUIT); 
        Switch = preferences.getUChar("Switch", SWITCH); 
        RCmon = preferences.getUChar("RCmon", RC_MON); 
        StartCurrent = preferences.getUShort("StartCurrent", START_CURRENT); 
        StopTime = preferences.getUShort("StopTime", STOP_TIME); 
        ImportCurrent = preferences.getUShort("ImportCurrent",IMPORT_CURRENT);
        Grid = preferences.getUChar("Grid",GRID);
        SB2_WIFImode = preferences.getUChar("SB2WIFImode",SB2_WIFI_MODE);
        RFIDReader = preferences.getUChar("RFIDReader",RFID_READER);

        MainsMeter.Type = preferences.getUChar("MainsMeter", MAINS_METER);
        MainsMeter.Address = preferences.getUChar("MainsMAddress",MAINS_METER_ADDRESS);
        EVMeter.Type = preferences.getUChar("EVMeter",EV_METER);
        EVMeter.Address = preferences.getUChar("EVMeterAddress",EV_METER_ADDRESS);
        CircuitMeter.Type = preferences.getUChar("CircuitMeter", CIRCUIT_METER);
        CircuitMeter.Address = preferences.getUChar("CirMeterAddr", CIRCUIT_METER_ADDRESS);
        MaxCircuitMains = preferences.getUShort("MaxCirMains", MAX_CIRCUIT_MAINS);
        EMConfig[EM_CUSTOM].Endianness = preferences.getUChar("EMEndianness",EMCUSTOM_ENDIANESS);
        EMConfig[EM_CUSTOM].IRegister = preferences.getUShort("EMIRegister",EMCUSTOM_IREGISTER);
        EMConfig[EM_CUSTOM].IDivisor = preferences.getUChar("EMIDivisor",EMCUSTOM_IDIVISOR);
        EMConfig[EM_CUSTOM].URegister = preferences.getUShort("EMURegister",EMCUSTOM_UREGISTER);
        EMConfig[EM_CUSTOM].UDivisor = preferences.getUChar("EMUDivisor",EMCUSTOM_UDIVISOR);
        EMConfig[EM_CUSTOM].PRegister = preferences.getUShort("EMPRegister",EMCUSTOM_PREGISTER);
        EMConfig[EM_CUSTOM].PDivisor = preferences.getUChar("EMPDivisor",EMCUSTOM_PDIVISOR);
        EMConfig[EM_CUSTOM].ERegister = preferences.getUShort("EMERegister",EMCUSTOM_EREGISTER);
        EMConfig[EM_CUSTOM].EDivisor = preferences.getUChar("EMEDivisor",EMCUSTOM_EDIVISOR);
        EMConfig[EM_CUSTOM].DataType = (mb_datatype)preferences.getUChar("EMDataType",EMCUSTOM_DATATYPE);
        EMConfig[EM_CUSTOM].Function = preferences.getUChar("EMFunction",EMCUSTOM_FUNCTION);
        WIFImode = preferences.getUChar("WIFImode",WIFI_MODE);
        DelayedStartTime.epoch2 = preferences.getULong("DelayedStartTim", DELAYEDSTARTTIME); //epoch2 is 4 bytes long on arduino; NVS key has reached max size
        DelayedStopTime.epoch2 = preferences.getULong("DelayedStopTime", DELAYEDSTOPTIME);    //epoch2 is 4 bytes long on arduino
        DelayedRepeat = preferences.getUShort("DelayedRepeat", 0);
        LCDlock = preferences.getUChar("LCDlock", LCD_LOCK);
        CableLock = preferences.getUChar("CableLock", CABLE_LOCK);
        LCDPin = preferences.getUShort("LCDPin", 0);
        AutoUpdate = preferences.getUChar("AutoUpdate", AUTOUPDATE);
        MQTTSmartServer = preferences.getBool("MQTTSmartServer", APPSERVER);
#if MQTT
        MQTTChangeOnly = preferences.getBool("MQTTChgOnly", true);
        MQTTHeartbeat = preferences.getUShort("MQTTHrtbt", 60);
#endif

        EnableC2 = (EnableC2_t) preferences.getUShort("EnableC2", ENABLE_C2);
#if MODEM
        strncpy(RequiredEVCCID, preferences.getString("RequiredEVCCID", "").c_str(), sizeof(RequiredEVCCID));
#endif
        maxTemp = preferences.getUShort("maxTemp", MAX_TEMPERATURE);
        PrioStrategy = preferences.getUChar("PrioStrategy", PRIO_MODBUS_ADDR);
        RotationInterval = preferences.getUShort("RotationIntvl", 0);
        IdleTimeout = preferences.getUShort("IdleTimeout", 60);

#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
        OcppMode = preferences.getUChar("OcppMode", OCPP_MODE);
#endif //ENABLE_OCPP

        CapacityLimit = preferences.getUShort("CapacityLim", 0);
        // Restore monthly peak from NVS
        CapacityState.monthly.monthly_peak_w = preferences.getInt("CapPeak", 0);
        CapacityState.monthly.peak_month = preferences.getUChar("CapMonth", 0);

        preferences.end();                                  

        // Populate settings cache with values just read from NVS
        settingsCache.Config = Config;
        settingsCache.Lock = Lock;
        settingsCache.Mode = Mode;
        settingsCache.AccessStatus = AccessStatus;
        settingsCache.CardOffset = CardOffset;
        settingsCache.DelayedStartTime = DelayedStartTime.epoch2;
        settingsCache.DelayedStopTime = DelayedStopTime.epoch2;
        settingsCache.DelayedRepeat = DelayedRepeat;
        settingsCache.LoadBl = LoadBl;
        settingsCache.MaxMains = MaxMains;
        settingsCache.MaxSumMains = MaxSumMains;
        settingsCache.MaxSumMainsTime = MaxSumMainsTime;
        settingsCache.MaxCurrent = MaxCurrent;
        settingsCache.MinCurrent = MinCurrent;
        settingsCache.MaxCircuit = MaxCircuit;
        settingsCache.Switch = Switch;
        settingsCache.RCmon = RCmon;
        settingsCache.StartCurrent = StartCurrent;
        settingsCache.StopTime = StopTime;
        settingsCache.ImportCurrent = ImportCurrent;
        settingsCache.Grid = Grid;
        settingsCache.SB2_WIFImode = SB2_WIFImode;
        settingsCache.RFIDReader = RFIDReader;
        settingsCache.MainsMeterType = MainsMeter.Type;
        settingsCache.MainsMeterAddress = MainsMeter.Address;
        settingsCache.EVMeterType = EVMeter.Type;
        settingsCache.EVMeterAddress = EVMeter.Address;
        settingsCache.CircuitMeterType = CircuitMeter.Type;
        settingsCache.CircuitMeterAddress = CircuitMeter.Address;
        settingsCache.MaxCircuitMains = MaxCircuitMains;
        settingsCache.EMEndianness = EMConfig[EM_CUSTOM].Endianness;
        settingsCache.EMIRegister = EMConfig[EM_CUSTOM].IRegister;
        settingsCache.EMIDivisor = EMConfig[EM_CUSTOM].IDivisor;
        settingsCache.EMURegister = EMConfig[EM_CUSTOM].URegister;
        settingsCache.EMUDivisor = EMConfig[EM_CUSTOM].UDivisor;
        settingsCache.EMPRegister = EMConfig[EM_CUSTOM].PRegister;
        settingsCache.EMPDivisor = EMConfig[EM_CUSTOM].PDivisor;
        settingsCache.EMERegister = EMConfig[EM_CUSTOM].ERegister;
        settingsCache.EMEDivisor = EMConfig[EM_CUSTOM].EDivisor;
        settingsCache.EMDataType = EMConfig[EM_CUSTOM].DataType;
        settingsCache.EMFunction = EMConfig[EM_CUSTOM].Function;
        settingsCache.WIFImode = WIFImode;
        settingsCache.EnableC2 = EnableC2;
#if MODEM
        strncpy(settingsCache.RequiredEVCCID, RequiredEVCCID, sizeof(settingsCache.RequiredEVCCID));
#endif
        settingsCache.maxTemp = maxTemp;
        settingsCache.PrioStrategy = PrioStrategy;
        settingsCache.RotationInterval = RotationInterval;
        settingsCache.IdleTimeout = IdleTimeout;
        settingsCache.AutoUpdate = AutoUpdate;
        settingsCache.LCDlock = LCDlock;
        settingsCache.CableLock = CableLock;
        settingsCache.LCDPin = LCDPin;
        settingsCache.MQTTSmartServer = MQTTSmartServer;
#if MQTT
        settingsCache.MQTTChangeOnly = MQTTChangeOnly;
        settingsCache.MQTTHeartbeat = MQTTHeartbeat;
#endif
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION)
        settingsCache.OcppMode = OcppMode;
#endif
        settingsCache.CapacityLimit = CapacityLimit;
        settingsCache.valid = true;
        _LOG_D("Settings cache populated from NVS\n");

        // Store settings when not initialized
        if (!Initialized) write_settings();

    } else {
        _LOG_A("Can not open preferences!\n");
    }
}

void write_settings(void) {

    validate_settings();

 if (preferences.begin("settings", false) ) {

    // Only write values that have actually changed from cached values
    PREFS_PUT_UCHAR_IF_CHANGED("Config", Config, Config);
    PREFS_PUT_UCHAR_IF_CHANGED("Lock", Lock, Lock);
    PREFS_PUT_UCHAR_IF_CHANGED("Mode", Mode, Mode);
    PREFS_PUT_UCHAR_IF_CHANGED("Access", AccessStatus, AccessStatus);
    PREFS_PUT_USHORT_IF_CHANGED("CardOffs16", CardOffset, CardOffset);
    PREFS_PUT_ULONG_IF_CHANGED("DelayedStartTim", DelayedStartTime.epoch2, DelayedStartTime);
    PREFS_PUT_ULONG_IF_CHANGED("DelayedStopTime", DelayedStopTime.epoch2, DelayedStopTime);
    PREFS_PUT_USHORT_IF_CHANGED("DelayedRepeat", DelayedRepeat, DelayedRepeat);
    PREFS_PUT_UCHAR_IF_CHANGED("LoadBl", LoadBl, LoadBl);
    PREFS_PUT_USHORT_IF_CHANGED("MaxMains", MaxMains, MaxMains);
    PREFS_PUT_USHORT_IF_CHANGED("MaxSumMains", MaxSumMains, MaxSumMains);
    PREFS_PUT_USHORT_IF_CHANGED("MaxSumMainsTime", MaxSumMainsTime, MaxSumMainsTime);
    PREFS_PUT_USHORT_IF_CHANGED("MaxCurrent", MaxCurrent, MaxCurrent);
    PREFS_PUT_USHORT_IF_CHANGED("MinCurrent", MinCurrent, MinCurrent);
    PREFS_PUT_USHORT_IF_CHANGED("MaxCircuit", MaxCircuit, MaxCircuit);
    PREFS_PUT_UCHAR_IF_CHANGED("Switch", Switch, Switch);
    PREFS_PUT_UCHAR_IF_CHANGED("RCmon", RCmon, RCmon);
    PREFS_PUT_USHORT_IF_CHANGED("StartCurrent", StartCurrent, StartCurrent);
    PREFS_PUT_USHORT_IF_CHANGED("StopTime", StopTime, StopTime);
    PREFS_PUT_USHORT_IF_CHANGED("ImportCurrent", ImportCurrent, ImportCurrent);
    PREFS_PUT_UCHAR_IF_CHANGED("Grid", Grid, Grid);
    PREFS_PUT_UCHAR_IF_CHANGED("SB2WIFImode", SB2_WIFImode, SB2_WIFImode);
    PREFS_PUT_UCHAR_IF_CHANGED("RFIDReader", RFIDReader, RFIDReader);

    PREFS_PUT_UCHAR_IF_CHANGED("MainsMeter", MainsMeter.Type, MainsMeterType);
    PREFS_PUT_UCHAR_IF_CHANGED("MainsMAddress", MainsMeter.Address, MainsMeterAddress);
    PREFS_PUT_UCHAR_IF_CHANGED("EVMeter", EVMeter.Type, EVMeterType);
    PREFS_PUT_UCHAR_IF_CHANGED("EVMeterAddress", EVMeter.Address, EVMeterAddress);
    PREFS_PUT_UCHAR_IF_CHANGED("CircuitMeter", CircuitMeter.Type, CircuitMeterType);
    PREFS_PUT_UCHAR_IF_CHANGED("CirMeterAddr", CircuitMeter.Address, CircuitMeterAddress);
    PREFS_PUT_USHORT_IF_CHANGED("MaxCirMains", MaxCircuitMains, MaxCircuitMains);
    PREFS_PUT_UCHAR_IF_CHANGED("EMEndianness", EMConfig[EM_CUSTOM].Endianness, EMEndianness);
    PREFS_PUT_USHORT_IF_CHANGED("EMIRegister", EMConfig[EM_CUSTOM].IRegister, EMIRegister);
    PREFS_PUT_UCHAR_IF_CHANGED("EMIDivisor", EMConfig[EM_CUSTOM].IDivisor, EMIDivisor);
    PREFS_PUT_USHORT_IF_CHANGED("EMURegister", EMConfig[EM_CUSTOM].URegister, EMURegister);
    PREFS_PUT_UCHAR_IF_CHANGED("EMUDivisor", EMConfig[EM_CUSTOM].UDivisor, EMUDivisor);
    PREFS_PUT_USHORT_IF_CHANGED("EMPRegister", EMConfig[EM_CUSTOM].PRegister, EMPRegister);
    PREFS_PUT_UCHAR_IF_CHANGED("EMPDivisor", EMConfig[EM_CUSTOM].PDivisor, EMPDivisor);
    PREFS_PUT_USHORT_IF_CHANGED("EMERegister", EMConfig[EM_CUSTOM].ERegister, EMERegister);
    PREFS_PUT_UCHAR_IF_CHANGED("EMEDivisor", EMConfig[EM_CUSTOM].EDivisor, EMEDivisor);
    PREFS_PUT_UCHAR_IF_CHANGED("EMDataType", EMConfig[EM_CUSTOM].DataType, EMDataType);
    PREFS_PUT_UCHAR_IF_CHANGED("EMFunction", EMConfig[EM_CUSTOM].Function, EMFunction);
    PREFS_PUT_UCHAR_IF_CHANGED("WIFImode", WIFImode, WIFImode);
    PREFS_PUT_USHORT_IF_CHANGED("EnableC2", EnableC2, EnableC2);
#if MODEM
    if (!settingsCache.valid || strcmp(RequiredEVCCID, settingsCache.RequiredEVCCID) != 0) {
        preferences.putString("RequiredEVCCID", String(RequiredEVCCID));
        strncpy(settingsCache.RequiredEVCCID, RequiredEVCCID, sizeof(settingsCache.RequiredEVCCID));
    }
#endif
    PREFS_PUT_USHORT_IF_CHANGED("maxTemp", maxTemp, maxTemp);
    PREFS_PUT_UCHAR_IF_CHANGED("PrioStrategy", PrioStrategy, PrioStrategy);
    PREFS_PUT_USHORT_IF_CHANGED("RotationIntvl", RotationInterval, RotationInterval);
    PREFS_PUT_USHORT_IF_CHANGED("IdleTimeout", IdleTimeout, IdleTimeout);
    PREFS_PUT_UCHAR_IF_CHANGED("AutoUpdate", AutoUpdate, AutoUpdate);
    PREFS_PUT_UCHAR_IF_CHANGED("LCDlock", LCDlock, LCDlock);
    PREFS_PUT_UCHAR_IF_CHANGED("CableLock", CableLock, CableLock);
    PREFS_PUT_USHORT_IF_CHANGED("LCDPin", LCDPin, LCDPin);
    PREFS_PUT_BOOL_IF_CHANGED("MQTTSmartServer", MQTTSmartServer, MQTTSmartServer);
#if MQTT
    PREFS_PUT_BOOL_IF_CHANGED("MQTTChgOnly", MQTTChangeOnly, MQTTChangeOnly);
    PREFS_PUT_USHORT_IF_CHANGED("MQTTHrtbt", MQTTHeartbeat, MQTTHeartbeat);
#endif

#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
    PREFS_PUT_UCHAR_IF_CHANGED("OcppMode", OcppMode, OcppMode);
#endif //ENABLE_OCPP

    PREFS_PUT_USHORT_IF_CHANGED("CapacityLim", CapacityLimit, CapacityLimit);
    // Persist monthly peak across reboots
    preferences.putInt("CapPeak", CapacityState.monthly.monthly_peak_w);
    preferences.putUChar("CapMonth", CapacityState.monthly.peak_month);

    // Mark cache as valid after first write
    settingsCache.valid = true;

    preferences.end();

    _LOG_I("settings saved\n");
#if SMARTEVSE_VERSION >= 40
    SendConfigToCH32();
#endif

 } else {
     _LOG_A("Can not open preferences!\n");
 }


    if (LoadBl == 1) {                                                          // Master mode
        // Broadcast settings to other controllers
        BroadcastSettings();
    }

    ConfigChanged = 1;                                                          // FIXME this variable never reset to 0?
    SEND_TO_CH32(ConfigChanged);

    // Update timestamp after successful write
    LastSettingsWriteTime = millis();
    SettingsDirty = false;
}


/* Request settings to be written to flash.
 * This does not write immediately - instead it sets a dirty flag.
 * The actual write happens in the main loop when 60 secs have passed since last write
*/ 
void request_write_settings(void) {
    SettingsDirty = true;
    _LOG_D("Settings write requested\n");
}


/* Takes TimeString in format
 * String = "2023-04-14T11:31"
 * and store it in the DelayedTimeStruct
 * returns 0 on success, 1 on failure
*/
int StoreTimeString(String DelayedTimeStr, DelayedTimeStruct *DelayedTime) {
    // Parse the time string
    tm delayedtime_tm = {};
    if (strptime(DelayedTimeStr.c_str(), "%Y-%m-%dT%H:%M", &delayedtime_tm)) {
        delayedtime_tm.tm_isdst = -1;                 //so mktime is going to figure out whether DST is there or not
        DelayedTime->epoch2 = mktime(&delayedtime_tm) - EPOCH2_OFFSET;
        // Compare the times
        time_t now = time(nullptr);             //get current local time
        DelayedTime->diff = DelayedTime->epoch2 - (mktime(localtime(&now)) - EPOCH2_OFFSET);
        return 0;
    }
    //error TODO not sure whether we keep the old time or reset it to zero?
    //DelayedTime.epoch2 = 0;
    //DelayedTime.diff = 0;
    return 1;
}


#if MODEM
// Recompute State of Charge, in case we have a known initial state of charge
// This function is called by kWh logic and after an EV state update through API, Serial or MQTT
void RecomputeSoC(void) {
    if (InitialSoC > 0 && FullSoC > 0 && EnergyCapacity > 0) {
        if (InitialSoC == FullSoC) {
            // We're already at full SoC
            ComputedSoC = FullSoC;
            RemainingSoC = 0;
            TimeUntilFull = -1;
        } else {
            int EnergyRemaining = -1;
            int TargetEnergyCapacity = (FullSoC / 100.f) * EnergyCapacity;

            if (EnergyRequest > 0) {
                // Attempt to use EnergyRequest to determine SoC with greater accuracy
                EnergyRemaining = EVMeter.EnergyCharged > 0 ? (EnergyRequest - EVMeter.EnergyCharged) : EnergyRequest;
            } else {
                // We use a rough estimation based on FullSoC and EnergyCapacity
                EnergyRemaining = TargetEnergyCapacity - (EVMeter.EnergyCharged + (InitialSoC / 100.f) * EnergyCapacity);
            }

            RemainingSoC = ((FullSoC * EnergyRemaining) / TargetEnergyCapacity);
            ComputedSoC = RemainingSoC > 1 ? (FullSoC - RemainingSoC) : FullSoC;

            // Only attempt to compute the SoC and TimeUntilFull if we have a EnergyRemaining and PowerMeasured
            if (EnergyRemaining > -1) {
                int TimeToGo = -1;
                // Do a very simple estimation in seconds until car would reach FullSoC according to current charging power
                if (EVMeter.PowerMeasured > 0) {
                    // Use real-time PowerMeasured data if available
                    TimeToGo = (3600 * EnergyRemaining) / EVMeter.PowerMeasured;
                } else if (Mode != MODE_SOLAR && MaxCapacity != 0) { //prevent divide by zero
                    // Else, fall back on the theoretical maximum of the cable + nr of phases
                    TimeToGo = (3600 * EnergyRemaining) / (MaxCapacity * (Nr_Of_Phases_Charging * 230));
                }

                // Wait until we have a somewhat sensible estimation while still respecting granny chargers
                if (TimeToGo < 100000) {
                    TimeUntilFull = TimeToGo;
                }
            }

            // We can't possibly charge to over 100% SoC
            if (ComputedSoC > FullSoC) {
                ComputedSoC = FullSoC;
                RemainingSoC = 0;
                TimeUntilFull = -1;
            }

            _LOG_I("SoC: EnergyRemaining %i RemaningSoC %i EnergyRequest %i EnergyCharged %i EnergyCapacity %i ComputedSoC %i FullSoC %i TimeUntilFull %i TargetEnergyCapacity %i\n", EnergyRemaining, RemainingSoC, EnergyRequest, EVMeter.EnergyCharged, EnergyCapacity, ComputedSoC, FullSoC, TimeUntilFull, TargetEnergyCapacity);
        }
    } else {
        if (TimeUntilFull != -1) TimeUntilFull = -1;
    }
    // There's also the possibility an external API/app is used for SoC info. In such case, we allow setting ComputedSoC directly.
}


// EV disconnected from charger. Triggered after 60 seconds of disconnect
// This is done so we can "re-plug" the car in the Modem process without triggering disconnect events
void DisconnectEvent(void){
    _LOG_A("EV disconnected for a while. Resetting SoC states");
    uint8_t ModemStage = 0; // Enable Modem states again
    SEND_TO_CH32(ModemStage)
    InitialSoC = -1;
    FullSoC = -1;
    RemainingSoC = -1;
    ComputedSoC = -1;
    EnergyCapacity = -1;
    EnergyRequest = -1;
    TimeUntilFull = -1;
    strncpy(EVCCID, "", sizeof(EVCCID));
}
#endif //MODEM


// handle_URI() has been moved to http_handlers.cpp


/*
 * OCPP-related function definitions
 */
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32

void ocppUpdateRfidReading(const unsigned char *uuid, size_t uuidLen) {
    if (!uuid || uuidLen > sizeof(OcppRfidUuid)) {
        _LOG_W("OCPP: invalid UUID\n");
        return;
    }
    memcpy(OcppRfidUuid, uuid, uuidLen);
    OcppRfidUuidLen = uuidLen;
    OcppLastRfidUpdate = millis();
}

bool ocppIsConnectorPlugged() {
    return OcppTrackCPvoltage >= PILOT_3V && OcppTrackCPvoltage <= PILOT_9V;
}

bool ocppHasTxNotification() {
    return OcppDefinedTxNotification && millis() - OcppLastTxNotification <= 3000;
}

MicroOcpp::TxNotification ocppGetTxNotification() {
    return OcppTrackTxNotification;
}

bool ocppLockingTxDefined() {
    return OcppLockingTx != nullptr;
}

void ocppInit() {

    ocpp_telemetry_init(&OcppTelemetry);

    //load OCPP library modules: Mongoose WS adapter and Core OCPP library

    auto filesystem = MicroOcpp::makeDefaultFilesystemAdapter(
            MicroOcpp::FilesystemOpt::Use_Mount_FormatOnFail // Enable FS access, mount LittleFS here, format data partition if necessary
            );

    OcppWsClient = new MicroOcpp::MOcppMongooseClient(
            &mgr,
            nullptr,    // OCPP backend URL (factory default)
            nullptr,    // ChargeBoxId (factory default)
            nullptr,    // WebSocket Basic Auth token (factory default)
            nullptr,    // CA cert (cert string must outlive WS client)
            filesystem);

    mocpp_initialize(
            *OcppWsClient, //WebSocket adapter for MicroOcpp
            ChargerCredentials("SmartEVSE", "Stegen Electronics", VERSION, String(serialnr).c_str(), NULL, (char *) EMConfig[EVMeter.Type].Desc),
            filesystem);

    //setup OCPP hardware bindings

    setEnergyMeterInput([] () { //Input of the electricity meter register in Wh
        return EVMeter.Energy;
    });

    setPowerMeterInput([] () { //Input of the power meter reading in W
        return EVMeter.PowerMeasured;
    });

    setConnectorPluggedInput([] () { //Input about if an EV is plugged to this EVSE
        return ocppIsConnectorPlugged();
    });

    setEvReadyInput([] () { //Input if EV is ready to charge (= J1772 State C)
        return OcppTrackCPvoltage >= PILOT_3V && OcppTrackCPvoltage <= PILOT_6V;
    });

    setEvseReadyInput([] () { //Input if EVSE allows charge (= PWM signal on)
        return GetCurrent() > 0; //PWM is enabled
    });

    addMeterValueInput([] () {
            return (float) (EVMeter.Irms[0] + EVMeter.Irms[1] + EVMeter.Irms[2])/10;
        },
        "Current.Import",
        "A");

    addMeterValueInput([] () {
            return (float) EVMeter.Irms[0]/10;
        },
        "Current.Import",
        "A",
        nullptr, // Location defaults to "Outlet"
        "L1");

    addMeterValueInput([] () {
            return (float) EVMeter.Irms[1]/10;
        },
        "Current.Import",
        "A",
        nullptr, // Location defaults to "Outlet"
        "L2");

    addMeterValueInput([] () {
            return (float) EVMeter.Irms[2]/10;
        },
        "Current.Import",
        "A",
        nullptr, // Location defaults to "Outlet"
        "L3");

    addMeterValueInput([] () {
            return (float)GetCurrent() * 0.1f;
        },
        "Current.Offered",
        "A");

    addMeterValueInput([] () {
            return (float)TempEVSE;
        },
        "Temperature",
        "Celsius");

#if MODEM
        addMeterValueInput([] () {
                return (float)ComputedSoC;
            },
            "SoC",
            "Percent");
#endif

    addErrorCodeInput([] () {
        return (ErrorFlags & TEMP_HIGH) ? "HighTemperature" : (const char*)nullptr;
    });

    addErrorCodeInput([] () {
        return ((ErrorFlags & RCM_TRIPPED) && !(ErrorFlags & RCM_TEST)) ? "GroundFailure" : (const char*)nullptr;
    });

    addErrorDataInput([] () -> MicroOcpp::ErrorData {
        if (ErrorFlags & CT_NOCOMM) {
            MicroOcpp::ErrorData error = "PowerMeterFailure";
            error.info = "Communication with mains meter lost";
            return error;
        }
        return nullptr;
    });

    addErrorDataInput([] () -> MicroOcpp::ErrorData {
        if (ErrorFlags & EV_NOCOMM) {
            MicroOcpp::ErrorData error = "PowerMeterFailure";
            error.info = "Communication with EV meter lost";
            return error;
        }
        return nullptr;
    });

    // Track LoadBl state at init time for runtime exclusivity checks
    OcppWasStandalone = !LoadBl;

    // If SmartEVSE load balancer is turned off, then enable OCPP Smart Charging
    // This means after toggling LB, OCPP must be disabled and enabled for changes to become effective
    if (!LoadBl) {
        setSmartChargingCurrentOutput([] (float currentLimit) {
            OcppCurrentLimit = currentLimit; // Can be negative which means that no limit is defined

            // Re-evaluate charge rate and apply
            if (!LoadBl) { // Execute only if LB is still disabled

                CalcBalancedCurrent(0);
                if (IsCurrentAvailable()) {
                    // OCPP is the exclusive LB, clear LESS_6A error if set
                    clearErrorFlags(LESS_6A);
                    setChargeDelay(0);
                }
                if ((State == STATE_B || State == STATE_C) && !CPDutyOverride) {
                    if (IsCurrentAvailable()) {
                        SetCurrent(ChargeCurrent);
                    } else {
                        setStatePowerUnavailable();
                    }
                }
            }
        });
    }

    setOnUnlockConnectorInOut([] () -> UnlockConnectorResult {
        // MO also stops transaction which should toggle OcppForcesLock false
        OcppLockingTx.reset();
        if (Lock == 0 || digitalRead(PIN_LOCK_IN) == (Lock == 2 ? 0:1 )) {
            // Success
            return UnlockConnectorResult_Unlocked;
        }

        // No result yet, wait (MO eventually times out)
        return UnlockConnectorResult_Pending;
    });

    setOccupiedInput([] () -> bool {
        // Keep Finishing state while LockingTx effectively blocks new transactions
        return OcppLockingTx != nullptr;
    });

    setStopTxReadyInput([] () {
        // Stop value synchronization: block StopTransaction for 5 seconds to give the Modbus readings some time to come through
        return millis() - OcppStopReadingSyncTime >= 5000;
    });

    setTxNotificationOutput([] (MicroOcpp::Transaction*, MicroOcpp::TxNotification event) {
        OcppDefinedTxNotification = true;
        OcppTrackTxNotification = event;
        OcppLastTxNotification = millis();

        // Update telemetry counters
        if (event == MicroOcpp::TxNotification::StartTx) {
            ocpp_telemetry_tx_started(&OcppTelemetry);
        } else if (event == MicroOcpp::TxNotification::StopTx) {
            ocpp_telemetry_tx_stopped(&OcppTelemetry);
        } else if (event == MicroOcpp::TxNotification::Authorized ||
                   event == MicroOcpp::TxNotification::RemoteStart) {
            ocpp_telemetry_auth_accepted(&OcppTelemetry);
        } else if (event == MicroOcpp::TxNotification::AuthorizationRejected ||
                   event == MicroOcpp::TxNotification::DeAuthorized) {
            ocpp_telemetry_auth_rejected(&OcppTelemetry);
        } else if (event == MicroOcpp::TxNotification::AuthorizationTimeout) {
            ocpp_telemetry_auth_timeout(&OcppTelemetry);
        }
    });

    // Declare custom "ConfigureMaxCurrent" key
    // Parameters: key name, default value, filename for persistence (optional, use CONFIGURATION_FN for default), readonly, rebootRequired, restricted
    MicroOcpp::declareConfiguration<int>("ConfigureMaxCurrent", 16);

    // Set MeterValuesSampledData to include Current.Import and Temperature in periodic meter values
    // Note: declareConfiguration only sets the default; setString() actively updates the value
    auto meterValuesSampledData = MicroOcpp::declareConfiguration<const char*>("MeterValuesSampledData", "");
    meterValuesSampledData->setString("Energy.Active.Import.Register,Power.Active.Import,Current.Import,Temperature");

    OcppUnlockConnectorOnEVSideDisconnect = MicroOcpp::declareConfiguration<bool>("UnlockConnectorOnEVSideDisconnect", true);

    endTransaction(nullptr, "PowerLoss"); // If a transaction from previous power cycle is still running, abort it here
}

void ocppDeinit() {

    // Record stop value for transaction manually (normally MO would wait until `mocpp_loop()`, but that's too late here)
    if (auto& tx = getTransaction()) {
        if (tx->getMeterStop() < 0) {
            // Stop value not defined yet
            tx->setMeterStop(EVMeter.Import_active_energy); // Use same reading as in `setEnergyMeterInput()`
            tx->setStopTimestamp(getOcppContext()->getModel().getClock().now());
        }
    }

    endTransaction(nullptr, "Other"); // If a transaction is running, shut it down forcefully. The StopTx request will be sent when OCPP runs again.

    OcppUnlockConnectorOnEVSideDisconnect.reset();
    OcppLockingTx.reset();
    OcppForcesLock = false;

    if (OcppTrackPermitsCharge) {
        _LOG_A("OCPP unset Access_bit\n");
        setAccess(OFF);
    }

    OcppTrackPermitsCharge = false;
    OcppTrackAccessBit = false;
    OcppTrackCPvoltage = PILOT_NOK;
    OcppCurrentLimit = -1.f;
    OcppWasStandalone = false;

    mocpp_deinitialize();

    delete OcppWsClient;
    OcppWsClient = nullptr;
}

void ocppLoop() {

    if (pilot >= PILOT_3V && pilot <= PILOT_12V) {
        OcppTrackCPvoltage = pilot;
    }

    mocpp_loop();

    // Check OCPP / LoadBl mutual exclusivity at runtime
    ocpp_lb_status_t lb_status = ocpp_check_lb_exclusivity(LoadBl, OcppMode, OcppWasStandalone);
    OcppTelemetry.lb_conflict = (lb_status != OCPP_LB_OK);
    if (lb_status == OCPP_LB_CONFLICT) {
        // LoadBl changed to non-zero while OCPP is active — Smart Charging limits
        // are silently ignored by the state machine. Neutralize the limit and warn.
        if (OcppCurrentLimit >= 0.0f) {
            _LOG_W("OCPP: LoadBl=%u conflicts with Smart Charging, disabling OCPP current limit\n", LoadBl);
            OcppCurrentLimit = -1.0f;
        }
    } else if (lb_status == OCPP_LB_NEEDS_REINIT) {
        // LoadBl changed from non-zero to 0 — Smart Charging callback was never
        // registered. User needs to disable/enable OCPP for it to take effect.
        static bool ocpp_reinit_warned = false;
        if (!ocpp_reinit_warned) {
            _LOG_W("OCPP: LoadBl changed to standalone but Smart Charging not registered. Disable/enable OCPP to activate.\n");
            ocpp_reinit_warned = true;
        }
    }

    // handle Configuration updates

    auto config = MicroOcpp::getConfigurationPublic("ConfigureMaxCurrent");
    if (config) {
        uint16_t current = config->getInt();
        // Check against max and min currents, only write settings when value changes
        if ((current >= 6) && (current <= 80) && (MaxCurrent != current)) {
            MaxCurrent = current;
            request_write_settings();
            // set to invalid value, so it only sets MaxCurrent once.
            config->setInt(0);
            MicroOcpp::configuration_save();
        } 
    }

    //handle RFID input

    if (OcppTrackLastRfidUpdate != OcppLastRfidUpdate) {
        // New RFID card swiped

        char uuidHex [2 * sizeof(OcppRfidUuid) + 1];
        uuidHex[0] = '\0';
        for (size_t i = 0; i < OcppRfidUuidLen; i++) {
            snprintf(uuidHex + 2*i, 3, "%02X", OcppRfidUuid[i]);
        }

        if (OcppLockingTx) {
            // Connector is still locked by earlier transaction

            if (!strcmp(uuidHex, OcppLockingTx->getIdTag())) {
                // Connector can be unlocked again
                OcppLockingTx.reset();
                endTransaction(uuidHex, "Local");
            } // else: Connector remains blocked for now
        } else if (getTransaction()) {
            //OCPP lib still has transaction (i.e. transaction running or authorization pending) --> swiping card again invalidates idTag
            endTransaction(uuidHex, "Local");
        } else {
            //OCPP lib has no idTag --> swiped card is used for new transaction
            OcppLockingTx = beginTransaction(uuidHex);
        }
    }
    OcppTrackLastRfidUpdate = OcppLastRfidUpdate;

    // Set / unset Access_bit
    // Allow to set Access_bit only once per OCPP transaction because other modules may override the Access_bit
    // Doesn't apply if SmartEVSE built-in RFID store is enabled
    if (RFIDReader == 6 || RFIDReader == 0) {
        // RFID reader in OCPP mode or RFID fully disabled - OCPP controls Access_bit
        if (!OcppTrackPermitsCharge && ocppPermitsCharge()) {
            // Guard: defer Access_bit if mode/delay conflicts (FreeVend + Solar, ChargeDelay)
            if (ocpp_should_defer_access(Mode, ChargeDelay, ErrorFlags)) {
                // Don't update OcppTrackPermitsCharge — retry rising edge on next loop
                _LOG_D("OCPP: deferring Access_bit (Mode=%u ChargeDelay=%u ErrorFlags=0x%04X)\n", Mode, ChargeDelay, ErrorFlags);
            } else {
                _LOG_A("OCPP set Access_bit\n");
                setAccess(ON);
                OcppTrackPermitsCharge = true;
            }
        } else if (AccessStatus == ON && !ocppPermitsCharge()) {
            _LOG_A("OCPP unset Access_bit\n");
            setAccess(OFF);
            OcppTrackPermitsCharge = false;
        } else {
            OcppTrackPermitsCharge = ocppPermitsCharge();
        }

        // Check if OCPP charge permission has been revoked by other module
        if (OcppTrackPermitsCharge && // OCPP has set Acess_bit and still allows charge
                AccessStatus == OFF) { // Access_bit is not active anymore
            endTransaction(nullptr, "Other");
        }
    } else {
        // Built-in RFID store enabled - OCPP does not control Access_bit, but starts transactions when Access_bit is set
        if ((AccessStatus == ON || AccessStatus == PAUSE ) && !OcppTrackAccessBit && !getTransaction() && isOperative()) {
            // Access_bit has been set
            OcppTrackAccessBit = true;
            _LOG_A("OCPP detected Access_bit set\n");
            char buf[15];
            if (RFID[0] == 0x01) {  // old reader 6 byte UID starts at RFID[1]
                snprintf(buf, sizeof(buf), "%02X%02X%02X%02X%02X%02X", RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
            } else {
                snprintf(buf, sizeof(buf), "%02X%02X%02X%02X%02X%02X%02X", RFID[0], RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
            }
            beginTransaction_authorized(buf);
        } else if (AccessStatus == OFF && (OcppTrackAccessBit || (getTransaction() && getTransaction()->isActive()))) {
            OcppTrackAccessBit = false;
            _LOG_A("OCPP detected Access_bit unset\n");
            char buf[15];
            if (RFID[0] == 0x01) {  // old reader 6 byte UID starts at RFID[1]
                snprintf(buf, sizeof(buf), "%02X%02X%02X%02X%02X%02X", RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
            } else {
                snprintf(buf, sizeof(buf), "%02X%02X%02X%02X%02X%02X%02X", RFID[0], RFID[1], RFID[2], RFID[3], RFID[4], RFID[5], RFID[6]);
            }
            endTransaction_authorized(buf);
        }
    }

    // Stop value synchronization: block StopTransaction for a short period as long as charging is permitted
    if (ocppPermitsCharge()) {
        OcppStopReadingSyncTime = millis();
    }

    auto& transaction = getTransaction(); // Common tx which OCPP is currently processing (or nullptr if no tx is ongoing)

    // Check if Locking Tx has been invalidated by something other than RFID swipe
    if (OcppLockingTx) {
        if (OcppUnlockConnectorOnEVSideDisconnect->getBool() && !OcppLockingTx->isActive()) {
            // No LockingTx mode configured (still, keep LockingTx until end of transaction because the config could be changed in the middle of tx)
            OcppLockingTx.reset();
        } else if (OcppLockingTx->isAborted()) {
            // LockingTx hasn't successfully started
            OcppLockingTx.reset();
        } else if (transaction && transaction != OcppLockingTx) {
            // Another Tx has already started
            OcppLockingTx.reset();
        } else if (digitalRead(PIN_LOCK_IN) == (Lock == 2 ? 0:1 ) && !OcppLockingTx->isActive()) {
            // Connector is has been unlocked and LockingTx has already run
            OcppLockingTx.reset();
        } // There may be further edge cases
    }

    OcppForcesLock = false;

    if (transaction && transaction->isAuthorized() && (transaction->isActive() || transaction->isRunning()) && // Common tx ongoing
            (OcppTrackCPvoltage >= PILOT_3V && OcppTrackCPvoltage <= PILOT_9V)) { // Connector plugged
        OcppForcesLock = true;
    }

    if (OcppLockingTx && OcppLockingTx->getStartSync().isRequested()) { // LockingTx goes beyond tx completion
        OcppForcesLock = true;
    }

    // Mark active session with OCPP flag when transaction is running
    {
        static bool ocpp_session_marked = false;
        if (session_is_active() && transaction && transaction->isRunning()) {
            if (!ocpp_session_marked) {
                session_set_ocpp_id(0); // Sets ocpp_active flag; ID 0 = OCPP-managed
                ocpp_session_marked = true;
            }
        } else if (!session_is_active()) {
            ocpp_session_marked = false;
        }
    }

}
#endif //ENABLE_OCPP


#if SMARTEVSE_VERSION >=40
void WCHUPDATE(unsigned long RunningVersion) {
        // we reset before flashing because when the WCH chip is sending messages (by printf) the programming can fail
        _LOG_D("reset WCH ic\n");
        WchReset();
        if (WchFirmwareUpdate(RunningVersion)) {
            _LOG_A("Firmware update failed.\n");
        } else { 
            _LOG_D("WCH programming done\n");
        }    
        // should not be needed to reset the WCH ic at powerup/reset on the production version.
        _LOG_D("reset WCH ic\n");
        WchReset();
}
#endif


void BuzzConfirmation (void) {
    if (!BuzzerPresent) return;
    ledcWriteTone(6, 2637); // E7
    ledcWrite(6, 128);      // Buzzer: 50% duty cycle
    delay(100);
    ledcWriteTone(6, 2794); // F7
    delay(100);
    ledcWriteTone(6, 3136); // G7
    delay(100);
    ledcWrite(6, 0);       // Buzzer off
}


void BuzzError (void) {
    if (!BuzzerPresent) return;
    ledcWriteTone(6, 3136); // G7
    ledcWrite(6, 128);      // Buzzer: 50% duty cycle
    delay(100);
    ledcWriteTone(6, 2794); // F7
    delay(100);
    ledcWriteTone(6, 2637); // E7
    delay(100);
    ledcWrite(6, 0);       // Buzzer off
}


void setup() {
    //detect if we are on 3.1 hardware version:
    uint8_t chip_ver = (( *(volatile uint32_t *) 0x3ff5A00c) >> 9 ) & 7 ;       // Read chip version directly from Efuses. 0=ESP32D0WDQ6 4=ESP32U4WDH
    // change default pins in case ESP32-MINI-1 is detected
    if (chip_ver == 4) { //SmartEVSE hw version 3.1
        PIN_SW_IN = PIN_SW_IN_V31;
        PIN_ACTA = PIN_ACTA_V31;
        PIN_ACTB = PIN_ACTB_V31;
        PIN_RCM_FAULT = PIN_RCM_FAULT_V31;
        PIN_RS485_RX = PIN_RS485_RX_V31;
        pinMode(PIN_EXT_V31, INPUT);
        pinMode(PIN_BUZZER_V31, OUTPUT);
        digitalWrite(PIN_BUZZER_V31, LOW);
        ledcSetup(6, 4186, 8);                      // channel 6, 4kHz, 8bit
        ledcAttachPin(PIN_BUZZER_V31, 6);
        BuzzerPresent = true;
        BuzzConfirmation();
    } else { //SmartEVSE hw version 3.0 or 4.0
        PIN_SW_IN = PIN_SW_IN_V30;
        PIN_ACTA = PIN_ACTA_V30;
        PIN_ACTB = PIN_ACTB_V30;
        PIN_RCM_FAULT = PIN_RCM_FAULT_V30;
        PIN_RS485_RX = PIN_RS485_RX_V30;
    }
    ds(); // initialize OneWire32 object on use, to avoid static initialization order fiasco

#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40

    pinMode(PIN_CP_OUT, OUTPUT);            // CP output
    //pinMode(PIN_SW_IN, INPUT);            // SW Switch input, handled by OneWire32 class
    pinMode(PIN_SSR, OUTPUT);               // SSR1 output
    pinMode(PIN_SSR2, OUTPUT);              // SSR2 output
    pinMode(PIN_RCM_FAULT, INPUT_PULLUP);   

    pinMode(PIN_LCD_LED, OUTPUT);           // LCD backlight
    pinMode(PIN_LCD_RST, OUTPUT);           // LCD reset
    pinMode(PIN_IO0_B1, INPUT);             // < button
    pinMode(PIN_LCD_A0_B2, OUTPUT);         // o Select button + A0 LCD
    pinMode(PIN_LCD_SDO_B3, OUTPUT);        // > button + SDA/MOSI pin

    pinMode(PIN_LOCK_IN, INPUT);            // Locking Solenoid input
    pinMode(PIN_LEDR, OUTPUT);              // Red LED output
    pinMode(PIN_LEDG, OUTPUT);              // Green LED output
    pinMode(PIN_LEDB, OUTPUT);              // Blue LED output
    pinMode(PIN_ACTA, OUTPUT);              // Actuator Driver output R
    pinMode(PIN_ACTB, OUTPUT);              // Actuator Driver output W
    pinMode(PIN_CPOFF, OUTPUT);             // Disable CP output (active high)
    pinMode(PIN_RS485_RX, INPUT);
    pinMode(PIN_RS485_TX, OUTPUT);
    pinMode(PIN_RS485_DIR, OUTPUT);

    digitalWrite(PIN_LEDR, LOW);
    digitalWrite(PIN_LEDG, LOW);
    digitalWrite(PIN_LEDB, LOW);
    digitalWrite(PIN_ACTA, LOW);
    digitalWrite(PIN_ACTB, LOW);        
    digitalWrite(PIN_SSR, LOW);             // SSR1 OFF
    digitalWrite(PIN_SSR2, LOW);            // SSR2 OFF
    digitalWrite(PIN_LCD_LED, HIGH);        // LCD Backlight ON
    PILOT_DISCONNECTED;                     // CP signal OFF

 
    // Uart 0 debug/program port
    Serial.begin(115200);
    while (!Serial);
    _LOG_A("SmartEVSE v3 powerup\n");

    // configure SPI connection to LCD
    // only the SPI_SCK and SPI_MOSI pins are used
    SPI.begin(SPI_SCK, SPI_MISO, SPI_MOSI, SPI_SS);
    // the ST7567's max SPI Clock frequency is 20Mhz at 3.3V/25C
    // We choose 10Mhz here, to reserve some room for error.
    // SPI mode is MODE3 (Idle = HIGH, clock in on rising edge)
    SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE3));
    

    // The CP (control pilot) output is a fixed 1khz square-wave (+6..9v / -12v).
    // It's pulse width varies between 10% and 96% indicating 6A-80A charging current.
    // to detect state changes we should measure the CP signal while it's at ~5% (so 50uS after the positive pulse started)
    // we use an i/o interrupt at the CP pin output, and a one shot timer interrupt to start the ADC conversion.
    // would be nice if there was an easier way...

    // setup timer, and one shot timer interrupt to 50us
    timerA = timerBegin(0, 80, true);
    timerAttachInterrupt(timerA, &onTimerA, false);
    // we start in STATE A, with a static +12V CP signal
    // set alarm to trigger every 1mS, and let it reload every 1ms
    timerAlarmWrite(timerA, PWM_100, true);
    // when PWM is active, we sample the CP pin after 5% 
    timerAlarmEnable(timerA);


    // Setup ADC on CP, PP and Temperature pin
    adc1_config_width(ADC_WIDTH_BIT_10);                                    // 10 bits ADC resolution is enough
    adc1_config_channel_atten(ADC1_CHANNEL_3, ADC_ATTEN_DB_12);             // setup the CP pin input attenuation to 11db
    adc1_config_channel_atten(ADC1_CHANNEL_6, ADC_ATTEN_DB_6);              // setup the PP pin input attenuation to 6db
    adc1_config_channel_atten(ADC1_CHANNEL_0, ADC_ATTEN_DB_6);              // setup the Temperature input attenuation to 6db

    //Characterize the ADC at particular attentuation for each channel
    adc_chars_CP = (esp_adc_cal_characteristics_t *) calloc(1, sizeof(esp_adc_cal_characteristics_t));
    adc_chars_PP = (esp_adc_cal_characteristics_t *) calloc(1, sizeof(esp_adc_cal_characteristics_t));
    adc_chars_Temperature = (esp_adc_cal_characteristics_t *) calloc(1, sizeof(esp_adc_cal_characteristics_t));
    esp_adc_cal_value_t val_type = esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_12, ADC_WIDTH_BIT_10, 1100, adc_chars_CP);
    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_6, ADC_WIDTH_BIT_10, 1100, adc_chars_PP);
    esp_adc_cal_characterize(ADC_UNIT_1, ADC_ATTEN_DB_6, ADC_WIDTH_BIT_10, 1100, adc_chars_Temperature);
          
    
    // Setup PWM on channel 0, 1000Hz, 10 bits resolution
    ledcSetup(CP_CHANNEL, 1000, 10);            // channel 0  => Group: 0, Channel: 0, Timer: 0
    // setup the RGB led PWM channels
    // as PWM channel 1 is used by the same timer as the CP timer (channel 0), we start with channel 2
    ledcSetup(RED_CHANNEL, 5000, 8);            // R channel 2, 5kHz, 8 bit
    ledcSetup(GREEN_CHANNEL, 5000, 8);          // G channel 3, 5kHz, 8 bit
    ledcSetup(BLUE_CHANNEL, 5000, 8);           // B channel 4, 5kHz, 8 bit
    ledcSetup(LCD_CHANNEL, 5000, 8);            // LCD channel 5, 5kHz, 8 bit

    // attach the channels to the GPIO to be controlled
    ledcAttachPin(PIN_CP_OUT, CP_CHANNEL);      
    //pinMode(PIN_CP_OUT, OUTPUT);                // Re-init the pin to output, required in order for attachInterrupt to work (2.0.2)
                                                // not required/working on master branch..
                                                // see https://github.com/espressif/arduino-esp32/issues/6140
    ledcAttachPin(PIN_LEDR, RED_CHANNEL);
    ledcAttachPin(PIN_LEDG, GREEN_CHANNEL);
    ledcAttachPin(PIN_LEDB, BLUE_CHANNEL);
    ledcAttachPin(PIN_LCD_LED, LCD_CHANNEL);

    SetCPDuty(1024);                            // channel 0, duty cycle 100%
    ledcWrite(RED_CHANNEL, 255);
    ledcWrite(GREEN_CHANNEL, 0);
    ledcWrite(BLUE_CHANNEL, 255);
    ledcWrite(LCD_CHANNEL, 0);

    // Setup PIN interrupt on rising edge
    // the timer interrupt will be reset in the ISR.
    attachInterrupt(PIN_CP_OUT, onCPpulse, RISING);   
   
    // Uart 1 is used for Modbus @ 9600 8N1
    RTUutils::prepareHardwareSerial(Serial1);
    Serial1.begin(MODBUS_BAUDRATE, SERIAL_8N1, PIN_RS485_RX, PIN_RS485_TX);

   
    //Check type of calibration value used to characterize ADC
    _LOG_A("Checking eFuse Vref settings: ");
    if (val_type == ESP_ADC_CAL_VAL_EFUSE_VREF) {
        _LOG_A_NO_FUNC("OK\n");
    } else if (val_type == ESP_ADC_CAL_VAL_EFUSE_TP) {
        _LOG_A_NO_FUNC("Two Point\n");
    } else {
        _LOG_A_NO_FUNC("not programmed!!!\n");
    }
    

#else //SMARTEVSE_VERSION v4

    //lower the CPU frequency to 160, 80, 40 MHz
    setCpuFrequencyMhz(160);

    pinMode(PIN_QCA700X_CS, OUTPUT);           // SPI_CS QCA7005
    pinMode(PIN_QCA700X_INT, INPUT);           // SPI_INT QCA7005
    pinMode(SPI_SCK, OUTPUT);
    pinMode(SPI_MISO, INPUT);
    pinMode(SPI_MOSI, OUTPUT);
    pinMode(PIN_QCA700X_RESETN, OUTPUT);

    pinMode(BUTTON1, INPUT_PULLUP);
    pinMode(BUTTON3, INPUT_PULLUP);

    pinMode(LCD_LED, OUTPUT);               // LCD backlight
    pinMode(PIN_LCD_RST, OUTPUT);           // LCD reset, active high
    pinMode(LCD_SDA, OUTPUT);               // LCD Data
    pinMode(LCD_SCK, OUTPUT);               // LCD Clock
    pinMode(PIN_LCD_A0_B2, OUTPUT);             // Select button + A0 LCD
    pinMode(LCD_CS, OUTPUT);

    pinMode(WCH_SWDIO, INPUT);              // WCH-Link (unused/unconnected)
    pinMode(WCH_SWCLK, INPUT);              // WCH-Link (unused) / BOOT0 select
    pinMode(WCH_NRST, INPUT);               // WCH NRST


    // shutdown QCA is done by the WCH32V, we set all IO pins low, so no current is flowing into the powered down chip.
    digitalWrite(PIN_QCA700X_CS, LOW);
    digitalWrite(PIN_QCA700X_RESETN, LOW);
    digitalWrite(SPI_SCK, LOW);
    digitalWrite(SPI_MOSI, LOW);

    // configure SPI connection to QCA modem
    QCA_SPI1.begin(SPI_SCK, SPI_MISO, SPI_MOSI, PIN_QCA700X_CS);
    // SPI mode is MODE3 (Idle = HIGH, clock in on rising edge), we use a 10Mhz SPI clock
    QCA_SPI1.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE3));
    //attachInterrupt(digitalPinToInterrupt(PIN_QCA700X_INT), SPI_InterruptHandler, RISING);

    // Setup SWDIO pin as Power Panic interrupt received from the WCH uC. (unused, we use serial comm)
    //attachInterrupt(WCH_SWDIO, PowerPanicESP, FALLING);

    Serial.setTxBufferSize(2048);                                       // prevent error message: [HWCDC.cpp:467] write(): write failed due to waiting USB Host - timeout
    Serial.begin();                                                     // Debug output on USB
    Serial.setTxTimeoutMs(1);                                           // Workaround for Serial.print while unplugged USB.
                                                                        // log_d does not have this issue?
    Serial1.setRxBufferSize(2048);                                      // increase RX/TX buffers, prevent buffer overruns
    Serial1.setTxBufferSize(2048);
    Serial1.begin(FUNCONF_UART_PRINTF_BAUD, SERIAL_8N1, USART_RX, USART_TX, false);       // Serial connection to main board microcontroller
    //Serial2.begin(115200, SERIAL_8N1, USART_TX, -1, false);
    Serial.printf("\nSmartEVSE v4 powerup\n");

    _LOG_D("Total heap: %u.\n", ESP.getHeapSize());
    _LOG_D("Free heap: %u.\n", ESP.getFreeHeap());
    _LOG_D("Flash Size: %u.\n", ESP.getFlashChipSize());
    _LOG_D("Total PSRAM: %u.\n", ESP.getPsramSize());
    _LOG_D("Free PSRAM: %u.\n", ESP.getFreePsram());


    // configure SPI connection to LCD
    // SPI_SCK, SPI_MOSI and LCD_CS pins are used.
    LCD_SPI2.begin(LCD_SCK, -1, LCD_SDA, LCD_CS);
    // the ST7567's max SPI Clock frequency is 20Mhz at 3.3V/25C
    // We choose 10Mhz here, to reserve some room for error.
    // SPI mode is MODE3 (Idle = HIGH, clock in on rising edge)
    LCD_SPI2.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE3));
    // Dummy transaction, to make sure SCLK idles high (IDF bug?)
    LCD_SPI2.transfer(0);
    _LOG_D("SPI for LCD configured.\n");

    //GLCD_init();                                // Initialize LCD


    ledcSetup(LCD_CHANNEL, 5000, 8);            // LCD channel 5, 5kHz, 8 bit
    ledcAttachPin(LCD_LED, LCD_CHANNEL);
    ledcWrite(LCD_CHANNEL, 255);                // Set LCD backlight brightness 0-255

    digitalWrite(PIN_QCA700X_RESETN, HIGH);         // get modem out of reset
    esp_read_mac(myMac, ESP_MAC_ETH); // select the Ethernet MAC
extern void setSeccIp();
    setSeccIp();  // use myMac to create link-local IPv6 address.
extern uint8_t modem_state;
    modem_state = MODEM_POWERUP;
    // Create Task 20ms Timer
extern void Timer20ms(void * parameter);
    xTaskCreate(
        Timer20ms,      // Function that should be called
        "Timer20ms",    // Name of the task (for debugging)
        10240,          // Stack size (bytes)
        NULL,           // Parameter to pass
        1,              // Task priority
        NULL            // Task handle
    );
#endif //SMARTEVSE_VERSION

    // Read all settings from non volatile memory; MQTTprefix will be overwritten if stored in NVS
    read_settings();                                                            // initialize with default data when starting for the first time
    validate_settings();
    ReadRFIDlist();                                                             // Read all stored RFID's from storage

    // Note that LittleFS is also used by OCPP
    if(!LittleFS.begin(true)) {
        _LOG_A("LittleFS Mount Failed\n");
    }
        
    getButtonState();
/*     * @param Buttons: < o >
 *          Value: 1 2 4
 *            Bit: 0:Pressed / 1:Released         */
    // Sample middle+right button, and lock/unlock LCD buttons.
    if (ButtonState == 1) {
        LCDlock = !LCDlock;
        write_settings();
    }

    BacklightTimer = BACKLIGHT;
    GLCD_init();

#if SMARTEVSE_VERSION >=40 //v4

    // After powerup request WCH version (version?)
    // then send Configuration to WCH
    unsigned long FlashTimeout = millis();
    uint16_t RXbyte, idx = 0;
    char *ret;
    char RxBuf[512];
    bool gotVersion = false;
    do {
        Serial1.print("@version?\n");            // send command to WCH ic
        _LOG_V("[->] version?\n");

        vTaskDelay(100 / portTICK_PERIOD_MS);

        // ESP32 requests version info from CH32; we need to do this outside of the ESP32 10ms routines because
        // we can not communicate with the CH32 and simultaneously reprogram it.
        if (Serial1.available()) {
            while (Serial1.available() && idx<sizeof(RxBuf)) {      // make sure buffer does not overflow
                RXbyte = Serial1.read();
                RxBuf[idx] = RXbyte;
                idx++;
            }
            _LOG_D("[(%u)<-] %.*s.\n", idx, idx, RxBuf);
        }

        // process data from mainboard
        if (idx > 5) {
            char token[64];
            strncpy(token, "version:", sizeof(token));
            ret = strstr(RxBuf, token);
            if (ret != NULL) {
                unsigned long WCHRunningVersion = atoi(ret+strlen(token));
                _LOG_V("version %lu received\n", WCHRunningVersion);
                WCHUPDATE(WCHRunningVersion);
                gotVersion = true;
            }
            memset(RxBuf,0,idx);                                    // Clear buffer
            idx = 0;
        }

    } while (!gotVersion && millis() - FlashTimeout < 10000);       // only try for 10s, then release so ESP32 can boot and OTA updates are possible
    memset(RxBuf, 0, sizeof(RxBuf));                                // clear SerialBuffer

    if (!gotVersion) {                                              // we timed out
        WCHUPDATE(0);
    }
#endif

    // Initialize state machine HAL callbacks (contactor, PWM, state change logging)
    // Must be called after read_settings() so globals are ready for evse_sync_globals_to_ctx()
    evse_bridge_init();
    session_init();
    {
        // Preserve monthly peak loaded from NVS across capacity_init()
        capacity_monthly_t saved_monthly = CapacityState.monthly;
        capacity_init(&CapacityState);
        CapacityState.monthly = saved_monthly;
        capacity_set_limit(&CapacityState, (int32_t)CapacityLimit);
    }
    diag_sampler_init();
    diag_storage_init();

    // Create Task EVSEStates, that handles changes in the CP signal
    xTaskCreate(
        Timer10ms,      // Function that should be called
        "Timer10ms",    // Name of the task (for debugging)
        4096,           // Stack size (bytes)                              // printf needs atleast 1kb
        NULL,           // Parameter to pass
        5,              // Task priority - high
        NULL            // Task handle
    );


#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
    // Create Task 100ms Timer
    xTaskCreate(
        Timer100ms,     // Function that should be called
        "Timer100ms",   // Name of the task (for debugging)
        4608,           // Stack size (bytes)
        NULL,           // Parameter to pass
        3,              // Task priority - medium
        NULL            // Task handle
    );
#endif //SMARTEVSE_VERSION

    // Create Task Second Timer (1000ms)
    xTaskCreate(
        Timer1S,        // Function that should be called
        "Timer1S",      // Name of the task (for debugging)
        4096,           // Stack size (bytes)                              
        NULL,           // Parameter to pass
        3,              // Task priority - medium
        NULL            // Task handle
    );

    WiFiSetup();


#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40
    Nr_Of_Phases_Charging = Force_Single_Phase_Charging() ? 1 : 3;              // to prevent unnecessary switching after boot
    // Set eModbus LogLevel to 1, to suppress possible E5 errors
    MBUlogLvl = LOG_LEVEL_CRITICAL;
    ConfigureModbusMode(255);
    PILOT_CONNECTED;           // CP signal ACTIVE
#endif

    firmwareUpdateTimer = random(FW_UPDATE_DELAY, 0xffff);
}


// returns true if current and latest version can be detected correctly and if the latest version is newer then current
// this means that ANY home compiled version, which has version format "11:20:03@Jun 17 2024", will NEVER be automatically updated!!
// same goes for current version with an -RC extension: this will NEVER be automatically updated!
// same goes for latest version with an -RC extension: this will NEVER be automatically updated! This situation should never occur since
// we only update from the "stable" repo !!
bool fwNeedsUpdate(char * version) {
    // version NEEDS to be in the format: vx.y.z[-RCa] where x, y, z, a are digits, multiple digits are allowed.
    // valid versions are v3.6.10   v3.17.0-RC13
    int latest_major, latest_minor, latest_patch, latest_rc, cur_major, cur_minor, cur_patch, cur_rc;
    int hit = sscanf(version, "v%i.%i.%i-RC%i", &latest_major, &latest_minor, &latest_patch, &latest_rc);
    _LOG_A("Firmware version detection hit=%i, LATEST version detected=v%i.%i.%i-RC%i.\n", hit, latest_major, latest_minor, latest_patch, latest_rc);
    int hit2 = sscanf(VERSION, "v%i.%i.%i-RC%i", &cur_major, &cur_minor, &cur_patch, &cur_rc);
    _LOG_A("Firmware version detection hit=%i, CURRENT version detected=v%i.%i.%i-RC%i.\n", hit2, cur_major, cur_minor, cur_patch, cur_rc);
    if (hit != 3 || hit2 != 3)                                                  // we couldnt detect simple vx.y.z version nrs, either current or latest
        return false;
    if (cur_major > latest_major)
        return false;
    if (cur_major < latest_major)
        return true;
    if (cur_major == latest_major) {
        if (cur_minor > latest_minor)
            return false;
        if (cur_minor < latest_minor)
            return true;
        if (cur_minor == latest_minor)
            return (cur_patch < latest_patch);
    }
    return false;
}

/**
  * Periodically retrieves current measurements from the HomeWizard P1 energy meter
  * and updates the main meter's currents.
  *
  * This function ensures a delay of at least 1.95 seconds between consecutive data retrieval attempts.
  */
 void homewizard_loop() {
    static unsigned long lastCheck_homewizard = 0;

    constexpr unsigned long interval = 1950; // 1.95 seconds - With this setting there can be 5 attempts for updating the data before the 10 second Mains Meter timeout.
    const unsigned long currentTime = millis();

    if (currentTime - lastCheck_homewizard < interval) {
        return;
    }

    _LOG_A("homewizard_loop(): start HomeWizrd P1 reading.");
    lastCheck_homewizard = currentTime;

    const auto result = getMainsFromHomeWizardP1();
#if SMARTEVSE_VERSION < 40 //v3
    for (int i = 0; i < result.phases; i++)
        MainsMeter.Irms[i] = result.currents[i];
    if (result.phases) {
        // BEGIN PLAN-09: HomeWizard energy data
        if (result.import_energy_wh > 0)
            MainsMeter.Import_active_energy = result.import_energy_wh;
        if (result.export_energy_wh > 0)
            MainsMeter.Export_active_energy = result.export_energy_wh;
        // END PLAN-09
        CalcIsum();
        MainsMeter.setTimeout(COMM_TIMEOUT);
    }
#else
    Serial1.printf("@Irms:%03u,%d,%d,%d\n", MainsMeter.Address, result.currents[0], result.currents[1], result.currents[2]); //Irms:011,312,123,124 means: the meter on address 11(dec) has Irms[0] 312 dA, Irms[1] of 123 dA, Irms[2] of 124 dA
#endif
}

void loop() {

    network_loop();
    if (MainsMeter.Type == EM_HOMEWIZARD_P1 && LoadBl < 2) {
        homewizard_loop();
    }
    
    static unsigned long lastCheck = 0;
    if (millis() - lastCheck >= 1000) {
        lastCheck = millis();
        //this block is for non-time critical stuff that needs to run approx 1 / second
#if !defined(SMARTEVSE_VERSION) || SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40 //not on ESP32 v4
        //printStatus:
        _LOG_I ("STATE: %s Error: %u StartCurrent: -%i ChargeDelay: %u SolarStopTimer: %u NoCurrent: %u Imeasured: %.1f A IsetBalanced: %.1f A, MainsMeter.Timeout=%u, EVMeter.Timeout=%u.\n", getStateName(State), ErrorFlags, StartCurrent, ChargeDelay, SolarStopTimer,  NoCurrent, (float)MainsMeter.Imeasured/10, (float)IsetBalanced/10, MainsMeter.Timeout, EVMeter.Timeout);
#else
        _LOG_I ("STATE: %s Error: %u StartCurrent: -%i ChargeDelay: %u SolarStopTimer: %u NoCurrent: %u Imeasured: %.1f A IsetBalanced: %.1f A.\n", getStateName(State), ErrorFlags, StartCurrent, ChargeDelay, SolarStopTimer,  NoCurrent, (float)MainsMeter.Imeasured/10, (float)IsetBalanced/10);
#endif
        _LOG_I("L1: %.1f A L2: %.1f A L3: %.1f A Isum: %.1f A\n", (float)MainsMeter.Irms[0]/10, (float)MainsMeter.Irms[1]/10, (float)MainsMeter.Irms[2]/10, (float)Isum/10);

#if SMARTEVSE_VERSION >=30 && SMARTEVSE_VERSION < 40 //v3
        // check if settings need to be written
        // and only write when enough time has passed
        if (SettingsDirty) {
            if ((lastCheck - LastSettingsWriteTime) >= (SETTINGS_WRITE_INTERVAL * 1000UL) || 
                (LastSettingsWriteTime == 0)) {  // First write after boot
                _LOG_A("Writing settings to flash\n");
                write_settings();
            }
        }
#endif

         // a reboot is requested, but we kindly wait until EV is not charging
        static uint8_t RebootDelay = 5;      
        if (shouldReboot && State != STATE_C) {                                 //slaves in STATE_C continue charging when Master reboots
            if (RebootDelay-- == 0) {                                           //give user some time to read any message on the webserver
                if (SettingsDirty) write_settings();                            //write any pending settings before reboot
                ESP.restart();                                                  //use non-blocking code so network_loop() keeps working.
            }
        }

        // TODO move this to a once a minute loop?
        if (DelayedStartTime.epoch2 && LocalTimeSet) {
            // Compare the times
            time_t now = time(nullptr);             //get current local time
            DelayedStartTime.diff = DelayedStartTime.epoch2 - (mktime(localtime(&now)) - EPOCH2_OFFSET);
            if (DelayedStartTime.diff > 0) {
                if (AccessStatus != OFF && (DelayedStopTime.epoch2 == 0 || DelayedStopTime.epoch2 > DelayedStartTime.epoch2))
                    setAccess(OFF);                         //switch to OFF, we are Delayed Charging
            }
            else {
                //starttime is in the past so we are NOT Delayed Charging, or we are Delayed Charging but the starttime has passed!
                if (DelayedRepeat == 1)
                    DelayedStartTime.epoch2 += 24 * 3600;                           //add 24 hours so we now have a new starttime
                else
                    DelayedStartTime.epoch2 = DELAYEDSTARTTIME;
                setAccess(ON);
            }
        }
        //only update StopTime.diff if starttime has already passed
        if (DelayedStopTime.epoch2 && LocalTimeSet) {
            // Compare the times
            time_t now = time(nullptr);             //get current local time
            DelayedStopTime.diff = DelayedStopTime.epoch2 - (mktime(localtime(&now)) - EPOCH2_OFFSET);
            if (DelayedStopTime.diff <= 0) {
                //DelayedStopTime has passed
                if (DelayedRepeat == 1)                                         //we are on a daily repetition schedule
                    DelayedStopTime.epoch2 += 24 * 3600;                        //add 24 hours so we now have a new starttime
                else
                    DelayedStopTime.epoch2 = DELAYEDSTOPTIME;
                setAccess(OFF);                         //switch to OFF
            }
        }
        //_LOG_A("DINGO: firmwareUpdateTimer just before decrement=%i.\n", firmwareUpdateTimer);
        if (AutoUpdate && !shouldReboot) {                                      // we don't want to autoupdate if we are on the verge of rebooting
            firmwareUpdateTimer--;
            char version[32];
            if (firmwareUpdateTimer == FW_UPDATE_DELAY) {                       // we now have to check for a new version
                //timer is not reset, proceeds to 65535 which is approx 18h from now
                if (getLatestVersion(String(String(OWNER_FACT) + "/" + String(REPO_FACT)), "", version)) {
                    if (fwNeedsUpdate(version)) {
                        _LOG_A("Firmware reports it needs updating, will update in %i seconds\n", FW_UPDATE_DELAY);
                        if (downloadUrl) { free(downloadUrl); downloadUrl = NULL; }
                        asprintf(&downloadUrl, "%s/fact_firmware.signed.bin", FW_DOWNLOAD_PATH); //will be freed in FirmwareUpdate() ; format: http://s3.com/fact_firmware.debug.signed.bin
                    } else {
                        _LOG_A("Firmware reports it needs NO update!\n");
                        firmwareUpdateTimer = random(FW_UPDATE_DELAY + 36000, 0xffff);  // at least 10 hours in between checks
                    }
                }
            } else if (firmwareUpdateTimer == 0) {                              // time to download & flash!
                if (getLatestVersion(String(String(OWNER_FACT) + "/" + String(REPO_FACT)), "", version)) { // recheck version info
                    if (fwNeedsUpdate(version)) {
                        _LOG_A("Firmware reports it needs updating, starting update NOW!\n");
                        if (downloadUrl) { free(downloadUrl); downloadUrl = NULL; }
                        asprintf(&downloadUrl, "%s/fact_firmware.signed.bin", FW_DOWNLOAD_PATH); //will be freed in FirmwareUpdate() ; format: http://s3.com/fact_firmware.debug.signed.bin
                        RunFirmwareUpdate();
                    } else {
                        _LOG_A("Firmware changed its mind, NOW it reports it needs NO update!\n");
                    }
                    //note: the firmwareUpdateTimer will decrement to 65535s so next check will be in 18hours or so....
                }
            }
        } // AutoUpdate
        /////end of non-time critical stuff
    }

    //OCPP lifecycle management
#if ENABLE_OCPP && defined(SMARTEVSE_VERSION) //run OCPP only on ESP32
    if (OcppMode && !getOcppContext() && WiFi.isConnected()) {
        ocppInit();
    } else if (!OcppMode && getOcppContext()) {
        ocppDeinit();
    }

    if (OcppMode && getOcppContext()) {
        ocppLoop();
    }
#endif //ENABLE_OCPP

}
#endif //ESP32