LibXR::STM32CAN Class Reference

STM32CAN 类，用于处理 STM32 系统的 CAN 通道。 Provides handling for STM32 CAN channels. More...

#include <stm32_can.hpp>

Inheritance diagram for LibXR::STM32CAN:

Collaboration diagram for LibXR::STM32CAN:

Public Member Functions
	STM32CAN (CAN_HandleTypeDef *hcan, uint32_t pool_size)
	STM32CAN 类，用于处理 STM32 系统的 CAN 通道。 Provides handling for STM32 CAN.
ErrorCode	Init (void)
	初始化
ErrorCode	AddMessage (const ClassicPack &pack) override
	添加 CAN 消息到系统 (Adds a CAN message to the system).
void	ProcessRxInterrupt ()
	处理接收中断
void	ProcessTxInterrupt ()
	处理发送中断
Public Member Functions inherited from LibXR::CAN
	CAN ()
	构造 CAN 对象，可指定主题名称和通信域 (Constructs a CAN object with an optional topic name and domain).
struct	__attribute__ ((packed))
	经典 CAN 消息结构 (Structure representing a classic CAN message).
void	Register (Callback cb, Type type, FilterMode mode=FilterMode::ID_RANGE, uint32_t start_id_mask=0, uint32_t end_id_match=UINT32_MAX)
	注册回调函数 Registers a callback function

Data Fields
CAN_HandleTypeDef *	hcan_
stm32_can_id_t	id_
uint32_t	fifo_
struct {
CAN_RxHeaderTypeDef   header
ClassicPack   pack
}	rx_buff_
struct {
CAN_TxHeaderTypeDef   header
ClassicPack   pack
}	tx_buff_
uint32_t	txMailbox
LockFreePool< ClassicPack >	tx_pool_
std::atomic< uint32_t >	bus_busy_ = 0
Data Fields inherited from LibXR::CAN
	ClassicPack

Static Public Attributes
static STM32CAN *	map [STM32_CAN_NUMBER] = {nullptr}

Additional Inherited Members
Public Types inherited from LibXR::CAN
enum class	Type : uint8_t {   STANDARD = 0 , EXTENDED = 1 , REMOTE_STANDARD = 2 , REMOTE_EXTENDED = 3 ,   TYPE_NUM }
	CAN 消息类型 (Enumeration of CAN message types). More...
enum class	FilterMode : uint8_t { ID_MASK = 0 , ID_RANGE = 1 }
using	Callback = LibXR::Callback<const ClassicPack &>
Protected Member Functions inherited from LibXR::CAN
void	OnMessage (const ClassicPack &pack, bool in_isr)

Detailed Description

STM32CAN 类，用于处理 STM32 系统的 CAN 通道。 Provides handling for STM32 CAN channels.

Definition at line 38 of file stm32_can.hpp.

Constructor & Destructor Documentation

STM32CAN()

STM32CAN::STM32CAN	(	CAN_HandleTypeDef *	hcan,
		uint32_t	pool_size )

STM32CAN 类，用于处理 STM32 系统的 CAN 通道。 Provides handling for STM32 CAN.

Parameters

hcan	STM32CAN对象 CAN object
pool_size	发送池大小 Send pool size

Definition at line 47 of file stm32_can.cpp.

    : CAN(), hcan_(hcan), id_(STM32_CAN_GetID(hcan->Instance)), tx_pool_(pool_size)
{
  map[id_] = this;
  Init();
}

Member Function Documentation

AddMessage()

ErrorCode STM32CAN::AddMessage ( const ClassicPack & pack )

overridevirtual

添加 CAN 消息到系统 (Adds a CAN message to the system).

Parameters

pack	经典 CAN 消息包 (The classic CAN message packet).

Returns

操作结果 (ErrorCode indicating success or failure).

Implements LibXR::CAN.

Definition at line 139 of file stm32_can.cpp.

{
  CAN_TxHeaderTypeDef txHeader;  // NOLINT
 
  txHeader.DLC = sizeof(pack.data);
 
  switch (pack.type)
  {
    case Type::STANDARD:
      txHeader.IDE = CAN_ID_STD;
      txHeader.RTR = CAN_RTR_DATA;
      break;
    case Type::EXTENDED:
      txHeader.IDE = CAN_ID_EXT;
      txHeader.RTR = CAN_RTR_DATA;
      break;
    case Type::REMOTE_STANDARD:
      txHeader.IDE = CAN_ID_STD;
      txHeader.RTR = CAN_RTR_REMOTE;
      break;
    case Type::REMOTE_EXTENDED:
      txHeader.IDE = CAN_ID_EXT;
      txHeader.RTR = CAN_RTR_REMOTE;
      break;
    default:
      ASSERT(false);
      return ErrorCode::FAILED;
  }
  txHeader.StdId = (pack.type == Type::EXTENDED) ? 0 : pack.id;
  txHeader.ExtId = (pack.type == Type::EXTENDED) ? pack.id : 0;
  txHeader.TransmitGlobalTime = DISABLE;
 
  while (true)
  {
    uint32_t slot = 0;
 
    if (HAL_CAN_AddTxMessage(hcan_, &txHeader, pack.data, &txMailbox) != HAL_OK)
    {
      if (tx_pool_.Put(pack, slot) != ErrorCode::OK)
      {
        return ErrorCode::FULL;
      }
    }
    else
    {
      return ErrorCode::OK;
    }
 
    if (bus_busy_.load(std::memory_order_acquire) == 0 &&
        tx_pool_.RecycleSlot(slot) == ErrorCode::OK)
    {
      continue;
    }
    else
    {
      return ErrorCode::OK;
    }
  }
}

Init()

ErrorCode STM32CAN::Init

(

void

)

初始化

Returns

ErrorCode

Definition at line 54 of file stm32_can.cpp.

{
  CAN_FilterTypeDef can_filter = {};
 
  can_filter.FilterIdHigh = 0;
  can_filter.FilterIdLow = 0;
  can_filter.FilterMode = CAN_FILTERMODE_IDMASK;
  can_filter.FilterScale = CAN_FILTERSCALE_32BIT;
  can_filter.FilterMaskIdHigh = 0;
  can_filter.FilterMaskIdLow = 0;
  can_filter.FilterFIFOAssignment = fifo_;
  can_filter.FilterActivation = ENABLE;
#ifdef CAN3
  if (id_ == STM32_CAN1)
  {
    can_filter.FilterBank = 0;
    can_filter.SlaveStartFilterBank = 14;
    fifo_ = CAN_RX_FIFO0;
  }
  else if (id_ == STM32_CAN2)
  {
    can_filter.FilterBank = 14;
    can_filter.SlaveStartFilterBank = 14;
    fifo_ = CAN_RX_FIFO0;
  }
  else if (id_ == STM32_CAN3)
  {
    can_filter.FilterBank = 3;
    fifo_ = CAN_RX_FIFO1;
  }
#else
#ifdef CAN2
  if (id_ == STM32_CAN1)
  {
    can_filter.FilterBank = 0;
    can_filter.SlaveStartFilterBank = 14;
    fifo_ = CAN_RX_FIFO0;
  }
  else if (id_ == STM32_CAN2)
  {
    can_filter.FilterBank = 14;
    can_filter.SlaveStartFilterBank = 14;
    fifo_ = CAN_RX_FIFO1;
  }
#else
  if (id_ == STM32_CAN1)
  {
    can_filter.FilterBank = 0;
    can_filter.SlaveStartFilterBank = 14;
    fifo_ = CAN_RX_FIFO0;
  }
#endif
#endif
  else
  {
    ASSERT(false);
    return ErrorCode::FAILED;
  }
  can_filter.FilterFIFOAssignment = fifo_;
 
  if (HAL_CAN_ConfigFilter(hcan_, &can_filter) != HAL_OK)
  {
    return ErrorCode::FAILED;
  }
 
  if (HAL_CAN_Start(hcan_) != HAL_OK)
  {
    return ErrorCode::FAILED;
  }
 
  if (fifo_ == CAN_RX_FIFO0)
  {
    HAL_CAN_ActivateNotification(hcan_, CAN_IT_RX_FIFO0_MSG_PENDING);
  }
  else
  {
    HAL_CAN_ActivateNotification(hcan_, CAN_IT_RX_FIFO1_MSG_PENDING);
  }
 
  HAL_CAN_ActivateNotification(hcan_, CAN_IT_ERROR);
  HAL_CAN_ActivateNotification(hcan_, CAN_IT_TX_MAILBOX_EMPTY);
 
  return ErrorCode::OK;
}

ProcessRxInterrupt()

void STM32CAN::ProcessRxInterrupt

(

)

处理接收中断

Definition at line 199 of file stm32_can.cpp.

{
  while (HAL_CAN_GetRxMessage(hcan_, fifo_, &rx_buff_.header, rx_buff_.pack.data) ==
         HAL_OK)
  {
    if (rx_buff_.header.IDE == CAN_ID_STD)
    {
      if (rx_buff_.header.StdId == 2046)
      {
        __NOP();
      }
      rx_buff_.pack.id = rx_buff_.header.StdId;
      rx_buff_.pack.type = Type::STANDARD;
    }
    else
    {
      rx_buff_.pack.id = rx_buff_.header.ExtId;
      rx_buff_.pack.type = Type::EXTENDED;
    }
 
    if (rx_buff_.header.RTR == CAN_RTR_REMOTE)
    {
      if (rx_buff_.pack.type == Type::STANDARD)
      {
        rx_buff_.pack.type = Type::REMOTE_STANDARD;
      }
      else
      {
        rx_buff_.pack.type = Type::REMOTE_EXTENDED;
      }
    }
    OnMessage(rx_buff_.pack, true);
  }
}

ProcessTxInterrupt()

void STM32CAN::ProcessTxInterrupt

(

)

处理发送中断

Definition at line 234 of file stm32_can.cpp.

{
  if (tx_pool_.Get(tx_buff_.pack) == ErrorCode::OK)
  {
    tx_buff_.header.DLC = sizeof(tx_buff_.pack.data);
    switch (tx_buff_.pack.type)
    {
      case Type::STANDARD:
        tx_buff_.header.IDE = CAN_ID_STD;
        tx_buff_.header.RTR = CAN_RTR_DATA;
        break;
      case Type::EXTENDED:
        tx_buff_.header.IDE = CAN_ID_EXT;
        tx_buff_.header.RTR = CAN_RTR_DATA;
        break;
      case Type::REMOTE_STANDARD:
        tx_buff_.header.IDE = CAN_ID_STD;
        tx_buff_.header.RTR = CAN_RTR_REMOTE;
        break;
      case Type::REMOTE_EXTENDED:
        tx_buff_.header.IDE = CAN_ID_EXT;
        tx_buff_.header.RTR = CAN_RTR_REMOTE;
        break;
      default:
        ASSERT(false);
        return;
    }
    tx_buff_.header.StdId = (tx_buff_.pack.type == Type::EXTENDED) ? 0 : tx_buff_.pack.id;
    tx_buff_.header.ExtId = (tx_buff_.pack.type == Type::EXTENDED) ? tx_buff_.pack.id : 0;
    tx_buff_.header.TransmitGlobalTime = DISABLE;
 
    HAL_CAN_AddTxMessage(hcan_, &tx_buff_.header, tx_buff_.pack.data, &txMailbox);
 
    bus_busy_.store(UINT32_MAX, std::memory_order_release);
  }
  else
  {
    uint32_t tsr = READ_REG(hcan_->Instance->TSR);
 
    if (((tsr & CAN_TSR_TME0) != 0U) && ((tsr & CAN_TSR_TME1) != 0U) &&
        ((tsr & CAN_TSR_TME2) != 0U))
    {
      bus_busy_.store(0, std::memory_order_release);
    }
    else
    {
      bus_busy_.store(UINT32_MAX, std::memory_order_release);
    }
  }
}

Field Documentation

bus_busy_

std::atomic<uint32_t> LibXR::STM32CAN::bus_busy_ = 0

Definition at line 92 of file stm32_can.hpp.

fifo_

uint32_t LibXR::STM32CAN::fifo_

Definition at line 73 of file stm32_can.hpp.

hcan_

CAN_HandleTypeDef* LibXR::STM32CAN::hcan_

Definition at line 70 of file stm32_can.hpp.

header [1/2]

CAN_RxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 78 of file stm32_can.hpp.

header [2/2]

CAN_TxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 84 of file stm32_can.hpp.

id_

stm32_can_id_t LibXR::STM32CAN::id_

Definition at line 72 of file stm32_can.hpp.

map

STM32CAN * STM32CAN::map = {nullptr}

static

Definition at line 74 of file stm32_can.hpp.

pack

ClassicPack LibXR::STM32CAN::pack

Definition at line 79 of file stm32_can.hpp.

tx_pool_

LockFreePool<ClassicPack> LibXR::STM32CAN::tx_pool_

Definition at line 90 of file stm32_can.hpp.

txMailbox

uint32_t LibXR::STM32CAN::txMailbox

Definition at line 88 of file stm32_can.hpp.

---

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

• driver/st/stm32_can.hpp
• driver/st/stm32_can.cpp