LibXR::CH32CAN Class Reference

CH32CAN driver (bxCAN-like) for LibXR::CAN. 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)
	Construct CH32CAN.
ErrorCode	Init ()
	Initialize filter + IRQ routing. Does NOT force a bitrate; call SetConfig().
ErrorCode	SetConfig (const CAN::Configuration &cfg) override
	Set CAN configuration (bit timing + mode). Also (re-)enables IRQs.
uint32_t	GetClockFreq () const override
	CAN clock frequency (Hz). CH32 CAN is on APB1.
ErrorCode	AddMessage (const ClassicPack &pack) override
	Enqueue a ClassicPack for transmission.
ErrorCode	GetErrorState (CAN::ErrorState &state) const override
	Read bus error state and counters.
void	ProcessRxInterrupt ()
	Process RX interrupt (call from CANx_RX0 / CANx_RX1 handlers).
void	ProcessTxInterrupt ()
	Process TX interrupt (call from CANx_TX handler).
void	ProcessErrorInterrupt ()
	Process SCE/error interrupt (call from CANx_SCE handler).
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}
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_ {}
CanRxMsg	rx_msg_ {}
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

CH32CAN driver (bxCAN-like) for LibXR::CAN.

Design goals (aligned with your STM32CAN driver):

• Lock-free TX queue (LockFreePool) + mailbox service in IRQ / thread contexts.
• RX dispatch in ISR via LibXR::CAN::OnMessage().
• Error to "virtual error frame" mapping using LibXR::CAN::ErrorID.

Notes:

• This driver is written against WCH StdPeriph CAN API (CAN_Init / CAN_Transmit / CAN_Receive / CAN_ITConfig...).
• Bit timing fields in Configuration are interpreted as: BRP, (PROP_SEG + PHASE_SEG1) -> BS1, PHASE_SEG2 -> BS2, SJW.
• triple_sampling is ignored (WCH StdPeriph init struct has no such field).

Definition at line 30 of file ch32_can.hpp.

Constructor & Destructor Documentation

CH32CAN()

CH32CAN::CH32CAN ( ch32_can_id_t id, uint32_t pool_size )

explicit

Construct CH32CAN.

Parameters

id	CAN instance ID.
pool_size	TX pool size (number of ClassicPack entries).

Definition at line 113 of file ch32_can.cpp.

    : CAN(), instance_(CH32_CAN_GetInstanceID(id)), id_(id), tx_pool_(pool_size)
{
#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 peripheral clock
  RCC_APB1PeriphClockCmd(CH32_CAN_RCC_PERIPH_MAP[id_], ENABLE);
 
  // Keep CAN in initialization mode until user calls SetConfig().
  (void)CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Initialization);
 
#if defined(CAN2)
  // If dual CAN exists and filters are shared, set a typical 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 a ClassicPack for transmission.

Implements LibXR::CAN.

Definition at line 509 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 442 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 180 of file ch32_can.cpp.

{
  if (instance_ == nullptr) return;
 
  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 219 of file ch32_can.cpp.

{
  if (instance_ == nullptr) return;
 
  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)
  {
    // WCH StdPeriph examples: clear pending bits before enabling interrupts
    // to avoid spurious entry and ensure proper ACK in some variants.
#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 clock frequency (Hz). CH32 CAN is on APB1.

Implements LibXR::CAN.

Definition at line 435 of file ch32_can.cpp.

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

GetErrorState()

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

overridevirtual

Read bus error state and counters.

Reimplemented from LibXR::CAN.

Definition at line 688 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 filter + IRQ routing. Does NOT force a bitrate; call SetConfig().

Definition at line 151 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // ===== Accept-all filter (ID Mask, 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();
 
  // Enable NVIC for this CAN instance (handles WCH alias IRQ names correctly)
  CH32_CAN_EnableNVIC(id_, fifo_);
 
  return ErrorCode::OK;
}

ProcessErrorInterrupt()

void CH32CAN::ProcessErrorInterrupt

(

)

Process SCE/error interrupt (call from CANx_SCE handler).

Definition at line 595 of file ch32_can.cpp.

{
  if (instance_ == nullptr) return;
 
  // NOTE (Fix #2):
  // WCH CAN_ClearITPendingBit(CAN_IT_ERR/CAN_IT_LEC) clears ERRSR.
  // Therefore snapshot flags + LEC BEFORE clearing any 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

(

)

Process RX interrupt (call from CANx_RX0 / CANx_RX1 handlers).

Definition at line 540 of file ch32_can.cpp.

{
  if (instance_ == nullptr) return;
 
  // NOTE:
  // WCH examples clear FMP pending in RX ISR.
  // We keep the "drain FIFO" behavior and ACK pending at the end.
  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);
  }
 
  // ACK RX pending (WCH StdPeriph style)
#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

(

)

Process TX interrupt (call from CANx_TX handler).

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

Set CAN configuration (bit timing + mode). Also (re-)enables IRQs.

Implements LibXR::CAN.

Definition at line 308 of file ch32_can.cpp.

{
  if (instance_ == nullptr)
  {
    return ErrorCode::ARG_ERR;
  }
 
  // RAII: ensure IRQs are always restored even if we early-return
  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;
 
  // Build an "effective" timing: support "0 means keep last applied".
  CAN::Configuration cfg = cfg_in;
 
  // Normalize bit timing (fill zeros from cache)
  if (!is_nonzero_bit_timing(cfg.bit_timing))
  {
    if (!fill_keep_zero_from_cache(cfg.bit_timing, cfg_cache_.bit_timing))
    {
      return ErrorCode::ARG_ERR;
    }
  }
  else
  {
    if (!fill_keep_zero_from_cache(cfg.bit_timing, cfg_cache_.bit_timing))
    {
      return ErrorCode::ARG_ERR;
    }
  }
 
  // ===== Validate timing (bxCAN 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 + phase1: 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 init struct =====
  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 knobs (best-effort mapping)
  init.CAN_NART = cfg.mode.one_shot ? ENABLE : DISABLE;
 
  // Reasonable defaults
  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 cache only when success
      cfg_cache_ = cfg;
      ec = ErrorCode::OK;
    }
  }
 
  // Best-effort: if we entered init but failed later, try to return to normal
  if (ec != ErrorCode::OK && entered_init)
  {
    (void)CAN_OperatingModeRequest(instance_, CAN_OperatingMode_Normal);
  }
 
  return ec;
}

TxService()

void CH32CAN::TxService ( )

private

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

Definition at line 105 of file ch32_can.hpp.

{};

fifo_

uint8_t LibXR::CH32CAN::fifo_ {0}

private

Definition at line 96 of file ch32_can.hpp.

{0};

filter_bank_

uint8_t LibXR::CH32CAN::filter_bank_ {0}

private

Definition at line 97 of file ch32_can.hpp.

{0};

id_

ch32_can_id_t LibXR::CH32CAN::id_ {CH32_CAN_ID_ERROR}

private

Definition at line 94 of file ch32_can.hpp.

{CH32_CAN_ID_ERROR};

instance_

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

private

Definition at line 93 of file ch32_can.hpp.

{nullptr};

map

CH32CAN * CH32CAN::map = {nullptr}

static

Definition at line 82 of file ch32_can.hpp.

rx_msg_

CanRxMsg LibXR::CH32CAN::rx_msg_ {}

private

Definition at line 108 of file ch32_can.hpp.

{};

tx_lock_

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

private

Definition at line 101 of file ch32_can.hpp.

{0};

tx_msg_

CanTxMsg LibXR::CH32CAN::tx_msg_ {}

private

Definition at line 109 of file ch32_can.hpp.

{};

tx_pend_

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

private

Definition at line 102 of file ch32_can.hpp.

{0};

tx_pool_

LockFreePool<ClassicPack> LibXR::CH32CAN::tx_pool_

private

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