stm32_can.hpp

#pragma once
 
#include "main.h"
 
#ifdef HAL_CAN_MODULE_ENABLED
 
#ifdef CAN
#if !defined(CAN1)
#define CAN1 ((CAN_TypeDef*)CAN_BASE)
#endif
#undef CAN
#endif
 
#include "can.hpp"
#include "queue.hpp"
 
typedef enum
{
#ifdef CAN1
  STM32_CAN1,
#endif
#ifdef CAN2
  STM32_CAN2,
#endif
#ifdef CAN3
  STM32_CAN3,
#endif
  STM32_CAN_NUMBER,
  STM32_CAN_ID_ERROR
} stm32_can_id_t;
 
static_assert(STM32_CAN_NUMBER >= 1, "No CAN instance detected for this MCU");
 
stm32_can_id_t STM32_CAN_GetID(CAN_TypeDef* addr);  // NOLINT
 
namespace LibXR
{
class STM32CAN : public CAN
{
 public:
  STM32CAN(CAN_HandleTypeDef* hcan, uint32_t queue_size);
 
  ErrorCode Init(void);
 
  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 ProcessErrorInterrupt();
 
  CAN_HandleTypeDef* hcan_;
 
  stm32_can_id_t id_;
  uint32_t fifo_;
  static STM32CAN* map[STM32_CAN_NUMBER];  // NOLINT
 
  struct
  {
    CAN_RxHeaderTypeDef header;
    ClassicPack pack;
  } rx_buff_;
 
  struct
  {
    CAN_TxHeaderTypeDef header;
    ClassicPack pack;
  } tx_buff_;
 
  uint32_t txMailbox;
 
  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};
 
  static inline void BuildTxHeader(const ClassicPack& p, CAN_TxHeaderTypeDef& h);
 
  void TxService();
};
}  // namespace LibXR
 
#endif