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 queue_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_
LockFreeQueue< ClassicPack >	tx_queue_
uint32_t	fifo_
struct {
CAN_RxHeaderTypeDef   header
ClassicPack   pack
}	rx_buff_
struct {
CAN_TxHeaderTypeDef   header
ClassicPack   pack
}	tx_buff_
uint32_t	txMailbox
Mutex	write_mutex_
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()

LibXR::STM32CAN::STM32CAN ( CAN_HandleTypeDef * hcan, uint32_t queue_size )

inline

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

Parameters

hcan	STM32CAN对象 CAN object
queue_size	发送队列大小 Send queue size

Definition at line 47 of file stm32_can.hpp.

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

Member Function Documentation

AddMessage()

ErrorCode LibXR::STM32CAN::AddMessage ( const ClassicPack & pack )

inlineoverridevirtual

添加 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 144 of file stm32_can.hpp.

  {
    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;
 
    if (HAL_CAN_AddTxMessage(hcan_, &txHeader, pack.data, &txMailbox) != HAL_OK)
    {
      Mutex::LockGuard lock(write_mutex_);
      if (tx_queue_.Push(pack) != ErrorCode::OK)
      {
        return ErrorCode::FULL;
      }
    }
 
    return ErrorCode::OK;
  }

Init()

ErrorCode LibXR::STM32CAN::Init ( void )

inline

初始化

Returns

ErrorCode

Definition at line 59 of file stm32_can.hpp.

  {
    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 LibXR::STM32CAN::ProcessRxInterrupt ( )

inline

处理接收中断

Definition at line 192 of file stm32_can.hpp.

  {
    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 LibXR::STM32CAN::ProcessTxInterrupt ( )

inline

处理发送中断

Definition at line 231 of file stm32_can.hpp.

  {
    if (tx_queue_.Peek(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;
 
      if (HAL_CAN_AddTxMessage(hcan_, &tx_buff_.header, tx_buff_.pack.data, &txMailbox) ==
          HAL_OK)
      {
        tx_queue_.Pop();
      }
    }
  }

Field Documentation

fifo_

uint32_t LibXR::STM32CAN::fifo_

Definition at line 276 of file stm32_can.hpp.

hcan_

CAN_HandleTypeDef* LibXR::STM32CAN::hcan_

Definition at line 272 of file stm32_can.hpp.

header [1/2]

CAN_RxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 281 of file stm32_can.hpp.

header [2/2]

CAN_TxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 287 of file stm32_can.hpp.

id_

stm32_can_id_t LibXR::STM32CAN::id_

Definition at line 274 of file stm32_can.hpp.

map

STM32CAN * STM32CAN::map = {nullptr}

static

Definition at line 277 of file stm32_can.hpp.

pack

ClassicPack LibXR::STM32CAN::pack

Definition at line 282 of file stm32_can.hpp.

tx_queue_

LockFreeQueue<ClassicPack> LibXR::STM32CAN::tx_queue_

Definition at line 275 of file stm32_can.hpp.

txMailbox

uint32_t LibXR::STM32CAN::txMailbox

Definition at line 291 of file stm32_can.hpp.

write_mutex_

Mutex LibXR::STM32CAN::write_mutex_

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