can.hpp

#pragma once
 
#include "libxr.hpp"
#include "message.hpp"
 
namespace LibXR
{
 
class CAN
{
 public:
  enum class Type : uint8_t
  {
    STANDARD = 0,  
    EXTENDED = 1,  
    REMOTE_STANDARD = 2,  
    REMOTE_EXTENDED = 3,  
    ERROR = 4,            
    TYPE_NUM = 5          
  };
 
  struct BitTiming
  {
    uint32_t brp = 0;         
    uint32_t prop_seg = 0;    
    uint32_t phase_seg1 = 0;  
    uint32_t phase_seg2 = 0;  
    uint32_t sjw = 0;         
  };
 
  struct Mode
  {
    bool loopback = false;     
    bool listen_only = false;  
    bool triple_sampling = false;  
    bool one_shot = false;         
  };
 
  struct Configuration
  {
    uint32_t bitrate = 0;  
    float sample_point = 0.0f;  
    BitTiming bit_timing;  
    Mode mode;             
  };
 
  virtual ErrorCode SetConfig(const CAN::Configuration &cfg) = 0;
 
  virtual uint32_t GetClockFreq() const = 0;
 
  struct ErrorState
  {
    uint8_t tx_error_counter = 0;  
    uint8_t rx_error_counter = 0;  
 
    bool bus_off = false;  
    bool error_passive = false;  
    bool error_warning = false;  
  };
 
  virtual ErrorCode GetErrorState(ErrorState &state) const
  {
    (void)state;
    return ErrorCode::NOT_SUPPORT;
  }
 
  CAN() = default;
 
  virtual ~CAN() = default;
 
#pragma pack(push, 1)
  struct ClassicPack
  {
    uint32_t id;  
    Type type;    
    uint8_t dlc;  
    uint8_t data[8];  
  };
#pragma pack(pop)
 
  static constexpr uint32_t CAN_ERROR_ID_PREFIX = 0xFFFF0000u;
 
  enum class ErrorID : uint32_t
  {
    CAN_ERROR_ID_GENERIC = CAN_ERROR_ID_PREFIX,
    CAN_ERROR_ID_BUS_OFF = CAN_ERROR_ID_PREFIX + 1,
    CAN_ERROR_ID_ERROR_PASSIVE = CAN_ERROR_ID_PREFIX + 2,
    CAN_ERROR_ID_ERROR_WARNING = CAN_ERROR_ID_PREFIX + 3,
    CAN_ERROR_ID_PROTOCOL = CAN_ERROR_ID_PREFIX + 4,
    CAN_ERROR_ID_ACK = CAN_ERROR_ID_PREFIX + 5,
    CAN_ERROR_ID_STUFF = CAN_ERROR_ID_PREFIX + 6,
    CAN_ERROR_ID_FORM = CAN_ERROR_ID_PREFIX + 7,
    CAN_ERROR_ID_BIT0 = CAN_ERROR_ID_PREFIX + 8,
    CAN_ERROR_ID_BIT1 = CAN_ERROR_ID_PREFIX + 9,
    CAN_ERROR_ID_CRC = CAN_ERROR_ID_PREFIX + 10,
    CAN_ERROR_ID_OTHER = CAN_ERROR_ID_PREFIX + 11
  };
 
  static constexpr uint32_t FromErrorID(ErrorID e) noexcept
  {
    return static_cast<uint32_t>(e);
  }
 
  static constexpr bool IsErrorId(uint32_t id) noexcept
  {
    return (id & 0xFFFF0000u) == CAN_ERROR_ID_PREFIX;
  }
 
  static constexpr ErrorID ToErrorID(uint32_t id) noexcept
  {
    return static_cast<ErrorID>(id);
  }
 
  using Callback = LibXR::Callback<const ClassicPack &>;
 
  enum class FilterMode : uint8_t
  {
    ID_MASK = 0,  
    ID_RANGE = 1  
  };
 
  struct Filter
  {
    FilterMode mode;         
    uint32_t start_id_mask;  
    uint32_t end_id_mask;    
    Type type;               
    Callback cb;             
  };
 
  void Register(Callback cb, Type type, FilterMode mode = FilterMode::ID_RANGE,
                uint32_t start_id_mask = 0, uint32_t end_id_mask = UINT32_MAX);
 
  virtual ErrorCode AddMessage(const ClassicPack &pack) = 0;
 
 protected:
  void OnMessage(const ClassicPack &pack, bool in_isr);
 
 private:
  LockFreeList subscriber_list_[static_cast<uint8_t>(Type::TYPE_NUM)];
};
 
class FDCAN : public CAN
{
 public:
  FDCAN() = default;
 
  virtual ~FDCAN() = default;
 
#pragma pack(push, 1)
  struct FDPack
  {
    uint32_t id;       
    Type type;         
    uint8_t len;       
    uint8_t data[64];  
  };
#pragma pack(pop)
 
  using CAN::AddMessage;
  using CAN::FilterMode;
  using CAN::Register;
 
  using CallbackFD = LibXR::Callback<const FDPack &>;
 
  struct Filter
  {
    FilterMode mode;         
    uint32_t start_id_mask;  
    uint32_t end_id_mask;    
    Type type;               
    CallbackFD cb;           
  };
 
  struct DataBitTiming
  {
    uint32_t brp = 0;         
    uint32_t prop_seg = 0;    
    uint32_t phase_seg1 = 0;  
    uint32_t phase_seg2 = 0;  
    uint32_t sjw = 0;         
  };
 
  struct FDMode
  {
    bool fd_enabled = false;  
    bool brs = false;         
    bool esi = false;         
  };
 
  struct Configuration : public CAN::Configuration
  {
    uint32_t data_bitrate = 0;       
    float data_sample_point = 0.0f;  
    DataBitTiming data_timing;       
    FDMode fd_mode;                  
  };
 
  virtual ErrorCode SetConfig(const CAN::Configuration &cfg) override = 0;
 
  virtual ErrorCode SetConfig(const FDCAN::Configuration &cfg) = 0;
 
  void Register(CallbackFD cb, Type type, FilterMode mode = FilterMode::ID_RANGE,
                uint32_t start_id_mask = 0, uint32_t end_id_mask = UINT32_MAX);
 
  virtual ErrorCode AddMessage(const FDPack &pack) = 0;
 
 protected:
  using CAN::OnMessage;
 
  void OnMessage(const FDPack &pack, bool in_isr);
 
 private:
  LockFreeList subscriber_list_fd_[static_cast<uint8_t>(Type::REMOTE_STANDARD)];
};
 
}  // namespace LibXR