Publish EIC event-code and protection sensors for seplos_bms_v3_ble

decode_eic_data_ only published problem_code/problem_text. Publish the
remaining EIC entities (already defined in the schema): the system state,
voltage, temperature and current event codes plus the voltage,
temperature, current protection and system-fault binary sensors.

The cell-temperature (TB03) and ambient/power-temperature (TB04) tables
are merged into a single temperature event code (TB03 high byte, TB04 low
byte) so no detail is lost; the heating status bit (TB04 bit6) stays in
the raw code but is masked out of the protection flag. The per-event
debug log is dropped now that the values are published.

Covered by EIC tests for every code and binary sensor, including a new
EIC_DATA_AMBIENT_TEMP frame for the combined temperature path.

Author: syssi

components/seplos_bms_v3_ble/seplos_bms_v3_ble.cpp

@@ -444,35 +444,35 @@ void SeplosBmsV3Ble::decode_eic_data_(const std::vector<uint8_t> &data) {
 
   // EIC carries ten single-byte event codes (registers 0x2200–0x2248, see protocol
   // status tables). System state (TB09), FET event (TB07) and equalization state
-  // (TB08) describe normal operation, not faults, so they must not raise a problem.
-  // Each remaining alarm/protection/fault byte contributes one bit to the problem code.
-  struct EventCode {
-    uint8_t index;
-    uint8_t fault_mask;
-    uint32_t flag;
-    const char *name;
-  };
-  static const EventCode EVENT_CODES[] = {
-      {1, 0xFF, 1 << 0, "voltage"},              // TB02
-      {2, 0xFF, 1 << 1, "cell temperature"},     // TB03
-      {3, 0x3F, 1 << 2, "ambient temperature"},  // TB04 (bit6 "low temperature heating" is status)
-      {4, 0xFF, 1 << 3, "current"},              // TB05
-      {5, 0xFF, 1 << 4, "current latch"},        // TB16
-      {6, 0xFF, 1 << 5, "capacity"},             // TB06
-      {9, 0xFF, 1 << 6, "hard fault"},           // TB15
-  };
-
+  // (TB08) describe normal operation, not faults, so they do not raise a problem.
+  // Each remaining alarm/protection/fault byte contributes one bit to the problem
+  // code; TB04 bit6 ("low temperature heating") is an operating state and is masked.
   uint32_t problem_code = 0;
-  for (auto &event : EVENT_CODES) {
-    uint8_t value = data[event.index] & event.fault_mask;
-    if (value == 0)
-      continue;
-    problem_code |= event.flag;
-    ESP_LOGD(TAG, "  %s event code: 0x%02X", event.name, value);
-  }
+  problem_code |= uint32_t(data[1] != 0) << 0;           // TB02 voltage
+  problem_code |= uint32_t(data[2] != 0) << 1;           // TB03 cell temperature
+  problem_code |= uint32_t((data[3] & 0x3F) != 0) << 2;  // TB04 ambient temperature
+  problem_code |= uint32_t(data[4] != 0) << 3;           // TB05 current
+  problem_code |= uint32_t(data[5] != 0) << 4;           // TB16 current latch
+  problem_code |= uint32_t(data[6] != 0) << 5;           // TB06 capacity
+  problem_code |= uint32_t(data[9] != 0) << 6;           // TB15 hard fault
 
   this->publish_state_(this->problem_code_sensor_, (float) problem_code);
   this->publish_state_(this->problem_text_sensor_, problem_code != 0 ? "Problem detected" : "No problems");
+
+  // Raw event-code registers (diagnostic). The temperature code merges the cell
+  // (TB03, data[2]) and ambient/power (TB04, data[3]) event bytes into one 16-bit
+  // value — TB03 high byte, TB04 low byte — so neither table is lost.
+  this->publish_state_(this->system_state_code_sensor_, (float) data[0]);                          // TB09
+  this->publish_state_(this->voltage_event_code_sensor_, (float) data[1]);                         // TB02
+  this->publish_state_(this->temperature_event_code_sensor_, (float) ((data[2] << 8) | data[3]));  // TB03 + TB04
+  this->publish_state_(this->current_event_code_sensor_, (float) data[4]);                         // TB05
+
+  // Protection / fault flags. "Low temperature heating" (TB04 bit6) is an operating
+  // state, not a fault, so it is masked out of the temperature protection flag.
+  this->publish_state_(this->voltage_protection_binary_sensor_, data[1] != 0);
+  this->publish_state_(this->temperature_protection_binary_sensor_, (data[2] != 0) || ((data[3] & 0x3F) != 0));
+  this->publish_state_(this->current_protection_binary_sensor_, (data[4] != 0) || (data[5] != 0));
+  this->publish_state_(this->system_fault_binary_sensor_, data[9] != 0);
 }
 
 void SeplosBmsV3Ble::decode_via_data_(const std::vector<uint8_t> &data) {

tests/components/seplos_bms_v3_ble/frames.h

@@ -162,6 +162,13 @@ static const std::vector<uint8_t> EIC_DATA_HEATING = {
     0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
+// EIC with an ambient/power temperature fault (TB04, byte 3, Bit0) — unlike the
+// heating status bit this is a real fault, so it must fold into the temperature
+// event code and raise temperature protection.
+static const std::vector<uint8_t> EIC_DATA_AMBIENT_TEMP = {
+    0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
 // SPA captures retained for upcoming sensor tests (no consumer yet).
 //
 // SPA payload, first request (106 bytes) – System Parameters, registers 0x1300–0x1334

tests/components/seplos_bms_v3_ble/seplos_bms_v3_ble_test.cpp

@@ -285,6 +285,105 @@ TEST(SeplosBmsV3BleEicTest, HeatingIsNotAProblem) {
   EXPECT_EQ(problem_text.state, "No problems");
 }
 
+// ── EIC: event-code sensors and protection binary sensors ─────────────────────
+
+// Raw event-code registers: TB09 state (byte 0), TB02 voltage (byte 1),
+// TB05 current (byte 4); the cell-temperature alarm (TB03, byte 2) lands in the
+// high byte of the combined temperature code.
+TEST(SeplosBmsV3BleEicTest, EventCodeSensors) {
+  TestableSeplosBmsV3Ble bms;
+  sensor::Sensor system_state, voltage_code, temperature_code, current_code;
+  bms.set_system_state_code_sensor(&system_state);
+  bms.set_voltage_event_code_sensor(&voltage_code);
+  bms.set_temperature_event_code_sensor(&temperature_code);
+  bms.set_current_event_code_sensor(&current_code);
+
+  bms.decode_eic(EIC_DATA_WITH_PROBLEM);  // data[2] = 0x01
+
+  EXPECT_FLOAT_EQ(system_state.state, 0.0f);
+  EXPECT_FLOAT_EQ(voltage_code.state, 0.0f);
+  EXPECT_FLOAT_EQ(temperature_code.state, 256.0f);  // (0x01 << 8) | 0x00
+  EXPECT_FLOAT_EQ(current_code.state, 0.0f);
+}
+
+// TB03 (cell temperature, high byte) and TB04 (ambient/power temperature, low byte)
+// share one temperature event-code sensor; an ambient fault sets the low byte and
+// raises temperature protection.
+TEST(SeplosBmsV3BleEicTest, TemperatureEventCodeCombinesCellAndAmbient) {
+  TestableSeplosBmsV3Ble bms;
+  sensor::Sensor temperature_code;
+  binary_sensor::BinarySensor temperature_protection;
+  bms.set_temperature_event_code_sensor(&temperature_code);
+  bms.set_temperature_protection_binary_sensor(&temperature_protection);
+
+  bms.decode_eic(EIC_DATA_AMBIENT_TEMP);  // data[3] = 0x01
+
+  EXPECT_FLOAT_EQ(temperature_code.state, 1.0f);  // (0x00 << 8) | 0x01
+  EXPECT_TRUE(temperature_protection.state);
+}
+
+// The heating status bit (TB04 bit6) is kept in the raw event code but masked out
+// of the protection flag.
+TEST(SeplosBmsV3BleEicTest, HeatingShowsInCodeButNotProtection) {
+  TestableSeplosBmsV3Ble bms;
+  sensor::Sensor temperature_code;
+  binary_sensor::BinarySensor temperature_protection;
+  bms.set_temperature_event_code_sensor(&temperature_code);
+  bms.set_temperature_protection_binary_sensor(&temperature_protection);
+
+  bms.decode_eic(EIC_DATA_HEATING);  // data[3] = 0x40
+
+  EXPECT_FLOAT_EQ(temperature_code.state, 64.0f);  // (0x00 << 8) | 0x40, raw byte kept
+  EXPECT_FALSE(temperature_protection.state);      // 0x40 & 0x3F == 0
+}
+
+TEST(SeplosBmsV3BleEicTest, ProtectionBinarySensors) {
+  TestableSeplosBmsV3Ble bms;
+  binary_sensor::BinarySensor voltage_protection, temperature_protection, current_protection, system_fault;
+  bms.set_voltage_protection_binary_sensor(&voltage_protection);
+  bms.set_temperature_protection_binary_sensor(&temperature_protection);
+  bms.set_current_protection_binary_sensor(&current_protection);
+  bms.set_system_fault_binary_sensor(&system_fault);
+
+  bms.decode_eic(EIC_DATA_WITH_PROBLEM);  // data[2] = 0x01 (cell temperature)
+
+  EXPECT_FALSE(voltage_protection.state);
+  EXPECT_TRUE(temperature_protection.state);
+  EXPECT_FALSE(current_protection.state);
+  EXPECT_FALSE(system_fault.state);
+}
+
+// Hard fault (TB15, byte 9) drives the dedicated system-fault flag.
+TEST(SeplosBmsV3BleEicTest, SystemFaultBinarySensor) {
+  TestableSeplosBmsV3Ble bms;
+  binary_sensor::BinarySensor system_fault;
+  bms.set_system_fault_binary_sensor(&system_fault);
+
+  bms.decode_eic(EIC_DATA_HARD_FAULT);  // data[9] = 0x02
+
+  EXPECT_TRUE(system_fault.state);
+}
+
+// Operating-status state code (TB09) is exposed but is not a protection event.
+TEST(SeplosBmsV3BleEicTest, SystemStateCodeIsNotProtection) {
+  TestableSeplosBmsV3Ble bms;
+  sensor::Sensor system_state;
+  binary_sensor::BinarySensor voltage_protection, temperature_protection, current_protection, system_fault;
+  bms.set_system_state_code_sensor(&system_state);
+  bms.set_voltage_protection_binary_sensor(&voltage_protection);
+  bms.set_temperature_protection_binary_sensor(&temperature_protection);
+  bms.set_current_protection_binary_sensor(&current_protection);
+  bms.set_system_fault_binary_sensor(&system_fault);
+
+  bms.decode_eic(EIC_DATA_STATUS_ONLY);  // data[0] = 0x10
+
+  EXPECT_FLOAT_EQ(system_state.state, 16.0f);
+  EXPECT_FALSE(voltage_protection.state);
+  EXPECT_FALSE(temperature_protection.state);
+  EXPECT_FALSE(current_protection.state);
+  EXPECT_FALSE(system_fault.state);
+}
+
 // ── PCT: inverter / protocol sensors ──────────────────────────────────────────
 
 TEST(SeplosBmsV3BlePctTest, Sensors) {
@@ -402,6 +501,7 @@ TEST(SeplosBmsV3BleSafetyTest, NullSensorsDoNotCrash) {
   EXPECT_NO_FATAL_FAILURE(bms.decode_eib(EIB_DATA));
   EXPECT_NO_FATAL_FAILURE(bms.decode_eic(EIC_DATA_NO_PROBLEM));
   EXPECT_NO_FATAL_FAILURE(bms.decode_eic(EIC_DATA_WITH_PROBLEM));
+  EXPECT_NO_FATAL_FAILURE(bms.decode_eic(EIC_DATA_AMBIENT_TEMP));
 }
 
 }  // namespace esphome::seplos_bms_v3_ble::testing