message_types.hpp

#pragma once
 
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
 
namespace blunux::pmu {
 
constexpr unsigned int NUMBER_OF_CELLS = 4;
constexpr unsigned int MANUFACTURE_NAME_LENGTH = 21;
constexpr unsigned int DEVICE_NAME_LENGTH = 21;
constexpr unsigned int DEVICE_CHEMISTRY = 5;
 
constexpr unsigned int ESC_SERIAL_LENGTH = 20;
constexpr unsigned int ESC_UID_LENGTH = 16;
constexpr unsigned int COMMIT_ID_LENGTH = 7;
 
enum class EscHwVersion : uint8_t { ipeaka = 0, speedy_bee = 1 };
 
namespace {
typedef struct __attribute__((__packed__)) {
  // Max reported cell voltage, [0, 32767], mV
  int16_t cell_max_voltages[NUMBER_OF_CELLS];
  // Min reported cell voltage, [0, 32767], mV
  int16_t cell_min_voltages[NUMBER_OF_CELLS];
  // Max delta between cells, [0, 32767], mV
  int16_t max_delta_cell_voltage;
  // Max reported current in the charge direction, [0, 32767], mA
  int16_t max_charge_current;
  // Max reported current in the discharge direction, [-32768, 0], mA
  int16_t max_discharge_current;
  // Max reported average current in the discharge direction, [-32768, 0], mA
  int16_t max_avg_discharge_current;
  // Max reported power in discharge direction, [-32768, 0], cW
  int16_t max_avg_discharge_power;
  // Max reported cell temperature, [-128, 127], °C
  int8_t max_cell_temperature;
  // Min reported cell temperature, [-128, 127], °C
  int8_t min_cell_temperature;
  // Max reported temperature delta for TSx inputs configured as cell
  // temperature, [-128, 127], °C
  int8_t max_delta_cell_temperature;
  // Max reported internal temperature sensor temperature, [-128, 127], °C
  int8_t max_temperature_internal_sensor;
  // Min reported internal temperature sensor temperature, [-128, 127], °C
  int8_t min_temperature_internal_sensor;
  // Max reported FET temperature, [-128, 127], °C
  int8_t max_temperature_fet;
} TBatteryLifetimesRaw;
 
typedef struct __attribute__((__packed__)) {
  // Number of cell overvoltage (COV) events, [0, 32767], events
  uint16_t cov_events_count;
  // Last COV event in cycle count cycles, [0, 32767], cycles
  uint16_t cov_last_event;
  // Number of cell undervoltage (CUV) events, [0, 32767], events
  uint16_t cuv_events_count;
  // Last CUV event in cycle count cycles, [0, 32767], cycles
  uint16_t cuv_last_event;
  // Number of Overcurrent in Discharge 1 (OCD1) events, [0, 32767], events
  uint16_t ocd1_events_count;
  // Last OCD1 event in cycle count cycles, [0, 32767], cycles
  uint16_t ocd1_last_event;
  // Number of Overcurrent in Discharge 2 (OCD2) events, [0, 32767], events
  uint16_t ocd2_events_count;
  // Last OCD2 event in cycle count cycles, [0, 32767], cycles
  uint16_t ocd2_last_event;
  // Number of Overcurrent in Charge 1 (OCC1) events, [0, 32767], events
  uint16_t occ1_events_count;
  // Last OCC1 event in cycle count cycles, [0, 32767], cycles
  uint16_t occ1_last_event;
  // Number of Overcurrent in Charge 2 (OCC2) events, [0, 32767], events
  uint16_t occ2_events_count;
  // Last OCC2 event in cycle count cycles, [0, 32767], cycles
  uint16_t occ2_last_event;
  // Number of Overload in discharge (AOLD) events, [0, 32767], events
  uint16_t aold_events_count;
  // Last AOLD event in cycle count cycles, [0, 32767], cycles
  uint16_t aold_last_event;
  // Number of Short Circuit in Discharge (ASCD) events, [0, 32767], events
  uint16_t ascd_events_count;
  // Last ASCD event in cycle count cycles, [0, 32767], cycles
  uint16_t ascd_last_event;
  // Number of Short Circuit in Charge (ASCC) events, [0, 32767], events
  uint16_t ascc_events_count;
  // Last ASCC event in cycle count cycles, [0, 32767], cycles
  uint16_t ascc_last_event;
  // Number of Overtemperature in Charge (OTC) events, [0, 32767], events
  uint16_t otc_events_count;
  // Last OTC event in cycle count cycles, [0, 32767], cycles
  uint16_t otc_last_event;
  // Number of Overtemperature in Discharge (OTD) events, [0, 32767], events
  uint16_t otd_events_count;
  // Last OTD event in cycle count cycles, [0, 32767], cycles
  uint16_t otd_last_event;
  // Number of Overtemperature in FET (OTF) events, [0, 32767], events
  uint16_t otf_events_count;
  // Last OTF event in cycle count cycles, [0, 32767], cycles
  uint16_t otf_last_event;
} TBatterySafetyEventsRaw;
 
typedef struct __attribute__((__packed__)) {
  // Total number of valid charge termination events, [0, 32767], events
  uint16_t charge_termination_events_count;
  // Last valid charge termination in cycle count cycles, [0, 32767], cycles
  uint16_t charge_termination_last_event;
} TBatteryChargingEventsRaw;
 
typedef struct __attribute__((__packed__)) {
  uint16_t temperature;
  uint16_t voltage;
  int32_t current;
  int32_t average_current;
 
  uint8_t state_of_charge_rel;
  uint16_t remaining_capacity;
  uint16_t full_charge_capacity;
  uint16_t run_time_to_empty;
  uint16_t avg_time_to_empty;
  uint16_t avg_time_to_full;
  uint16_t at_rate_time_to_full;
  uint16_t at_rate_time_to_empty;
 
  uint16_t charging_current;
  uint16_t charging_voltage;
 
  uint16_t battery_status;
 
  uint16_t cell_voltage[NUMBER_OF_CELLS];
  int16_t cell_temperature[NUMBER_OF_CELLS];
} TBatteryStatusRaw;
 
typedef struct __attribute__((__packed__)) {
  uint8_t max_error;
  uint8_t abs_soc;
  uint16_t cycle_count;
  uint16_t design_capacity;
  uint16_t manufacture_date;
  uint16_t serial_number;
  char manufacture_name[MANUFACTURE_NAME_LENGTH];
  char device_name[DEVICE_NAME_LENGTH];
  char device_chemistry[DEVICE_CHEMISTRY];
  TBatteryLifetimesRaw lifetimes;
  TBatterySafetyEventsRaw safety_events;
  TBatteryChargingEventsRaw charging_events;
} TBatteryInfoRaw;
 
typedef struct __attribute__((__packed__)) {
  EscHwVersion hw_version;
  char serial_number[ESC_SERIAL_LENGTH];
  char uid[ESC_UID_LENGTH];
  uint8_t serial_number_read_status;
  uint8_t uid_read_status;
  uint8_t hw_version_read_status;
} TEscInfoRaw;
 
typedef struct __attribute__((__packed__)) {
  uint8_t transfer_status;
} TEscSetSerialReplyRaw;
 
typedef struct __attribute__((__packed__)) {
  uint8_t ver_major;
  uint8_t ver_minor;
  uint16_t ver_patch;
  char commit_id[COMMIT_ID_LENGTH];
} TVersionInfoRaw;
 
typedef struct __attribute__((__packed__)) {
  uint8_t humidity_low_byte;
  uint8_t humidity_high_byte;
  uint8_t temperature_low_byte;
  uint8_t temperature_high_byte;
} TTempHumidityRaw;
}  // namespace
 
struct TBatteryLifetimes {
  // Max reported cell voltage, V
  float cell_max_voltages[NUMBER_OF_CELLS];
  // Min reported cell voltage, V
  float cell_min_voltages[NUMBER_OF_CELLS];
  // Max delta between cells, V
  float max_delta_cell_voltage;
  // Max reported current in the charge direction, A
  float max_charge_current;
  // Max reported current in the discharge direction, A
  float max_discharge_current;
  // Max reported average current in the discharge direction, A
  float max_avg_discharge_current;
  // Max reported power in discharge direction, W
  float max_avg_discharge_power;
  // Max reported cell temperature, °C
  float max_cell_temperature;
  // Min reported cell temperature, °C
  float min_cell_temperature;
  // Max reported temperature delta for TSx inputs configured as cell
  // temperature, °C
  float max_delta_cell_temperature;
  // Max reported internal temperature sensor temperature, °C
  float max_temperature_internal_sensor;
  // Min reported internal temperature sensor temperature, °C
  float min_temperature_internal_sensor;
  // Max reported FET temperature, °C
  float max_temperature_fet;
};
 
struct TBatterySafetyEvents {
  // Number of cell overvoltage (COV) events, [0, 32767], events
  uint16_t cov_events_count;
  // Last COV event in cycle count cycles, [0, 32767], cycles
  uint16_t cov_last_event;
  // Number of cell undervoltage (CUV) events, [0, 32767], events
  uint16_t cuv_events_count;
  // Last CUV event in cycle count cycles, [0, 32767], cycles
  uint16_t cuv_last_event;
  // Number of Overcurrent in Discharge 1 (OCD1) events, [0, 32767], events
  uint16_t ocd1_events_count;
  // Last OCD1 event in cycle count cycles, [0, 32767], cycles
  uint16_t ocd1_last_event;
  // Number of Overcurrent in Discharge 2 (OCD2) events, [0, 32767], events
  uint16_t ocd2_events_count;
  // Last OCD2 event in cycle count cycles, [0, 32767], cycles
  uint16_t ocd2_last_event;
  // Number of Overcurrent in Charge 1 (OCC1) events, [0, 32767], events
  uint16_t occ1_events_count;
  // Last OCC1 event in cycle count cycles, [0, 32767], cycles
  uint16_t occ1_last_event;
  // Number of Overcurrent in Charge 2 (OCC2) events, [0, 32767], events
  uint16_t occ2_events_count;
  // Last OCC2 event in cycle count cycles, [0, 32767], cycles
  uint16_t occ2_last_event;
  // Number of Overload in discharge (AOLD) events, [0, 32767], events
  uint16_t aold_events_count;
  // Last AOLD event in cycle count cycles, [0, 32767], cycles
  uint16_t aold_last_event;
  // Number of Short Circuit in Discharge (ASCD) events, [0, 32767], events
  uint16_t ascd_events_count;
  // Last ASCD event in cycle count cycles, [0, 32767], cycles
  uint16_t ascd_last_event;
  // Number of Short Circuit in Charge (ASCC) events, [0, 32767], events
  uint16_t ascc_events_count;
  // Last ASCC event in cycle count cycles, [0, 32767], cycles
  uint16_t ascc_last_event;
  // Number of Overtemperature in Charge (OTC) events, [0, 32767], events
  uint16_t otc_events_count;
  // Last OTC event in cycle count cycles, [0, 32767], cycles
  uint16_t otc_last_event;
  // Number of Overtemperature in Discharge (OTD) events, [0, 32767], events
  uint16_t otd_events_count;
  // Last OTD event in cycle count cycles, [0, 32767], cycles
  uint16_t otd_last_event;
  // Number of Overtemperature in FET (OTF) events, [0, 32767], events
  uint16_t otf_events_count;
  // Last OTF event in cycle count cycles, [0, 32767], cycles
  uint16_t otf_last_event;
};
 
struct TBatteryChargingEvents {
  // Total number of valid charge termination events, [0, 32767], events
  uint16_t charge_termination_events_count;
  // Last valid charge termination in cycle count cycles, [0, 32767], cycles
  uint16_t charge_termination_last_event;
};
 
struct TBatteryStatus {
  float temperature;      // (°C)
  float voltage;          // (V)
  float current;          // (A)
  float average_current;  // (A)
 
  float state_of_charge_rel;         // (0..1)
  float state_of_charge_calculated;  // (0..1)
  float remaining_capacity;          // (Ah)
  float full_charge_capacity;        // (Ah)
  uint32_t run_time_to_empty;        // (s)
  uint32_t avg_time_to_empty;        // (s)
  uint32_t avg_time_to_full;         // (s)
 
  float charging_current;  // (A)
  float charging_voltage;  // (V)
 
  uint16_t battery_status;
 
  float cell_voltage[NUMBER_OF_CELLS];      // (V)
  float cell_temperature[NUMBER_OF_CELLS];  // (°C)
};
 
struct TBatteryInfo {
  uint8_t max_error;
  float abs_soc;
  uint16_t cycle_count;
  float design_capacity;
  tm manufacture_date;
  uint16_t serial_number;
  std::string manufacture_name;
  std::string device_name;
  std::string device_chemistry;
  TBatteryLifetimes lifetimes;
  TBatterySafetyEvents safety_events;
  TBatteryChargingEvents charging_events;
};
 
struct EscUid {
  char uid[ESC_UID_LENGTH];
};
 
enum class PMUI2CStatusCode {
  Ok,               // Transfer completed successfully
  Busy,             // I2C is busy with other transfer
  Idle,             // Bus is idle
  Nak,              // NAK received during transfer
  ArbitrationLost,  // Arbitration lost during transfer
  Timeout,          // Transfer timed out
  AddressNak,       // NAK received during address probe
  UnknownError,     // Unknown error
};
 
struct TEscInfo {
  EscHwVersion hw_version;
  std::string serial_number;
  EscUid uid;
  PMUI2CStatusCode serial_number_read_status;
  PMUI2CStatusCode uid_read_status;
  PMUI2CStatusCode hw_version_read_status;
};
 
struct TEscSetSerialReply {
  PMUI2CStatusCode transfer_status;
};
 
struct TVersionInfo {
  uint8_t ver_major = 0;
  uint8_t ver_minor = 0;
  uint16_t ver_patch = 0;
  std::string commit_id = "Unknown";
};
 
struct TTempHumidity {
  double humidity;
  double temperature;
};
 
enum class PMUErrorCode {
  NoMagicByte,
  WrongProtocolVersion,
  UnknownPacketType,
  CRCError,
  NoAck,
  NoVersion,
  NoEscInfo,
  NoEscSetSerialReply,
  NoBatteryInfo,
};
 
struct TPMUError {
  PMUErrorCode errorcode;
};
 
}  // namespace blunux::pmu
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::EscHwVersion version) {
  switch (version) {
    case blunux::pmu::EscHwVersion::ipeaka:
      return os << "iPeaka";
    case blunux::pmu::EscHwVersion::speedy_bee:
      return os << "SpeedyBee";
    default:
      return os << static_cast<int>(version);
  }
}
template <>
struct fmt::formatter<blunux::pmu::EscHwVersion> : formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  // NOLINTNEXTLINE(runtime/references)
  auto format(blunux::pmu::EscHwVersion version, FormatContext& ctx) const {
    std::stringstream ss;
    ss << version;
    return formatter<string_view>::format(ss.str(), ctx);
  }
};
 
template <>
struct fmt::formatter<blunux::pmu::EscUid> : formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  // NOLINTNEXTLINE(runtime/references)
  auto format(blunux::pmu::EscUid uid, FormatContext& ctx) const {
    std::stringstream ss;
    ss << std::hex << std::setfill('0');
    for (unsigned int i = 0; i < blunux::pmu::ESC_UID_LENGTH; i++) {
      ss << std::setw(2) << std::hex << static_cast<int>(uid.uid[i]);
      if (i == 3 || i == 5 || i == 7 || i == 9) {
        ss << "-";
      }
    }
    return formatter<string_view>::format(ss.str(), ctx);
  }
};
 
inline std::ostream& operator<<(std::ostream& os, blunux::pmu::EscUid data) {
  return os << fmt::format("{}", data);
}
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::TVersionInfo version) {
  return os << fmt::format("{}.{}.{} {}", version.ver_major, version.ver_minor,
                           version.ver_patch, version.commit_id);
}
 
template <>
struct fmt::formatter<blunux::pmu::TVersionInfo> : formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  // NOLINTNEXTLINE(runtime/references)
  auto format(blunux::pmu::TVersionInfo version, FormatContext& ctx) const {
    std::stringstream ss;
    ss << version;
    return formatter<string_view>::format(ss.str(), ctx);
  }
};
 
template <>
struct fmt::formatter<blunux::pmu::PMUErrorCode> {
  template <typename ParseContext>
  // NOLINTNEXTLINE(runtime/references)
  constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }
  template <typename FormatContext>
  auto format(blunux::pmu::PMUErrorCode const& error,
              FormatContext& ctx) const {  // NOLINT(runtime/references)
    switch (error) {
      case blunux::pmu::PMUErrorCode::NoMagicByte:
        return fmt::format_to(ctx.out(), "NoMagicByte");
      case blunux::pmu::PMUErrorCode::WrongProtocolVersion:
        return fmt::format_to(ctx.out(), "WrongProtocolVersion");
      case blunux::pmu::PMUErrorCode::UnknownPacketType:
        return fmt::format_to(ctx.out(), "UnknownPacketType");
      case blunux::pmu::PMUErrorCode::CRCError:
        return fmt::format_to(ctx.out(), "CRCError");
      case blunux::pmu::PMUErrorCode::NoAck:
        return fmt::format_to(ctx.out(), "NoAck");
      case blunux::pmu::PMUErrorCode::NoVersion:
        return fmt::format_to(ctx.out(), "NoVersion");
      case blunux::pmu::PMUErrorCode::NoEscInfo:
        return fmt::format_to(ctx.out(), "NoEscInfo");
      case blunux::pmu::PMUErrorCode::NoEscSetSerialReply:
        return fmt::format_to(ctx.out(), "NoEscSetSerialReply");
      case blunux::pmu::PMUErrorCode::NoBatteryInfo:
        return fmt::format_to(ctx.out(), "NoBatteryInfo");
    }
    return fmt::format_to(ctx.out(), "");
  }
};
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::PMUErrorCode data) {
  return os << fmt::format("{}", data);
}
 
template <>
struct fmt::formatter<blunux::pmu::PMUI2CStatusCode> {
  template <typename ParseContext>
  // NOLINTNEXTLINE(runtime/references)
  constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }
  template <typename FormatContext>
  auto format(blunux::pmu::PMUI2CStatusCode const& status,
              FormatContext& ctx) const {  // NOLINT(runtime/references)
    switch (status) {
      case blunux::pmu::PMUI2CStatusCode::Ok:
        return fmt::format_to(ctx.out(), "Ok");
      case blunux::pmu::PMUI2CStatusCode::Busy:
        return fmt::format_to(ctx.out(), "Busy");
      case blunux::pmu::PMUI2CStatusCode::Idle:
        return fmt::format_to(ctx.out(), "Idle");
      case blunux::pmu::PMUI2CStatusCode::Nak:
        return fmt::format_to(ctx.out(), "Nak");
      case blunux::pmu::PMUI2CStatusCode::ArbitrationLost:
        return fmt::format_to(ctx.out(), "ArbitrationLost");
      case blunux::pmu::PMUI2CStatusCode::Timeout:
        return fmt::format_to(ctx.out(), "Timeout");
      case blunux::pmu::PMUI2CStatusCode::AddressNak:
        return fmt::format_to(ctx.out(), "AddressNak");
      case blunux::pmu::PMUI2CStatusCode::UnknownError:
        return fmt::format_to(ctx.out(), "UnknownError");
    }
    return fmt::format_to(ctx.out(), "");
  }
};
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::PMUI2CStatusCode data) {
  return os << fmt::format("{}", data);
}
 
template <>
struct fmt::formatter<blunux::pmu::TPMUError> {
  template <typename ParseContext>
  // NOLINTNEXTLINE(runtime/references)
  constexpr auto parse(ParseContext& ctx) {
    return ctx.begin();
  }
 
  template <typename FormatContext>
  // NOLINTNEXTLINE(runtime/references)
  auto format(blunux::pmu::TPMUError const& error, FormatContext& ctx) const {
    return fmt::format_to(ctx.out(), "{}", error.errorcode);
  }
};
 
inline std::ostream& operator<<(std::ostream& os, blunux::pmu::TPMUError data) {
  return os << fmt::format("{}", data);
}
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::TEscInfo esc_info) {
  return os << fmt::format(
             "HW version: {}\nHW version transfer status: {}\nSerial: "
             "{}\nSerial transfer status: {}\nUID: {}\nUID transfer status: {}",
             esc_info.hw_version, esc_info.hw_version_read_status,
             esc_info.serial_number, esc_info.serial_number_read_status,
             esc_info.uid, esc_info.uid_read_status);
}
 
template <>
struct fmt::formatter<blunux::pmu::TEscInfo> : formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  // NOLINTNEXTLINE(runtime/references)
  auto format(blunux::pmu::TEscInfo esc_info, FormatContext& ctx) const {
    std::stringstream ss;
    ss << esc_info;
    return formatter<string_view>::format(ss.str(), ctx);
  }
};
 
template <>
struct fmt::formatter<blunux::pmu::TBatteryInfo> : formatter<string_view> {
  // parse is inherited from formatter<string_view>.
  template <typename FormatContext>
  auto format(blunux::pmu::TBatteryInfo battery_info,
              // NOLINTNEXTLINE(runtime/references)
              FormatContext& ctx) const {
    std::stringstream ss;
    ss << "Max Error: " << static_cast<int>(battery_info.max_error) << " %\n"
       << "Absolute SOC: " << static_cast<int>(battery_info.abs_soc * 100)
       << " %\n"
       << "Cycle Count: " << battery_info.cycle_count << "\n"
       << "Design Capacity: " << battery_info.design_capacity << " Ah\n"
       << "Manufacture Date: " << battery_info.manufacture_date.tm_year << "-"
       << battery_info.manufacture_date.tm_mon << "-"
       << battery_info.manufacture_date.tm_mday << "\n"
       << "Serial Number: " << battery_info.serial_number << "\n"
       << "Manufacture Name: " << battery_info.manufacture_name << "\n"
       << "Device Name: " << battery_info.device_name << "\n"
       << "Device Chemistry: " << battery_info.device_chemistry << "\n"
 
       << "Max Cell Voltage: [";
    for (uint8_t i = 0; i < blunux::pmu::NUMBER_OF_CELLS; i++) {
      ss << battery_info.lifetimes.cell_max_voltages[i];
      if (i < blunux::pmu::NUMBER_OF_CELLS - 1) {
        ss << ", ";
      }
    }
    ss << "] (mV)\nMin Cell Voltage: [";
    for (uint8_t i = 0; i < blunux::pmu::NUMBER_OF_CELLS; i++) {
      ss << battery_info.lifetimes.cell_min_voltages[i];
      if (i < blunux::pmu::NUMBER_OF_CELLS - 1) {
        ss << ", ";
      }
    }
 
    ss << "] (mV)\n";
 
    ss << "Max Delta Cell Voltage: "
       << battery_info.lifetimes.max_delta_cell_voltage << " mV\n"
       << "Max Charge Current: " << battery_info.lifetimes.max_charge_current
       << "mA\n"
       << "Max Discharge Current: "
       << battery_info.lifetimes.max_discharge_current << " mA\n"
       << "Max Avg Discharge Current: "
       << battery_info.lifetimes.max_avg_discharge_current << " mA\n"
       << "Max Avg Discharge Power: "
       << battery_info.lifetimes.max_avg_discharge_power << " cW\n"
       << "Max Cell Temperature: "
       << static_cast<int>(battery_info.lifetimes.max_cell_temperature)
       << " °C\n"
       << "Min Cell Temperature: "
       << static_cast<int>(battery_info.lifetimes.min_cell_temperature)
       << " °C\n"
       << "Max Delta Cell Temperature: "
       << static_cast<int>(battery_info.lifetimes.max_delta_cell_temperature)
       << " °C\n"
       << "Max Temperature Internal Sensor: "
       << static_cast<int>(
              battery_info.lifetimes.max_temperature_internal_sensor)
       << " °C\n"
       << "Min Temperature Internal Sensor: "
       << static_cast<int>(
              battery_info.lifetimes.min_temperature_internal_sensor)
       << " °C\n"
       << "Max Temperature FET: "
       << static_cast<int>(battery_info.lifetimes.max_temperature_fet)
       << " °C\n"
       << "Number of COV events: "
       << battery_info.safety_events.cov_events_count
       << ", last occurred cycle " << battery_info.safety_events.cov_last_event
       << "\n"
       << "Number of CUV events: "
       << battery_info.safety_events.cuv_events_count
       << ", last occurred cycle " << battery_info.safety_events.cuv_last_event
       << "\n"
       << "Number of OCD1 events: "
       << battery_info.safety_events.ocd1_events_count
       << ", last occurred cycle " << battery_info.safety_events.ocd1_last_event
       << "\n"
       << "Number of OCD2 events: "
       << battery_info.safety_events.ocd2_events_count
       << ", last occurred cycle " << battery_info.safety_events.ocd2_last_event
       << "\n"
       << "Number of OCC1 events: "
       << battery_info.safety_events.occ1_events_count
       << ", last occurred cycle " << battery_info.safety_events.occ1_last_event
       << "\n"
       << "Number of OCC2 events: "
       << battery_info.safety_events.occ2_events_count
       << ", last occurred cycle " << battery_info.safety_events.occ2_last_event
       << "\n"
       << "Number of AOLD events: "
       << battery_info.safety_events.aold_events_count
       << ", last occurred cycle " << battery_info.safety_events.aold_last_event
       << "\n"
       << "Number of ASCD events: "
       << battery_info.safety_events.ascd_events_count
       << ", last occurred cycle " << battery_info.safety_events.ascd_last_event
       << "\n"
       << "Number of ASCC events: "
       << battery_info.safety_events.ascc_events_count
       << ", last occurred cycle " << battery_info.safety_events.ascc_last_event
       << "\n"
       << "Number of OTC events: "
       << battery_info.safety_events.otc_events_count
       << ", last occurred cycle " << battery_info.safety_events.otc_last_event
       << "\n"
       << "Number of OTD events: "
       << battery_info.safety_events.otd_events_count
       << ", last occurred cycle " << battery_info.safety_events.otd_last_event
       << "\n"
       << "Number of OTF events: "
       << battery_info.safety_events.otf_events_count
       << ", last occurred cycle " << battery_info.safety_events.otf_last_event
       << "\n"
       << "Number of Charge Termination events: "
       << battery_info.charging_events.charge_termination_events_count
       << ", last occurred cycle "
       << battery_info.charging_events.charge_termination_last_event;
 
    return formatter<string_view>::format(ss.str(), ctx);
  }
};
 
inline std::ostream& operator<<(std::ostream& os,
                                blunux::pmu::TBatteryInfo battery_info) {
  return os << fmt::format("{}", battery_info);
}