Add temperature monitoring with warning/error thresholds to LEM DCBM 400/600 (EVerest#1936)

Summary:
Implements configurable temperature monitoring for the LEM DCBM 400/600
powermeter module, monitoring temperatureH and temperatureL sensors against
configurable warning and error thresholds with hysteresis and minimum
exceedance duration.

Features:
- Temperature monitoring with independent warning and error thresholds
- Hysteresis-based clearing to prevent oscillation
- Minimum time requirement before raising events (configurable)
- Uses max(temperatureH, temperatureL) for evaluation
- Raises powermeter/VendorWarning (non-blocking) and powermeter/VendorError
  (stops charging) via error framework

Configuration Options (manifest.yaml):
- temperature_warning_level_C: Warning threshold in °C (default: 5000 = disabled)
- temperature_error_level_C: Error threshold in °C (default: 5000 = disabled)
- temperature_hysteresis_K: Hysteresis in Kelvin for clearing (default: 3)
- temperature_min_time_as_valid_ms: Minimum exceedance duration in ms (default: 5000)

Error Framework Integration:
- Added powermeter/VendorWarning to EvseManager ignore list (allows charging to continue)
- Updated EvseManager documentation to reflect new error types

Signed-off-by: Florin Mihut <florinmihut1@gmail.com>

Author: florinmihut

errors/powermeter.yaml

@@ -34,4 +34,4 @@ vars:
     description: The public key for OCMF
     type: string
 errors:
-  - reference: /errors/powermeter
+  - reference: /errors/generic

interfaces/powermeter.yaml

@@ -16,7 +16,7 @@ interfaces/ocpp.yaml,46a82fad56f8437d8567da9a1b7c4013ffa8eca9db187e034d02beda496
 interfaces/ocpp_data_transfer.yaml,dec8974ba68bf9ef20ba68616873f714bd0a3255c6ea28fefc6f5c524666aebe
 interfaces/over_voltage_monitor.yaml,e900756a2058fca6c24434ac153c34afdf109ad582ca33c5aad0a725b70ddbfa
 interfaces/power_supply_DC.yaml,7cc64002367143c4898589610739acd80063962e97a1456f66897b0856f916b3
-interfaces/powermeter.yaml,e976a19789e0e9dee51a4682821399b8e5e546e0f8770571044e8757bd5f6eb9
+interfaces/powermeter.yaml,0a563ca6f885a13df69a570d7c02d39805c8eb4b6010fe93b1fb287d80c3b510
 interfaces/session_cost.yaml,4afd6dd67938dbc50e3d92751b27313cdcc083fb016998236d32f329df0ac806
 interfaces/slac.yaml,973bb6d035e7ada95a0a589e0c1453000d37f637cecac53af5c12afe73be05e7
 interfaces/system.yaml,4a5eb3f88d7934c3b7d0945aed369e4a6d95028a2c97d4e3090a0f73c1e0dcaf

lib/everest/everest_api_types/tests/expected_interfaces_file_hashes.csv

@@ -42,7 +42,7 @@ static const struct IgnoreErrors {
     ErrorList ac_rcd{"ac_rcd/VendorWarning"};
     ErrorList imd{"isolation_monitor/VendorWarning"};
     ErrorList powersupply{"power_supply_DC/VendorWarning"};
-    ErrorList powermeter{};
+    ErrorList powermeter{"powermeter/VendorWarning"};
     ErrorList over_voltage_monitor{"over_voltage_monitor/VendorWarning"};
 } ignore_errors;
 

modules/EVSE/EvseManager/ErrorHandling.cpp

@@ -288,6 +288,11 @@ powermeter
 Powermeter errors cause the EvseManager to become Inoperative, if fail_on_powermeter_errors is configured to true. If it is configured to false, errors from the powermeter will not cause the EvseManager to become Inoperative.
 
 * powermeter/CommunicationFault
+* powermeter/VendorError
+
+Note that ``powermeter/VendorWarning`` is explicitly ignored by the EvseManager's inoperative logic (similar to other ``VendorWarning`` errors)
+and will not block charging even if ``fail_on_powermeter_errors`` is set to true. It should be used to signal non-fatal conditions such as
+high temperature warnings from the powermeter.
 
 When a charging session is stopped because of an error, the EvseManager differentiates between **Emergency Shutdowns** and **Error Shutdowns**. The severity of the
 error influences the type of the shudown. Emergency shutdowns are caused by errors with `Severity::High` and error shutdowns are caused by errors with `Severity::Medium` or `Severity::Low`.

modules/EVSE/EvseManager/docs/index.rst

@@ -39,6 +39,10 @@ struct Conf {
     int SC;
     std::string UV;
     std::string UD;
+    double temperature_warning_level_C;
+    double temperature_error_level_C;
+    double temperature_hysteresis_K;
+    int temperature_min_time_as_valid_ms;
     int command_timeout_ms;
 };
 

modules/HardwareDrivers/PowerMeters/LemDCBM400600/LemDCBM400600.hpp

@@ -5,6 +5,8 @@
 #include "http_client.hpp"
 #include "lem_dcbm_time_sync_helper.hpp"
 #include <chrono>
+#include <everest/logging.hpp>
+#include <fmt/core.h>
 #include <string>
 #include <thread>
 
@@ -27,6 +29,21 @@ void powermeterImpl::init() {
             mod->config.resilience_transaction_request_retries, mod->config.resilience_transaction_request_retry_delay,
             mod->config.cable_id, mod->config.tariff_id, mod->config.meter_timezone, mod->config.meter_dst,
             mod->config.SC, mod->config.UV, mod->config.UD, mod->config.command_timeout_ms});
+
+    // Validate and normalize temperature thresholds for the monitor.
+    // If the error level is configured below the warning level, clamp it and log a warning.
+    double warning_level_C = mod->config.temperature_warning_level_C;
+    double error_level_C = mod->config.temperature_error_level_C;
+    if (error_level_C < warning_level_C) {
+        EVLOG_warning << "LEM DCBM 400/600: temperature_error_level_C (" << error_level_C
+                      << " °C) is below temperature_warning_level_C (" << warning_level_C
+                      << " °C). Clamping error level to the warning level.";
+        error_level_C = warning_level_C;
+    }
+
+    this->temperature_monitor = std::make_unique<TemperatureMonitor>(
+        TemperatureMonitor::Config{warning_level_C, error_level_C, mod->config.temperature_hysteresis_K,
+                                   std::chrono::milliseconds(mod->config.temperature_min_time_as_valid_ms)});
 }
 
 void powermeterImpl::ready() {
@@ -41,14 +58,23 @@ void powermeterImpl::ready() {
                         std::chrono::milliseconds(mod->config.resilience_initial_connection_retry_delay));
                 } else {
                     std::this_thread::sleep_for(std::chrono::milliseconds(1000));
-                    this->publish_powermeter(this->controller->get_powermeter());
+                    auto powermeter_data = this->controller->get_powermeter();
+                    this->publish_powermeter(powermeter_data);
                     // if the communication error is set, clear the error
                     if (this->error_state_monitor->is_error_active("powermeter/CommunicationFault",
                                                                    "Communication timed out")) {
                         // need to update LEM status since we have recovered from a communication loss
                         this->controller->update_lem_status();
                         clear_error("powermeter/CommunicationFault", "Communication timed out");
                     }
+
+                    // Evaluate temperature thresholds
+                    if (powermeter_data.temperatures.has_value() && powermeter_data.temperatures->size() >= 2) {
+                        const double temp_H = powermeter_data.temperatures->at(0).temperature;
+                        const double temp_L = powermeter_data.temperatures->at(1).temperature;
+                        auto events = this->temperature_monitor->update(temp_H, temp_L);
+                        handle_temperature_events(events, this->temperature_monitor->last_max_temperature());
+                    }
                 }
             } catch (LemDCBM400600Controller::DCBMUnexpectedResponseException& dcbm_exception) {
                 EVLOG_error << "Failed to publish powermeter value due to an invalid device response: "
@@ -77,4 +103,39 @@ types::powermeter::TransactionStopResponse powermeterImpl::handle_stop_transacti
     return this->controller->stop_transaction(transaction_id);
 }
 
+void powermeterImpl::handle_temperature_events(const TemperatureMonitor::Events& events, double max_temperature) {
+    if (events.warning_raised) {
+        EVLOG_warning << fmt::format(
+            "LEM DCBM 400/600: Temperature warning raised — max temperature {:.1f} °C exceeds warning level {:.1f} °C",
+            max_temperature, mod->config.temperature_warning_level_C);
+        auto error =
+            this->error_factory->create_error("powermeter/VendorWarning", "TemperatureWarning",
+                                              fmt::format("Max temperature {:.1f} °C exceeds warning level {:.1f} °C",
+                                                          max_temperature, mod->config.temperature_warning_level_C));
+        raise_error(error);
+    }
+    if (events.warning_cleared) {
+        EVLOG_info << fmt::format(
+            "LEM DCBM 400/600: Temperature warning cleared — max temperature {:.1f} °C dropped below {:.1f} °C",
+            max_temperature, mod->config.temperature_warning_level_C - mod->config.temperature_hysteresis_K);
+        clear_error("powermeter/VendorWarning", "TemperatureWarning");
+    }
+    if (events.error_raised) {
+        EVLOG_error << fmt::format(
+            "LEM DCBM 400/600: Temperature error raised — max temperature {:.1f} °C exceeds error level {:.1f} °C",
+            max_temperature, mod->config.temperature_error_level_C);
+        auto error =
+            this->error_factory->create_error("powermeter/VendorError", "TemperatureError",
+                                              fmt::format("Max temperature {:.1f} °C exceeds error level {:.1f} °C",
+                                                          max_temperature, mod->config.temperature_error_level_C));
+        raise_error(error);
+    }
+    if (events.error_cleared) {
+        EVLOG_info << fmt::format(
+            "LEM DCBM 400/600: Temperature error cleared — max temperature {:.1f} °C dropped below {:.1f} °C",
+            max_temperature, mod->config.temperature_error_level_C - mod->config.temperature_hysteresis_K);
+        clear_error("powermeter/VendorError", "TemperatureError");
+    }
+}
+
 } // namespace module::main

modules/HardwareDrivers/PowerMeters/LemDCBM400600/main/powermeterImpl.cpp

@@ -16,6 +16,7 @@
 // insert your custom include headers here
 #include "http_client_interface.hpp"
 #include "lem_dcbm_400600_controller.hpp"
+#include "temperature_monitor.hpp"
 // ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
 
 namespace module {
@@ -61,6 +62,10 @@ class powermeterImpl : public powermeterImplBase {
     // Initially it's a default-constructed thread (which is valid, but doesn't represent an actual running thread)
     // In ready(), the live_measure_publisher thread is started and placed in this field.
     std::thread live_measure_publisher_thread;
+
+    // Temperature monitoring with warning/error thresholds and hysteresis
+    std::unique_ptr<TemperatureMonitor> temperature_monitor;
+    void handle_temperature_events(const TemperatureMonitor::Events& events, double max_temperature);
     // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
 };
 

modules/HardwareDrivers/PowerMeters/LemDCBM400600/main/powermeterImpl.hpp

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#ifndef LEM_DCBM_TEMPERATURE_MONITOR_HPP
+#define LEM_DCBM_TEMPERATURE_MONITOR_HPP
+
+#include <algorithm>
+#include <chrono>
+#include <optional>
+
+namespace module::main {
+
+/// Monitors temperature readings against warning and error thresholds
+/// with hysteresis and a minimum exceedance duration before raising events.
+class TemperatureMonitor {
+public:
+    struct Config {
+        double warning_level_C;
+        double error_level_C;
+        double hysteresis_K;
+        std::chrono::milliseconds min_time_as_valid;
+    };
+
+    struct Events {
+        bool warning_raised{false};
+        bool warning_cleared{false};
+        bool error_raised{false};
+        bool error_cleared{false};
+    };
+
+    explicit TemperatureMonitor(const Config& config) : config_(config) {
+    }
+
+    /// Feed new temperature readings and get back any state-change events.
+    /// The evaluation uses max(temperature_H, temperature_L).
+    Events update(double temperature_H_C, double temperature_L_C) {
+        last_max_temperature_ = std::max(temperature_H_C, temperature_L_C);
+        const auto now = std::chrono::steady_clock::now();
+
+        Events events;
+        evaluate_level(warning_active_, warning_exceeded_since_, config_.warning_level_C, now, events.warning_raised,
+                       events.warning_cleared);
+        evaluate_level(error_active_, error_exceeded_since_, config_.error_level_C, now, events.error_raised,
+                       events.error_cleared);
+        return events;
+    }
+
+    /// Returns the current max temperature from the last update (for logging).
+    [[nodiscard]] double last_max_temperature() const {
+        return last_max_temperature_;
+    }
+
+private:
+    Config config_;
+
+    bool warning_active_{false};
+    std::optional<std::chrono::steady_clock::time_point> warning_exceeded_since_;
+
+    bool error_active_{false};
+    std::optional<std::chrono::steady_clock::time_point> error_exceeded_since_;
+
+    double last_max_temperature_{0.0};
+
+    void evaluate_level(bool& active, std::optional<std::chrono::steady_clock::time_point>& exceeded_since,
+                        double threshold, std::chrono::steady_clock::time_point now, bool& raised_event,
+                        bool& cleared_event) {
+
+        if (!active) {
+            // Not yet active — check if we should start or continue timing
+            if (last_max_temperature_ >= threshold) {
+                if (!exceeded_since.has_value()) {
+                    // First time exceeding: start the timer
+                    exceeded_since = now;
+                }
+                // Check if minimum exceedance duration has elapsed
+                if ((now - exceeded_since.value()) >= config_.min_time_as_valid) {
+                    active = true;
+                    exceeded_since.reset();
+                    raised_event = true;
+                }
+            } else {
+                // Temperature dropped below threshold before timer expired — reset
+                exceeded_since.reset();
+            }
+        } else {
+            // Active — check if we should clear (with hysteresis)
+            if (last_max_temperature_ < (threshold - config_.hysteresis_K)) {
+                active = false;
+                exceeded_since.reset();
+                cleared_event = true;
+            }
+        }
+    }
+};
+
+} // namespace module::main
+
+#endif // LEM_DCBM_TEMPERATURE_MONITOR_HPP

modules/HardwareDrivers/PowerMeters/LemDCBM400600/main/temperature_monitor.hpp

@@ -75,6 +75,35 @@ config:
     description: UD (OCMF/transaction fields)
     type: string
     default: ""
+  temperature_warning_level_C:
+    description: >-
+      Temperature warning threshold in degrees Celsius. If the maximum of temperatureH
+      and temperatureL exceeds this value for at least temperature_min_time_as_valid_ms,
+      a VendorWarning is raised. Charging continues. Default of 5000 effectively disables this.
+    type: number
+    default: 5000
+  temperature_error_level_C:
+    description: >-
+      Temperature error threshold in degrees Celsius. If the maximum of temperatureH
+      and temperatureL exceeds this value for at least temperature_min_time_as_valid_ms,
+      a VendorError is raised. Charging is stopped. Default of 5000 effectively disables this.
+    type: number
+    default: 5000
+  temperature_hysteresis_K:
+    description: >-
+      Hysteresis in Kelvin for clearing temperature warnings and errors.
+      A warning is cleared when max temperature drops below warning_level - hysteresis.
+      An error is cleared when max temperature drops below error_level - hysteresis.
+    type: number
+    default: 3
+    minimum: 0
+  temperature_min_time_as_valid_ms:
+    description: >-
+      Minimum time in milliseconds that the temperature must continuously exceed
+      the warning or error level before the corresponding event is raised.
+    type: integer
+    default: 5000
+    minimum: 0
   command_timeout_ms:
     description: The timeout in milliseconds for a HTTP command to the LEM power meter.
     type: integer