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,  
    TYPE_NUM
  };
 
  CAN() {}
 
  typedef struct __attribute__((packed))
  {
    uint32_t id;      
    Type type;        
    uint8_t data[8];  
  } ClassicPack;
 
  using Callback = LibXR::Callback<const ClassicPack &>;
 
  enum class FilterMode : uint8_t
  {
    ID_MASK = 0,
    ID_RANGE = 1
  };
 
  typedef struct
  {
    FilterMode mode;
    uint32_t start_id_mask;
    uint32_t end_id_match;
    Type type;
    Callback cb;
  } Filter;
 
  void Register(Callback cb, Type type, FilterMode mode = FilterMode::ID_RANGE,
                uint32_t start_id_mask = 0, uint32_t end_id_match = 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() {}
 
  typedef struct __attribute__((packed))
  {
    uint32_t id;       
    Type type;         
    uint8_t len;       
    uint8_t data[64];  
  } FDPack;
 
  using CAN::AddMessage;
  using CAN::FilterMode;
  using CAN::OnMessage;
 
  using CallbackFD = LibXR::Callback<const FDPack &>;
 
  typedef struct
  {
    FilterMode mode;
    uint32_t start_id_mask;
    uint32_t end_id_mask;
    Type type;
    CallbackFD cb;
  } Filter;
 
  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:
  void OnMessage(const FDPack &pack, bool in_isr);
 
 private:
  LockFreeList subscriber_list_fd_[static_cast<uint8_t>(Type::TYPE_NUM)];
};
 
}  // namespace LibXR