ch32_can.hpp

#pragma once
 
#include <atomic>
#include <cstdint>
#include <cstring>
 
#include "can.hpp"
#include "ch32_can_def.hpp"
#include "queue.hpp"
 
#include DEF2STR(LIBXR_CH32_CONFIG_FILE)
 
namespace LibXR
{
class CH32CAN : public CAN
{
 public:
  explicit CH32CAN(ch32_can_id_t id, uint32_t queue_size);
  ~CH32CAN() override = default;
 
  ErrorCode Init();
 
  ErrorCode SetConfig(const CAN::Configuration& cfg) override;
 
  uint32_t GetClockFreq() const override;
 
  ErrorCode AddMessage(const ClassicPack& pack) override;
 
  ErrorCode GetErrorState(CAN::ErrorState& state) const override;
 
  void ProcessRxInterrupt();
 
  void ProcessTxInterrupt();
 
  void ProcessErrorInterrupt();
 
  static CH32CAN* map[CH32_CAN_NUMBER];  // NOLINT
 
 private:
  static inline void BuildTxMsg(const ClassicPack& p, CanTxMsg& m);
 
  void EnableIRQs();
  void DisableIRQs();
 
  void TxService();
 
 private:
  CAN_TypeDef* instance_{nullptr};
  ch32_can_id_t id_{CH32_CAN_ID_ERROR};
 
  uint8_t fifo_{0};
  uint8_t filter_bank_{0};
 
  MPMCQueue<ClassicPack> tx_queue_;
  bool tx_retry_valid_{false};
  ClassicPack tx_retry_pack_{};
 
  std::atomic<uint32_t> tx_lock_{0};
  std::atomic<uint32_t> tx_pend_{0};
 
  CAN::Configuration cfg_cache_{};
 
  CanRxMsg rx_msg_{};
  CanTxMsg tx_msg_{};
};
}  // namespace LibXR