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, const char *tp_name, 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 (const char *name_tp="can", Topic::Domain *domain=nullptr)
	构造 CAN 对象，可指定主题名称和通信域 (Constructs a CAN object with an optional topic name and domain).
struct	__attribute__ ((packed))
	经典 CAN 消息结构 (Structure representing a classic CAN message).

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
Data Fields inherited from LibXR::CAN
	ClassicPack
Topic	classic_tp_
	经典 CAN 消息的主题 (Topic for classic CAN messages).

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 }
	CAN 消息类型 (Enumeration of CAN message types). More...

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, const char *  tp_name, uint32_t  queue_size  )

inline

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

Parameters

hcan	STM32CAN对象 CAN object
tp_name	话题名称 Topic name
queue_size	发送队列大小 Send queue size

Definition at line 48 of file stm32_can.hpp.

      : CAN(tp_name),
        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 148 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;
    }
    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)
    {
      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 63 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)
      {
        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;
        }
      }
 
      classic_tp_.PublishFromCallback(rx_buff_.pack, true);
    }
  }

ProcessTxInterrupt()

void LibXR::STM32CAN::ProcessTxInterrupt ( )

inline

处理发送中断

Definition at line 228 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;
      }
      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 270 of file stm32_can.hpp.

hcan_

CAN_HandleTypeDef* LibXR::STM32CAN::hcan_

Definition at line 266 of file stm32_can.hpp.

header [1/2]

CAN_RxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 275 of file stm32_can.hpp.

header [2/2]

CAN_TxHeaderTypeDef LibXR::STM32CAN::header

Definition at line 281 of file stm32_can.hpp.

id_

stm32_can_id_t LibXR::STM32CAN::id_

Definition at line 268 of file stm32_can.hpp.

map

STM32CAN * STM32CAN::map = {nullptr}

static

Definition at line 271 of file stm32_can.hpp.

pack

ClassicPack LibXR::STM32CAN::pack

Definition at line 276 of file stm32_can.hpp.

tx_queue_

LockFreeQueue<ClassicPack> LibXR::STM32CAN::tx_queue_

Definition at line 269 of file stm32_can.hpp.

txMailbox

uint32_t LibXR::STM32CAN::txMailbox

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