BaseCan.h

Go to the documentation of this file.

 
#pragma once
 
#include "HardwareTypes.h"
#include <atomic>
#include <cstdint>
#include <string_view>
 
//--------------------------------------
//  HardFOC CAN Error Codes (Table)
//--------------------------------------
#define HF_CAN_ERR_LIST(X)                                                                         \
  /* Success codes */                                                                              \
  X(CAN_SUCCESS, 0, "Success")                                                                     \
  /* General errors */                                                                             \
  X(CAN_ERR_FAILURE, 1, "General failure")                                                         \
  X(CAN_ERR_NOT_INITIALIZED, 2, "Not initialized")                                                 \
  X(CAN_ERR_ALREADY_INITIALIZED, 3, "Already initialized")                                         \
  X(CAN_ERR_INVALID_PARAMETER, 4, "Invalid parameter")                                             \
  X(CAN_ERR_NULL_POINTER, 5, "Null pointer")                                                       \
  X(CAN_ERR_OUT_OF_MEMORY, 6, "Out of memory")                                                     \
  /* Bus errors */                                                                                 \
  X(CAN_ERR_BUS_OFF, 7, "Bus off state")                                                           \
  X(CAN_ERR_BUS_ERROR, 8, "Bus error")                                                             \
  X(CAN_ERR_BUS_BUSY, 9, "Bus busy")                                                               \
  X(CAN_ERR_BUS_NOT_AVAILABLE, 10, "Bus not available")                                            \
  X(CAN_ERR_BUS_RECOVERY_FAILED, 11, "Bus recovery failed")                                        \
  X(CAN_ERR_BUS_ARBITRATION_LOST, 12, "Bus arbitration lost")                                      \
  /* Message errors */                                                                             \
  X(CAN_ERR_MESSAGE_TIMEOUT, 13, "Message timeout")                                                \
  X(CAN_ERR_MESSAGE_LOST, 14, "Message lost")                                                      \
  X(CAN_ERR_MESSAGE_INVALID, 15, "Invalid message")                                                \
  X(CAN_ERR_MESSAGE_TOO_LONG, 16, "Message too long")                                              \
  X(CAN_ERR_MESSAGE_INVALID_ID, 17, "Invalid message ID")                                          \
  X(CAN_ERR_MESSAGE_INVALID_DLC, 18, "Invalid data length code")                                   \
  X(CAN_ERR_QUEUE_FULL, 19, "Queue full")                                                          \
  X(CAN_ERR_QUEUE_EMPTY, 20, "Queue empty")                                                        \
  /* Transmission errors */                                                                        \
  X(CAN_ERR_TX_FAILED, 21, "Transmission failed")                                                  \
  X(CAN_ERR_TX_ABORTED, 22, "Transmission aborted")                                                \
  X(CAN_ERR_TX_ERROR_PASSIVE, 23, "Transmit error passive")                                        \
  X(CAN_ERR_TX_ERROR_WARNING, 24, "Transmit error warning")                                        \
  /* Reception errors */                                                                           \
  X(CAN_ERR_RX_OVERRUN, 25, "Receive overrun")                                                     \
  X(CAN_ERR_RX_ERROR_PASSIVE, 26, "Receive error passive")                                         \
  X(CAN_ERR_RX_ERROR_WARNING, 27, "Receive error warning")                                         \
  X(CAN_ERR_RX_FIFO_FULL, 28, "Receive FIFO full")                                                 \
  /* Hardware errors */                                                                            \
  X(CAN_ERR_HARDWARE_FAULT, 29, "Hardware fault")                                                  \
  X(CAN_ERR_COMMUNICATION_FAILURE, 30, "Communication failure")                                    \
  X(CAN_ERR_DEVICE_NOT_RESPONDING, 31, "Device not responding")                                    \
  X(CAN_ERR_VOLTAGE_OUT_OF_RANGE, 32, "Voltage out of range")                                      \
  X(CAN_ERR_CLOCK_ERROR, 33, "Clock error")                                                        \
  X(CAN_ERR_TRANSCEIVER_ERROR, 34, "Transceiver error")                                            \
  /* Configuration errors */                                                                       \
  X(CAN_ERR_INVALID_CONFIGURATION, 35, "Invalid configuration")                                    \
  X(CAN_ERR_UNSUPPORTED_OPERATION, 36, "Unsupported operation")                                    \
  X(CAN_ERR_INVALID_BAUD_RATE, 37, "Invalid baud rate")                                            \
  X(CAN_ERR_INVALID_CONTROLLER_ID, 38, "Invalid controller ID")                                    \
  X(CAN_ERR_FILTER_ERROR, 39, "Filter error")                                                      \
  X(CAN_ERR_FILTER_FULL, 40, "Filter table full")                                                  \
  /* Protocol errors */                                                                            \
  X(CAN_ERR_STUFF_ERROR, 41, "Bit stuffing error")                                                 \
  X(CAN_ERR_FORM_ERROR, 42, "Frame format error")                                                  \
  X(CAN_ERR_CRC_ERROR, 43, "CRC error")                                                            \
  X(CAN_ERR_ACK_ERROR, 44, "Acknowledgment error")                                                 \
  X(CAN_ERR_BIT_ERROR, 45, "Bit error")                                                            \
  /* System errors */                                                                              \
  X(CAN_ERR_SYSTEM_ERROR, 46, "System error")                                                      \
  X(CAN_ERR_PERMISSION_DENIED, 47, "Permission denied")                                            \
  X(CAN_ERR_OPERATION_ABORTED, 48, "Operation aborted")                                            \
                                                                                                   \
  /* Extended CAN errors (for ESP32 compatibility) */                                              \
  X(CAN_ERR_FAIL, 49, "Generic failure")                                                           \
  X(CAN_ERR_RESOURCE_BUSY, 50, "Resource busy")                                                    \
  X(CAN_ERR_INVALID_STATE, 51, "Invalid state")                                                    \
  X(CAN_ERR_NOT_SUPPORTED, 52, "Not supported")                                                    \
  X(CAN_ERR_TIMEOUT_ALT, 53, "Operation timeout")                                                  \
  X(CAN_ERR_UNKNOWN, 54, "Unknown error")
 
enum class hf_can_err_t : hf_u8_t {
#define X(NAME, VALUE, DESC) NAME = VALUE,
  HF_CAN_ERR_LIST(X)
#undef X
};
 
constexpr std::string_view HfCanErrToString(hf_can_err_t err) noexcept {
  switch (err) {
#define X(NAME, VALUE, DESC)                                                                       \
  case hf_can_err_t::NAME:                                                                         \
    return DESC;
    HF_CAN_ERR_LIST(X)
#undef X
  default:
    return HfCanErrToString(hf_can_err_t::CAN_ERR_UNKNOWN);
  }
}
 
struct hf_can_config_t {
  hf_pin_num_t tx_pin;     
  hf_pin_num_t rx_pin;     
  hf_baud_rate_t baudrate; 
  bool loopback_mode;      
  bool silent_mode;        
  hf_u16_t tx_queue_size;  
  hf_u16_t rx_queue_size;  
 
  hf_can_config_t() noexcept
      : tx_pin(HF_INVALID_PIN), rx_pin(HF_INVALID_PIN), baudrate(500000), loopback_mode(false),
        silent_mode(false), tx_queue_size(10), rx_queue_size(10) {}
};
 
//--------------------------------------
//  CAN / CAN FD frame model (BaseCan v2)
//--------------------------------------
 
inline constexpr hf_u8_t HF_CAN_CLASSIC_MAX_LEN = 8U;
inline constexpr hf_u8_t HF_CAN_FD_MAX_LEN = 64U;
inline constexpr hf_u32_t HF_CAN_MAX_STD_ID = 0x7FFU;
inline constexpr hf_u32_t HF_CAN_MAX_EXT_ID = 0x1FFFFFFFU;
inline constexpr hf_u8_t HF_CAN_DLC_INVALID = 0xFFU;
 
namespace hf_can_flag {
inline constexpr hf_u8_t EXT = 0x01U; 
inline constexpr hf_u8_t RTR = 0x02U; 
inline constexpr hf_u8_t FDF = 0x04U; 
inline constexpr hf_u8_t BRS = 0x08U; 
inline constexpr hf_u8_t ESI = 0x10U; 
inline constexpr hf_u8_t ALL = EXT | RTR | FDF | BRS | ESI;
} // namespace hf_can_flag
 
constexpr hf_u8_t HfCanDlcToLen(hf_u8_t dlc, bool fd) noexcept {
  constexpr hf_u8_t kFdTable[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64};
  if (dlc > 15U) {
    return 0U;
  }
  if (!fd) {
    return dlc > 8U ? 8U : dlc;
  }
  return kFdTable[dlc];
}
 
constexpr hf_u8_t HfCanLenToDlc(hf_u8_t len, bool fd) noexcept {
  if (len <= 8U) {
    return len;
  }
  if (!fd || len > HF_CAN_FD_MAX_LEN) {
    return HF_CAN_DLC_INVALID;
  }
  for (hf_u8_t dlc = 9U; dlc < 16U; ++dlc) {
    if (HfCanDlcToLen(dlc, true) >= len) {
      return dlc;
    }
  }
  return HF_CAN_DLC_INVALID;
}
 
constexpr bool HfCanIsValidLength(hf_u8_t len, bool fd) noexcept {
  if (!fd) {
    return len <= HF_CAN_CLASSIC_MAX_LEN;
  }
  const hf_u8_t dlc = HfCanLenToDlc(len, true);
  return dlc != HF_CAN_DLC_INVALID && HfCanDlcToLen(dlc, true) == len;
}
 
enum class hf_can_frame_error_t : hf_u8_t {
  NONE = 0,
  ID_RANGE,            
  CLASSIC_TOO_LONG,    
  FD_TOO_LONG,         
  FD_LENGTH_NOT_EXACT, 
  RTR_ON_FD,           
  FD_BITS_ON_CLASSIC,  
  RTR_WITH_DATA,       
};
 
struct hf_can_message_t {
  // === Core CAN Message Fields ===
  hf_u32_t id;                     
  hf_u8_t dlc;                     
  hf_u8_t data[HF_CAN_FD_MAX_LEN]; 
 
  // === Standard CAN Flags ===
  bool is_extended;  
  bool is_rtr;       
  bool is_ss;        
  bool is_self;      
  bool dlc_non_comp; 
 
  // === Metadata and Diagnostics ===
  hf_u64_t timestamp_us;    
  hf_u32_t sequence_number; 
  hf_u8_t controller_id;    
  hf_u8_t retry_count;      
  hf_u8_t error_count;      
 
  // === CAN FD Fields ===
  bool is_canfd; 
  bool is_brs;   
  bool is_esi;   
 
  hf_can_message_t() noexcept
      : id(0), dlc(8), data{}, is_extended(false), is_rtr(false), is_ss(false), is_self(false),
        dlc_non_comp(false), timestamp_us(0), sequence_number(0), controller_id(0), retry_count(0),
        error_count(0), is_canfd(false), is_brs(false), is_esi(false) {}
 
  // --- Length -------------------------------------------------------------
 
  constexpr hf_u8_t GetMaxDataLength() const noexcept {
    return is_canfd ? HF_CAN_FD_MAX_LEN : HF_CAN_CLASSIC_MAX_LEN;
  }
 
  constexpr hf_u8_t GetLength() const noexcept {
    return dlc;
  }
 
  constexpr bool IsValidLength(hf_u8_t len) const noexcept {
    return HfCanIsValidLength(len, is_canfd);
  }
 
  bool SetLength(hf_u8_t len) noexcept {
    if (!IsValidLength(len)) {
      return false;
    }
    dlc = len;
    dlc_non_comp = false;
    return true;
  }
 
  constexpr bool IsValidDLC(hf_u8_t len) const noexcept {
    return IsValidLength(len);
  }
 
  constexpr hf_u8_t GetEffectiveDLC() const noexcept {
    return dlc;
  }
 
  bool SetDLC(hf_u8_t len) noexcept {
    return SetLength(len);
  }
 
  constexpr hf_u8_t GetDlcCode() const noexcept {
    return IsValidLength(dlc) ? HfCanLenToDlc(dlc, is_canfd) : HF_CAN_DLC_INVALID;
  }
 
  bool SetDlcCode(hf_u8_t code) noexcept {
    if (code > 15U) {
      return false;
    }
    dlc = HfCanDlcToLen(code, is_canfd);
    dlc_non_comp = !is_canfd && code > 8U;
    return true;
  }
 
  bool SetData(const hf_u8_t* src, hf_u8_t len) noexcept {
    if (!IsValidLength(len) || (src == nullptr && len != 0U)) {
      return false;
    }
    for (hf_u8_t i = 0; i < len; ++i) {
      data[i] = src[i];
    }
    dlc = len;
    dlc_non_comp = false;
    return true;
  }
 
  // --- Frame kind and flags ---------------------------------------------------
 
  void SetStandardFrame() noexcept {
    is_extended = false;
  }
 
  void SetExtendedFrame() noexcept {
    is_extended = true;
  }
 
  void SetDataFrame() noexcept {
    is_rtr = false;
  }
 
  void SetRemoteFrame() noexcept {
    is_rtr = true;
  }
 
  void SetSingleShot() noexcept {
    is_ss = true;
  }
 
  void SetSelfReception() noexcept {
    is_self = true;
  }
 
  void SetFdFrame(bool brs = false) noexcept {
    is_canfd = true;
    is_rtr = false;
    is_brs = brs;
  }
 
  bool SetClassicFrame() noexcept {
    if (dlc > HF_CAN_CLASSIC_MAX_LEN) {
      return false;
    }
    is_canfd = false;
    is_brs = false;
    is_esi = false;
    return true;
  }
 
  constexpr hf_u8_t GetFlags() const noexcept {
    return static_cast<hf_u8_t>(
        (is_extended ? hf_can_flag::EXT : 0U) | (is_rtr ? hf_can_flag::RTR : 0U) |
        (is_canfd ? hf_can_flag::FDF : 0U) | (is_brs ? hf_can_flag::BRS : 0U) |
        (is_esi ? hf_can_flag::ESI : 0U));
  }
 
  bool SetFlags(hf_u8_t flags) noexcept {
    if ((flags & static_cast<hf_u8_t>(~hf_can_flag::ALL)) != 0U) {
      return false;
    }
    is_extended = (flags & hf_can_flag::EXT) != 0U;
    is_rtr = (flags & hf_can_flag::RTR) != 0U;
    is_canfd = (flags & hf_can_flag::FDF) != 0U;
    is_brs = (flags & hf_can_flag::BRS) != 0U;
    is_esi = (flags & hf_can_flag::ESI) != 0U;
    return true;
  }
 
  // --- Validation -------------------------------------------------------------
 
  constexpr bool IsValidId() const noexcept {
    return id <= (is_extended ? HF_CAN_MAX_EXT_ID : HF_CAN_MAX_STD_ID);
  }
 
  constexpr hf_can_frame_error_t Validate() const noexcept {
    if (!IsValidId()) {
      return hf_can_frame_error_t::ID_RANGE;
    }
    if (is_canfd) {
      if (is_rtr) {
        return hf_can_frame_error_t::RTR_ON_FD;
      }
      if (dlc > HF_CAN_FD_MAX_LEN) {
        return hf_can_frame_error_t::FD_TOO_LONG;
      }
      if (!HfCanIsValidLength(dlc, true)) {
        return hf_can_frame_error_t::FD_LENGTH_NOT_EXACT;
      }
      return hf_can_frame_error_t::NONE;
    }
    if (is_brs || is_esi) {
      return hf_can_frame_error_t::FD_BITS_ON_CLASSIC;
    }
    if (dlc > HF_CAN_CLASSIC_MAX_LEN) {
      return is_rtr ? hf_can_frame_error_t::RTR_WITH_DATA : hf_can_frame_error_t::CLASSIC_TOO_LONG;
    }
    return hf_can_frame_error_t::NONE;
  }
 
  constexpr bool IsValid() const noexcept {
    return Validate() == hf_can_frame_error_t::NONE;
  }
 
  // --- Conversion to / from a transport frame ---------------------------------
 
  template <typename Frame>
  void ToFrame(Frame& out) const noexcept {
    static_assert(sizeof(out.data) == HF_CAN_FD_MAX_LEN, "frame data must be 64 bytes");
    out.id = id;
    out.len = dlc;
    out.flags = GetFlags();
    for (hf_u8_t i = 0; i < HF_CAN_FD_MAX_LEN; ++i) {
      out.data[i] = data[i];
    }
    out.ts_us = static_cast<decltype(out.ts_us)>(timestamp_us);
  }
 
  template <typename Frame>
  static hf_can_message_t FromFrame(const Frame& in) noexcept {
    static_assert(sizeof(in.data) == HF_CAN_FD_MAX_LEN, "frame data must be 64 bytes");
    hf_can_message_t m;
    m.id = in.id;
    m.dlc = in.len;
    (void)m.SetFlags(static_cast<hf_u8_t>(in.flags & hf_can_flag::ALL));
    for (hf_u8_t i = 0; i < HF_CAN_FD_MAX_LEN; ++i) {
      m.data[i] = in.data[i];
    }
    m.timestamp_us = static_cast<hf_u64_t>(in.ts_us);
    return m;
  }
};
 
enum class hf_can_bus_state_t : hf_u8_t {
  STOPPED = 0,   
  ERROR_ACTIVE,  
  ERROR_WARNING, 
  ERROR_PASSIVE, 
  BUS_OFF,       
};
 
constexpr hf_can_bus_state_t HfCanStateFromCounters(hf_u16_t tec, hf_u16_t rec) noexcept {
  if (tec > 255U) {
    return hf_can_bus_state_t::BUS_OFF;
  }
  if (tec >= 128U || rec >= 128U) {
    return hf_can_bus_state_t::ERROR_PASSIVE;
  }
  if (tec >= 96U || rec >= 96U) {
    return hf_can_bus_state_t::ERROR_WARNING;
  }
  return hf_can_bus_state_t::ERROR_ACTIVE;
}
 
struct hf_can_bus_status_t {
  hf_can_bus_state_t state{hf_can_bus_state_t::STOPPED}; 
  hf_u16_t tec{0};                                       
  hf_u16_t rec{0};                                       
  hf_u32_t rx_overruns{0};   
  hf_u32_t tx_queue_full{0}; 
  hf_u32_t bus_off_count{0}; 
};
 
struct hf_can_status_t {
  hf_u32_t tx_error_count;  
  hf_u32_t rx_error_count;  
  hf_u32_t tx_failed_count; 
  hf_u32_t rx_missed_count; 
  bool bus_off;             
  bool error_warning;       
  bool error_passive;       
 
  // CAN-FD specific status
  bool canfd_enabled;        
  bool canfd_brs_enabled;    
  hf_u32_t nominal_baudrate; 
  hf_u32_t data_baudrate;    
  hf_u32_t canfd_tx_count;   
  hf_u32_t canfd_rx_count;   
  hf_u32_t brs_tx_count;     
  hf_u32_t brs_rx_count;     
  hf_u32_t form_errors;      
  hf_u32_t stuff_errors;     
  hf_u32_t crc_errors;       
  hf_u32_t bit_errors;       
  hf_u32_t ack_errors;       
 
  hf_can_status_t() noexcept
      : tx_error_count(0), rx_error_count(0), tx_failed_count(0), rx_missed_count(0),
        bus_off(false), error_warning(false), error_passive(false), canfd_enabled(false),
        canfd_brs_enabled(false), nominal_baudrate(0), data_baudrate(0), canfd_tx_count(0),
        canfd_rx_count(0), brs_tx_count(0), brs_rx_count(0), form_errors(0), stuff_errors(0),
        crc_errors(0), bit_errors(0), ack_errors(0) {}
};
 
using hf_can_receive_callback_t = void (*)(const hf_can_message_t& message);
 
struct hf_can_reception_info_t {
  hf_u32_t timestamp_us;      
  hf_u8_t rx_fifo_level;      
  bool data_phase_error;      
  bool arbitration_lost;      
  float bit_timing_tolerance; 
};
using hf_can_fd_receive_callback_t = void (*)(const hf_can_message_t& message,
                                              const hf_can_reception_info_t& info);
 
struct hf_can_statistics_t {
  // Message counters (atomic for ISR safety)
  std::atomic<hf_u64_t> messages_sent{0};     
  std::atomic<hf_u64_t> messages_received{0}; 
  std::atomic<hf_u64_t> bytes_transmitted{0}; 
  std::atomic<hf_u64_t> bytes_received{0};    
 
  // Error counters (atomic for ISR safety)
  std::atomic<hf_u32_t> send_failures{0};          
  std::atomic<hf_u32_t> receive_failures{0};       
  std::atomic<hf_u32_t> bus_error_count{0};        
  std::atomic<hf_u32_t> arbitration_lost_count{0}; 
  std::atomic<hf_u32_t> tx_failed_count{0};        
  std::atomic<hf_u32_t> bus_off_events{0};         
  std::atomic<hf_u32_t> error_warning_events{0};   
 
  // Performance metrics (atomic for ISR safety)
  std::atomic<hf_u64_t> uptime_seconds{0};                         
  std::atomic<hf_u32_t> last_activity_timestamp{0};                
  std::atomic<hf_can_err_t> last_error{hf_can_err_t::CAN_SUCCESS}; 
 
  // Queue statistics (atomic for ISR safety)
  std::atomic<hf_u32_t> tx_queue_peak{0};      
  std::atomic<hf_u32_t> rx_queue_peak{0};      
  std::atomic<hf_u32_t> tx_queue_overflows{0}; 
  std::atomic<hf_u32_t> rx_queue_overflows{0}; 
 
  // Default constructor - all fields are initialized with in-class initialization
  hf_can_statistics_t() noexcept = default;
};
 
struct hf_can_diagnostics_t {
  hf_u32_t tx_error_count;       
  hf_u32_t rx_error_count;       
  hf_u32_t tx_queue_peak;        
  hf_u32_t rx_queue_peak;        
  hf_u32_t last_error_timestamp; 
  hf_u32_t controller_resets;    
  hf_u32_t bus_load_percentage;  
  float bit_error_rate;          
 
  hf_can_diagnostics_t() noexcept
      : tx_error_count(0), rx_error_count(0), tx_queue_peak(0), rx_queue_peak(0),
        last_error_timestamp(0), controller_resets(0), bus_load_percentage(0),
        bit_error_rate(0.0f) {}
};
 
class BaseCan {
public:
  virtual ~BaseCan() noexcept = default;
 
  // Non-copyable, non-movable (can be changed in derived classes if needed)
  BaseCan(const BaseCan&) = delete;
  BaseCan& operator=(const BaseCan&) = delete;
  BaseCan(BaseCan&&) = delete;
  BaseCan& operator=(BaseCan&&) = delete;
 
  bool EnsureInitialized() noexcept {
    if (!initialized_) {
      initialized_ = (Initialize() == hf_can_err_t::CAN_SUCCESS);
    }
    return initialized_;
  }
 
  bool EnsureDeinitialized() noexcept {
    if (initialized_) {
      initialized_ = !(Deinitialize() == hf_can_err_t::CAN_SUCCESS);
    }
    return !initialized_;
  }
 
  [[nodiscard]] bool IsInitialized() const noexcept {
    return initialized_;
  }
 
  //==============================================//
  // PURE VIRTUAL FUNCTIONS [MUST BE OVERRIDDEN]  //
  //==============================================//
 
  virtual hf_can_err_t Initialize() noexcept = 0;
 
  virtual hf_can_err_t Deinitialize() noexcept = 0;
 
  virtual hf_can_err_t SendMessage(const hf_can_message_t& message,
                                   hf_u32_t timeout_ms = 1000) noexcept = 0;
 
  virtual hf_can_err_t ReceiveMessage(hf_can_message_t& message,
                                      hf_u32_t timeout_ms = 0) noexcept = 0;
 
  virtual hf_can_err_t SetReceiveCallback(hf_can_receive_callback_t callback) noexcept = 0;
 
  virtual hf_can_err_t SetAcceptanceFilter(hf_u32_t id, hf_u32_t mask,
                                           bool extended = false) noexcept = 0;
 
  virtual hf_can_err_t GetStatus(hf_can_status_t& status) noexcept = 0;
 
  virtual hf_can_err_t Reset() noexcept = 0;
 
  //==============================================//
  // (OPTIONAL IMPLEMENTATIONS)                   //
  //==============================================//
 
  virtual void ClearReceiveCallback() noexcept {}
 
  virtual hf_can_err_t ClearAcceptanceFilter() noexcept {
    return SetAcceptanceFilter(0, 0, false);
  }
 
  hf_can_err_t TrySendMessage(const hf_can_message_t& message) noexcept {
    return SendMessage(message, 0);
  }
 
  virtual hf_can_err_t GetBusStatus(hf_can_bus_status_t& status) noexcept {
    (void)status;
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_can_err_t RequestBusRecovery() noexcept {
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_can_err_t SetReceiveCallbackFD(hf_can_fd_receive_callback_t callback) noexcept {
    (void)callback; // Suppress unused parameter warning
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual bool SupportsCanFD() const noexcept {
    return false;
  }
 
  virtual bool SetCanFDMode(bool enable, hf_u32_t data_baudrate = 2000000,
                            hf_u32_t timeout_ms = 1000) noexcept {
    (void)enable;
    (void)data_baudrate;
    (void)timeout_ms;
    return false;
  }
 
  virtual bool ConfigureCanFDTiming(hf_u16_t nominal_prescaler, hf_u8_t nominal_tseg1,
                                    hf_u8_t nominal_tseg2, hf_u16_t data_prescaler,
                                    hf_u8_t data_tseg1, hf_u8_t data_tseg2,
                                    hf_u8_t sjw = 1) noexcept {
    (void)nominal_prescaler;
    (void)nominal_tseg1;
    (void)nominal_tseg2;
    (void)data_prescaler;
    (void)data_tseg1;
    (void)data_tseg2;
    (void)sjw;
    return false;
  }
 
  virtual bool SetTransmitterDelayCompensation(hf_u8_t tdc_offset, hf_u8_t tdc_filter) noexcept {
    (void)tdc_offset;
    (void)tdc_filter;
    return false;
  }
 
  virtual hf_u32_t SendMessageBatch(const hf_can_message_t* messages, hf_u32_t count,
                                    hf_u32_t timeout_ms = 1000) noexcept {
    if (!messages || count == 0) {
      return 0;
    }
 
    hf_u32_t sent_count = 0;
    for (hf_u32_t i = 0; i < count; ++i) {
      if (SendMessage(messages[i], timeout_ms) == hf_can_err_t::CAN_SUCCESS) {
        sent_count++;
      }
    }
    return sent_count;
  }
 
  virtual hf_u32_t ReceiveMessageBatch(hf_can_message_t* messages, hf_u32_t max_count,
                                       hf_u32_t timeout_ms = 100) noexcept {
    if (!messages || max_count == 0) {
      return 0;
    }
 
    hf_u32_t received_count = 0;
    for (hf_u32_t i = 0; i < max_count; ++i) {
      if (ReceiveMessage(messages[i], timeout_ms) == hf_can_err_t::CAN_SUCCESS) {
        received_count++;
      } else {
        break; // No more messages available
      }
    }
    return received_count;
  }
 
  //==============================================//
  // STATISTICS AND DIAGNOSTICS STRUCTURES        //
  //==============================================//
 
  virtual hf_can_err_t ResetStatistics() noexcept {
    // Reset all atomic counters to zero (atomic operations are thread-safe)
    statistics_.messages_sent.store(0);
    statistics_.messages_received.store(0);
    statistics_.bytes_transmitted.store(0);
    statistics_.bytes_received.store(0);
    statistics_.send_failures.store(0);
    statistics_.receive_failures.store(0);
    statistics_.bus_error_count.store(0);
    statistics_.arbitration_lost_count.store(0);
    statistics_.tx_failed_count.store(0);
    statistics_.bus_off_events.store(0);
    statistics_.error_warning_events.store(0);
    statistics_.uptime_seconds.store(0);
    statistics_.last_activity_timestamp.store(0);
    statistics_.last_error.store(hf_can_err_t::CAN_SUCCESS);
    statistics_.tx_queue_peak.store(0);
    statistics_.rx_queue_peak.store(0);
    statistics_.tx_queue_overflows.store(0);
    statistics_.rx_queue_overflows.store(0);
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_can_err_t ResetDiagnostics() noexcept {
    diagnostics_ = hf_can_diagnostics_t{}; // Reset diagnostics to default values
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_can_err_t GetStatistics(hf_can_statistics_t& statistics) noexcept {
    // Copy atomic values to non-atomic structure for return (atomic operations are thread-safe)
    statistics.messages_sent = statistics_.messages_sent.load();
    statistics.messages_received = statistics_.messages_received.load();
    statistics.bytes_transmitted = statistics_.bytes_transmitted.load();
    statistics.bytes_received = statistics_.bytes_received.load();
    statistics.send_failures = statistics_.send_failures.load();
    statistics.receive_failures = statistics_.receive_failures.load();
    statistics.bus_error_count = statistics_.bus_error_count.load();
    statistics.arbitration_lost_count = statistics_.arbitration_lost_count.load();
    statistics.tx_failed_count = statistics_.tx_failed_count.load();
    statistics.bus_off_events = statistics_.bus_off_events.load();
    statistics.error_warning_events = statistics_.error_warning_events.load();
    statistics.uptime_seconds = statistics_.uptime_seconds.load();
    statistics.last_activity_timestamp = statistics_.last_activity_timestamp.load();
    statistics.last_error = statistics_.last_error.load();
    statistics.tx_queue_peak = statistics_.tx_queue_peak.load();
    statistics.rx_queue_peak = statistics_.rx_queue_peak.load();
    statistics.tx_queue_overflows = statistics_.tx_queue_overflows.load();
    statistics.rx_queue_overflows = statistics_.rx_queue_overflows.load();
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
  virtual hf_can_err_t GetDiagnostics(hf_can_diagnostics_t& diagnostics) noexcept {
    diagnostics = diagnostics_; // Return diagnostics by default
    return hf_can_err_t::CAN_ERR_UNSUPPORTED_OPERATION;
  }
 
protected:
  BaseCan() noexcept : initialized_(false), statistics_{}, diagnostics_{} {}
 
  //==============================================//
  // VARIABLES                                    //
  //==============================================//
 
  bool initialized_;                 
  hf_can_statistics_t statistics_;   
  hf_can_diagnostics_t diagnostics_; 
};
 
//==============================================//
// END OF BASECAN - CLEAN AND MODERN API        //
//==============================================//