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)
  {
    ASSERT(type < Type::TYPE_NUM);
 
    auto node = new (std::align_val_t(LIBXR_CACHE_LINE_SIZE))
        LockFreeList::Node<Filter>({mode, start_id_mask, end_id_match, type, cb});
    subscriber_list_[static_cast<uint8_t>(type)].Add(*node);
  }
 
  virtual ErrorCode AddMessage(const ClassicPack &pack) = 0;
 
 protected:
  void OnMessage(const ClassicPack &pack, bool in_isr)
  {
    ASSERT(pack.type < Type::TYPE_NUM);
    subscriber_list_[static_cast<uint8_t>(pack.type)].Foreach<Filter>(
        [&](Filter &node)
        {
          switch (node.mode)
          {
            case FilterMode::ID_MASK:
              if ((pack.id & node.start_id_mask) == node.end_id_match)
              {
                node.cb.Run(in_isr, pack);
              }
              break;
            case FilterMode::ID_RANGE:
              if (pack.id >= node.start_id_mask && pack.id <= node.end_id_match)
              {
                node.cb.Run(in_isr, pack);
              }
              break;
          }
 
          return ErrorCode::OK;
        });
  }
 
 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)
  {
    ASSERT(type < Type::TYPE_NUM);
    auto node = new (std::align_val_t(LIBXR_CACHE_LINE_SIZE))
        LockFreeList::Node<Filter>({mode, start_id_mask, end_id_mask, type, cb});
    subscriber_list_fd_[static_cast<uint8_t>(type)].Add(*node);
  }
 
  virtual ErrorCode AddMessage(const FDPack &pack) = 0;
 
 protected:
  void OnMessage(const FDPack &pack, bool in_isr)
  {
    ASSERT(pack.type < Type::TYPE_NUM);
    subscriber_list_fd_[static_cast<uint8_t>(pack.type)].Foreach<Filter>(
        [&](Filter &node)
        {
          if (pack.id >= node.start_id_mask && pack.id <= node.end_id_mask)
          {
            node.cb.Run(in_isr, pack);
          }
 
          return ErrorCode::OK;
        });
  }
 
 private:
  LockFreeList subscriber_list_fd_[static_cast<uint8_t>(Type::TYPE_NUM)];
};
 
}  // namespace LibXR