HfCanPort.h

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
 
namespace hf::can {
 
inline constexpr uint8_t kClassicMaxLen = 8U;
inline constexpr uint8_t kFdMaxLen = 64U;
inline constexpr uint32_t kMaxStdId = 0x7FFU;
inline constexpr uint32_t kMaxExtId = 0x1FFFFFFFU;
 
namespace frame_flag {
inline constexpr uint8_t kExt = 0x01U;  
inline constexpr uint8_t kRtr = 0x02U;  
inline constexpr uint8_t kFdf = 0x04U;  
inline constexpr uint8_t kBrs = 0x08U;  
inline constexpr uint8_t kEsi = 0x10U;  
inline constexpr uint8_t kAll = kExt | kRtr | kFdf | kBrs | kEsi;
}  // namespace frame_flag
 
struct CanFrame {
  uint32_t id{0};
  uint8_t len{0};
  uint8_t flags{0};
  uint8_t data[kFdMaxLen]{};
  uint32_t ts_us{0};  
 
  constexpr bool IsExtended() const noexcept { return (flags & frame_flag::kExt) != 0U; }
  constexpr bool IsRemote() const noexcept { return (flags & frame_flag::kRtr) != 0U; }
  constexpr bool IsFd() const noexcept { return (flags & frame_flag::kFdf) != 0U; }
};
 
constexpr bool IsExactFdLength(uint8_t len) noexcept {
  return len <= 8U || len == 12U || len == 16U || len == 20U || len == 24U || len == 32U || len == 48U || len == 64U;
}
 
constexpr bool IsWellFormed(const CanFrame& f) noexcept {
  if ((f.flags & static_cast<uint8_t>(~frame_flag::kAll)) != 0U) return false;
  if (f.id > (f.IsExtended() ? kMaxExtId : kMaxStdId)) return false;
  if (f.IsFd()) return !f.IsRemote() && f.len <= kFdMaxLen && IsExactFdLength(f.len);
  if ((f.flags & (frame_flag::kBrs | frame_flag::kEsi)) != 0U) return false;
  return f.len <= kClassicMaxLen;
}
 
struct PortCaps {
  bool fd{false};
  uint8_t max_len{kClassicMaxLen};
  uint32_t nominal_bps{0};  
  uint32_t data_bps{0};
  uint8_t hw_filters{0};
};
 
enum class TxResult : uint8_t { Ok = 0, QueueFull, BusOff, NotAllowed };
 
enum class BusState : uint8_t { Stopped = 0, ErrorActive, ErrorWarning, ErrorPassive, BusOff };
 
struct PortStatus {
  BusState state{BusState::Stopped};
  uint16_t tec{0};
  uint16_t rec{0};
  uint32_t rx_overruns{0};
  uint32_t tx_queue_full{0};
  uint32_t bus_off_count{0};
};
 
using RxSink = bool (*)(void* ctx, const CanFrame& frame);
using TxDoneSink = void (*)(void* ctx);
 
class ICanPort {
 public:
  virtual ~ICanPort() = default;
 
  virtual PortCaps Caps() const = 0;
  virtual TxResult Send(const CanFrame& frame) = 0;
  virtual void SetRxSink(RxSink sink, void* ctx) = 0;
  virtual PortStatus Status() const = 0;
  virtual bool Recover() = 0;
  virtual bool RxBackpressure() const { return false; }
  virtual void SetTxDoneSink(TxDoneSink sink, void* ctx) {
    (void)sink;
    (void)ctx;
  }
 
 protected:
  ICanPort() = default;
  ICanPort(const ICanPort&) = default;
  ICanPort& operator=(const ICanPort&) = default;
};
 
}  // namespace hf::can