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 pool_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 constexpr uint32_t	CAN_ERROR_ID_PREFIX = 0xFFFF0000u
	错误 ID 前缀 Error ID prefix.

Private Member Functions
void	EnableIRQs ()
void	DisableIRQs ()
void	TxService ()

Static Private Member Functions
static void	BuildTxMsg (const ClassicPack &p, CanTxMsg &m)

Private Attributes
CAN_TypeDef *	instance_ {nullptr}
ch32_can_id_t	id_ {CH32_CAN_ID_ERROR}
uint8_t	fifo_ {0}
uint8_t	filter_bank_ {0}
LockFreePool< ClassicPack >	tx_pool_
std::atomic< uint32_t >	tx_lock_ {0}
std::atomic< uint32_t >	tx_pend_ {0}
CAN::Configuration	cfg_cache_ {}
	缓存配置（用于保留原值语义） / Cached configuration for keep-previous semantics
CanRxMsg	rx_msg_ {}
	中断上下文收发缓冲 / RX/TX buffers in IRQ context
CanTxMsg	tx_msg_ {}

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 pool_size )

explicit

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

Parameters

id	CAN 实例编号 / CAN instance ID
pool_size	发送池大小 / TX pool size (ClassicPack entries)

Definition at line 128 of file ch32_can.cpp.

    : CAN(), instance_(CH32_CAN_GetInstanceID(id)), id_(id), tx_pool_(pool_size)
{
  if constexpr (LibXR::CH32UsbCanShared::usb_can_share_enabled())
  {
#if defined(CAN1) && !defined(CAN2)
    const bool USB_ALREADY_INITED =
        LibXR::CH32UsbCanShared::usb_inited.load(std::memory_order_acquire);
    // 在 USB/CAN 共享中断拓扑下，CAN1 必须先于 USB 初始化。
    // On shared USB/CAN interrupt configurations, CAN1 must initialize before USB.
    ASSERT(USB_ALREADY_INITED == false);
#endif
  }
 
#if defined(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);
 
  // 在调用 SetConfig() 之前，保持 CAN 处于初始化模式。
  // Keep CAN in initialization mode until SetConfig() is called.
  (void)CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Initialization);
 
#if defined(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 554 of file ch32_can.cpp.

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

BuildTxMsg()

void CH32CAN::BuildTxMsg ( const ClassicPack & p, CanTxMsg & m )

inlinestaticprivate

Definition at line 484 of file ch32_can.cpp.

{
  const bool IS_EXT = (p.type == Type::EXTENDED) || (p.type == Type::REMOTE_EXTENDED);
  const bool IS_RTR =
      (p.type == Type::REMOTE_STANDARD) || (p.type == Type::REMOTE_EXTENDED);
 
  m.DLC = (p.dlc <= 8u) ? static_cast<uint8_t>(p.dlc) : 8u;
  m.IDE = IS_EXT ? CAN_ID_EXT : CAN_ID_STD;
  m.RTR = IS_RTR ? CAN_RTR_REMOTE : CAN_RTR_DATA;
 
  m.StdId = IS_EXT ? 0u : (p.id & 0x7FFu);
  m.ExtId = IS_EXT ? (p.id & 0x1FFFFFFFu) : 0u;
 
  std::memcpy(m.Data, p.data, 8);
}

DisableIRQs()

void CH32CAN::DisableIRQs ( )

private

Definition at line 220 of file ch32_can.cpp.

{
  uint32_t it = 0u;
 
#ifdef CAN_IT_FMP0
  if (fifo_ == 0u)
  {
    it |= CAN_IT_FMP0;
  }
#endif
#ifdef CAN_IT_FMP1
  if (fifo_ == 1u)
  {
    it |= CAN_IT_FMP1;
  }
#endif
 
#ifdef CAN_IT_TME
  it |= CAN_IT_TME;
#endif
 
#ifdef CAN_IT_ERR
  it |= CAN_IT_ERR;
#endif
#ifdef CAN_IT_BOF
  it |= CAN_IT_BOF;
#endif
#ifdef CAN_IT_EPV
  it |= CAN_IT_EPV;
#endif
#ifdef CAN_IT_EWG
  it |= CAN_IT_EWG;
#endif
#ifdef CAN_IT_LEC
  it |= CAN_IT_LEC;
#endif
 
  if (it != 0u)
  {
    CAN_ITConfig(instance_, it, DISABLE);
  }
}

EnableIRQs()

void CH32CAN::EnableIRQs ( )

private

Definition at line 263 of file ch32_can.cpp.

{
  uint32_t it = 0u;
 
#ifdef CAN_IT_FMP0
  if (fifo_ == 0u)
  {
    it |= CAN_IT_FMP0;
  }
#endif
#ifdef CAN_IT_FMP1
  if (fifo_ == 1u)
  {
    it |= CAN_IT_FMP1;
  }
#endif
 
#ifdef CAN_IT_TME
  it |= CAN_IT_TME;
#endif
 
#ifdef CAN_IT_ERR
  it |= CAN_IT_ERR;
#endif
#ifdef CAN_IT_BOF
  it |= CAN_IT_BOF;
#endif
#ifdef CAN_IT_EPV
  it |= CAN_IT_EPV;
#endif
#ifdef CAN_IT_EWG
  it |= CAN_IT_EWG;
#endif
#ifdef CAN_IT_LEC
  it |= CAN_IT_LEC;
#endif
 
  if (it != 0u)
  {
    // Clear pending interrupt flags before enabling interrupt sources.
#ifdef CAN_IT_TME
    if ((it & CAN_IT_TME) != 0u)
    {
      CAN_ClearITPendingBit(instance_, CAN_IT_TME);
    }
#endif
 
#ifdef CAN_IT_FMP0
    if (fifo_ == 0u && ((it & CAN_IT_FMP0) != 0u))
    {
      CAN_ClearITPendingBit(instance_, CAN_IT_FMP0);
    }
#endif
#ifdef CAN_IT_FMP1
    if (fifo_ == 1u && ((it & CAN_IT_FMP1) != 0u))
    {
      CAN_ClearITPendingBit(instance_, CAN_IT_FMP1);
    }
#endif
 
    CAN_ITConfig(instance_, it, ENABLE);
  }
}

GetClockFreq()

uint32_t CH32CAN::GetClockFreq ( ) const

overridevirtual

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

Implements LibXR::CAN.

Definition at line 477 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 741 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 180 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);
 
  EnableIRQs();
 
  // 为当前 CAN 实例打开 NVIC。
  // Enable NVIC for this CAN instance.
  ch32_can_enable_nvic(id_, fifo_);
 
  if constexpr (LibXR::CH32UsbCanShared::usb_can_share_enabled())
  {
#if defined(CAN1) && !defined(CAN2)
    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);
#endif
  }
 
  return ErrorCode::OK;
}

ProcessErrorInterrupt()

void CH32CAN::ProcessErrorInterrupt

(

)

处理错误中断 / Handle error interrupt

Definition at line 646 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 588 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 570 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 352 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)
  {
    ASSERT(false);
    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)
  {
    ASSERT(false);
    return ErrorCode::ARG_ERR;
  }
 
  // BS2: 1..8.
  if (bt.phase_seg2 < 1u || bt.phase_seg2 > 8u)
  {
    ASSERT(false);
    return ErrorCode::ARG_ERR;
  }
 
  // SJW: 1..4 and SJW <= BS2.
  if (bt.sjw < 1u || bt.sjw > 4u || bt.sjw > bt.phase_seg2)
  {
    ASSERT(false);
    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;
}

TxService()

void CH32CAN::TxService ( )

private

Definition at line 500 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return;
  }
 
  tx_pend_.store(1u, std::memory_order_release);
 
  uint32_t expected = 0u;
  if (!tx_lock_.compare_exchange_strong(expected, 1u, std::memory_order_acquire,
                                        std::memory_order_relaxed))
  {
    return;
  }
 
  for (;;)
  {
    tx_pend_.store(0u, std::memory_order_release);
 
    for (;;)
    {
      ClassicPack p{};
      if (tx_pool_.Get(p) != ErrorCode::OK)
      {
        break;
      }
 
      BuildTxMsg(p, tx_msg_);
 
      uint8_t mb = CAN_Transmit(instance_, &tx_msg_);
      if (mb == CAN_TxStatus_NoMailBox)
      {
        (void)tx_pool_.Put(p);
        break;
      }
    }
 
    tx_lock_.store(0u, std::memory_order_release);
 
    if (tx_pend_.load(std::memory_order_acquire) == 0u)
    {
      return;
    }
 
    expected = 0u;
    if (!tx_lock_.compare_exchange_strong(expected, 1u, std::memory_order_acquire,
                                          std::memory_order_relaxed))
    {
      return;
    }
  }
}

Field Documentation

cfg_cache_

CAN::Configuration LibXR::CH32CAN::cfg_cache_ {}

private

缓存配置（用于保留原值语义） / Cached configuration for keep-previous semantics

Definition at line 99 of file ch32_can.hpp.

{};

fifo_

uint8_t LibXR::CH32CAN::fifo_ {0}

private

Definition at line 90 of file ch32_can.hpp.

{0};

filter_bank_

uint8_t LibXR::CH32CAN::filter_bank_ {0}

private

Definition at line 91 of file ch32_can.hpp.

{0};

id_

ch32_can_id_t LibXR::CH32CAN::id_ {CH32_CAN_ID_ERROR}

private

Definition at line 88 of file ch32_can.hpp.

{CH32_CAN_ID_ERROR};

instance_

CAN_TypeDef* LibXR::CH32CAN::instance_ {nullptr}

private

Definition at line 87 of file ch32_can.hpp.

{nullptr};

map

CH32CAN * CH32CAN::map = {nullptr}

static

中断分发表 / IRQ dispatch map

Definition at line 76 of file ch32_can.hpp.

rx_msg_

CanRxMsg LibXR::CH32CAN::rx_msg_ {}

private

中断上下文收发缓冲 / RX/TX buffers in IRQ context

Definition at line 102 of file ch32_can.hpp.

{};

tx_lock_

std::atomic<uint32_t> LibXR::CH32CAN::tx_lock_ {0}

private

Definition at line 95 of file ch32_can.hpp.

{0};

tx_msg_

CanTxMsg LibXR::CH32CAN::tx_msg_ {}

private

Definition at line 103 of file ch32_can.hpp.

{};

tx_pend_

std::atomic<uint32_t> LibXR::CH32CAN::tx_pend_ {0}

private

Definition at line 96 of file ch32_can.hpp.

{0};

tx_pool_

LockFreePool<ClassicPack> LibXR::CH32CAN::tx_pool_

private

Definition at line 93 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