LibXR::CH32CAN Class Reference

CH32 CAN 驱动实现 / CH32 CAN driver implementation. More...

#include <ch32_can.hpp>

Inheritance diagram for LibXR::CH32CAN:

Collaboration diagram for LibXR::CH32CAN:

Public Member Functions
	CH32CAN (ch32_can_id_t id, uint32_t queue_size)
	构造 CAN 驱动对象 / Construct CAN driver object
ErrorCode	Init ()
	初始化过滤器和中断路由 / Initialize filters and IRQ routing
ErrorCode	SetConfig (const CAN::Configuration &cfg) override
	设置 CAN 配置 / Set CAN configuration
uint32_t	GetClockFreq () const override
	获取 CAN 时钟频率 / Get CAN clock frequency
ErrorCode	AddMessage (const ClassicPack &pack) override
	发送消息入队 / Enqueue TX message
ErrorCode	GetErrorState (CAN::ErrorState &state) const override
	获取总线错误状态 / Get bus error state
void	ProcessRxInterrupt ()
	处理接收中断 / Handle RX interrupt
void	ProcessTxInterrupt ()
	处理发送中断 / Handle TX interrupt
void	ProcessErrorInterrupt ()
	处理错误中断 / Handle error interrupt
Public Member Functions inherited from LibXR::CAN
	CAN ()=default
	构造函数 / Constructor.
virtual	~CAN ()=default
	虚析构函数 / Virtual destructor.
void	Register (Callback cb, Type type, FilterMode mode=FilterMode::ID_RANGE, uint32_t start_id_mask=0, uint32_t end_id_mask=UINT32_MAX)
	注册经典 CAN 消息回调。 Register classic CAN message callback.

Static Public Attributes
static CH32CAN *	map [CH32_CAN_NUMBER] = {nullptr}
	中断分发表 / IRQ dispatch map
Static Public Attributes inherited from LibXR::CAN
static LIBXR_PACKED_END constexpr uint32_t	CAN_ERROR_ID_PREFIX = 0xFFFF0000u
	错误 ID 前缀 / Error ID prefix.

Additional Inherited Members
Public Types inherited from LibXR::CAN
enum class	Type : uint8_t {   STANDARD = 0 , EXTENDED = 1 , REMOTE_STANDARD = 2 , REMOTE_EXTENDED = 3 ,   ERROR = 4 , TYPE_NUM = 5 }
	CAN 消息类型 / CAN frame type. More...
enum class	ErrorID : uint32_t {   CAN_ERROR_ID_GENERIC = CAN_ERROR_ID_PREFIX , CAN_ERROR_ID_BUS_OFF = CAN_ERROR_ID_PREFIX + 1 , CAN_ERROR_ID_ERROR_PASSIVE = CAN_ERROR_ID_PREFIX + 2 , CAN_ERROR_ID_ERROR_WARNING = CAN_ERROR_ID_PREFIX + 3 ,   CAN_ERROR_ID_PROTOCOL = CAN_ERROR_ID_PREFIX + 4 , CAN_ERROR_ID_ACK = CAN_ERROR_ID_PREFIX + 5 , CAN_ERROR_ID_STUFF = CAN_ERROR_ID_PREFIX + 6 , CAN_ERROR_ID_FORM = CAN_ERROR_ID_PREFIX + 7 ,   CAN_ERROR_ID_BIT0 = CAN_ERROR_ID_PREFIX + 8 , CAN_ERROR_ID_BIT1 = CAN_ERROR_ID_PREFIX + 9 , CAN_ERROR_ID_CRC = CAN_ERROR_ID_PREFIX + 10 , CAN_ERROR_ID_OTHER = CAN_ERROR_ID_PREFIX + 11 }
	ClassicPack::type == Type::ERROR 时使用的虚拟 ID。 Virtual IDs used when ClassicPack::type == Type::ERROR. More...
enum class	FilterMode : uint8_t { ID_MASK = 0 , ID_RANGE = 1 }
	CAN 过滤器模式 / CAN filter mode. More...
using	Callback = LibXR::Callback<const ClassicPack&>
	回调类型 / Callback type.
Static Public Member Functions inherited from LibXR::CAN
static constexpr uint32_t	FromErrorID (ErrorID e) noexcept
	将 ErrorID 转为 id / Convert ErrorID to ClassicPack::id.
static constexpr bool	IsErrorId (uint32_t id) noexcept
	判断 id 是否处于错误 ID 空间 / Check if id is in error ID space.
static constexpr ErrorID	ToErrorID (uint32_t id) noexcept
	将 id 解释为 ErrorID / Interpret id as ErrorID.
Protected Member Functions inherited from LibXR::CAN
void	OnMessage (const ClassicPack &pack, bool in_isr)
	分发接收到的经典 CAN 帧。 Dispatch a received classic CAN frame.

Detailed Description

CH32 CAN 驱动实现 / CH32 CAN driver implementation.

设计目标与 STM32 CAN 驱动行为保持一致。 Designed to keep behavior aligned with the STM32 CAN driver.

Note

基于 WCH StdPeriph CAN 接口实现 / Implemented on top of WCH StdPeriph CAN APIs.

Definition at line 23 of file ch32_can.hpp.

Constructor & Destructor Documentation

CH32CAN()

CH32CAN::CH32CAN ( ch32_can_id_t id, uint32_t queue_size )

explicit

构造 CAN 驱动对象 / Construct CAN driver object

Parameters

id	CAN 实例编号 / CAN instance ID
queue_size	发送队列大小 / TX queue size (ClassicPack entries)

Precondition

queue_size 必须大于 1 / queue_size must be greater than 1.

Definition at line 128 of file ch32_can.cpp.

    : CAN(), instance_(CH32_CAN_GetInstanceID(id)), id_(id), tx_queue_(queue_size)
{
  if constexpr (LibXR::CH32UsbCanShared::usb_can_share_enabled())
  {
    // 端点地址在 Stop 后仍有效，不能在分配 PMA 后扩大 CAN 过滤器占用。
    // Endpoint addresses survive Stop; reserve CAN filters before allocating PMA.
    ASSERT(!LibXR::CH32UsbCanShared::usb_pma_configured.load(std::memory_order_acquire));
  }
 
#if LIBXR_CH32_HAS_CAN2
  if (id == CH32_CAN1)
  {
    filter_bank_ = 0;
    fifo_ = CAN_FilterFIFO0;  // 0
  }
  else
  {
    filter_bank_ = 14;
    fifo_ = CAN_FilterFIFO1;  // 1
  }
#else
  filter_bank_ = 0;
  fifo_ = CAN_FilterFIFO0;  // 0
#endif
 
  ASSERT(id_ < CH32_CAN_NUMBER);
  ASSERT(instance_ != nullptr);
 
  map[id_] = this;
 
  // 打开外设时钟。
  // Enable the peripheral clock.
  RCC_APB1PeriphClockCmd(CH32_CAN_RCC_PERIPH_MAP[id_], ENABLE);
#if LIBXR_CH32_HAS_CAN2
  if (id_ == CH32_CAN2)
  {
    // CAN2 的共享过滤器寄存器位于 CAN1，不能依赖应用先创建 CAN1 对象。
    // CAN2 filter registers belong to CAN1, even in a CAN2-only application.
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
  }
#endif
 
  // 在调用 SetConfig() 之前，保持 CAN 处于初始化模式。
  // Keep CAN in initialization mode until SetConfig() is called.
  (void)CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Initialization);
 
#if LIBXR_CH32_HAS_CAN2
  // 在双 CAN 变体上，配置默认的共享过滤器分界点。
  // On dual-CAN variants, configure the default shared filter split point.
  CAN_SlaveStartBank(CH32_CAN_DEFAULT_SLAVE_START_BANK);
#endif
 
  (void)Init();
}

Member Function Documentation

AddMessage()

ErrorCode CH32CAN::AddMessage ( const ClassicPack & pack )

overridevirtual

发送消息入队 / Enqueue TX message

Implements LibXR::CAN.

Definition at line 571 of file ch32_can.cpp.

{
  if (pack.type == Type::ERROR)
  {
    return ErrorCode::ARG_ERR;
  }
 
  if (tx_queue_.Put(pack) != ErrorCode::OK)
  {
    return ErrorCode::FULL;
  }
 
  TxService();
  return ErrorCode::OK;
}

GetClockFreq()

uint32_t CH32CAN::GetClockFreq ( ) const

overridevirtual

获取 CAN 时钟频率 / Get CAN clock frequency

Implements LibXR::CAN.

Definition at line 485 of file ch32_can.cpp.

{
  RCC_ClocksTypeDef clocks{};
  RCC_GetClocksFreq(&clocks);
  return clocks.PCLK1_Frequency;
}

GetErrorState()

ErrorCode CH32CAN::GetErrorState ( CAN::ErrorState & state ) const

overridevirtual

获取总线错误状态 / Get bus error state

Reimplemented from LibXR::CAN.

Definition at line 758 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return ErrorCode::ARG_ERR;
  }
 
  state.rx_error_counter = CAN_GetReceiveErrorCounter(instance_);
  state.tx_error_counter = CAN_GetLSBTransmitErrorCounter(instance_);
 
  state.bus_off = (CAN_GetFlagStatus(instance_, CAN_FLAG_BOF) != RESET);
  state.error_passive = (CAN_GetFlagStatus(instance_, CAN_FLAG_EPV) != RESET);
  state.error_warning = (CAN_GetFlagStatus(instance_, CAN_FLAG_EWG) != RESET);
 
  return ErrorCode::OK;
}

Init()

ErrorCode CH32CAN::Init

(

)

初始化过滤器和中断路由 / Initialize filters and IRQ routing

Definition at line 184 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // 默认全接收过滤器（ID-mask 模式，全 0）。
  // Default accept-all filter (ID-mask mode, all zeros).
  CAN_FilterInitTypeDef f = {};
  f.CAN_FilterIdHigh = 0u;
  f.CAN_FilterIdLow = 0u;
  f.CAN_FilterMaskIdHigh = 0u;
  f.CAN_FilterMaskIdLow = 0u;
  f.CAN_FilterFIFOAssignment = fifo_;
  f.CAN_FilterNumber = filter_bank_;
  f.CAN_FilterMode = CAN_FilterMode_IdMask;
  f.CAN_FilterScale = CAN_FilterScale_32bit;
  f.CAN_FilterActivation = ENABLE;
 
  CAN_FilterInit(&f);
 
  // 在放行中断源之前发布回调，防止已有 pending 中断进入空分发器。
  // Publish callbacks before enabling an interrupt source with pending events.
  if constexpr (LibXR::CH32UsbCanShared::usb_can_irq_share_enabled())
  {
#if defined(CAN1) && defined(RCC_APB1Periph_USB)
    if (id_ == CH32_CAN1)
    {
      LibXR::CH32UsbCanShared::register_can1_rx0(&can1_rx0_thunk);
      LibXR::CH32UsbCanShared::register_can1_tx(&can1_tx_thunk);
      LibXR::CH32UsbCanShared::can1_inited.store(true, std::memory_order_release);
    }
#if LIBXR_CH32_HAS_CAN2
    else if (id_ == CH32_CAN2)
    {
      LibXR::CH32UsbCanShared::can2_inited.store(true, std::memory_order_release);
    }
#endif
#endif
  }
 
  EnableIRQs();
  ch32_can_enable_nvic(id_, fifo_);
 
  return ErrorCode::OK;
}

ProcessErrorInterrupt()

void CH32CAN::ProcessErrorInterrupt

(

)

处理错误中断 / Handle error interrupt

Definition at line 663 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return;
  }
 
  // 在清 pending 位前先快照错误标志和 LEC。
  // Snapshot error flags and LEC before clearing pending bits.
  const bool BOF = (CAN_GetFlagStatus(instance_, CAN_FLAG_BOF) != RESET);
  const bool EPV = (CAN_GetFlagStatus(instance_, CAN_FLAG_EPV) != RESET);
  const bool EWG = (CAN_GetFlagStatus(instance_, CAN_FLAG_EWG) != RESET);
  const uint8_t LEC = CAN_GetLastErrorCode(instance_);
 
#ifdef CAN_IT_LEC
  if (CAN_GetITStatus(instance_, CAN_IT_LEC) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_LEC);
  }
#endif
#ifdef CAN_IT_ERR
  if (CAN_GetITStatus(instance_, CAN_IT_ERR) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_ERR);
  }
#endif
#ifdef CAN_IT_BOF
  if (CAN_GetITStatus(instance_, CAN_IT_BOF) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_BOF);
  }
#endif
#ifdef CAN_IT_EPV
  if (CAN_GetITStatus(instance_, CAN_IT_EPV) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_EPV);
  }
#endif
#ifdef CAN_IT_EWG
  if (CAN_GetITStatus(instance_, CAN_IT_EWG) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_EWG);
  }
#endif
 
  ClassicPack p{};
  p.type = Type::ERROR;
  p.dlc = 0u;
 
  CAN::ErrorID eid = CAN::ErrorID::CAN_ERROR_ID_GENERIC;
 
  if (BOF)
  {
    eid = CAN::ErrorID::CAN_ERROR_ID_BUS_OFF;
  }
  else if (EPV)
  {
    eid = CAN::ErrorID::CAN_ERROR_ID_ERROR_PASSIVE;
  }
  else if (EWG)
  {
    eid = CAN::ErrorID::CAN_ERROR_ID_ERROR_WARNING;
  }
  else
  {
    switch (LEC)
    {
      case CAN_ErrorCode_StuffErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_STUFF;
        break;
      case CAN_ErrorCode_FormErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_FORM;
        break;
      case CAN_ErrorCode_ACKErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_ACK;
        break;
      case CAN_ErrorCode_BitRecessiveErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_BIT1;
        break;
      case CAN_ErrorCode_BitDominantErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_BIT0;
        break;
      case CAN_ErrorCode_CRCErr:
        eid = CAN::ErrorID::CAN_ERROR_ID_CRC;
        break;
      default:
        eid = CAN::ErrorID::CAN_ERROR_ID_OTHER;
        break;
    }
  }
 
  p.id = static_cast<uint32_t>(eid);
  OnMessage(p, true);
}

ProcessRxInterrupt()

void CH32CAN::ProcessRxInterrupt

(

)

处理接收中断 / Handle RX interrupt

Definition at line 605 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return;
  }
 
  // 先排空 RX FIFO，再确认 RX 挂起标志。
  // Drain the RX FIFO first, then acknowledge RX pending flags.
  while (CAN_MessagePending(instance_, fifo_) != 0u)
  {
    CAN_Receive(instance_, fifo_, &rx_msg_);
 
    ClassicPack p{};
    if (rx_msg_.IDE == CAN_ID_STD)
    {
      p.id = rx_msg_.StdId;
      p.type = Type::STANDARD;
    }
    else
    {
      p.id = rx_msg_.ExtId;
      p.type = Type::EXTENDED;
    }
 
    if (rx_msg_.RTR == CAN_RTR_REMOTE)
    {
      p.type = (p.type == Type::STANDARD) ? Type::REMOTE_STANDARD : Type::REMOTE_EXTENDED;
    }
 
    p.dlc = (rx_msg_.DLC <= 8u) ? rx_msg_.DLC : 8u;
    std::memcpy(p.data, rx_msg_.Data, 8);
 
    OnMessage(p, true);
  }
 
  // 确认 RX 挂起标志。
  // Acknowledge RX pending flags.
#ifdef CAN_IT_FMP0
  if (fifo_ == 0u)
  {
    if (CAN_GetITStatus(instance_, CAN_IT_FMP0) != RESET)
    {
      CAN_ClearITPendingBit(instance_, CAN_IT_FMP0);
    }
  }
#endif
#ifdef CAN_IT_FMP1
  if (fifo_ == 1u)
  {
    if (CAN_GetITStatus(instance_, CAN_IT_FMP1) != RESET)
    {
      CAN_ClearITPendingBit(instance_, CAN_IT_FMP1);
    }
  }
#endif
}

ProcessTxInterrupt()

void CH32CAN::ProcessTxInterrupt

(

)

处理发送中断 / Handle TX interrupt

Definition at line 587 of file ch32_can.cpp.

{
#ifdef CAN_IT_TME
  if (instance_ == nullptr)
  {
    return;
  }
 
  if (CAN_GetITStatus(instance_, CAN_IT_TME) != RESET)
  {
    CAN_ClearITPendingBit(instance_, CAN_IT_TME);
    TxService();
  }
#else
  TxService();
#endif
}

SetConfig()

ErrorCode CH32CAN::SetConfig ( const CAN::Configuration & cfg )

overridevirtual

设置 CAN 配置 / Set CAN configuration

Implements LibXR::CAN.

Definition at line 364 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // 保证所有返回路径都会恢复 IRQ 状态。
  // Ensure IRQ state restoration on all return paths.
  struct IrqGuard
  {
    CH32CAN* self;
    explicit IrqGuard(CH32CAN* s) : self(s) { self->DisableIRQs(); }
    ~IrqGuard() { self->EnableIRQs(); }
  } guard(this);
 
  ErrorCode ec = ErrorCode::OK;
  bool entered_init = false;
 
  // 构造实际使用的时序参数；为 0 的字段复用缓存配置。
  // Build effective timing values; zero fields reuse cached configuration.
  CAN::Configuration cfg = cfg_in;
 
  if (!fill_keep_zero_from_cache(cfg.bit_timing, cfg_cache_.bit_timing))
  {
    return ErrorCode::ARG_ERR;
  }
 
  // 校验 bxCAN 时序约束。
  // Validate bxCAN timing constraints.
  const CAN::BitTiming& bt = cfg.bit_timing;
 
  // BRP: 1..1024.
  if (bt.brp < 1u || bt.brp > 1024u)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // BS1 = PROP_SEG + PHASE_SEG1: 1..16.
  const uint32_t BS1 = bt.prop_seg + bt.phase_seg1;
  if (BS1 < 1u || BS1 > 16u)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // BS2: 1..8.
  if (bt.phase_seg2 < 1u || bt.phase_seg2 > 8u)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // SJW: 1..4 and SJW <= BS2.
  if (bt.sjw < 1u || bt.sjw > 4u || bt.sjw > bt.phase_seg2)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // 进入初始化模式。
  // Enter initialization mode.
  if (CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Initialization) ==
      CAN_ModeStatus_Failed)
  {
    return ErrorCode::FAILED;
  }
  entered_init = true;
 
  // 填充并应用初始化结构体。
  // Apply the initialization structure.
  CAN_InitTypeDef init;
  std::memset(&init, 0, sizeof(init));
  CAN_StructInit(&init);
 
  init.CAN_Prescaler = static_cast<uint16_t>(bt.brp);
  init.CAN_Mode = ch32_can_mode_macro(cfg.mode);
 
  init.CAN_SJW = static_cast<uint8_t>(bt.sjw - 1u);
  init.CAN_BS1 = static_cast<uint8_t>(BS1 - 1u);
  init.CAN_BS2 = static_cast<uint8_t>(bt.phase_seg2 - 1u);
 
  // 工作模式映射。
  // Mode mapping.
  init.CAN_NART = cfg.mode.one_shot ? ENABLE : DISABLE;
 
  // 控制器默认选项。
  // Default controller options.
  init.CAN_TTCM = DISABLE;
  init.CAN_ABOM = ENABLE;   // auto bus-off management
  init.CAN_AWUM = DISABLE;  // auto wake-up
  init.CAN_RFLM = DISABLE;  // FIFO not locked
  init.CAN_TXFP = ENABLE;   // prioritize by TX request order
 
  if (CAN_Init(instance_, &init) != CAN_InitStatus_Success)
  {
    ec = ErrorCode::FAILED;
  }
  else
  {
    if (CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Normal) ==
        CAN_ModeStatus_Failed)
    {
      ec = ErrorCode::FAILED;
    }
    else
    {
      // 仅在配置成功后更新缓存。
      // Update the cache only on successful configuration.
      cfg_cache_ = cfg;
      ec = ErrorCode::OK;
    }
  }
 
  // 如果进入 init 模式后配置失败，则请求回到 normal 模式。
  // If configuration fails after entering init mode, request normal mode.
  if (ec != ErrorCode::OK && entered_init)
  {
    (void)CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Normal);
  }
 
  return ec;
}

Member Data Documentation

map

CH32CAN * CH32CAN::map = {nullptr}

static

中断分发表 / IRQ dispatch map

Definition at line 77 of file ch32_can.hpp.

---

The documentation for this class was generated from the following files:

• driver/ch/ch32_can.hpp
• driver/ch/ch32_can.cpp