【经验分享】STM32H7的FDCAN总线基础知识和HAL库API

[复制链接]

STMCU小助手发布时间：2021-11-6 23:50

文章
文章封面:
文章简介:	本章节为大家讲解FDCAN的基础知识和对应的HAL库API。CAN FD中的FD含义就是flexible data，灵活数据通信，且波特率可以和仲裁阶段波特率不同

91.1 初学者重要提示
FDCAN基础知识点可以看第90章，已经进行了详细说明
特别推荐瑞萨的CAN入门中英文手册，做的非常好：地址链接
91.2 FDCAN基础知识
FDCAN的基础知识在本教程的第90章进行了非常详细的说明。我们这里将本章用到的几个知识点再做个说明，详情推荐看第90章。

91.2.1 CAN FD协议介绍
STM32H7的CAN FD符合ISO 11898-12015标准。STM32器件上的FDCAN的功能如下所示：

（1）符合CAN协议2.0版A，B和ISO 11898-1：2015，-4。

（2）可访问的10 KB RAM内存，最多可分配2560个字。

（3）改进了接收过滤。

（4）两个可配置的接收FIFO。

（5）多达64个专用接收缓冲区。

（6）接收高优先级消息时的单独信令。

（7）多达32个专用发送缓冲区。

（8）可配置的发送FIFO和发送队列。

（9）可配置的发送事件FIFO。

（10）时钟校准单元。

（11）收发器延迟补偿。

下图说明了FDCAN框图。

通过这个框图要了解到以下信息：

（1）CANFD1和CANFD2共用一个RAM空间。

（2）每个CANFD都有自己的内核。

（3）CAN内核实现协议控制和收发移位寄存器。

（4）Tx handler控制消息从CAN消息RAM到CAN内核。

（5）Rx handler控制CAN内核到CAN消息RAM。

91.2.2 CAN FD特性
（1）兼容经典CAN，可以遵循ISO 11898-1做数据收发。

（2）提升错误检测，支持高达CRC 21位的校验和。

（3）消息优先级。

（4）保证延迟时间。

（5）配置灵活性。

（6）具有时间同步的组播接收。

（7）系统范围内的数据一致性，每条消息最多64个字节。

（8）多主机。

（9）错误检测和信号。

（10）区分节点的临时错误和永久性故障以及自动关闭缺陷节点。

91.2.3 CAN FD格式

第一个仲裁阶段（The first arbitration phase）是一条消息，其中包含：

（1）帧开始（SOF）。

（2）ID号和其他位，指示消息的目的（提供或请求数据），以及速度和格式配置（CAN或CAN-FD）。

数据传输阶段（The data transmission phase）包括：

（1）数据长度代码（DLC），指示消息包含多少数据字节。

（2）用户希望发送的数据。

（3）检查循环冗余序列（CRC）。

（4）显性位。

第二个仲裁阶段（The second arbitration phase）包含：

（1）总线上其他节点发送的确认（ACK）的接收器（如果至少有一个接收器成功收到消息）

（2）帧尾（EOF），在IFS期间不传输任何消息：目标是将当前帧与下一帧分开。

注意：对于29bit标识符帧，当添加18bit标识到第1个仲裁阶段的IDE bit之后与标准CAN FD是类似的。

91.2.4 CAN FD相比CAN2.0的提升
CAN-FD的开发可以满足需要更高带宽的通信网络需求。每帧最多具有64个字节的CAN-FD以及将比特率提高到最大的可能性，使数据阶段要快8倍，在第二个仲裁阶段要恢复到正常的比特率。通过以下方式确保数据传输的完整性：

（1）17级多项式对最大16字节的有效载荷进行CRC。

（2）21级多项式对16到64字节之间的有效载荷进行校验。

标准帧和CAN FD的区别：

标识符后，CAN 2.0和CAN-FD具有不同的作用：

（1）CAN 2.0发送RTR位以精确确定帧类型：数据帧（RTR为主要）或远程帧（RTR）是隐性的）。

（2）由于CAN-FD仅支持数据帧，因此始终发送占优势的RRS（保留）。

IDE位保持在相同位置，并以相同的动作来区分基本格式（11位标识符）。请注意，在扩展格式的情况下，IDE位以显性或隐性方式传输（29位标识符）。

与CAN 2.0相比，在CAN-FD帧中，在控制字段中添加了三个新位：

（1）扩展数据长度（EDL）位：隐性表示帧为CAN-FD，否则该位为显性（称为R0）在CAN 2.0帧中。

（2）比特率切换（BRS）：指示是否启用两个比特率（例如，当数据阶段位以不同的比特率传输到仲裁阶段）。

（3）错误状态指示器（ESI）：指示节点处于错误活动模式还是错误被动模式。

控制字段的最后一部分是数据长度代码（DLC），它具有相同的位置和相同的长度（4位），用于CAN 2.0和CAN-FD。 DLC功能在CAN-FD和CAN 2.0中相同，但CAN-FD有很小变化（下表中的详细信息）。 CAN-FD扩展帧允许单个消息中发送64个数据字节，而CAN 2.0有效负载数据最多可以发送8个字节。

通过增加有效载荷数据的数据字段来改善网络带宽，因为需要更少的包处理。同时，通过为CRC添加更多位来增强消息完整性：

（1）如果有效载荷数据最多为16个字节，则CRC以17位编码。

（2）如果有效载荷数据大于20（16）个字节，则CRC以21位编码。

另外，为了确保CAN-FD帧的鲁棒性，填充位机制支持CRC字段。下表总结了CAN-FD和CAN 2.0之间的主要区别。提供的主要功能与CAN 2.0相比，CAN FD的改进之处在于数据有效负载的增加和速度的提高由CAN-FD中可用的BRS，EDL和ESI位来确保。

91.3 FDCAN总线的HAL库用法
91.3.1 FDCAN总线结构体FDCAN_GlobalTypeDef
FD CAN总线相关的寄存器是通过HAL库中的结构体FDCAN_GlobalTypeDef定义，在stm32h743xx.h中可以找到这个类型定义：

typedef struct
* H& k- v: f$ C8 }( N6 e3 O9 B. i
{1 w, f, A" x9 f
__IO uint32_t CREL;
9 `0 C1 T6 E E
__IO uint32_t ENDN;
) N: |# g& R# Q; V
__IO uint32_t RESERVED1; 4 O) G4 u0 ?4 m3 r$ {# o
__IO uint32_t DBTP; $ k( _( o! J: O) P/ A: o
__IO uint32_t TEST;
4 N6 X( f0 S1 q" M/ Q3 a# C
__IO uint32_t RWD; $ n/ }/ I! ?9 f
__IO uint32_t CCCR;
$ b4 x3 |+ o, e& N3 W6 e( m/ ]
__IO uint32_t NBTP; ( M+ B/ c% B. r3 g3 u
__IO uint32_t TSCC; + a, U$ n* U8 N( \
__IO uint32_t TSCV;
0 q$ u7 |' D/ y1 b7 J6 o3 q8 X
__IO uint32_t TOCC;
+ ]$ r) ?! R* @" o1 k
__IO uint32_t TOCV;
# ~6 R [% g: J$ |
__IO uint32_t RESERVED2[4];
* A v0 g2 U4 L1 v- t ~8 h
__IO uint32_t ECR; 7 Y/ n' M1 N* y# e' b9 K. W; S
__IO uint32_t PSR;
8 y# @- T" ^; T' v4 M4 j5 M
__IO uint32_t TDCR;
* A" P6 f) r( M/ h+ {; d5 b
__IO uint32_t RESERVED3;
2 P9 T$ n: \3 k& {, {0 R
__IO uint32_t IR;
' `8 f. O8 m" @2 i7 V1 F
__IO uint32_t IE; i& b( H& u# D+ v i) D( m4 x
__IO uint32_t ILS;
# k9 U( b5 O) v9 z
__IO uint32_t ILE;
1 Q, A6 _6 _ a) @: G- S
__IO uint32_t RESERVED4[8];
8 Y! M& {' c& f, p; c$ g5 B
__IO uint32_t GFC;
3 s6 i) X3 I. [0 |! h
__IO uint32_t SIDFC; - ]# @+ L6 n3 h+ U! l, e5 X
__IO uint32_t XIDFC; - }7 A! d" Q9 o2 Q( _( |0 B
__IO uint32_t RESERVED5; * {% X( O& u( b- X3 m& P" V
__IO uint32_t XIDAM; ' u6 x$ d8 E1 ^# |
__IO uint32_t HPMS;
- v9 S7 n3 s' i$ [$ Y9 o
__IO uint32_t NDAT1;
/ i, d2 n/ S* }# \7 j5 J U% B
__IO uint32_t NDAT2; , F4 k. P. f5 z& M* J
__IO uint32_t RXF0C;
$ h8 B- ^% y1 B- s! G8 M, I. W
__IO uint32_t RXF0S;
% f" r! }3 A8 {4 k9 h
__IO uint32_t RXF0A;
0 }" j; S. y* B
__IO uint32_t RXBC;
+ n9 Q2 V! l$ h! ` G
__IO uint32_t RXF1C; 0 V* S* K! e5 N/ K
__IO uint32_t RXF1S;
2 e1 c& v8 u. V
__IO uint32_t RXF1A; ; Q9 J0 N& B. G* H
__IO uint32_t RXESC;
T9 {( F" y) K" v
__IO uint32_t TXBC;
4 Z: r! d, j6 @. B8 d
__IO uint32_t TXFQS;
Y- A2 ?& Q8 k0 L
__IO uint32_t TXESC;
/ y! e9 [4 [- R; F5 A$ Z
__IO uint32_t TXBRP; & Z3 X) U- o4 ~. U9 K
__IO uint32_t TXBAR; : p0 c, A+ i/ B1 p3 `4 n
__IO uint32_t TXBCR;
4 G5 S& [# Z+ T+ u' y: M
__IO uint32_t TXBTO;
9 b) M2 a$ I3 `0 D Q9 J/ k
__IO uint32_t TXBCF;
! J6 S9 C/ D0 N" d- S3 Y
__IO uint32_t TXBTIE;
9 I* y) U0 P: v( p$ ]4 g9 g Z
__IO uint32_t TXBCIE; + Y: F! x3 |5 X2 ^
__IO uint32_t RESERVED6[2];
6 w& B V1 D" K( p6 `
__IO uint32_t TXEFC; ) l* r, S4 a% Y( L7 [3 P, W! o
__IO uint32_t TXEFS;
7 N8 H, _) W: v/ }+ d( _
__IO uint32_t TXEFA;
/ z" E& g" Y- O- n; q* Y( U
__IO uint32_t RESERVED7; / p2 Y$ |/ p/ M- W
} FDCAN_GlobalTypeDef;

复制代码

这个结构体的成员名称和排列次序和CPU的寄存器是一一对应的。

__IO表示volatile, 这是标准C语言中的一个修饰字，表示这个变量是非易失性的，编译器不要将其优化掉。core_m7.h 文件定义了这个宏：

#define __O volatile /*!< Defines 'write only' permissions */
! v6 r# }$ E4 b& _5 g( u( i% c( x
#define __IO volatile /*!< Defines 'read / write' permissions */

复制代码

下面我们看下FDCAN的定义，在stm32h743xx.h文件。

#define PERIPH_BASE (0x40000000UL)
/ j- B4 H/ [9 C% `( |! |
#define D2_APB1PERIPH_BASE PERIPH_BASE% r8 f2 b U1 S4 f) e
5 r& L8 r$ A" R. y) q
#define FDCAN1_BASE (D2_APB1PERIPH_BASE + 0xA000UL)
b8 M j8 N5 }/ `# P3 u; \. c
#define FDCAN2_BASE (D2_APB1PERIPH_BASE + 0xA400UL)" w: M3 o$ E7 u, Q
#define FDCAN_CCU_BASE (D2_APB1PERIPH_BASE + 0xA800UL)
% q9 b; r+ I6 U/ _
8 E! u$ L8 ?/ @% ~
#define FDCAN1 ((FDCAN_GlobalTypeDef *) FDCAN1_BASE) <----- 展开这个宏，(FDCAN_GlobalTypeDef *)0x4000A000. N( _" o4 B0 }2 B% {% H0 B' U
#define FDCAN2 ((FDCAN_GlobalTypeDef *) FDCAN2_BASE)
& X0 P+ {( {7 W: e q6 P; E. q
#define FDCAN_CCU ((FDCAN_ClockCalibrationUnit_TypeDef *) FDCAN_CCU_BASE)

复制代码

我们访问FDCAN1的CCCR寄存器可以采用这种形式：FDCAN1->CCCR = 0。

91.3.2 FDCAN总线时间触发结构体TTCAN_TypeDef
FDCAN总线时间触发相关的寄存器是通过HAL库中的结构体TTCAN_TypeDef定义，在stm32h743xx.h中可以找到这个类型定义：

typedef struct
( p0 u7 s$ b( b7 L' ?
{
" d6 M% ~- J6 i; y
__IO uint32_t TTTMC; /*!< TT Trigger Memory Configuration register, Address offset: 0x100 */
2 w3 y, j. A. \ M& D
__IO uint32_t TTRMC; /*!< TT Reference Message Configuration register, Address offset: 0x104 */* t& J3 l' n. i7 @
__IO uint32_t TTOCF; /*!< TT Operation Configuration register, Address offset: 0x108 */
1 L' y/ ~& J4 b, x& K4 a- P3 t+ J
__IO uint32_t TTMLM; /*!< TT Matrix Limits register, Address offset: 0x10C */
1 k9 @+ S% `: A9 {
__IO uint32_t TURCF; /*!< TUR Configuration register, Address offset: 0x110 */. D1 j; o: Z9 k" U) J. `0 t* e
__IO uint32_t TTOCN; /*!< TT Operation Control register, Address offset: 0x114 */2 u9 Z0 a7 V! L$ T
__IO uint32_t TTGTP; /*!< TT Global Time Preset register, Address offset: 0x118 */$ I2 g9 N' q3 X
__IO uint32_t TTTMK; /*!< TT Time Mark register, Address offset: 0x11C */
* k: C N0 }2 G i
__IO uint32_t TTIR; /*!< TT Interrupt register, Address offset: 0x120 */4 [6 I/ n* ^8 y& g5 V; ^" f4 b! m; g
__IO uint32_t TTIE; /*!< TT Interrupt Enable register, Address offset: 0x124 */
1 O: F: h4 Z/ o& L9 Q7 B, A
__IO uint32_t TTILS; /*!< TT Interrupt Line Select register, Address offset: 0x128 */
# n) ?, `: ]; z% ~
__IO uint32_t TTOST; /*!< TT Operation Status register, Address offset: 0x12C */
) u" k% a: E! y0 `
__IO uint32_t TURNA; /*!< TT TUR Numerator Actual register, Address offset: 0x130 */
$ p: q3 O- h+ T0 t+ a L+ v2 e" S
__IO uint32_t TTLGT; /*!< TT Local and Global Time register, Address offset: 0x134 */
* n8 K" p: K R5 h
__IO uint32_t TTCTC; /*!< TT Cycle Time and Count register, Address offset: 0x138 */* d1 `2 s* i! A' y: t1 ]( ~/ g
__IO uint32_t TTCPT; /*!< TT Capture Time register, Address offset: 0x13C */ J* e( F% Z& l; F
__IO uint32_t TTCSM; /*!< TT Cycle Sync Mark register, Address offset: 0x140 *// i. Z- A9 A* N2 @
__IO uint32_t RESERVED1[111]; /*!< Reserved, 0x144 - 0x2FC */
/ i: ~ ~8 {2 G: H9 J4 Q4 L& ]
__IO uint32_t TTTS; /*!< TT Trigger Select register, Address offset: 0x300 */' s. u s& W9 @, }
} TTCAN_TypeDef;

复制代码

91.3.3 FDCAN总线初始化结构体FDCAN_InitTypeDef
下面是FDCAN总线的初始化结构体：

typedef struct
$ {! Y @6 X' F% a) {
{
1 {4 H5 B3 M# ] b% ^& F" t
uint32_t FrameFormat; /*!< Specifies the FDCAN frame format.
9 S2 l2 S1 \/ T: T
This parameter can be a value of @ref FDCAN_frame_format */; G: h/ k" r5 A
% \: R6 ^6 {) y) S j5 j* x- X
uint32_t Mode; /*!< Specifies the FDCAN mode.) Q7 v, S7 S. N# d$ {
This parameter can be a value of @ref FDCAN_operating_mode */' k* U2 g6 i* @6 c1 [
2 r; V+ |) r' e% }
FunctionalState AutoRetransmission; /*!< Enable or disable the automatic retransmission mode." g4 h* Z$ `4 l; M. C- d
This parameter can be set to ENABLE or DISABLE */
Y4 b( t f$ w* h2 O
9 M. Z9 O o4 e: M
FunctionalState TransmitPause; /*!< Enable or disable the Transmit Pause feature.2 V I A6 A* s2 O, g- b
This parameter can be set to ENABLE or DISABLE */5 }: Z9 w5 [/ v) S6 x/ V
4 Y5 u0 S. P- b
FunctionalState ProtocolException; /*!< Enable or disable the Protocol Exception Handling.$ C& b2 s, O: [
This parameter can be set to ENABLE or DISABLE */
4 T9 M& c: P" b0 p
! [/ _" G7 n# h" v1 N+ `9 o! o
uint32_t NominalPrescaler; /*!< Specifies the value by which the oscillator frequency is* o$ h: A1 b3 V( r$ h5 s
divided for generating the nominal bit time quanta.
; x- e- b8 z3 u4 P; K0 z7 I! i) p
This parameter must be a number between 1 and 512 */
9 t( V% k! [1 w
' G4 a% ~6 T3 F% E3 k; j8 g4 A2 T- {
uint32_t NominalSyncJumpWidth; /*!< Specifies the maximum number of time quanta the FDCAN6 T5 x# k2 X& G1 c# _# D
hardware is allowed to lengthen or shorten a bit to perform. ~% U3 x( D( k% t9 d% m, q; U" k3 n
resynchronization.
6 R8 Y' q) B* h( `: A
This parameter must be a number between 1 and 128 */$ y. ^+ X, f2 S( _9 M6 ?2 D
2 H; z3 }8 w3 z. A0 J3 H: l, q
uint32_t NominalTimeSeg1; /*!< Specifies the number of time quanta in Bit Segment 1.
5 ~5 z$ C8 z6 e# r1 y
This parameter must be a number between 2 and 256 */. I- b: Y% z x" T y' B8 Q5 T, t
- n$ }7 x. S4 P ^8 Z, m
uint32_t NominalTimeSeg2; /*!< Specifies the number of time quanta in Bit Segment 2.
6 S5 H& t7 F( i( t) u4 `
This parameter must be a number between 2 and 128 */& r; ]+ K: `6 N4 j
+ Z S. k3 H V5 T1 Y
uint32_t DataPrescaler; /*!< Specifies the value by which the oscillator frequency is- G( N' H E+ ^3 e/ f8 ?
divided for generating the data bit time quanta.* k. T4 f- z$ C6 H3 U* c4 v' \
This parameter must be a number between 1 and 32 */1 ~& S+ |" A+ O
& c" T. |0 ^& [
uint32_t DataSyncJumpWidth; /*!< Specifies the maximum number of time quanta the FDCAN! ?& y! A0 I; K1 N
hardware is allowed to lengthen or shorten a data bit to
6 L2 h2 a( o; M8 |& r4 S3 P
perform resynchronization.
2 L) D2 ]6 T9 B/ i7 R: @. Q
This parameter must be a number between 1 and 16 */5 l& v q+ i; c- F) i1 P3 `1 J) ^: ]
. p. U/ H* X7 \3 w1 c
uint32_t DataTimeSeg1; /*!< Specifies the number of time quanta in Data Bit Segment 1.: ?$ q$ Q* W |! n5 ^" V2 a% |
This parameter must be a number between 1 and 32 */
, H) G5 R* d/ ~3 q8 J
) ~$ P, F0 t, A% H; q- O; J5 U# N
uint32_t DataTimeSeg2; /*!< Specifies the number of time quanta in Data Bit Segment 2.. z [+ R9 p2 X7 I$ A0 W8 R- p$ j$ E
This parameter must be a number between 1 and 16 */; |$ {) S$ d' E1 G7 k$ l0 Y
/ d& `$ [4 }. ~& q* Y4 j; t2 C
uint32_t MessageRAMOffset; /*!< Specifies the message RAM start address.6 `( C* o7 F2 B( x7 P4 G" H: }
This parameter must be a number between 0 and 2560 */! v: P; j" O. H# ~+ y+ Q" Z
! ]/ a% L0 a5 X/ ?7 D2 R' y
uint32_t StdFiltersNbr; /*!< Specifies the number of standard Message ID filters.- S5 |5 n' x( V; P0 @1 a1 N
This parameter must be a number between 0 and 128 */' a1 c q2 w' e( J% ?, F( R( ?
+ ]2 k- u6 L! F+ ^5 x$ D5 {
uint32_t ExtFiltersNbr; /*!< Specifies the number of extended Message ID filters.
9 B U, M7 Z, m
This parameter must be a number between 0 and 64 */
4 z$ O5 k0 d* i
" |5 a( I6 v1 p- C7 ?& h O
uint32_t RxFifo0ElmtsNbr; /*!< Specifies the number of Rx FIFO0 Elements./ C% d5 B, p9 L" x1 {: J: @" p
This parameter must be a number between 0 and 64 */
3 a! k( m! t! X/ G0 r, o
7 F- m( Z& @8 X
uint32_t RxFifo0ElmtSize; /*!< Specifies the Data Field Size in an Rx FIFO 0 element.
# Y8 V- z6 b5 L
This parameter can be a value of @ref FDCAN_data_field_size */) E5 V4 D7 \' t5 K5 I9 M
, v+ X' T1 t' I
uint32_t RxFifo1ElmtsNbr; /*!< Specifies the number of Rx FIFO 1 Elements.
. h+ U& o/ N2 j, W
This parameter must be a number between 0 and 64 */. L6 f% O a: X3 x- L6 Z; w+ B
. u9 F% v# N3 F) \
uint32_t RxFifo1ElmtSize; /*!< Specifies the Data Field Size in an Rx FIFO 1 element.
( l: U/ H6 c, n! z9 Z
This parameter can be a value of @ref FDCAN_data_field_size */
9 [! o1 m* N8 O( {7 r% ~
9 x' ^* Z$ A5 s4 a! L
uint32_t RxBuffersNbr; /*!< Specifies the number of Dedicated Rx Buffer elements.3 c c1 u, s; G+ E9 T K
This parameter must be a number between 0 and 64 */: X4 e% B" t7 m9 S' O
8 y" d# M( K( p' p' u
uint32_t RxBufferSize; /*!< Specifies the Data Field Size in an Rx Buffer element.
2 [, K( _/ L6 C/ ~7 L# S' X
This parameter can be a value of @ref FDCAN_data_field_size */( Y# o( `7 R( L2 ]+ I& W) I k6 d
# E' ^4 @" b) P- z+ r
uint32_t TxEventsNbr; /*!< Specifies the number of Tx Event FIFO elements.! D5 R T) Q! A% ?) \
This parameter must be a number between 0 and 32 */
$ c) F' @/ e7 E. j9 Y' c
2 g- n' G( [! F) F. f
uint32_t TxBuffersNbr; /*!< Specifies the number of Dedicated Tx Buffers.
% V1 C l1 s) z( A1 h" F8 B; [5 A
This parameter must be a number between 0 and 32 */
0 A" t! d) C) |8 F7 a6 v9 p6 w& A
+ @4 C; J8 t5 z$ |
uint32_t TxFifoQueueElmtsNbr; /*!< Specifies the number of Tx Buffers used for Tx FIFO/Queue.
I4 k7 W. j( X6 @% W% d
This parameter must be a number between 0 and 32 */
' {, t2 W8 z- w: N- O1 p( N, u9 p
uint32_t TxFifoQueueMode; /*!< Tx FIFO/Queue Mode selection.1 B: a7 Y# c2 _' k* D0 _0 |
This parameter can be a value of @ref FDCAN_txFifoQueue_Mode */
- S4 F5 [2 c9 X: t* z( L
/ p7 B) [) Q/ M
uint32_t TxElmtSize; /*!< Specifies the Data Field Size in a Tx Element.
( c# K( ]/ c2 ]
This parameter can be a value of @ref FDCAN_data_field_size */
T+ n2 g9 u3 L$ M- y
9 a1 ^" ]) g7 B7 f
} FDCAN_InitTypeDef;

复制代码

下面将结构体成员逐一做个说明：

FrameFormat
用于设置CAN帧格式。

#define FDCAN_FRAME_CLASSIC ((uint32_t)0x00000000U) /* 经典CAN模式 */9 M3 b3 _. {! u
#define FDCAN_FRAME_FD_NO_BRS ((uint32_t)FDCAN_CCCR_FDOE) /* FD CAN不带可变波特率 */
2 e' f6 r3 R7 O: k# J5 n
#define FDCAN_FRAME_FD_BRS ((uint32_t)(FDCAN_CCCR_FDOE | FDCAN_CCCR_BRSE)) /* FD CAN带可变波特率 */

复制代码

Mode
用于设置CAN操作模式。

#define FDCAN_MODE_NORMAL ((uint32_t)0x00000000U) /*!< 正常模式 */
2 ^, w( C M3 j: e5 q2 \
#define FDCAN_MODE_RESTRICTED_OPERATION ((uint32_t)0x00000001U) /*!< 有限制的操作模式 */' e) ] q8 ]. O; x' a6 s. f
#define FDCAN_MODE_BUS_MONITORING ((uint32_t)0x00000002U) /*!< 总线监测模式 */
8 }0 }0 }, p @7 o
#define FDCAN_MODE_INTERNAL_LOOPBACK ((uint32_t)0x00000003U) /*!< 内部环回模式 */
% n# h. `5 ]/ @& E$ q
#define FDCAN_MODE_EXTERNAL_LOOPBACK ((uint32_t)0x00000004U) /*!< 外部环回模式 */

复制代码

  AutoRetransmission
使能自动重传模式。

使能ENABLE或者禁止DISABLE。

  TransmitPause
使能或者禁止传输暂停特性。ENABLE使能或者DISABLE禁止。

  ProtocolException
使能或者禁止协议异常管理。ENABLE表示使能，DISABLE表示禁止。

  NominalPrescaler
用于CAN FD仲裁阶段分频设置，产生标称位时间量，参数范围1-512。

  NominalSyncJumpWidth
设置FD CAN仲裁阶段最大支持的时间量来加长或者缩短一个bit来实现再同步，参数范围1-128。

  NominalTimeSeg1
设置仲裁阶段Bit Segment 1的时间量，范围2 – 256。

  NominalTimeSeg2
设置仲裁阶段Bit Segment 2的时间量，范围2 – 128。

  DataPrescaler
用于CAN FD数据阶段分频设置，范围1-32。

  DataSyncJumpWidth
设置FD CAN数据阶段最大支持的时间量来加长或者缩短一个bit来实现数据再同步，参数范围1-16。

  DataTimeSeg1
设置数据阶段Data Bit Segment 1的时间量，范围1 – 32。

  DataTimeSeg2
设置数据阶段Data Bit Segment 2的时间量，范围1 – 16。

  MessageRAMOffset
设置消息RAM起始地址，范围0到2560。

  StdFiltersNbr
标准ID过滤个数，范围0到128。

  ExtFiltersNbr
扩展ID过滤个数，范围0到64。

  RxFifo0ElmtsNbr
RX FIFO0元素个数，范围0到64。

  RxFifo0ElmtSize
RX FIFO0每个元素中数据大小，支持参数如下：

#define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */
[& K( U) A3 [5 c* R% N6 P- A
#define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */3 H; {# _7 x/ Q: M. B4 N
#define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */* S( {" V5 d" N4 p* S1 k
#define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */
3 {. i& i/ Z; y$ K$ Y: f9 L8 ^* x+ e( H
#define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */' H& X9 q3 Z, l
#define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */
, `, j, j3 s6 V9 I* `% j v6 _
#define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
I6 I! d1 L& r8 I3 N: E8 ?. {# X
#define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */

复制代码

RxFifo1ElmtsNbr
RX FIFO1个数，范围0到64。

RxFifo1ElmtSize
RX FIFO1每个元素中数据大小，支持参数如下：

#define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */
, X3 N9 @6 r2 C7 i8 D4 f
#define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */
9 q6 y+ p! N- g$ I
#define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */& g* V I. P, e
#define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */
. r8 a; u1 c7 r+ u
#define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */( n) Z ^" V0 {: D* m, I
#define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */
" u- |: G# _* \/ Z
#define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
) S5 L9 l: Y4 w2 @: |( y
#define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */

复制代码

RxBuffersNbr
设置Rx Buffer元素个数，范围0 - 64：

RxBuffersSize
设置Rx Buffer元素中每个数据大小，范围0 - 64：

#define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */3 P1 [. z; s% e/ V0 T) z, B0 }6 Z
#define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */. a/ [. f1 P L# j8 {8 {
#define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */
: O9 A* j; @* G
#define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */
: [$ x2 A. Z( W' T2 c0 f
#define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */
2 j3 h6 {" v+ c$ d& e
#define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */8 {' Q# t1 E6 p- N
#define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
0 ]$ |% J( ~/ l# O' d6 F
#define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */

复制代码

  TxEventsNbr
Tx Event FIFO元素个数，范围0到32。

  TxBuffersNbr
设置专用的Tx Buffer元素个数，范围0到32。

  TxFifoQueueElmtsNbr
设置用于Tx FIFO/Queue的Tx Buffers个数。范围0到32。

  TxFifoQueueMode
设置FIFO模式或者QUEUE队列模式。

#define FDCAN_TX_FIFO_OPERATION ((uint32_t)0x00000000U) /*!< FIFO mode */
9 ]3 S3 b6 K8 z0 L
#define FDCAN_TX_QUEUE_OPERATION ((uint32_t)FDCAN_TXBC_TFQM) /*!< Queue mode */

复制代码

TxElmtSize
设置Tx Element中的数据域大小。支持参数如下：

#define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */5 o* J/ `- L. D+ r9 {
#define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */
/ g) j" L& j8 f+ B% k
#define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */, z- s/ b8 }& s- [3 R- v; c; F1 P
#define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */$ z+ N" W3 `2 s
#define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */8 h$ D2 }! |1 r/ A7 D& g4 j
#define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */
9 _( F% v2 X+ Q' g A
#define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
8 o* ~, @, v) }
#define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */

复制代码

91.3.4 FDCAN总线消息RAM地址FDCAN_MsgRamAddressTypeDef
下面是消息RAM结构体：

2 h8 V$ }4 P( I9 {" E
typedef struct3 C" H1 L& R$ I1 V2 E
{
& x" C8 d1 |& t, ~1 }
uint32_t StandardFilterSA; /*!< Specifies the Standard Filter List Start Address.
7 f7 C3 [8 R8 a* x- n0 V% O
This parameter must be a 32-bit word address */
2 \0 o7 U% Y& B: j
0 Q% Y6 _1 y8 m+ E' T
uint32_t ExtendedFilterSA; /*!< Specifies the Extended Filter List Start Address.; n- X; j0 G0 J9 T* h J
This parameter must be a 32-bit word address */
: Z+ c+ R) Q* B" Y4 N5 R6 ~
9 y/ E2 z) D5 W% V5 @
uint32_t RxFIFO0SA; /*!< Specifies the Rx FIFO 0 Start Address.
) }% i# I) t/ V! j s% O9 A7 ?; ~" r
This parameter must be a 32-bit word address */6 O' b0 \! J' d( F% d" }" V2 l
3 N( J( e3 I& l/ Z
uint32_t RxFIFO1SA; /*!< Specifies the Rx FIFO 1 Start Address.5 r6 }- K1 v/ ~7 c2 v; ?7 B
This parameter must be a 32-bit word address */
6 X% j5 r `* ]. [
/ _3 v* Z& D3 J/ v3 Q; p
uint32_t RxBufferSA; /*!< Specifies the Rx Buffer Start Address.9 {0 `% @4 s/ I# G
This parameter must be a 32-bit word address */: ~! ]( t" X1 E* W2 B
: q: J& K k' q: X$ L' ^6 z3 l# G
uint32_t TxEventFIFOSA; /*!< Specifies the Tx Event FIFO Start Address.
4 w- y s7 u3 s' D3 m
This parameter must be a 32-bit word address */
/ @; l) U( v. b( `3 k4 W
, ^6 H- G' z; A7 y1 `# m. K
uint32_t TxBufferSA; /*!< Specifies the Tx Buffers Start Address.2 h3 Z2 j T. }
This parameter must be a 32-bit word address */0 Y( P7 j1 G1 a0 h, ]" F. r
. S `4 [9 n" \9 E* s
uint32_t TxFIFOQSA; /*!< Specifies the Tx FIFO/Queue Start Address.
N% u' S2 ^ Y* k9 K
This parameter must be a 32-bit word address */
2 K8 f0 n5 K9 ] i
) K* U7 \2 `0 w0 U$ j+ m
uint32_t TTMemorySA; /*!< Specifies the Trigger Memory Start Address.
$ a9 m2 e# C. t2 @7 @, K. ?! m
This parameter must be a 32-bit word address */. y1 z# I! ~' R0 ^3 n
$ K+ ^9 K# z2 T0 E
uint32_t EndAddress; /*!< Specifies the End Address of the allocated RAM.
9 r2 p5 x) a! J% b* y
This parameter must be a 32-bit word address */
3 N8 n `8 P! C7 n$ k7 }1 E
5 P0 G' P8 g1 z" x; \
} FDCAN_MsgRamAddressTypeDef;

复制代码

下面将结构体成员逐一做个说明：

  StandardFilterSA
设置标准过滤器起始地址，必须是32bit地址。

  ExtendedFilterSA
设置扩展过滤器起始地址，必须是32bit地址。

  RxFIFO0SA
设置RX FIFO 0起始地址，必须是32bit地址。

  RxFIFO1SA
设置RX FIFO 1起始地址，必须是32bit地址。

  RxBufferSA
设置RX Buffer起始地址，必须是32bit地址。

  TxEventFIFOSA
设置Tx Event FIFO起始地址，必须是32bit地址。

  TTMemorySA
设置触发内存起始地址，必须是32bit地址。

  EndAddress
设置申请RAM空间的结束地址，必须是32bit地址。

91.3.5 FDCAN总线过滤结构体FDCAN_FilterTypeDef
下面是过滤结构体：

typedef struct3 [: T! Z. H# l* P3 w) A6 Q
{0 w. C3 ]) d+ E/ _4 [2 B2 G3 w- A
uint32_t IdType; /*!< Specifies the identifier type.$ x) o8 O3 ?8 A; n5 }, b
This parameter can be a value of @ref FDCAN_id_type */8 s, ]1 a. F: j/ ]) k
. r; q4 m; v8 z( [
uint32_t FilterIndex; /*!< Specifies the filter which will be initialized.
: j/ C ~* R) m. N; ~
This parameter must be a number between:
7 L9 U; n9 s, \ @: y' }
- 0 and 127, if IdType is FDCAN_STANDARD_ID
2 D! x1 ]" i; L, ^, J
- 0 and 63, if IdType is FDCAN_EXTENDED_ID */
6 J5 \' a! d9 [2 {* W/ i. R
; c- x9 p- T7 b+ ^) a0 j/ \
uint32_t FilterType; /*!< Specifies the filter type.: ~+ Z$ W% e2 n) J3 C
This parameter can be a value of @ref FDCAN_filter_type.0 |+ n, \$ G5 i1 Y8 z. V: ~. g
The value FDCAN_EXT_FILTER_RANGE_NO_EIDM is permitted
! t, X! n y2 u- G9 F. i
only when IdType is FDCAN_EXTENDED_ID.
% X5 E6 X% c8 o6 w9 j E
This parameter is ignored if FilterConfig is set to; Y9 G% P9 M( i' X, K2 D& B1 W
FDCAN_FILTER_TO_RXBUFFER */
4 R0 H$ ^ s' B6 ^4 f
1 J0 q) v. a I: i% i
uint32_t FilterConfig; /*!< Specifies the filter configuration.
6 B' P; N% N9 {' O" g6 f
This parameter can be a value of @ref FDCAN_filter_config */$ B2 q r. _3 f+ c! N8 ?
) B* {- T5 p$ c4 w. G; l
uint32_t FilterID1; /*!< Specifies the filter identification 1.
# [+ [$ }9 M: n
This parameter must be a number between:
9 ]* [0 s; s# r$ v, \: j9 W
- 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID5 M( x" u" y9 t, @ J1 c9 V
- 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */5 d- V7 z6 y& g9 ~) Y
" T1 u5 M F( n' {" D- {, L
uint32_t FilterID2; /*!< Specifies the filter identification 2.
. T& j j7 T9 {* [4 `9 G J0 \
This parameter is ignored if FilterConfig is set to
4 @3 i% n# `7 g
FDCAN_FILTER_TO_RXBUFFER./ D5 {+ \" i) s& j7 [* C
This parameter must be a number between:
2 D! ~9 m% \! Z. U7 S
- 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID
9 G2 Z1 |1 q' n- @( |4 c9 u
- 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */
) v0 Z$ i) r$ q4 P1 p
- `: d% q2 ~6 X
uint32_t RxBufferIndex; /*!< Contains the index of the Rx buffer in which the
* z" u3 D# T2 p+ \' a/ \5 G J. ^2 o
matching message will be stored.
# o" c( Q( X, F" X+ ?
This parameter must be a number between 0 and 63.
L4 T z& r8 b9 N/ f
This parameter is ignored if FilterConfig is different
$ K; c( p' \9 u6 M s4 T8 M
from FDCAN_FILTER_TO_RXBUFFER */
' q3 Q( D$ l, }$ n& d0 _
' q, d8 }0 ~0 }
uint32_t IsCalibrationMsg; /*!< Specifies whether the filter is configured for
1 v" Z4 r% k% u$ y. ~
calibration messages.
* L* d) t. K' t$ F% l" G7 \, |/ L* a
This parameter is ignored if FilterConfig is different
6 @; S3 t4 P2 o7 G# [/ d" P
from FDCAN_FILTER_TO_RXBUFFER.+ L2 D5 X0 R3 V
This parameter can be:# o3 B9 ]& ~8 K4 _ p, Y) D
- 0 : ordinary message: F9 j2 j* i- v9 n( m3 K
- 1 : calibration message */, G7 Y9 J6 O% w! ?; P+ @2 a$ y
0 p8 a1 R* s1 K1 d3 M
} FDCAN_FilterTypeDef;

复制代码

IdType
用于设置标准ID和扩展ID。

#define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */
8 Y2 z! {- Z$ }; v
#define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */

复制代码

FilterIndex
用于过滤索引，如果是标准ID，范围0到127。如果是扩展ID，范围0到64。

FilterType
用于设置过滤类型。如果成员FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER，本参数将不起作用。

#define FDCAN_FILTER_RANGE ((uint32_t)0x00000000U) /*!< 范围过滤从FilterID1 到 FilterID2 */
8 [* y$ O7 D# B# e. I1 E
#define FDCAN_FILTER_DUAL ((uint32_t)0x00000001U) /*!< 专用ID过滤，FilterID1 或者FilterID2 */6 R5 I% R3 q- b5 N; n
! e% X5 I% v- p9 D$ `) }4 h
/*!< 精度屏蔽过滤，FilterID1 = filter, FilterID2 = mask */' W* r( l! O9 A6 a
#define FDCAN_FILTER_MASK ((uint32_t)0x00000002U) # @5 n9 P3 K, @! a
; \5 T e) x$ }, Q8 U
/*!< 仅ID扩展模式支持此参数，范围从FilterID1 到 FilterID2, EIDM mask not applied */
! s$ S6 k" G) F# Z" d; ~
#define FDCAN_FILTER_RANGE_NO_EIDM ((uint32_t)0x00000003U)

复制代码

FilterConfig
用于设置过滤类型。

#define FDCAN_FILTER_DISABLE ((uint32_t)0x00000000U) 禁止过滤
4 W/ H" G3 h1 q( p- ]
#define FDCAN_FILTER_TO_RXFIFO0 ((uint32_t)0x00000001U) 如果过滤匹配，将数据保存到Rx FIFO 0
5 {! b+ Q1 M! Q6 j# S
#define FDCAN_FILTER_TO_RXFIFO1 ((uint32_t)0x00000002U) 如果过滤匹配，将数据保存到Rx FIFO 1
+ o$ ~3 W5 a" ]6 |2 c* s4 _
#define FDCAN_FILTER_REJECT ((uint32_t)0x00000003U) 如果过滤匹配，拒绝此ID2 d/ y) ^9 M' q9 r1 j6 ^$ }( C
#define FDCAN_FILTER_HP ((uint32_t)0x00000004U) 如果过滤匹配，设置高优先级
6 F, N% Z. o% X: a( ]! s. K
#define FDCAN_FILTER_TO_RXFIFO0_HP ((uint32_t)0x00000005U) 如果过滤匹配，设置高优先级并保存到FIFO 0$ Z: E, ^" c; N+ Y
#define FDCAN_FILTER_TO_RXFIFO1_HP ((uint32_t)0x00000006U) 如果过滤匹配，设置高优先级并保存到FIFO 1 c) v" E0 H% q9 @# E5 v6 h
#define FDCAN_FILTER_TO_RXBUFFER ((uint32_t)0x00000007U) 如果过滤匹配，保存到Rx Buffer，并忽略FilterType

复制代码

配置
  FilterID1
用于设置过滤ID1。如果ID类型是FDCAN_STANDARD_ID，范围0到0x7FF。如果ID类型是FDCAN_EXTENDED_ID，范围是0 到0x1FFFFFFF。

  FilterID2
用于设置过滤ID2。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER，此参数不起作用。如果ID类型是FDCAN_STANDARD_ID，范围0到0x7FF。如果ID类型是FDCAN_EXTENDED_ID，范围是0 到0x1FFFFFFF。

  RxBufferIndex
匹配消息存储到Rx buffer中的索引。参数范围0到63。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER，此参数不起作用。

  IsCalibrationMsg
用于设置是否配置校准消息。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER，此参数不起作用。

0 ：表示正常消息。

1 ：标志校准消息。

91.3.6 FDCAN总线消息发送结构体FDCAN_TxHeaderTypeDef
下面是CAN FD发送消息结构体：

typedef struct
4 Q6 f/ C" v. V) _
{, p$ d- s3 E! p* W0 d
uint32_t Identifier; /*!< Specifies the identifier.$ m x+ i' F. x
This parameter must be a number between:
0 I. P0 \8 J2 I6 `: x" H8 Q9 ?5 C
- 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID
+ X# b! r* G- l$ m
- 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */
# ^5 W- }& w5 ]5 i
# }. B. o& s& l" ^( {
uint32_t IdType; /*!< Specifies the identifier type for the message that will be# U6 Z% l) ^2 u% O: v# c, u6 [9 \
transmitted.
+ x y+ A2 U' o2 b7 y9 T
This parameter can be a value of @ref FDCAN_id_type */
! q- P) x& B9 f3 Y$ ?1 t4 n. W
) O; l+ f* h2 z0 ~' F
uint32_t TxFrameType; /*!< Specifies the frame type of the message that will be transmitted.
* S O2 M# R+ I4 \! x7 w
This parameter can be a value of @ref FDCAN_frame_type */
9 A. U& ~; ?9 S7 o* ^& i
* K3 o% S: t( W* R0 w( S* k
uint32_t DataLength; /*!< Specifies the length of the frame that will be transmitted.
. L. Q7 ?1 n2 Y3 s' _
This parameter can be a value of @ref FDCAN_data_length_code */
' U2 ^2 O% J' U' [6 f
$ B8 H. y: N4 Y' g }' \
uint32_t ErrorStateIndicator; /*!< Specifies the error state indicator.
7 }0 N/ S; @3 f& M+ S' f! _" G
This parameter can be a value of @ref FDCAN_error_state_indicator */
" u$ q( e2 B" W$ F8 b# P
P8 ]- M. G" o
uint32_t BitRateSwitch; /*!< Specifies whether the Tx frame will be transmitted with or without
_3 W" \8 e7 @. o
bit rate switching.1 A) D2 \" R( S6 |: j
This parameter can be a value of @ref FDCAN_bit_rate_switching */8 G8 R7 d5 d7 u4 R' Y9 h. n
9 X/ l% i! f! T3 N3 h( _6 I/ Z# G
uint32_t FDFormat; /*!< Specifies whether the Tx frame will be transmitted in classic or' I" \0 j% {4 V/ y) P2 o# m3 N
FD format.. T* e' B% p3 [- s- ^4 R3 T+ \/ t
This parameter can be a value of @ref FDCAN_format */
2 W3 B( B/ k9 l" {
. A. Z# E* r3 o1 x
uint32_t TxEventFifoControl; /*!< Specifies the event FIFO control., h7 {# x0 _6 e1 \
This parameter can be a value of @ref FDCAN_EFC */
u2 a# W( @& [: w% I7 _
; Y# k F7 y" B
uint32_t MessageMarker; /*!< Specifies the message marker to be copied into Tx Event FIFO* g. X( X. q0 I5 X* W
element for identification of Tx message status.
$ T, V6 Z0 u9 F y# P" B! u: s+ U
This parameter must be a number between 0 and 0xFF */9 f, M8 b8 ~/ T$ V
2 S5 f# _6 X. ?
} FDCAN_TxHeaderTypeDef;

复制代码

Identifier
用于设置ID，如果IdType是标准FDCAN_STANDARD_ID，范围0到0x7FF，如果IdType是FDCAN_EXTENDED_ID扩展ID，范围0到0x1FFFFFFF。

IdType
用于设置标准ID或者扩展ID。

#define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */ |5 m; |$ ]7 I- U+ A& U$ q2 A/ |
#define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */

复制代码

TxFrameType
用于设置帧类型，数据帧或遥控帧。

#define FDCAN_DATA_FRAME ((uint32_t)0x00000000U) /*!< 数据帧 */( ]$ u: n; C: `1 K; s
#define FDCAN_REMOTE_FRAME ((uint32_t)0x20000000U) /*!< 遥控帧 */

复制代码

DataLength
用于设置数据长度。

#define FDCAN_DLC_BYTES_0 ((uint32_t)0x00000000U) /*!< 0 bytes data field */$ x3 H+ i; W" _5 u( G9 q
#define FDCAN_DLC_BYTES_1 ((uint32_t)0x00010000U) /*!< 1 bytes data field */! t2 { ]5 v* f3 [
#define FDCAN_DLC_BYTES_2 ((uint32_t)0x00020000U) /*!< 2 bytes data field */ ?. w: @& S' f/ h
#define FDCAN_DLC_BYTES_3 ((uint32_t)0x00030000U) /*!< 3 bytes data field */. E+ C9 O5 c" B9 v
#define FDCAN_DLC_BYTES_4 ((uint32_t)0x00040000U) /*!< 4 bytes data field */& [8 Y, a9 E3 a8 c2 T
#define FDCAN_DLC_BYTES_5 ((uint32_t)0x00050000U) /*!< 5 bytes data field */& M1 P7 F6 c+ P3 r
#define FDCAN_DLC_BYTES_6 ((uint32_t)0x00060000U) /*!< 6 bytes data field */# W4 @# k) e% v. q" w
#define FDCAN_DLC_BYTES_7 ((uint32_t)0x00070000U) /*!< 7 bytes data field */
2 ?/ `' D5 ?9 X
#define FDCAN_DLC_BYTES_8 ((uint32_t)0x00080000U) /*!< 8 bytes data field */7 g V I' i1 q
#define FDCAN_DLC_BYTES_12 ((uint32_t)0x00090000U) /*!< 12 bytes data field */
6 `: ?8 n" g: ]& j
#define FDCAN_DLC_BYTES_16 ((uint32_t)0x000A0000U) /*!< 16 bytes data field */
& |' r* V$ I1 M k
#define FDCAN_DLC_BYTES_20 ((uint32_t)0x000B0000U) /*!< 20 bytes data field */
- Z$ E: f5 ?& B' T" D; b
#define FDCAN_DLC_BYTES_24 ((uint32_t)0x000C0000U) /*!< 24 bytes data field */1 H! P8 C$ b1 Z" \
#define FDCAN_DLC_BYTES_32 ((uint32_t)0x000D0000U) /*!< 32 bytes data field */
, P+ X+ X6 l* z, v W7 v$ c
#define FDCAN_DLC_BYTES_48 ((uint32_t)0x000E0000U) /*!< 48 bytes data field */1 P# v6 r% x7 Y
#define FDCAN_DLC_BYTES_64 ((uint32_t)0x000F0000U) /*!< 64 bytes data field */

复制代码

ErrorStateIndicator
用于设置错误状态指示：

#define FDCAN_ESI_ACTIVE ((uint32_t)0x00000000U) /*!< 传输节点 error active */6 P6 t' w+ [1 ]" r3 e3 A1 Q' _
#define FDCAN_ESI_PASSIVE ((uint32_t)0x80000000U) /*!< 传输节点error passive */

复制代码

BitRateSwitch
用于设置发送是否波特率可变。

#define FDCAN_BRS_OFF ((uint32_t)0x00000000U) /*!< FDCAN帧发送/接收不带波特率可变 */, ~3 [$ Z" }1 d) \3 e8 c% ?. V
#define FDCAN_BRS_ON ((uint32_t)0x00100000U) /*!< FDCAN帧发送/接收带波特率可变 */

复制代码

FDFormat
用于设置发送帧是经典格式还是CANFD格式。

8 M4 U+ S% _, R0 A" y: M$ F0 A* O
#define FDCAN_CLASSIC_CAN ((uint32_t)0x00000000U) /*!< 帧发送/接收使用经典CAN */
# x( \% Y) l" k% Z6 m
#define FDCAN_FD_CAN ((uint32_t)0x00200000U) /*!< 帧发送/接收使用FDCAN格式 */

复制代码

TxEventFifoControl
用于设置发送事件FIFO控制。

#define FDCAN_NO_TX_EVENTS ((uint32_t)0x00000000U) /*!< 不存储 Tx events */
]$ H% p0 B7 a3 d/ H
#define FDCAN_STORE_TX_EVENTS ((uint32_t)0x00800000U) /*!< 存储Tx events */

复制代码

MessageMarker
用于设置复制到TX EVENT FIFO的消息Maker，来识别消息状态，范围0到0xFF。

91.3.7 FDCAN总线消息接收结构体FDCAN_RxHeaderTypeDef
下面是CAN FD接收消息结构体：

typedef struct/ B6 |+ O5 \& H8 s: {7 W7 X: P$ F* e
{
. @' j. y) Q( I3 v; y h9 v3 s1 C
uint32_t Identifier; /*!< Specifies the identifier.
3 J% t) |9 E) S
This parameter must be a number between:
# }4 D$ M; ?( `4 \0 R
- 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID% t/ `" D9 g$ l
- 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */* K6 ~4 [+ \+ P3 k+ n* `
; d6 X' j9 E: M
uint32_t IdType; /*!< Specifies the identifier type of the received message.
+ x3 R: S7 {* R9 G" s
This parameter can be a value of @ref FDCAN_id_type *// J' J+ s. U& G$ ~) A4 u: K; I) z
- M8 ]( J2 m& _2 o
uint32_t RxFrameType; /*!< Specifies the the received message frame type.
1 U- c! x L1 y
This parameter can be a value of @ref FDCAN_frame_type */8 ]2 B/ U5 p$ S6 y( N/ H3 \* g
- U; a# l0 e2 |* k4 D* h4 ?0 ?. y- S
uint32_t DataLength; /*!< Specifies the received frame length.
6 [' k: l; r! u! q0 V
This parameter can be a value of @ref FDCAN_data_length_code */
! |0 t9 [' S4 K- i$ Q2 |
! l2 Y ~ g& Y' h9 Z1 x( A
uint32_t ErrorStateIndicator; /*!< Specifies the error state indicator.5 g! |& T$ i; z* b, H
This parameter can be a value of @ref FDCAN_error_state_indicator */2 z1 y5 ~, d! a p3 d+ c) G( k
0 q' K3 M8 B( e; J% D6 b
uint32_t BitRateSwitch; /*!< Specifies whether the Rx frame is received with or without bit" H: L( y: U& B. j1 W/ T& K$ w
rate switching.2 L4 j2 T/ B4 n$ O8 ]* T; ~
This parameter can be a value of @ref FDCAN_bit_rate_switching */
0 ?' X. o) {( k4 S* e/ a
_) O# W1 g, w% w- `: Q3 G
uint32_t FDFormat; /*!< Specifies whether the Rx frame is received in classic or FD
% k3 `# q8 k: Q+ p) N
format.3 f* _* U/ }" ~" b# u/ L
This parameter can be a value of @ref FDCAN_format *// L: J$ @5 v; m. D( S3 Y
, G7 T+ D+ H/ }3 K: c$ @2 U8 \; Z
uint32_t RxTimestamp; /*!< Specifies the timestamp counter value captured on start of frame
1 }9 U/ {+ `, a2 R4 I
reception.
8 \4 X1 n1 O5 C( ]) V9 U3 H; s" j" n
This parameter must be a number between 0 and 0xFFFF */: x$ g, ^1 \0 G6 g
. ?% x0 a- G3 R8 n6 _1 g3 Q
uint32_t FilterIndex; /*!< Specifies the index of matching Rx acceptance filter element.
# t5 S2 Q" C% B( }7 }
This parameter must be a number between:, h3 V! K, G* X3 t6 ?: B; G
- 0 and 127, if IdType is FDCAN_STANDARD_ID
* E+ V" L# ~3 `9 m5 Z3 H3 Y8 B
- 0 and 63, if IdType is FDCAN_EXTENDED_ID */
e Y# }0 T) x, w, Z8 s
$ _+ h5 L4 V) Q6 q4 Y
uint32_t IsFilterMatchingFrame; /*!< Specifies whether the accepted frame did not match any Rx filter.
- y+ O/ c6 O5 Z
Acceptance of non-matching frames may be enabled via
: J: v. Y/ R0 }
HAL_FDCAN_ConfigGlobalFilter().
0 z$ f+ ?- Y- D. h# T9 d
This parameter can be 0 or 1 */
% w, V% c2 B$ U. g8 ?8 ]" C! L) G
5 R4 e0 E& z, o' X/ _- D/ d
} FDCAN_RxHeaderTypeDef;

复制代码

Identifier
用于设置ID，如果IdType是标准FDCAN_STANDARD_ID，范围0到0x7FF，如果IdType是FDCAN_EXTENDED_ID扩展ID，范围0到0x1FFFFFFF。

IdType
用于设置标志ID或者扩展ID。

#define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */
x. H3 B" w+ L5 Z5 @8 {# ^
#define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */

复制代码

RxFrameType
用于设置接收帧类型，数据帧或遥控帧

#define FDCAN_DATA_FRAME ((uint32_t)0x00000000U) /*!< 数据帧 */
8 w( F/ C: A. p7 A2 I2 d5 x E
#define FDCAN_REMOTE_FRAME ((uint32_t)0x20000000U) /*!< 遥控帧 */

复制代码

DataLength
用于设置数据长度。

#define FDCAN_DLC_BYTES_0 ((uint32_t)0x00000000U) /*!< 0 bytes data field */1 h! Y% m: E2 C; x6 p6 B0 ~5 s% S. \
#define FDCAN_DLC_BYTES_1 ((uint32_t)0x00010000U) /*!< 1 bytes data field */
% \, e+ M0 k1 ?: [
#define FDCAN_DLC_BYTES_2 ((uint32_t)0x00020000U) /*!< 2 bytes data field */
* V. J3 V! D# U1 s) N2 y" w
#define FDCAN_DLC_BYTES_3 ((uint32_t)0x00030000U) /*!< 3 bytes data field */- f) M8 i% s; e l7 `
#define FDCAN_DLC_BYTES_4 ((uint32_t)0x00040000U) /*!< 4 bytes data field */: X+ |8 R/ s- T6 k* i
#define FDCAN_DLC_BYTES_5 ((uint32_t)0x00050000U) /*!< 5 bytes data field */
8 j- Y: d3 ~3 {
#define FDCAN_DLC_BYTES_6 ((uint32_t)0x00060000U) /*!< 6 bytes data field */
' `9 k }- {+ I7 s6 m( A
#define FDCAN_DLC_BYTES_7 ((uint32_t)0x00070000U) /*!< 7 bytes data field */8 L9 U5 X' O4 k" o" C
#define FDCAN_DLC_BYTES_8 ((uint32_t)0x00080000U) /*!< 8 bytes data field */
2 T* c5 r* \/ U* ?- q: S
#define FDCAN_DLC_BYTES_12 ((uint32_t)0x00090000U) /*!< 12 bytes data field */
( T/ ]) ^! [3 B$ f5 f& S8 \
#define FDCAN_DLC_BYTES_16 ((uint32_t)0x000A0000U) /*!< 16 bytes data field *// _, \* t6 y5 h( Q0 n" [
#define FDCAN_DLC_BYTES_20 ((uint32_t)0x000B0000U) /*!< 20 bytes data field */
. D# g; s3 _6 N
#define FDCAN_DLC_BYTES_24 ((uint32_t)0x000C0000U) /*!< 24 bytes data field */
# k; I8 `2 q3 g. D) [
#define FDCAN_DLC_BYTES_32 ((uint32_t)0x000D0000U) /*!< 32 bytes data field */9 I. R9 ~3 E2 X& D7 Q' ?
#define FDCAN_DLC_BYTES_48 ((uint32_t)0x000E0000U) /*!< 48 bytes data field */) N# c* q1 d! m/ t9 I! N3 ?
#define FDCAN_DLC_BYTES_64 ((uint32_t)0x000F0000U) /*!< 64 bytes data field */
+ p( _5 n1 d. Q& `) p0 V ]
ErrorStateIndicator

复制代码

用于设置错误状态指示：

#define FDCAN_ESI_ACTIVE ((uint32_t)0x00000000U) /*!< 传输节点error active */
: G& A5 \% |4 X" B
#define FDCAN_ESI_PASSIVE ((uint32_t)0x80000000U) /*!< 传输节点error passive */

复制代码

BitRateSwitch
用于设置接收是否带波特率切换

#define FDCAN_BRS_OFF ((uint32_t)0x00000000U) /*!< FDCAN 帧发送/接收不支持波特率可变*/
, l2 J, `9 o- H( r1 \+ x [
#define FDCAN_BRS_ON ((uint32_t)0x00100000U) /*!< FDCAN 帧发送/接收支持波特率可变 */

复制代码

FDFormat
用于设置接收帧是经典格式还是CANFD格式

#define FDCAN_CLASSIC_CAN ((uint32_t)0x00000000U) /*!< 经典帧 */
* U1 Y! f: } p; P8 m7 t8 F6 U
#define FDCAN_FD_CAN ((uint32_t)0x00200000U) /*!< FDCAN帧 */

复制代码

  RxTimestamp
用于设置帧接收时间戳，范围0到0xFFFF。

  FilterIndex
用于设置接收过滤索引。如果是标准ID，范围0到127，如果是扩展ID，范围0到63。

  IsFilterMatchingFrame
用于设置是否接收非匹配帧，通过函数HAL_FDCAN_ConfigGlobalFilter()可以使能。

0：表示不接受。

1：表示接收。

91.3.8 FDCAN总线句柄结构体FDCAN_HandleTypeDef
下面是CANFD句柄结构体：

#if USE_HAL_FDCAN_REGISTER_CALLBACKS == 11 f( l2 t3 h5 B/ T* k
typedef struct __FDCAN_HandleTypeDef
; j/ D, ], m. ?6 k& \9 A
#else; A, |; r+ g* h2 U& ~2 \
typedef struct
5 U# O+ M" A) l" E+ y5 Y- n
#endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
0 M! q: Y* M- ^% x3 _
{ t4 R: E6 a$ L3 J$ X- g1 z
FDCAN_GlobalTypeDef *Instance; /*!< Register base address */
- K( I) L: A8 [; k
8 F% r& S) S4 u ]" p
TTCAN_TypeDef *ttcan; /*!< TT register base address */1 q' r4 W; G( v' @. K4 E( x8 @" C) C
$ L7 c: p, ^. {* `
FDCAN_InitTypeDef Init; /*!< FDCAN required parameters */
9 H% u- R9 m9 F7 e1 g8 W6 J
FDCAN_MsgRamAddressTypeDef msgRam; /*!< FDCAN Message RAM blocks */# ?+ ]1 K0 |+ [+ E: B2 U
; V! x5 F2 _5 I2 b
uint32_t LatestTxFifoQRequest; /*!< FDCAN Tx buffer index
k, |7 P" ]6 i5 u1 i9 Z+ `! h2 [
of latest Tx FIFO/Queue request */. ~! C: o- N; j# R9 J( F3 `+ k3 M9 Z3 d7 d
2 c+ m+ c9 U( L: v( X
__IO HAL_FDCAN_StateTypeDef State; /*!< FDCAN communication state */% F' ^: `* M6 O5 Y; E, h
1 \7 Z$ D! ]8 J1 e0 k/ l& j
HAL_LockTypeDef Lock; /*!< FDCAN locking object */2 H2 e$ u9 \% d6 S, J+ k5 v9 l# d
7 Q) J+ x# Y' d, Y
__IO uint32_t ErrorCode; /*!< FDCAN Error code */
8 h6 D) ]/ _3 j2 M" J
9 X" i/ B+ c# Y/ {% Z' i, R6 F( x
#if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
, {8 W$ S( k! a9 m6 I$ J$ R
void (* ClockCalibrationCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t ClkCalibrationITs); /*!< FDCAN Clock Calibration callback */! F8 d, q; }% I n
void (* TxEventFifoCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TxEventFifoITs); /*!< FDCAN Tx Event Fifo callback */) L. _1 I# g4 I, D. G) c- i
void (* RxFifo0Callback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs); /*!< FDCAN Rx Fifo 0 callback */
$ }& R" X/ ?$ R# v
void (* RxFifo1Callback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs); /*!< FDCAN Rx Fifo 1 callback */
' z) h) J+ l8 M1 O
void (* TxFifoEmptyCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Tx Fifo Empty callback */8 P/ Z" ?+ o4 |4 D2 D4 ^, j0 ^! ~
void (* TxBufferCompleteCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t BufferIndexes); /*!< FDCAN Tx Buffer complete callback */5 t' F- d" }6 e$ {; P: u+ Y
void (* TxBufferAbortCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t BufferIndexes); /*!< FDCAN Tx Buffer abort callback */$ E0 ^( H; u# `* Y" {. n7 W/ ]
void (* RxBufferNewMessageCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Rx Buffer New Message callback */
% k0 ^+ D' Q$ ~8 c: O# h7 m: |
void (* HighPriorityMessageCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN High priority message callback */; R/ t! J7 T( r6 c, g5 Y9 B
void (* TimestampWraparoundCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Timestamp wraparound callback */7 M. |1 i$ _+ L' |& H* X4 w
void (* TimeoutOccurredCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Timeout occurred callback */$ C @% T" F( _4 n
void (* ErrorCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Error callback */ T% q6 J2 f* t' D j
void (* ErrorStatusCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t ErrorStatusITs); /*!< FDCAN Error status callback */
7 J' J: h# X* { ], x+ o
void (* TT_ScheduleSyncCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTSchedSyncITs); /*!< FDCAN T Schedule Synchronization callback */
& |! E k0 }) e6 y0 P3 r
void (* TT_TimeMarkCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTTimeMarkITs); /*!< FDCAN TT Time Mark callback */
; m: {- A, i9 u$ Q( Y
void (* TT_StopWatchCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t SWTime, uint32_t SWCycleCount); /*!< FDCAN TT Stop Watch callback */4 P; x/ |/ m$ D: H
void (* TT_GlobalTimeCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTGlobTimeITs); /*!< FDCAN TT Global Time callback */
5 R* h+ p- n7 h8 ~
3 r2 E, I& G) C
void (* MspInitCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Msp Init callback */) y0 {! x6 j) R7 `- a m
void (* MspDeInitCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Msp DeInit callback */
3 ?4 j0 \0 o1 y+ E6 |% i& E
#endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
$ E2 Y0 w, ~# P6 S& o) h
$ F" K p* v% `% b+ s+ w
} FDCAN_HandleTypeDef;

复制代码

注意事项：

条件编译USE_HAL_FDCAN_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调，此定义一般放在stm32h7xx_hal_conf.h文件里面设置：

#define USE_HAL_FDCAN_REGISTER_CALLBACKS 1

复制代码

函数HAL_FDCAN_RegisterCallback注册回调，取消注册使用函数HAL_FDCAN_UnRegisterCallback。

这里重点介绍下面几个参数，其它参数主要是HAL库内部使用和自定义回调函数。

  FDCAN_GlobalTypeDef       *Instance
这个参数是寄存器的例化，方便操作寄存器。

  TTCAN_TypeDef             *ttcan
TT CAN时间触发寄存器基地址。

  FDCAN_InitTypeDef          Init
FDCAN相关的初始化参数。

  FDCAN_MsgRamAddressTypeDef  msgRam
消息RAM地址。

  uint32_t LatestTxFifoQRequest
Tx buffer索引最后一个Tx FIFO/Queue参数。

  __IO HAL_FDCAN_StateTypeDef State
HAL_LockTypeDef          Lock

__IO uint32_t             ErrorCode

程序内部使用的状态参数。

  剩下的都是回调函数
91.4 FD CAN总线源文件stm32h7xx_hal_fdcan.c
此文件涉及到的函数较多，这里把几个常用的函数做个说明：

91.4.1 函数HAL_FDCAN_Init
函数原型：

HAL_StatusTypeDef HAL_FDCAN_Init(FDCAN_HandleTypeDef *hfdcan)
* d# V! X% n2 p7 J ]) B2 A
{
; d5 V2 B, z& X$ u+ T
uint32_t tickstart;
" h: N& ` N# E, J1 `. ?
HAL_StatusTypeDef status;2 x9 B1 I9 j" k) B" s
const uint32_t CvtEltSize[] = {0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7};
% W& ~: N5 p6 z( e3 S q
/ P) R, h2 a7 G! q
/* 检测FDCAN句柄是否有效 */. @( y5 N% R4 s6 s. i
if (hfdcan == NULL)
+ q, y8 @8 I/ d$ G6 s b" } z
{
: E% i' O/ v# p, V3 _' Z3 ~
return HAL_ERROR;
' D" t. d* H( A' |; d/ e/ T, b+ f
}
6 H$ P. n$ X0 e" g# ^
4 t5 h ^( |6 S/ U) l8 O T/ d* f
/* 检查FDCAN例化 */: W) Q0 x0 P# ~" Q C
if (hfdcan->Instance == FDCAN1)" S1 {& R( ?, n4 \$ v
{
; R) @; L& H- i6 {$ n, m
hfdcan->ttcan = (TTCAN_TypeDef *)((uint32_t)hfdcan->Instance + 0x100U);
" k- c' w. z& z1 l. Q
}
, ~7 Z# E- C% j
! E$ j3 V: e0 I. }; v0 G
/* 检查函数参数 */
8 a4 Y# y) e$ }2 e) b ^
assert_param(IS_FDCAN_ALL_INSTANCE(hfdcan->Instance));
$ r5 k# A: ?$ T! L- a K% M
assert_param(IS_FDCAN_FRAME_FORMAT(hfdcan->Init.FrameFormat));$ S; C2 ], v2 X" R) p4 A
assert_param(IS_FDCAN_MODE(hfdcan->Init.Mode));: @! }: O9 X f# Y
assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.AutoRetransmission));' O# W% c: _ Z) g
assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.TransmitPause));
5 H* S, G7 L* c: i$ i
assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.ProtocolException));
+ z- s! m! _8 P, Q1 |
assert_param(IS_FDCAN_NOMINAL_PRESCALER(hfdcan->Init.NominalPrescaler));
! s& u9 Y5 s2 E% L1 H5 i; X) R
assert_param(IS_FDCAN_NOMINAL_SJW(hfdcan->Init.NominalSyncJumpWidth));
0 ]7 u: n7 g9 X8 v) L; J
assert_param(IS_FDCAN_NOMINAL_TSEG1(hfdcan->Init.NominalTimeSeg1));
- n& @; l" }* s7 J( x# I# B! b. W
assert_param(IS_FDCAN_NOMINAL_TSEG2(hfdcan->Init.NominalTimeSeg2));
$ @/ [$ _* k" U
if (hfdcan->Init.FrameFormat == FDCAN_FRAME_FD_BRS)/ J. |# C9 k8 |/ o7 @, g& U1 Q
{
! S4 c' l- \( T6 F/ j7 I2 m
assert_param(IS_FDCAN_DATA_PRESCALER(hfdcan->Init.DataPrescaler));2 {/ b6 o; }: D+ C
assert_param(IS_FDCAN_DATA_SJW(hfdcan->Init.DataSyncJumpWidth));
5 n) D% c' z* i! \ X
assert_param(IS_FDCAN_DATA_TSEG1(hfdcan->Init.DataTimeSeg1));1 @6 F% [! c2 d7 E- d
assert_param(IS_FDCAN_DATA_TSEG2(hfdcan->Init.DataTimeSeg2));
# o/ w( Q' @; j( T0 M; K
}
: s* L+ j7 @( f/ n M
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.StdFiltersNbr, 128U));
, i: n5 K+ C2 }
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.ExtFiltersNbr, 64U));
5 {; d: y+ F& Q4 D3 d. D# r; k
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxFifo0ElmtsNbr, 64U));
% E7 j( w/ r) c: U9 T' c! u. v
if (hfdcan->Init.RxFifo0ElmtsNbr > 0U)
( a& i% T% c/ G, E
{
, j3 Z1 ~8 Q0 L Z0 y* O
assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxFifo0ElmtSize));# v" ]% N1 n3 \
}. p& [+ I8 p2 T) t" H( E3 k. w$ H
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxFifo1ElmtsNbr, 64U));& |+ ]! x, k& U/ U# v% u" N
if (hfdcan->Init.RxFifo1ElmtsNbr > 0U)% K( ] B& K- O" P! F# {: _
{
7 B, \# J& |3 T6 |( c
assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxFifo1ElmtSize));; h& V+ c4 X$ n9 L2 L: }" Q# o
}, q3 P( z3 B$ u
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxBuffersNbr, 64U));+ H: t/ d$ o# w W; y1 K
if (hfdcan->Init.RxBuffersNbr > 0U)
& \9 I0 R: e5 k- k/ p. X
{
' m3 {. P& H# l9 `
assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxBufferSize));
# Z) Y7 @ @4 y: J" T9 ]+ g) U
}) m ^& j; C9 O% F
assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.TxEventsNbr, 32U));
, }0 J: |; p3 V
assert_param(IS_FDCAN_MAX_VALUE((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr), 32U));& c/ \4 y) l F8 x) t( g
if (hfdcan->Init.TxFifoQueueElmtsNbr > 0U)
: q4 o2 N$ G: O2 J$ f
{
+ F7 Q& a$ A3 X2 I0 O! |/ _: o3 Y
assert_param(IS_FDCAN_TX_FIFO_QUEUE_MODE(hfdcan->Init.TxFifoQueueMode));- L: v) S7 ~$ W, }! b1 N' o" C$ d1 X# B; s
}
, Z& o1 G( O" [# d. u% M1 [+ I) \
if ((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr) > 0U)
$ O3 ]6 @0 w; c) M b6 v- c
{ n5 g6 E; P" y; V3 h3 @
assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.TxElmtSize));) C/ D( B2 c* \, ^# ]
}) w% o* U0 Q2 {/ \% x
7 P; Y& f4 z, t5 W# @6 B
#if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
( ]# y; G( G9 A1 X4 G
if (hfdcan->State == HAL_FDCAN_STATE_RESET)1 w- j+ Q/ Z5 K2 l @: M7 c0 ?
{8 S# n: S& B" w4 i( d: R5 G0 M
/* 解锁*/- m7 v4 k8 M* `, ^2 W2 ~
hfdcan->Lock = HAL_UNLOCKED;5 |& a; g, w W: B- _: P$ S0 O3 U r
: X* d# v9 J6 a. c1 g- T9 K# S; U5 Q) M
/* 复位设置默认回调 */
' w" o/ r z: w$ K- T
hfdcan->ClockCalibrationCallback = HAL_FDCAN_ClockCalibrationCallback; /* Legacy weak ClockCalibrationCallback */8 ~2 d* r0 e* E
hfdcan->TxEventFifoCallback = HAL_FDCAN_TxEventFifoCallback; /* Legacy weak TxEventFifoCallback */
% Q! F) ?/ ]9 [5 c1 D; q) \
hfdcan->RxFifo0Callback = HAL_FDCAN_RxFifo0Callback; /* Legacy weak RxFifo0Callback */
* D% D* i% L% m, P
hfdcan->RxFifo1Callback = HAL_FDCAN_RxFifo1Callback; /* Legacy weak RxFifo1Callback */3 G, g, Z8 j: ]7 v
hfdcan->TxFifoEmptyCallback = HAL_FDCAN_TxFifoEmptyCallback; /* Legacy weak TxFifoEmptyCallback */0 }. {) `! Z6 Y) r, o) \7 t3 u
hfdcan->TxBufferCompleteCallback = HAL_FDCAN_TxBufferCompleteCallback; /* Legacy weak TxBufferCompleteCallback */
% B, s( |+ Y. L! z
hfdcan->TxBufferAbortCallback = HAL_FDCAN_TxBufferAbortCallback; /* Legacy weak TxBufferAbortCallback */
: x. ]: h6 Z; c' {
hfdcan->RxBufferNewMessageCallback = HAL_FDCAN_RxBufferNewMessageCallback; /* Legacy weak RxBufferNewMessageCallback */4 K9 o/ Q- S- ^; V
hfdcan->HighPriorityMessageCallback = HAL_FDCAN_HighPriorityMessageCallback; /* Legacy weak HighPriorityMessageCallback */- @; e" E T9 J! n: y3 r' d
hfdcan->TimestampWraparoundCallback = HAL_FDCAN_TimestampWraparoundCallback; /* Legacy weak TimestampWraparoundCallback */
5 [7 y8 R; U6 B) Y: a5 x% w9 I+ ~
hfdcan->TimeoutOccurredCallback = HAL_FDCAN_TimeoutOccurredCallback; /* Legacy weak TimeoutOccurredCallback */
3 n: b( L9 J0 S* h) c
hfdcan->ErrorCallback = HAL_FDCAN_ErrorCallback; /* Legacy weak ErrorCallback */
" C. U3 T9 S$ c6 o0 w8 K
hfdcan->ErrorStatusCallback = HAL_FDCAN_ErrorStatusCallback; /* Legacy weak ErrorStatusCallback */* E5 S* b$ k% L/ l, L. R
hfdcan->TT_ScheduleSyncCallback = HAL_FDCAN_TT_ScheduleSyncCallback; /* Legacy weak TT_ScheduleSyncCallback */: K' Y, |9 a2 p. f2 k& [
hfdcan->TT_TimeMarkCallback = HAL_FDCAN_TT_TimeMarkCallback; /* Legacy weak TT_TimeMarkCallback */: h8 ]$ f% M" `$ y. s0 e! X: p
hfdcan->TT_StopWatchCallback = HAL_FDCAN_TT_StopWatchCallback; /* Legacy weak TT_StopWatchCallback */
! i1 g7 P3 |+ B3 N9 [. [8 \: o
hfdcan->TT_GlobalTimeCallback = HAL_FDCAN_TT_GlobalTimeCallback; /* Legacy weak TT_GlobalTimeCallback */
& W5 \9 f4 C3 @! z$ j) F9 r6 e
* p0 H/ p, `2 A: y3 u' m2 D
if (hfdcan->MspInitCallback == NULL)7 o2 ` x4 |9 G; I% J5 E
{ X4 d( D. y9 c0 N% ~# N2 Z# m% f5 q
hfdcan->MspInitCallback = HAL_FDCAN_MspInit; /* Legacy weak MspInit */0 E$ r9 Q! `+ ~7 Z7 i: Q
}% J0 Q. T D# e5 w
' E1 B' A+ x$ {2 s
/* 初始化CLOCK和NVIC */
7 z6 K0 O, @( z; Y0 `
hfdcan->MspInitCallback(hfdcan);
6 O' S$ T5 h& r1 A0 J- U- T3 n
}0 `, O0 u! i* y `/ j
#else1 t0 U8 Q' q( k* G8 r/ m
if (hfdcan->State == HAL_FDCAN_STATE_RESET)
6 `# A2 L0 L' D0 C2 p
{
6 t' v- n; o _: E8 s, s8 i
/* 解锁 */
/ P, I, v4 X4 u; A+ t
hfdcan->Lock = HAL_UNLOCKED;- P& X. a; j8 h6 M! P0 ]8 D
3 b3 p$ R q' t
/* 初始化底层硬件 */8 k! @- s# |+ A$ ~$ t/ n& `
HAL_FDCAN_MspInit(hfdcan);
6 w4 ? p2 ~/ @( Y
}" @, b8 g) u5 W+ K# i$ o3 I5 p
#endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
8 W6 o' N+ s8 t, Z
" Y! |' Y' e2 O! B* F: [
/* 退出Sleep */
" b- a6 G7 p, s7 v8 |: I* K" K% q
CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_CSR);
! ~! S e9 i) w; h- W
: P/ x3 g9 n, p! G
/* 获取时钟 */
* g) t5 e; ?& w
tickstart = HAL_GetTick();+ R% T* y9 R" U$ }8 A& ~; f
# S. A" x7 J& E! ^4 R
/* 等待Sleep模式确认 */
) o' a n; Y3 v+ g6 W9 } W
while ((hfdcan->Instance->CCCR & FDCAN_CCCR_CSA) == FDCAN_CCCR_CSA)
; x1 U6 U* b, M0 |6 }, ]) g% Q. r
{- L P$ V1 z9 ]+ s* }' C, A. V
if ((HAL_GetTick() - tickstart) > FDCAN_TIMEOUT_VALUE)& r _! m; t) r6 `, u* J, Q
{
; I/ r$ b2 q: Q3 T+ L1 m. t4 }
/* 更新错误码 */ b3 T5 \+ d! \3 Z: }( |
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_TIMEOUT;0 ?- c, z0 R" s# L
7 `! i [: V& r' {' _# [
/* 改变FDCAN状态 */" F; D- A: ]9 x- [7 B& g, q/ k
hfdcan->State = HAL_FDCAN_STATE_ERROR;
i) Z7 I b% S( h$ b4 j+ f
! h/ c6 z% k( Q- b. u
return HAL_ERROR;* L, o6 A8 z8 H# M2 x- N, }
}
; g* w& C6 d$ o! |2 `, W
}
( p9 l! \% T* h+ o7 k; N
4 F) W6 q- {0 g7 j# A* r9 l
/* 请求初始化 */- X# y" W( q/ c/ E3 x" g
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_INIT);
; K. t c. }6 s% Q: Y& C
8 A! c `: A, d1 Q
/* 获取时钟 */
6 U( ^: e6 N. s/ q" D& l
tickstart = HAL_GetTick();
& p- J& v( q+ F) m
}, o# p. O; n- W
/* 等待CCCR寄存器的INIT位 */
4 `' ?' B4 j- |' { G
while ((hfdcan->Instance->CCCR & FDCAN_CCCR_INIT) == 0U)
. Q* l* Z0 s" L c/ |
{
; s. _' H4 ~: S" g$ c
/* 检查溢出时间 */
) X4 p+ @ t+ t \6 M' H2 s
if ((HAL_GetTick() - tickstart) > FDCAN_TIMEOUT_VALUE)
7 V. _ P4 y0 @+ b: C' H
{
2 s4 m6 G6 ^- y$ r! |9 ~
/* 更新错误码 */
& z3 \/ t' Z0 L" N; ]9 A0 s
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_TIMEOUT;' z+ I" p- I0 |9 f, n
# T% ?4 ~$ q. a. d5 S
/* 设置FDCAN状态 */# @1 k7 D4 |% R* C. O) c7 ?% W
hfdcan->State = HAL_FDCAN_STATE_ERROR;
5 T- K! e' V9 F8 O. d: F) U2 e* E
. [9 l/ S$ _% U# b$ b* [
return HAL_ERROR; Y+ o# i7 a) k& w2 a
} L" T9 b( [: t# ~
}; B: p7 r2 F( F! \0 q
, l$ [& X' \1 _: `0 l7 j3 @: O
/* 使能配置修改 */6 ?! W" }2 Y. S4 |' c
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_CCE);) Y& N# C4 X }
; P: R# [7 o1 L. X7 w
/* 设置是否自动重传 */# s9 ~+ A& N, l* J, L
if (hfdcan->Init.AutoRetransmission == ENABLE)6 N: ^4 A* ~5 k# u
{" a. L8 a" P$ R! N3 ?! O7 x
CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_DAR);
6 d) o' g2 g9 y
}+ e+ x3 z* o- x8 k5 t9 [
else
6 g: b! \; o: l1 B
{, u- z$ u% w Y. j+ Q
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_DAR);
3 J# q* V( J2 U
}
3 [( B4 U& R8 m, h
8 y+ G2 g( Q/ j7 G0 ~
/* 设置传输暂停特性 */
1 H$ G; B, y' r0 l3 Y) p, I
if (hfdcan->Init.TransmitPause == ENABLE)
7 B: R8 d% o# _7 ]. H
{$ g0 x% A2 d) B9 R: j
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TXP);
$ I) {5 u1 I# y5 g
}4 \5 l/ `. y* n& M# V
else9 B. @ k5 y1 t. [5 Q$ ?
{
$ d/ E( h2 ^5 u# {7 p
CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TXP);, _7 N5 e& G) D
}8 [4 Y X; X' ?3 n. n; m0 }$ P
4 C& t$ v% x! O/ Q% v {% L) B7 D
/* 设置协议异常处理 */" r% D7 @9 r7 L d. v G
if (hfdcan->Init.ProtocolException == ENABLE)0 `' p: E: e! C h9 L
{3 c/ M' Z& I4 X
CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_PXHD);
9 R" T( c7 \+ k7 K$ e( l: X+ D
}0 ]* r4 I b) ? j" e" I# Y. ]
else. D ?" w7 H: u3 O8 q. E: |
{
9 O" d0 w/ k& c: V% M: {* k
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_PXHD);
! ? o+ n% m+ J: s2 e9 y
}
5 m+ A2 S# O7 \2 l
0 U8 h j* S: H9 w
/* 设置FDCAN帧格式 *// }/ T6 \) T( Z& o# y1 q! L7 W' c% G
MODIFY_REG(hfdcan->Instance->CCCR, FDCAN_FRAME_FD_BRS, hfdcan->Init.FrameFormat);
1 X* t* v" {. L5 A* i. d% R0 N4 l
$ d o2 I/ l1 L4 ^# o1 i$ F
/* 复位FDCAN操作模式 */
4 ^) X$ D" Q" _5 R. x
CLEAR_BIT(hfdcan->Instance->CCCR, (FDCAN_CCCR_TEST | FDCAN_CCCR_MON | FDCAN_CCCR_ASM));
8 o; U5 m5 U7 C7 c- y3 |7 l7 A8 }
CLEAR_BIT(hfdcan->Instance->TEST, FDCAN_TEST_LBCK);: | ]& C* \+ G' S- U/ R- I" [
! n+ v. G: z. G1 P
/* 设置FDCAN操作模式:
0 B4 ?( J! d; A7 |: W; z' @4 p. e
| Normal | Restricted | Bus | Internal | External5 F; q1 G* B" o4 t$ e# X4 n+ j
| | Operation | Monitoring | LoopBack | LoopBack
2 u% @! \/ e6 p& c! O$ c
CCCR.TEST | 0 | 0 | 0 | 1 | 1: p" {$ b) W' r/ z4 Y* j
CCCR.MON | 0 | 0 | 1 | 1 | 0* }6 | |) @2 J
TEST.LBCK | 0 | 0 | 0 | 1 | 1
, ^$ ^4 E/ v& |3 e
CCCR.ASM | 0 | 1 | 0 | 0 | 0
z) t+ w3 P% ~) r, n
*/4 L* R# [5 c; e* c
if (hfdcan->Init.Mode == FDCAN_MODE_RESTRICTED_OPERATION)
$ x% k% X% Q+ H8 J2 c
{- w5 P1 ]! X6 q0 {
/* 使能限制操作模式 */
6 h8 x7 X9 A. Y% i$ H
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_ASM);
2 l$ \, y3 U4 v1 m& h
}
3 q$ n; m, Y7 h; J' L4 a4 I
else if (hfdcan->Init.Mode != FDCAN_MODE_NORMAL)
' I$ a8 u' M' M7 x7 K
{6 E( x+ N! U7 v5 L3 Z
if (hfdcan->Init.Mode != FDCAN_MODE_BUS_MONITORING)
, `3 H- M: c( s) I. v
{- U1 r) o1 S1 A9 ?
/* TEST寄存器写访问使能 */
1 A1 y% |5 j) m: c6 b8 d8 q2 l7 c
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TEST);0 ?" G' [) \: S1 {& B ?% z
2 {+ t+ q8 }( k6 j& i3 Y
/* 使能回环模式 */
( X7 s4 h3 q* | i0 I- D' M7 T
SET_BIT(hfdcan->Instance->TEST, FDCAN_TEST_LBCK);
8 \% H0 X9 [+ h
4 i8 {: k4 H: k3 e* ?
if (hfdcan->Init.Mode == FDCAN_MODE_INTERNAL_LOOPBACK)7 Q0 V$ ]8 ~( x" M0 K+ R
{; Q9 J; p- N5 |
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_MON);
}' m) e" U% [% W' t
}2 _3 ^; W5 }# _2 r$ a# a5 k
}# a( p' [ P/ [& L/ d4 }
else' M0 v# Q% y- K7 w) ?
{2 C- B- l* X" F: U+ Z$ B; d
/* 使能检测模式 */
7 ^; ~2 E$ l/ c
SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_MON);! G3 A3 [6 Z2 l! g$ o
}
) W0 Q$ t+ F, X6 c9 U2 M
}
6 O+ n# Q* Z1 S1 a- }. O
else( J7 W- o9 W* X' R
{* o5 K7 Y! k; z# e& l; r$ N
/* Nothing to do: normal mode */. G1 z. O2 k% T' e+ _
}
2 y) Q4 I+ I, S: O: f
4 j4 H" L. P+ c& K3 }) x" F
/* 设置nominal bit timing 寄存器 */
( o; n( z8 e) v* h* c, ?. p
hfdcan->Instance->NBTP = ((((uint32_t)hfdcan->Init.NominalSyncJumpWidth - 1U) << FDCAN_NBTP_NSJW_Pos) | \
, W* C* I. U- X4 |
(((uint32_t)hfdcan->Init.NominalTimeSeg1 - 1U) << FDCAN_NBTP_NTSEG1_Pos) | \6 n3 ]6 @. q% c, d: F
(((uint32_t)hfdcan->Init.NominalTimeSeg2 - 1U) << FDCAN_NBTP_NTSEG2_Pos) | \
+ |) w* W4 g% [- m8 Z0 _
(((uint32_t)hfdcan->Init.NominalPrescaler - 1U) << FDCAN_NBTP_NBRP_Pos));
$ P) j$ N+ d1 \: y3 l$ \( W9 W
* Z/ F4 R% V1 q. R. T: y7 V
/* 如果使能BRS（BitRate Switching可变波特率），设置data bit timing 寄存器*/
& @7 _- e6 T E- B2 D
if (hfdcan->Init.FrameFormat == FDCAN_FRAME_FD_BRS). V% |: v% j. u/ ?4 T8 L5 N3 P
{' W( a, T* z: m
hfdcan->Instance->DBTP = ((((uint32_t)hfdcan->Init.DataSyncJumpWidth - 1U) << FDCAN_DBTP_DSJW_Pos) | \7 W6 e1 W; S8 ~, k0 g9 B) F
(((uint32_t)hfdcan->Init.DataTimeSeg1 - 1U) << FDCAN_DBTP_DTSEG1_Pos) | \
1 F$ i n$ F4 [! [
(((uint32_t)hfdcan->Init.DataTimeSeg2 - 1U) << FDCAN_DBTP_DTSEG2_Pos) | \
3 R* l. L% V k8 V
(((uint32_t)hfdcan->Init.DataPrescaler - 1U) << FDCAN_DBTP_DBRP_Pos));7 E+ H' T4 V0 r/ a1 D
}
' O# W/ F& s1 ?
& V# y( s; X' [8 n) a. k
if (hfdcan->Init.TxFifoQueueElmtsNbr > 0U)
2 Y& b# m7 s, }2 O; Y) l. J2 J# T# w
{
, ~0 w0 v$ A* R: I- P W" d
/* 设置Tx FIFO 或 Tx Queue 操作模式 */
" V$ m& |% e3 H7 N8 I) Z
SET_BIT(hfdcan->Instance->TXBC, hfdcan->Init.TxFifoQueueMode);6 T1 u7 e: t6 e% D# x' t( ?) z
}
2 @1 c6 p- A7 ~
$ |9 e- I5 J9 Z0 H% x4 _9 b
/* 配置Tx element 大小 */
0 C- ]" F& v& C+ F6 _ x4 U! A
if ((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr) > 0U)
/ v& v+ C: p. n3 @. x
{
. E5 }, i. g# I K3 E9 ~- f% |
MODIFY_REG(hfdcan->Instance->TXESC, FDCAN_TXESC_TBDS, CvtEltSize[hfdcan->Init.TxElmtSize]);
% x' J$ C" F0 j( u" ^( b
}
4 Z5 A1 c8 \+ F% u3 h$ I
0 R. y* G0 T2 `
/* 配置Rx FIFO 0 大小 */2 y p1 Y f2 q/ U5 Q3 S
if (hfdcan->Init.RxFifo0ElmtsNbr > 0U)1 v' K+ ^8 D/ {( j& C! b
{
2 u+ @+ z& I' `, Z5 f/ R
MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_F0DS, (CvtEltSize[hfdcan->Init.RxFifo0ElmtSize] << FDCAN_RXESC_F0DS_Pos));/ |) {; y9 ]8 W3 {+ m
}
2 o+ u' k" x: t6 J
& o7 K _. D; g7 } C- H
/* 配置Rx FIFO 1大小 */1 t% O9 ~. a; q: f' }' s
if (hfdcan->Init.RxFifo1ElmtsNbr > 0U)3 [+ X4 r1 Z6 ^" A
{! E4 y1 l0 P/ H8 w8 W
MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_F1DS, (CvtEltSize[hfdcan->Init.RxFifo1ElmtSize] << FDCAN_RXESC_F1DS_Pos));9 q' s( J! `" j( X" n% y
}
, m* z# h @9 S* h- i1 B
4 I$ u: J4 l- G; D% S# @
/* 配置 Rx buffer element 大小 */
: B: o9 t4 \% w+ f
if (hfdcan->Init.RxBuffersNbr > 0U); Y* D0 z! R4 ^. S4 w# v) S6 x
{
3 X; s8 F- v5 @% }2 i/ g0 J) ?
MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_RBDS, (CvtEltSize[hfdcan->Init.RxBufferSize] << FDCAN_RXESC_RBDS_Pos));
# z Q2 T! [$ \7 G5 V8 \6 a
}2 ~4 V; R6 k. y* b0 i
O( q% \3 m k* i
/* 默认是的事件触发模式，如果使用时间触发模式，用户需要在HAL_FDCAN_Init
8 ^4 O; Y! W1 h* N8 | Y5 z: g
后调用HAL_FDCAN_TT_ConfigOperation */! T0 o# j: ^! t
if (hfdcan->Instance == FDCAN1)8 L# g) e. ~- |% j [' u# L6 e
{: M: C* ]: i, b/ Z4 f! c2 h
CLEAR_BIT(hfdcan->ttcan->TTOCF, FDCAN_TTOCF_OM);8 c8 {9 K4 k) u& e9 ]3 [+ j& g
}* u) b% ~) M. u1 U3 \# t
' s$ V% I9 X: ]7 B4 O: f
/* 初始化Tx FIFO/Queue */5 S8 W* D- i4 N5 w) C9 [
hfdcan->LatestTxFifoQRequest = 0U;
, x0 W) _2 y7 y7 p; A5 A
% \6 A* Q' R( x
/* 初始化错误码 */
. G4 O* K' b5 T" v1 A$ z$ {
hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;/ q' G; F9 R1 H$ s b; I! Y
6 T) T2 X2 X6 n/ {# v+ |
/* 初始化FDCAN状态 */* }& R9 ^( g: z1 S* u [6 m3 A
hfdcan->State = HAL_FDCAN_STATE_READY;9 U- T/ p: L: }- ~! `, m2 g) h, L0 e
8 o( U m9 j, V- | g% I
/* 计算每个RAM块地址 */8 M( b& o+ {$ v% Z
status = FDCAN_CalcultateRamBlockAddresses(hfdcan);
) j; J' I1 o$ M0 _4 a
1 a2 g! n' y7 _& X# R0 g
/* 返回函数状态 */
) E8 f: H# Q F; d( K
return status;
2 Z* ^; g% o( [+ K! h; ?; S0 i
}

复制代码

函数描述：

此函数用于初始化FDCAN。

函数参数：

  第1个参数是FDCAN_HandleTypeDef类型结构体指针变量，用于配置要初始化的参数。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
注意事项：

函数HAL_FDCAN_MspInit用于初始化FDCAN的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的，允许用户在工程其它源文件里面重新实现此函数。当然，不限制一定要在此函数里面实现，也可以像早期的标准库那样，用户自己初始化即可，更灵活些。
如果形参hfdcan的结构体成员State没有做初始状态，这个地方就是个坑。特别是用户搞了一个局部变量FDCAN_HandleTypeDef FdCANHandle。
对于局部变量来说，这个参数就是一个随机值，如果是全局变量还好，一般MDK和IAR都会将全部变量初始化为0，而恰好这个 HAL_FDCAN_STATE_RESET  = 0x00U。

解决办法有三

方法1：用户自己初始化FDCAN和涉及到的GPIO等。

方法2：定义FDCAN_HandleTypeDef FdCANHandle为全局变量。

方法3：下面的方法

if(HAL_FDCAN_DeInit(&FdCANHandle) != HAL_OK)
- f" F( O. l. Y5 T* f5 Z* y
{
9 ?& P$ I8 l; t% k& b \: i
Error_Handler();6 P+ t, i1 i; G2 G
}
0 w2 l, V5 y# \/ J
if(HAL_FDCAN_Init(&FdCANHandle) != HAL_OK)- J5 n& c" p0 x% P; B' x
{
& X+ m3 B2 K- W: M- Z
Error_Handler();
8 W" O! W7 q" _" R7 z) i7 D: O
}

复制代码

使用举例：

FDCAN_HandleTypeDef hfdcan1;) F$ R9 `9 j6 W2 D) L' T
- F+ S+ l3 R- |/ m
/*4 J' r$ W' v( u4 l% s: D4 B
*********************************************************************************************************
4 ? b- |! H$ j" C8 g% L0 F
* 函数名: bsp_InitCan1% {& B- D$ ` s1 n% H% |6 }
* 功能说明: 初始CAN1
6 g" Z7 Z' V8 V; t& z
* 形参: 无3 G( q% t: E8 |% c. W' A1 n: b
* 返回值: 无# |% ^4 ?$ K8 k5 y# d
*********************************************************************************************************& a% n4 Y# Q1 g$ \3 Y
*/6 w& e- ^6 X5 o( N. x, C: T: F
void bsp_InitCan1(void)$ @; b4 J- ]! p: R7 K
{ / w) I# G" T( W
/* 位时间特性配置7 V4 i4 B" x4 i, j# `. H
Bit time parameter | Nominal | Data; d% X1 o. t7 H8 Z" @
---------------------------|--------------|----------------
6 ~; K% S/ q9 Z" y2 W9 M" O6 b$ s i
fdcan_ker_ck | 20 MHz | 20 MHz1 r0 I! @# U H$ f$ S6 T3 M
Time_quantum (tq) | 50 ns | 50 ns4 k* b( ^ l. d. }8 i+ ^+ Z
Synchronization_segment | 1 tq | 1 tq
9 P* J1 y- y6 Z; i
Propagation_segment | 23 tq | 1 tq
" b$ z2 m8 X4 |
Phase_segment_1 | 8 tq | 4 tq9 n" |2 N& M5 I' X
Phase_segment_2 | 8 tq | 4 tq
" m' ~" K1 O7 X$ Z u1 p
Synchronization_Jump_width | 8 tq | 4 tq! t, U7 q$ J7 z" H- x$ l
Bit_length | 40 tq = 2us | 10 tq = 0.5us: N5 A- O, c2 A8 X& S
Bit_rate | 0.5 MBit/s | 2 MBit/s2 P2 A ^0 [! @0 B2 d5 {$ |" Z
*/( N ], C# F+ E o2 R. X
hfdcan1.Instance = FDCAN1; /* 配置FDCAN1 */
3 U j. S# l ^: w! c. B
hfdcan1.Init.FrameFormat = FDCAN_FRAME_FD_BRS; /* 配置使用FDCAN可变波特率 */ " t6 y$ V& `: k/ a
hfdcan1.Init.Mode = FDCAN_MODE_NORMAL; /* 配置使用正常模式 */
# E6 v/ r7 s4 ?3 i/ g
hfdcan1.Init.AutoRetransmission = ENABLE; /*使能自动重发 */
* J: F5 j- |! o6 ?
hfdcan1.Init.TransmitPause = DISABLE; /* 配置禁止传输暂停特性 */+ s; |" n/ g, q/ o4 U+ H% F
hfdcan1.Init.ProtocolException = ENABLE; /* 协议异常处理使能 */
3 g# j6 A6 }! U$ O6 N$ P
% e7 s6 P! c5 L) Y
/* ! Q& |- ^9 ]# J* X
配置仲裁阶段波特率
2 l7 v3 K" N; P% M
CAN时钟20MHz时，仲裁阶段的波特率就是
% z/ M" \1 p$ n: `& v! z
CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / （1+0x1F + 8） = 0.5Mbps / Z' ]8 A. k; v( P* l
% h. S. { n7 H) K
其中Sync_Seg是固定值 = 1 ， Pro_Seg + Phase_Seg1 = NominalTimeSeg1， Phase_Seg2 = NominalTimeSeg2. ]+ g- ], s! p m1 |
*/
" t% [( @' O U
/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck) */! |0 }+ S3 G* J" {. q8 L- w9 y
hfdcan1.Init.NominalPrescaler = 0x01; 0 b& \' e* f9 E$ l; H- w
- H0 ]# V* Y9 }
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大 */# D2 Q, s0 f7 a
hfdcan1.Init.NominalSyncJumpWidth = 0x08;
( B" E6 H' s! O
0 L, d5 r+ O, \6 P) L3 M+ J1 }
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1 */' [! m/ Q& C1 J3 P- H H
hfdcan1.Init.NominalTimeSeg1 = 0x1F; ! M' m6 Y- }' H2 a1 `$ W4 f9 M/ ~" h
! R7 P6 {* @5 n/ f3 G7 }: d
/* 对应位时间特性图的 Phase_Seg2 */
; r! Q( l& c1 V( @) s' u
hfdcan1.Init.NominalTimeSeg2 = 0x08;
0 o) }+ y( Q6 X! J9 `: B
" e, U% W T K5 g, D% f
1 b! V* q8 v$ D6 ?# l
/* % G- x8 ]2 {* k: ]5 W
配置数据阶段波特率 + l4 `7 I. h. E$ P) r! V
CAN时钟20MHz时，数据阶段的波特率就是 W5 K9 }% n" e5 X
CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / （1+5+ 4） = 2Mbps
" V* c0 l( X/ ~- m. \
/ C" F, ~8 ^3 H! ~+ |/ p: K( \: b+ @
其中Sync_Seg是固定值 = 1 ， Pro_Seg + Phase_Seg1 = DataTimeSeg1， Phase_Seg2 = DataTimeSeg2
) @( M1 {1 H) i+ Z
*/# Y0 b' a. E) T" q3 U$ x
/* CAN时钟分配设置，一般设置为1即可，全部由PLL配置好，tq = NominalPrescaler x (1/ fdcan_ker_ck)，# C- a9 E" R! v* J( @
范围1-32 */
7 {, ~9 r0 O- W0 C2 f. n
hfdcan1.Init.DataPrescaler = 0x01; / o4 a2 f5 g% s
; Y# e1 K: m: c; W+ j, @% u8 l; Q
/* 用于动态调节 Phase_Seg1和 Phase_Seg1，所以不可以比Phase_Seg1和 Phase_Seg1大，范围1-16 */2 r, Y. z) t1 K) ?% Z2 h
hfdcan1.Init.DataSyncJumpWidth = 0x04;
1 M% W3 b7 y( G0 }8 N7 o
/ u0 Y9 |+ L& o, A
/* 特别注意这里的Seg1，这里是两个参数之和，对应位时间特性图的 Pro_Seg + Phase_Seg1，范围 */1 b6 _. k# i! P& A7 H" B7 |4 ]& h
hfdcan1.Init.DataTimeSeg1 = 0x05; + T3 M- p; P% V2 I6 T A
' H: ?/ O: g7 W
/* 对应位时间特性图的 Phase_Seg2 */ ! G7 R3 ~9 o: y" M
hfdcan1.Init.DataTimeSeg2 = 0x04;
6 v) y" ?! l$ R- Z$ Y
# X) J F( A( w% N* `2 b/ O% l7 q
* e+ c3 c( a" e, M
hfdcan1.Init.MessageRAMOffset = 0; /* CAN1和CAN2共享2560个字, 这里CAN1分配前1280字 */) o0 z3 e6 s0 i; W, e9 d
{, ~2 Q" v# s. K0 ~+ a$ k
* h9 ~8 h* T# e' l. n5 {+ ^
hfdcan1.Init.StdFiltersNbr = 1; /* 设置标准ID过滤器个数，范围0-128 */
3 j7 U! Z5 S4 A4 x- K5 e* W' k s
hfdcan1.Init.ExtFiltersNbr = 0; /* 设置扩展ID过滤器个数，范围0-64 */ 9 |7 ?+ y2 G. L! d7 V! d( n6 @
hfdcan1.Init.RxFifo0ElmtsNbr = 2; /* 设置Rx FIFO0的元素个数，范围0-64 */ ( x) a* u; M/ k
/* 设置Rx FIFO0中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */
0 v6 E/ Q, ?9 z
hfdcan1.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8; $ v5 {8 r& X ~) o) v# O( F
hfdcan1.Init.RxFifo1ElmtsNbr = 0; /* 设置Rx FIFO1的元素个数，范围0-64 */
+ z' G3 F0 d4 N u& l
; T; c4 l: x: a% W
/* 设置Rx FIFO1中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */
* B% F+ @, k5 w6 L0 p/ h. c$ ~
hfdcan1.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
/ Y2 w3 o/ ~2 V& D
hfdcan1.Init.RxBuffersNbr = 0; /* 设置Rx Buffer个数，范围0-64 */
3 k1 w1 q8 c6 V8 B$ x I
( z3 }% P; q B/ v
/* 设置Rx Buffer中每个元素大小，支持8,12,16,20,24,32,48或者64字节 */4 {: |; s7 h7 M l
hfdcan1.Init.RxBufferSize = 0;
% ~5 G7 y. ^6 Q3 T
}! n% @% ~* K+ X3 q3 |! w/ T
hfdcan1.Init.TxEventsNbr = 0; /* 设置Tx Event FIFO中元素个数，范围0-32 */ . f! ^! ~! D+ r. x" c5 x0 t/ r4 U
hfdcan1.Init.TxBuffersNbr = 0; /* 设置Tx Buffer中元素个数，范围0-32 */
4 ^2 H; r- P6 {0 J' \. }- `9 X1 f
hfdcan1.Init.TxFifoQueueElmtsNbr = 2; /* 设置用于Tx FIFO/Queue的Tx Buffers个数。范围0到32 */
* S! f/ _6 {$ z' X1 i
hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; /* 设置FIFO模式或者QUEUE队列模式 */
- p# F7 ]9 E$ S5 i. G$ R2 d
7 l: {8 j9 L( H/ A
/* 设置Tx Element中的数据域大小，支持8,12,16,20,24,32,48或者64字节 */
p* G' b% Q/ @8 \" i3 d0 Y9 h
hfdcan1.Init.TxElmtSize = FDCAN_DATA_BYTES_8; ' `) g$ G* A) N; _! P
HAL_FDCAN_Init(&hfdcan1);
+ M' R \7 ~( |' s3 F! a: V: U
% x5 ^- Q3 J3 ?1 H& `6 H
1 t4 S* w8 {1 e ~ w( r
//省略未写' M' G+ p! R7 B% H' I! j- J
4 L8 q1 Y3 u* A1 L
}

复制代码

91.4.2 函数HAL_FDCAN_DeInit
函数原型：

HAL_StatusTypeDef HAL_FDCAN_DeInit(FDCAN_HandleTypeDef *hfdcan)
1 u+ n& I1 e6 K2 u( g: t
{2 X4 H. Y# d4 C$ V& p# a
/* 检测句柄 */
# X" {+ l ?" F+ `4 N) u* G
if (hfdcan == NULL)- s. r0 G$ H# i+ k- Y5 v
{
8 P3 L7 s# B4 \; M
return HAL_ERROR;
. I1 e5 j$ k( ~6 W; r
}" I C: n# N& U
0 X; s3 V7 s( [
/* 检查函数形参 */
% c6 G1 C' [% p6 k( l6 L* g0 I
assert_param(IS_FDCAN_ALL_INSTANCE(hfdcan->Instance));
4 N% V4 H( m% ?: q# e
- n; K) i' }. S7 V! e
/* 停止FDCAN */3 d3 R, H+ q3 W% A, N2 a
(void)HAL_FDCAN_Stop(hfdcan);0 j' i" g8 ^. L/ I+ V5 U
% K. @0 e/ c' z8 j! w- q. I/ N
/* 禁止中断 */
0 o# D$ s/ o0 _: Q8 q
CLEAR_BIT(hfdcan->Instance->ILE, (FDCAN_INTERRUPT_LINE0 | FDCAN_INTERRUPT_LINE1));
6 Y4 I" t/ r1 \. f
1 ~+ D; _6 |! a: s0 P$ ?) R+ L
#if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
0 B. [( p; N( k
if (hfdcan->MspDeInitCallback == NULL)
- M" V; t/ B& @3 _. i' I1 H
{
" Z9 ^7 n& l B7 f# A f$ ?: ~$ G
hfdcan->MspDeInitCallback = HAL_FDCAN_MspDeInit; /* Legacy weak MspDeInit */' L, ], u* \! O. ~" r3 S' V
}
: J6 r/ B9 L& G! {2 L5 j! T% [
0 Y& ^; D7 ~) V9 F/ ~, {( Q+ T
/* 复位底层硬件，如时钟，NVIC等 */
( N- Z0 s. \# G2 B9 v0 f
hfdcan->MspDeInitCallback(hfdcan);% w- C( U: P7 c: s# j; P1 M! _! g
#else
) p y3 {! ^5 w# `7 ]
/* 复位底层硬件，如时钟，NVIC等 */
) ^& }+ m6 K* K2 _1 K J9 I
HAL_FDCAN_MspDeInit(hfdcan);
$ [3 ^1 R6 q; m P8 {2 H P( t/ D
#endif
6 T* D; R7 P3 N& {; M- u1 j; g* _
5 `. G+ S/ P/ y$ Z; ^2 C: ]
/* 复位错误码 */
4 [* ~- y& O' u3 v7 \3 Y& S8 y, L
hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;
2 u+ j5 e$ Y9 g' x2 K# L5 I) z
( V9 P9 j! h* b7 ?
/* 设置FDCAN状态 */
5 p9 e2 N% c, p8 t
hfdcan->State = HAL_FDCAN_STATE_RESET;0 R2 z$ |2 x- C0 c
* `( ~ b7 B3 T/ s/ ^( M/ [! {
/* 返回HAL_OK */, z& ^% x4 X5 S3 b1 A# w
return HAL_OK;: B6 O) B0 r, f1 [: {, m
}

复制代码

函数描述：

用于复位FDCAN。

函数参数：

第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
91.4.3 函数HAL_FDCAN_ConfigFilter
函数原型：

HAL_StatusTypeDef HAL_FDCAN_ConfigFilter(FDCAN_HandleTypeDef *hfdcan, FDCAN_FilterTypeDef *sFilterConfig) J6 N7 G. e- ]$ E9 e
{
; l3 J, x2 i' t* ]( s& @/ ~! J) @
uint32_t FilterElementW1;
9 p w8 @- x: Z, p1 I6 Z
uint32_t FilterElementW2;6 o4 h* h5 @9 N, H+ d6 S
uint32_t *FilterAddress; m+ j4 I4 m& i* f! ~+ v' O
HAL_FDCAN_StateTypeDef state = hfdcan->State;
, a( x |+ O$ V9 ^
) t9 K2 c3 C4 r% d! ? s
if ((state == HAL_FDCAN_STATE_READY) || (state == HAL_FDCAN_STATE_BUSY))
' x0 m$ C) t/ b; D! o: W
{
7 R+ x7 f# z- T' i
/* 检测函数参数 */
4 [' \7 J7 t m# C/ W# n2 q u: b
assert_param(IS_FDCAN_ID_TYPE(sFilterConfig->IdType));$ A3 l9 c6 W2 I
assert_param(IS_FDCAN_FILTER_CFG(sFilterConfig->FilterConfig));
: z2 w3 i$ i) v7 G
if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)$ H5 K* L9 h2 ^/ c4 ?" b# i% j
{" G) f! A( B3 ?0 k( n
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->RxBufferIndex, 63U));
3 O2 G8 R+ ^! H) M
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->IsCalibrationMsg, 1U));) V( I& S! h) c, I. J# Q
}5 m2 l+ D9 N) \
1 y$ @2 L8 z2 ]' K/ S
/* 标准ID */4 T& a0 O/ l/ @- m6 e5 @! H/ g6 q( ~& Q
if (sFilterConfig->IdType == FDCAN_STANDARD_ID)
: H6 \- i2 V5 j0 H% t6 v* ^
{
, v* `6 \. Z5 {8 W# t- V
/* 检测函数形参 */
2 o+ w4 u* [; ~/ b, A: i
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterIndex, (hfdcan->Init.StdFiltersNbr - 1U)));1 S: S6 Q& F6 j
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID1, 0x7FFU));9 O# i" B' U! W" B
if (sFilterConfig->FilterConfig != FDCAN_FILTER_TO_RXBUFFER)) @" A+ { w7 N3 y$ s
{
9 }& m; ]" }) p2 H# |" b" a
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID2, 0x7FFU));
3 j1 d$ E5 }* S) }1 c' N% ?# J, e
assert_param(IS_FDCAN_STD_FILTER_TYPE(sFilterConfig->FilterType));; U+ v: [9 n" H$ N8 `. Y4 B* e
}7 H; @* F+ q1 J& R; t9 V
& y6 X8 f9 _! {1 O" J
/* 构建过滤元素 */
3 ]% L2 k; h* E O8 g
if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)
5 i/ D8 p( q: v
{3 v: F' l' Y% G4 _: ?6 _
FilterElementW1 = ((FDCAN_FILTER_TO_RXBUFFER << 27U) |
/ y$ s+ Q Z& b# q0 A
(sFilterConfig->FilterID1 << 16U) |8 q0 B0 J# N' L% u: e% _' `
(sFilterConfig->IsCalibrationMsg << 8U) |! B9 n1 M" x" U4 `
sFilterConfig->RxBufferIndex);
9 m" I# y- Y3 J! i
}6 V+ T3 w7 U. W. b8 T
else$ R* C u; ]3 `1 u2 ]* i8 G1 x
{$ i3 x& ^$ C# h9 S, y
FilterElementW1 = ((sFilterConfig->FilterType << 30U) |
1 }* R2 b. h0 e' c+ m S$ U/ T
(sFilterConfig->FilterConfig << 27U) |& n& f$ n; Y& p
(sFilterConfig->FilterID1 << 16U) |0 g% p% ~) U" g* M7 L. f* J
sFilterConfig->FilterID2);
; @7 i6 |) e. V b& i+ M
}/ j. f& z. Z# G( B. k
/ k+ t; y- H6 @7 Q6 u5 r
/* 计算过滤地址 */6 x$ B6 l( Y( l" H* n
FilterAddress = (uint32_t *)(hfdcan->msgRam.StandardFilterSA + (sFilterConfig->FilterIndex * 4U));2 M: [" _! I3 h' h/ d- e) U0 ~& t' K1 f
3 ?+ S3 L* K5 r! n- q0 ], O6 ^
/* 将过滤元素写到消息RAM中 */
! G% K* j N" Z1 Y
*FilterAddress = FilterElementW1;
! ~# h" r2 Y' ~. g6 ^$ J
}) ~5 W2 b4 c' e: U/ T" ?
/* 扩展ID */
3 {8 H/ J3 `) _7 x6 C2 |
else / }/ r6 V1 F4 ?" Z0 q- E* U" J
{
: x* {6 s X5 K# U) @9 D' @0 O
/* 检测函数参数 */* y9 W4 w3 P6 @+ T9 e8 S5 ~9 p
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterIndex, (hfdcan->Init.ExtFiltersNbr - 1U)));
+ Y/ v' Z0 G- q6 m
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID1, 0x1FFFFFFFU));1 U+ J# e9 d; _
if (sFilterConfig->FilterConfig != FDCAN_FILTER_TO_RXBUFFER)' M$ R1 c ^, L) d) A1 G4 ^. L
{9 k3 P' ?9 X/ d8 M+ e/ g& n6 a
assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID2, 0x1FFFFFFFU));' T3 o* n4 `$ B H7 Z. ?
assert_param(IS_FDCAN_EXT_FILTER_TYPE(sFilterConfig->FilterType));* q8 h5 `( c% K! r$ R; U1 m
}9 Q( m$ |( X' R& l3 E! q
% z, `1 x3 {% [9 Y5 y
/* 构建第1个word的过滤元素 */, A# h) m; t0 b& u
FilterElementW1 = ((sFilterConfig->FilterConfig << 29U) | sFilterConfig->FilterID1);5 ^# m( z& z% T% @
! L5 c) z6 l# u8 V
/* 构建第2个word的过滤元素 */
; V# m: V* y0 s* |. b# ~
if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)
9 O, }; `/ }! j" S3 e- e [0 o9 L
{- I- A4 {) l' J/ o X
FilterElementW2 = sFilterConfig->RxBufferIndex;
% i _" A' U% D% F: Q
}1 ~8 l$ X" o7 g) T; f* T3 ?/ z! f$ Q
else. i. U/ \& V) O
{7 J/ u6 \- W0 W4 x+ Y5 v; [
FilterElementW2 = ((sFilterConfig->FilterType << 30U) | sFilterConfig->FilterID2);1 E0 O+ p6 S" v( A1 F- V" y% E
} h% O, L, e" k7 z$ Z1 j2 c& o
) l G) B( Y: e) X: a7 G/ x
/* 计算过滤地址 */+ U z# x$ z+ z9 w* Q
FilterAddress = (uint32_t *)(hfdcan->msgRam.ExtendedFilterSA + (sFilterConfig->FilterIndex * 4U * 2U));
6 c+ p8 k' Q8 A' z& x
2 G) V: t1 F$ e9 c, q
/* 写过滤元素到消息RAM */
8 V0 {6 V m( _1 A
*FilterAddress = FilterElementW1;6 D# @3 w. p Y4 @+ K4 E! c, F0 n. ^
FilterAddress++;
# e% w9 A+ R0 E
*FilterAddress = FilterElementW2;4 ? z, n0 ^) x* ^& x! a
}% |5 \6 I; A/ P1 v2 T1 M
* e1 K- m7 I* X9 y$ }9 @' \
return HAL_OK;
; S9 K0 I. c3 I
}4 X4 |! F& y! ^' C
else
/ ?# p3 h) w6 y2 W( A# j# d/ H
{
u% w$ A# V; u* w0 n5 y& V
/* 更新错误码e */
1 O: _4 q1 V+ g) T0 K, {9 s
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_INITIALIZED;3 z6 t) n( |! ?7 `
2 ]: V; l3 I/ h! K1 |
return HAL_ERROR;
% j' m) a6 r U
}; a& b, C# \" H, [
}

复制代码

函数描述：

此函数主要用于设置FDCAN过滤。

函数参数：

  第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
  第2个参数是FDCAN_FilterTypeDef类型结构体变量，主要用于过滤参数配置。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

FDCAN_HandleTypeDef hfdcan1;7 K1 m+ ?7 |2 [9 D
) F% w0 P$ ~7 Q* ~' S& j7 k# @
/*% t; _% J1 h9 ?9 m
*********************************************************************************************************/ N" ^) e, {5 ?/ }$ c" d
* 函数名: bsp_InitCan1) i' t1 R' @: f# ~* P0 y, C' W
* 功能说明: 初始CAN1
0 r2 I1 b. L/ _" n& K# M' S& ~* V& @, v
* 形参: 无
& l$ ^: G, l! _8 h/ V4 |
* 返回值: 无. ?* C9 m- s' M8 q0 k& W, {2 v" Q+ ]
********************************************************************************************************** i* X, i6 {$ A/ C/ A
*/" O) q7 P; K/ |4 z6 v! L
void bsp_InitCan1(void)' S9 d5 }. |% h8 K# U1 a
{ 1 d' I! d1 w4 J* n: N3 t9 m# i
: g3 s [8 v# |: d1 m
/*
* O0 i w. R( k' ~" r5 r
配置过滤器, 过滤器主要用于接收，这里采样屏蔽位模式。& ]1 [0 ^7 E1 [2 M; h3 N8 [
FilterID1 = filter' p2 W, f! g2 O1 }6 D) H
FilterID2 = mask/ k' i; o; `# l% _9 W8 E8 z6 [
8 o0 K, K) `8 ~3 j, k' \0 s
FilterID2的mask每个bit含义
e" p$ H0 {5 i% Q7 [& a9 K
0: 不关心，该位不用于比较；: J+ b$ O. q; |# X
1: 必须匹配，接收到的ID必须与滤波器对应的ID位相一致。
, h7 {/ k% h: `0 n5 |
- R/ Q: U; s$ ^' _0 J
举例说明：
6 _5 n6 C+ p U4 i- V& Q
FilterID1 = 0x1116 p( V" K4 B) p, g
FilterID2 = 0x7FF
1 @) s9 P, `+ E6 u. d7 O
表示仅接收ID为0x111的FDCAN帧。
1 J% e" H3 c! D3 {* X
* b; N0 s. H6 l- b& B
*/
4 b3 |8 w( r; i( S
sFilterConfig1.IdType = FDCAN_STANDARD_ID; /* 设置标准ID或者扩展ID */. v' f" i; W+ |: v, t* d
/* 用于过滤索引，如果是标准ID，范围0到127。如果是扩展ID，范围0到64 */
, h0 @% a- N) R, q0 J
sFilterConfig1.FilterIndex = 0;
+ v! x( ]3 H1 w. Z
sFilterConfig1.FilterType = FDCAN_FILTER_MASK; /* 过滤器采样屏蔽位模式 */% o+ r6 r. _6 z* R$ o
sFilterConfig1.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; /* 如果过滤匹配，将数据保存到Rx FIFO 0 */
" x% Q& K2 I% q; H
sFilterConfig1.FilterID1 = 0x111; /* 屏蔽位模式下，FilterID1是消息ID */
8 d* D, N7 M2 T' H
sFilterConfig1.FilterID2 = 0x7FF; /* 屏蔽位模式下，FilterID2是消息屏蔽位 */
1 v: q0 u: U0 f( G- s5 `8 n6 R+ t4 O0 S
HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig1); /* 配置过滤器 */
& p+ p$ E: A$ g
) N. k! s2 Z* `" _; ^! ]
}

复制代码

91.4.4 函数HAL_FDCAN_ConfigFifoWatermark
函数原型：

HAL_StatusTypeDef HAL_FDCAN_ConfigFifoWatermark(FDCAN_HandleTypeDef *hfdcan, uint32_t FIFO, uint32_t Watermark)0 c0 D0 C( z# g
{6 |" L% T- ?4 |+ n
/* 检测参数 */7 f8 C+ m u2 ^! S& \
assert_param(IS_FDCAN_FIFO_WATERMARK(FIFO));
; R, ?$ Q) F0 h0 Q- e* v7 i- s) Q
if (FIFO == FDCAN_CFG_TX_EVENT_FIFO)
5 g7 J; f( ]$ x/ S8 e6 y. h. F
{
/ W+ t/ K/ I3 e+ n
assert_param(IS_FDCAN_MAX_VALUE(Watermark, 32U));
5 K, l+ L9 q3 y3 U
}7 B: |6 q3 a( D/ i) J" J0 a1 ]
else /* (FIFO == FDCAN_CFG_RX_FIFO0) || (FIFO == FDCAN_CFG_RX_FIFO1) */
0 j, o9 i( Q" V/ x0 o2 k7 _
{
3 P0 w- ?. E5 G5 c+ n% `
assert_param(IS_FDCAN_MAX_VALUE(Watermark, 64U));
# ^2 `$ W# r+ W% X. d* J
}6 z; t' O! t: C% [9 U
* a+ J1 k6 t. n3 w
if (hfdcan->State == HAL_FDCAN_STATE_READY)
. ~' f9 j1 d5 w1 S2 D
{: c1 H! V8 X4 s2 x1 l. \5 Q1 O# i/ H, d8 n
/* 设置发送事件FIFO */0 j% ]* y! _: ]+ Q% L% u2 o# H7 t/ h
if (FIFO == FDCAN_CFG_TX_EVENT_FIFO)
0 i U% T7 O+ o+ x9 e) E
{
8 [$ @, R+ |5 i+ C8 \. Z
MODIFY_REG(hfdcan->Instance->TXEFC, FDCAN_TXEFC_EFWM, (Watermark << FDCAN_TXEFC_EFWM_Pos));
: K; M$ N( l0 c' X" [& k
}
0 B# \# @2 W8 U1 F! c2 s
/* 设置接收FIFO0 */8 v3 x" y, Z4 `* h
else if (FIFO == FDCAN_CFG_RX_FIFO0)" ^. I* A- o/ C: ^
{
9 a1 B+ `0 W9 N+ B4 v
MODIFY_REG(hfdcan->Instance->RXF0C, FDCAN_RXF0C_F0WM, (Watermark << FDCAN_RXF0C_F0WM_Pos));' W1 \% P$ A8 T! e% d2 c% I$ y' c
}3 ~- G% a' C# P# Q
/* 设置接收FIFO1 */ Z7 k! Y# v* y, {7 [& ?! f- U! r- V
else
/ a2 `! e7 e0 L+ {
{* h! C, k3 p$ W' i1 [# Z
MODIFY_REG(hfdcan->Instance->RXF1C, FDCAN_RXF1C_F1WM, (Watermark << FDCAN_RXF1C_F1WM_Pos));: L U1 {; u, @$ \* s/ d: Z. l
}
' ^1 n* N% A6 R. q! l. ^; V, }7 R
9 ^( _% V- O* v( J8 l
/* 返回状态 */
2 O2 H8 b# w/ r
return HAL_OK;
P9 x) E& z8 r% G9 F8 F" I ^
}
. Q5 j" g, ]6 V* O' o/ g
else
# B, X" S. K4 N' @8 c+ r
{
! G3 v O7 y* z. @/ B3 O1 ?
/* 更新错误码 */
! L/ t, c8 t2 h- T; l8 @
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_READY;
+ }; ^+ ]0 l0 O; c* b5 J/ _, c
- {5 Y4 G+ Q8 `; m
return HAL_ERROR;
; W5 X4 Z, [2 }+ a
}
& o- H1 u3 A0 j* N
}

复制代码

函数描述：

此函数主要用于配置FIFO Watermark

函数参数：

第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
第2个参数是FDCAN FIFO Watermark

#define FDCAN_CFG_TX_EVENT_FIFO ((uint32_t)0x00000000U) /*!< Tx event FIFO */
1 i9 B; _0 D4 l; F# n
#define FDCAN_CFG_RX_FIFO0 ((uint32_t)0x00000001U) /*!< Rx FIFO0 */
, Q; [$ }3 J+ g% n/ s' S9 c. m
#define FDCAN_CFG_RX_FIFO1 ((uint32_t)0x00000002U) /*!< Rx FIFO1 */

复制代码

第3个参数FIFO Watermark 中断位置，如果是FDCAN_CFG_TX_EVENT_FIFO，范围0到32，如果是FDCAN_CFG_RX_FIFO0 或FDCAN_CFG_RX_FIFO1，范围0到64。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

FDCAN_HandleTypeDef hfdcan1;
+ |5 A1 y! L5 E& s# }) ^% F% B
: m. |3 X3 u/ j: I3 e+ g7 {
/* 设置Rx FIFO0的wartermark为1 */
9 x9 w/ [) @! Q9 f) d4 V) `( h4 c ~
HAL_FDCAN_ConfigFifoWatermark(&hfdcan1, FDCAN_CFG_RX_FIFO0, 1);

复制代码

91.4.5 函数HAL_FDCAN_ActivateNotification
函数原型：

HAL_StatusTypeDef HAL_FDCAN_ActivateNotification(FDCAN_HandleTypeDef *hfdcan, uint32_t ActiveITs, uint32_t BufferIndexes)
! q0 l8 Z) O y, n
{9 I: o+ z" q+ T [& \$ C8 d
HAL_FDCAN_StateTypeDef state = hfdcan->State;& d/ s3 h! P: K1 W5 {1 j2 v
0 F S! d' M' W u* a5 P1 e( }
/* 检测函数形参 */
5 E K! y% t! W
assert_param(IS_FDCAN_IT(ActiveITs));4 X2 _* r! R6 I t; F
: h* s7 l6 O! W' Y
if ((state == HAL_FDCAN_STATE_READY) || (state == HAL_FDCAN_STATE_BUSY))
% c7 q' p2 V* ]7 x* ^! |3 X$ D
{
9 O$ z" D. c% G$ S1 D
/* 使能中断行 */: V- ~4 O' N( Z! ^3 F- ] h$ [4 _
if ((ActiveITs & hfdcan->Instance->ILS) == 0U)
7 V# @3 ?: D# o1 n, v. \1 ?8 e) u
{6 J: h1 _% o) ^5 N6 h9 R
/* 使能中断行0 */# E9 [* t% l9 V( p3 `5 A# T. [/ ?
SET_BIT(hfdcan->Instance->ILE, FDCAN_INTERRUPT_LINE0);
0 Q0 e' u. a) O6 I0 C) y
}
& r$ L7 z9 y) C1 O# @: q
else if ((ActiveITs & hfdcan->Instance->ILS) == ActiveITs)
- c0 X, n( E5 g
{
7 I* M8 z: N3 L0 q
/* 使能中断行1 */
( E2 R0 ~$ W* M `8 s5 h6 R
SET_BIT(hfdcan->Instance->ILE, FDCAN_INTERRUPT_LINE1);; r4 P5 v1 c: E$ Z7 _
}3 ?( e) g3 j/ F$ z5 L; b: z
else
1 G/ F0 o7 f" ?/ G3 }( B( U
{1 d9 y0 M6 A* p0 U+ s2 Z
/* 使能中断行0和中断行1 */
! U. G, B0 B$ J( ]$ U
hfdcan->Instance->ILE = (FDCAN_INTERRUPT_LINE0 | FDCAN_INTERRUPT_LINE1);7 `7 G. p5 M) m; e6 @3 J4 A
}& B, ?# [& m0 M+ u( G
3 S) ~8 Z, X, v; K
if ((ActiveITs & FDCAN_IT_TX_COMPLETE) != 0U)
# O2 r. V0 l9 ~1 Z
{
( M0 X! N. z! N4 m
/* 使能Tx Buffer Transmission 中断 */# D3 D) T, g: u8 H* A; J
SET_BIT(hfdcan->Instance->TXBTIE, BufferIndexes);/ Z& P' D e) M* l
}
2 o$ V: E$ T& @1 y- k% K8 G
- q5 |8 @: g" V3 i, F1 Q
if ((ActiveITs & FDCAN_IT_TX_ABORT_COMPLETE) != 0U)* T3 a5 q/ Q+ F. V; S
{
7 }$ B8 l) M* U7 Y( c
/* 使能 Tx Buffer Cancellation Finished 中断 */# c( [1 L" M) s( Z+ w
SET_BIT(hfdcan->Instance->TXBCIE, BufferIndexes);
, a; q3 S. {( K" Y
}" N- e& h1 K: W3 [% `9 |& s
2 f; g" a0 V2 Z9 @" T9 F2 `
/* 使能选择的中断 */+ Q' j1 O# k8 W5 t" F
__HAL_FDCAN_ENABLE_IT(hfdcan, ActiveITs);5 \+ T" V- ?( T7 @& v6 s/ _. T# D
+ d7 r6 k( A% ]7 n" h
/* 返回函数状态 */
% `+ @. z8 ~4 \6 Q3 X2 d
return HAL_OK;
6 {0 W, m" M+ Q. n% C" J, m
}; N6 [+ D- v. |' L; V" j: z( A: q
else
+ w$ B& S! x/ b4 u9 [
{4 Q; S7 J; G$ y* F7 I
/* 更新错误码 */4 p5 |: A7 ?, @ I4 B) c4 q
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_INITIALIZED;
: p* r; B/ n9 ?% }1 E
/ k( S6 {$ {3 r9 k
return HAL_ERROR;, r! H. w7 l+ A, Q6 ~$ L
}
* U; p6 l6 B: L. u X
}

复制代码

函数描述：

此函数主要用于使能中断。

函数参数：

第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
第2个参数用于设置要使能的中断，支持的参数如下：

#define FDCAN_IT_TX_COMPLETE FDCAN_IE_TCE /*!< Transmission Completed
u8 u$ i1 p; Z$ G" y$ K- ^. p5 e! b
#define FDCAN_IT_TX_ABORT_COMPLETE FDCAN_IE_TCFE /*!< Transmission Cancellation Finished */
; Z2 s3 I( ?3 y3 g
#define FDCAN_IT_TX_FIFO_EMPTY FDCAN_IE_TFEE /*!< Tx FIFO Empty
- b5 p- U/ J2 r x& z; o
#define FDCAN_IT_RX_HIGH_PRIORITY_MSG FDCAN_IE_HPME /*!< High priority message received */, g/ u7 ^ ^% f
#define FDCAN_IT_RX_BUFFER_NEW_MESSAGE FDCAN_IE_DRXE /*!< At least one received message stored into a Rx Buffer 0 Y6 H7 I/ y! E$ B+ G
#define FDCAN_IT_TIMESTAMP_WRAPAROUND FDCAN_IE_TSWE /*!< Timestamp counter wrapped around */9 m. c8 { M) K8 O1 J& @3 f+ O# p* G2 k
#define FDCAN_IT_TIMEOUT_OCCURRED FDCAN_IE_TOOE /*!< Timeout reached */
! i6 @: d5 L& _6 E
5 C. o, [% q" w! J/ n9 @
#define FDCAN_IT_CALIB_STATE_CHANGED (FDCANCCU_IE_CSCE << 30) /*!< Clock calibration state changed */
# |, L5 C. ^0 c$ R0 f) x
#define FDCAN_IT_CALIB_WATCHDOG_EVENT (FDCANCCU_IE_CWEE << 30) /*!< Clock calibration watchdog event occurred
1 B, d ]; [5 R0 z" Z- t8 S$ A. j
#define FDCAN_IT_TX_EVT_FIFO_ELT_LOST FDCAN_IE_TEFLE /*!< Tx Event FIFO element lost */8 j2 v% A8 J3 M* Y) b
#define FDCAN_IT_TX_EVT_FIFO_FULL FDCAN_IE_TEFFE /*!< Tx Event FIFO full */ R& y: s j* N! P+ J( L
#define FDCAN_IT_TX_EVT_FIFO_WATERMARK FDCAN_IE_TEFWE /*!< Tx Event FIFO fill level reached watermark */
" E3 t2 L- H, v
#define FDCAN_IT_TX_EVT_FIFO_NEW_DATA FDCAN_IE_TEFNE /*!< Tx Handler wrote Tx Event FIFO element */3 d/ m! Q7 I; W
7 l$ a" ^7 r, B" Q4 M3 F$ [
#define FDCAN_IT_RX_FIFO0_MESSAGE_LOST FDCAN_IE_RF0LE /*!< Rx FIFO 0 message lost */
4 F4 `7 o- Y6 w& j3 I, ^* y& c* Y
#define FDCAN_IT_RX_FIFO0_FULL FDCAN_IE_RF0FE /*!< Rx FIFO 0 full */5 n( _. |5 Y1 K. M$ b6 T" j+ r
#define FDCAN_IT_RX_FIFO0_WATERMARK FDCAN_IE_RF0WE /*!< Rx FIFO 0 fill level reached watermark */
% x1 y' \* t/ ^+ M
#define FDCAN_IT_RX_FIFO0_NEW_MESSAGE FDCAN_IE_RF0NE /*!< New message written to Rx FIFO 0 */
2 ~# ^1 f* x4 `; X6 W
% x2 w/ J0 N5 [$ x
#define FDCAN_IT_RX_FIFO1_MESSAGE_LOST FDCAN_IE_RF1LE /*!< Rx FIFO 1 message lost */
; s! `* G3 b; D7 c! A- M$ o
#define FDCAN_IT_RX_FIFO1_FULL FDCAN_IE_RF1FE /*!< Rx FIFO 1 full */
7 v4 ^* G' B( \! x7 s2 X7 G
#define FDCAN_IT_RX_FIFO1_WATERMARK FDCAN_IE_RF1WE /*!< Rx FIFO 1 fill level reached watermark */4 m/ h- a+ |3 D) |* b. \0 l$ _' {
#define FDCAN_IT_RX_FIFO1_NEW_MESSAGE FDCAN_IE_RF1NE /*!< New message written to Rx FIFO 1 */0 r3 H% L1 G9 ~/ J8 a- P
5 \0 d4 w. @( T' S! T
#define FDCAN_IT_RAM_ACCESS_FAILURE FDCAN_IE_MRAFE /*!< Message RAM access failure occurred ; E3 x5 W6 X/ ^, i2 t8 H" c
#define FDCAN_IT_ERROR_LOGGING_OVERFLOW FDCAN_IE_ELOE /*!< Overflow of FDCAN Error Logging Counter occurred - `2 _% D$ T; Z1 `+ X' z/ Q
#define FDCAN_IT_RAM_WATCHDOG FDCAN_IE_WDIE /*!< Message RAM Watchdog event due to missing READY
6 G3 c; u1 z$ j1 C1 k8 E8 `. H
#define FDCAN_IT_ARB_PROTOCOL_ERROR FDCAN_IE_PEAE /*!< Protocol error in arbitration phase detected
6 @& X+ U! B5 R# I$ Q
#define FDCAN_IT_DATA_PROTOCOL_ERROR FDCAN_IE_PEDE /*!< Protocol error in data phase detected
( F' Y7 G' D! C k4 m! O
#define FDCAN_IT_RESERVED_ADDRESS_ACCESS FDCAN_IE_ARAE /*!< Access to reserved address occurred
1 V( t2 ]) J$ }1 Z# ]' G2 M( R& q+ }
#define FDCAN_IT_ERROR_PASSIVE FDCAN_IE_EPE /*!< Error_Passive status changed */
0 ^2 z& K. {" x6 t/ C4 N% [
#define FDCAN_IT_ERROR_WARNING FDCAN_IE_EWE /*!< Error_Warning status changed */
* ~- l# J/ r8 T) N
#define FDCAN_IT_BUS_OFF FDCAN_IE_BOE /*!< Bus_Off status changed */

复制代码

第3个参数是Tx Buffer Indexes，可以如下参数的任意组合：

#define FDCAN_TX_BUFFER0 ((uint32_t)0x00000001U) /*!< Add message to Tx Buffer 0 */3 c6 u6 x8 z2 O U$ s2 L) g
#define FDCAN_TX_BUFFER1 ((uint32_t)0x00000002U) /*!< Add message to Tx Buffer 1 */" Y: S. z" m) D; Q2 K8 D- Y
#define FDCAN_TX_BUFFER2 ((uint32_t)0x00000004U) /*!< Add message to Tx Buffer 2 */9 p A8 Y$ t; e) T( k5 q+ m
#define FDCAN_TX_BUFFER3 ((uint32_t)0x00000008U) /*!< Add message to Tx Buffer 3 */
! q0 }: l) }( ~+ r9 o. ]
#define FDCAN_TX_BUFFER4 ((uint32_t)0x00000010U) /*!< Add message to Tx Buffer 4 */9 P1 E4 n; G& g8 a! C
#define FDCAN_TX_BUFFER5 ((uint32_t)0x00000020U) /*!< Add message to Tx Buffer 5 */
3 ^$ b9 `% q: J. b! b! q
#define FDCAN_TX_BUFFER6 ((uint32_t)0x00000040U) /*!< Add message to Tx Buffer 6 */
$ I: t/ d5 L& b1 H. T( |* w3 ^
#define FDCAN_TX_BUFFER7 ((uint32_t)0x00000080U) /*!< Add message to Tx Buffer 7 */2 A% h7 H5 M( u" Z
#define FDCAN_TX_BUFFER8 ((uint32_t)0x00000100U) /*!< Add message to Tx Buffer 8 */6 y# S! F( u! T/ G. v
#define FDCAN_TX_BUFFER9 ((uint32_t)0x00000200U) /*!< Add message to Tx Buffer 9 */
- l" } [" e; x) I# j ~5 W
#define FDCAN_TX_BUFFER10 ((uint32_t)0x00000400U) /*!< Add message to Tx Buffer 10 */8 l+ s: ~( S9 T2 `8 Y( a$ x9 H: v
#define FDCAN_TX_BUFFER11 ((uint32_t)0x00000800U) /*!< Add message to Tx Buffer 11 */& w& v* G( q3 O2 t9 F \' |
#define FDCAN_TX_BUFFER12 ((uint32_t)0x00001000U) /*!< Add message to Tx Buffer 12 */
W5 t; u9 ~' A# l1 K3 T
#define FDCAN_TX_BUFFER13 ((uint32_t)0x00002000U) /*!< Add message to Tx Buffer 13 */
: V( ?! ^+ y# R R, N! p8 L* ^" H
#define FDCAN_TX_BUFFER14 ((uint32_t)0x00004000U) /*!< Add message to Tx Buffer 14 */
/ t4 @5 Y8 |: B* u ^8 ?" p
#define FDCAN_TX_BUFFER15 ((uint32_t)0x00008000U) /*!< Add message to Tx Buffer 15 */2 O4 g* c1 E' ~$ j. J v, \2 V
#define FDCAN_TX_BUFFER16 ((uint32_t)0x00010000U) /*!< Add message to Tx Buffer 16 */
- t' G0 ]7 O+ x, j/ ^- k9 H7 i
#define FDCAN_TX_BUFFER17 ((uint32_t)0x00020000U) /*!< Add message to Tx Buffer 17 */
. k) ]+ ~2 U6 P) e/ F4 m
#define FDCAN_TX_BUFFER18 ((uint32_t)0x00040000U) /*!< Add message to Tx Buffer 18 */
! }' N& B( J2 [6 n
#define FDCAN_TX_BUFFER19 ((uint32_t)0x00080000U) /*!< Add message to Tx Buffer 19 */
% {) G6 s6 h: S1 _
#define FDCAN_TX_BUFFER20 ((uint32_t)0x00100000U) /*!< Add message to Tx Buffer 20 */
; @3 c; s; l7 K Y, r) }( Z6 T5 `% E
#define FDCAN_TX_BUFFER21 ((uint32_t)0x00200000U) /*!< Add message to Tx Buffer 21 */
9 T. g I; }2 R( h
#define FDCAN_TX_BUFFER22 ((uint32_t)0x00400000U) /*!< Add message to Tx Buffer 22 */
2 v1 v3 `. U. `% d, c
#define FDCAN_TX_BUFFER23 ((uint32_t)0x00800000U) /*!< Add message to Tx Buffer 23 */
8 @. W8 A+ m' L* L& z
#define FDCAN_TX_BUFFER24 ((uint32_t)0x01000000U) /*!< Add message to Tx Buffer 24 */0 o1 j* Y6 w6 I0 V% H
#define FDCAN_TX_BUFFER25 ((uint32_t)0x02000000U) /*!< Add message to Tx Buffer 25 */) Z# K% l% J. N
#define FDCAN_TX_BUFFER26 ((uint32_t)0x04000000U) /*!< Add message to Tx Buffer 26 */
+ v+ f# P8 R* @: C! X% _
#define FDCAN_TX_BUFFER27 ((uint32_t)0x08000000U) /*!< Add message to Tx Buffer 27 */. i5 }2 U: F' U& A" ?( G5 } ? A
#define FDCAN_TX_BUFFER28 ((uint32_t)0x10000000U) /*!< Add message to Tx Buffer 28 */
( n: w+ r- K/ Z, k \5 n; l2 ]. t
#define FDCAN_TX_BUFFER29 ((uint32_t)0x20000000U) /*!< Add message to Tx Buffer 29 */
) u7 B1 H Y7 v: h" h _
#define FDCAN_TX_BUFFER30 ((uint32_t)0x40000000U) /*!< Add message to Tx Buffer 30 */
#define FDCAN_TX_BUFFER31 ((uint32_t)0x80000000U) /*!< Add message to Tx Buffer 31 */

复制代码

如果第2个参数不包括FDCAN_IT_TX_COMPLETE或FDCAN_IT_TX_ABORT_COMPLETE，此参数将被忽略。

返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

FDCAN_HandleTypeDef hfdcan1;

/* 激活RX FIFO0的watermark通知中断，位开启Tx Buffer中断*/
HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_RX_FIFO0_WATERMARK, 0);
91.4.6 函数HAL_FDCAN_Start
函数原型：

HAL_StatusTypeDef HAL_FDCAN_Start(FDCAN_HandleTypeDef *hfdcan)
* B" m7 y: j* o5 o, [( _3 w
{7 U/ E" l$ l- r% F3 @8 L
if (hfdcan->State == HAL_FDCAN_STATE_READY)
$ s5 @# E+ P8 H' S8 d
{% v1 J! j2 m- S
/* 设置FDCAN外设状态 */
% b, r4 z6 C$ f% \% K- P( Q
hfdcan->State = HAL_FDCAN_STATE_BUSY;$ g0 [4 o- W3 k& _2 l" \
6 W9 t- w8 a& Q+ u, b1 U' g
/* 请求离开初始化状态 */
& ?% }6 V5 C% P1 b: |
CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_INIT);+ ?4 u7 o3 u3 c8 z# ]2 T' R2 G5 |
3 b. j3 X% g+ C0 z% |; L
/* 设置错误码 */1 ~' ^( y/ @8 h5 s# T+ v6 H
hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;
7 I( J, _! E' H5 q( W
" Q& N( k! u8 C1 p4 J
return HAL_OK;
: R9 V, |! F: E& {, ~6 Y9 F' \1 Z) `
}8 ]( f5 f3 ^2 o& M- t& ^6 `
else$ I( {7 w# Z' Y9 t
{4 @, m3 p# h3 W2 ?; u$ o$ ^# D
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_READY;
# W5 J0 J9 ~$ F! x2 G' I
5 {1 S' X3 b% e0 r3 g( A- t3 |* h, N* C
return HAL_ERROR;* w. l/ U/ }6 C# ~2 N3 b
}; o$ @; U' A/ k. U& ~
}

复制代码

函数描述：

此函数主要用于启动FDCAN。

函数参数：

第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

/**
1 M! e, u( Y: U4 r
* @brief Writes block(s) to a specified address in an SD card, in DMA mode.9 j% t+ |" J0 s D! s8 L
* @param pData: Pointer to the buffer that will contain the data to transmit
0 Q4 C+ q! Y2 n6 P
* @param WriteAddr: Address from where data is to be written
; f, \# M+ G8 E7 M7 w
* @param NumOfBlocks: Number of SD blocks to write6 q9 L" ~7 d+ T+ x
* @retval SD status
, E2 i0 c" `3 w+ d2 O4 s
*/+ H: N9 Y9 j5 v7 n1 ^
uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)
, B; \' ?& J& {: D' H( k
{
! i/ a+ i" }# N1 ~4 g
% p; ^& x' {' N5 w3 F w6 h
if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
% d i# y6 z! N( K
{
, _& }7 F% Z1 |- _) p4 t9 A: i
return MSD_OK;) ?' j2 f/ A4 a5 n" ^$ I: j2 H
}; @5 p% ]% ~: {, f0 \# b( G9 l
else0 w4 q2 L. r4 [, b
{
# m' `1 B% b! J+ X
return MSD_ERROR;' l9 H0 J, L. @8 C
}
+ G0 g& ~6 ?( d8 c& V4 f; V
}

复制代码

91.4.7 函数HAL_FDCAN_AddMessageToTxFifoQ
函数原型：

HAL_StatusTypeDef HAL_FDCAN_AddMessageToTxFifoQ(FDCAN_HandleTypeDef *hfdcan, FDCAN_TxHeaderTypeDef *pTxHeader, uint8_t *pTxData)
9 m$ b3 C! \& } y) b: c
{
7 f! ^9 d, {. C/ r( {" t2 `
uint32_t PutIndex;' ]% e" x, Q3 |" B* P4 `8 W/ o- I! ]8 }
/ B$ r( P1 S% L0 Z/ K% r
/* 检查函数形参 */' D, M4 b3 u5 \3 E% ~
assert_param(IS_FDCAN_ID_TYPE(pTxHeader->IdType));
( Z# P3 @" U! G. l% Q6 Q
if (pTxHeader->IdType == FDCAN_STANDARD_ID) j) ^) z. ? p A5 B) _3 N
{* B1 [6 v3 o$ n, \
assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->Identifier, 0x7FFU));
( s$ X3 F: ]5 I% g/ S( i' z
}; C1 V) c& i* i- w2 K: g; `
else /* pTxHeader->IdType == FDCAN_EXTENDED_ID */# b0 B6 |$ Z* o% J2 f
{
/ ]6 p% A( S! m: Q! H& [* h
assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->Identifier, 0x1FFFFFFFU));, q2 g( \1 x: N
}7 q5 |+ T" Z8 v1 i3 M! y
assert_param(IS_FDCAN_FRAME_TYPE(pTxHeader->TxFrameType));7 C! _0 R" U- A- u2 ~
assert_param(IS_FDCAN_DLC(pTxHeader->DataLength));/ a4 u# ~$ v* c6 J4 H3 D+ K5 C. E
assert_param(IS_FDCAN_ESI(pTxHeader->ErrorStateIndicator));
# s9 @# n* T4 r( q: V
assert_param(IS_FDCAN_BRS(pTxHeader->BitRateSwitch));
3 t8 l- J: R1 U3 s* m
assert_param(IS_FDCAN_FDF(pTxHeader->FDFormat));, Y6 `+ k1 u% N+ x
assert_param(IS_FDCAN_EFC(pTxHeader->TxEventFifoControl));% L9 W$ \8 H7 r' _( X
assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->MessageMarker, 0xFFU));
5 [0 g# W- L2 w# T- \. D# s
( u5 c& w' O! C9 f
if (hfdcan->State == HAL_FDCAN_STATE_BUSY): b7 }2 j1 ]- U
{! U: t/ l* p6 ^1 `" R1 W( H/ K, t7 j
/* 检测Tx FIFO/Queue 是否在RAM中分配到空间 */
l& M4 [+ _$ P% w; W& C% T
if ((hfdcan->Instance->TXBC & FDCAN_TXBC_TFQS) == 0U)
2 j9 F- A7 e, }" e; E
{, m4 j& X5 g2 L
/* 更新错误码 */2 n+ W5 Z, a) ?6 D* e, @
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
( I1 b0 ^' X2 }, y2 p
" J" r( M' T/ I
return HAL_ERROR;
, u7 r/ d7 d3 P" ]
}
& k! C2 ]9 S) r) ~/ G
2 |4 ~0 d) u# t# w/ \: [
/* 检查Tx FIFO/Queue 是否满 */' R6 G. q, s x3 y4 c2 q9 S
if ((hfdcan->Instance->TXFQS & FDCAN_TXFQS_TFQF) != 0U)
k! u3 W5 H% v! _8 e4 e. p+ t! r! e
{6 S/ Q/ `: s4 j# s9 @6 V
/* 更新错误码 */
( \8 w3 ^: H) C! U) D! T2 t1 \
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_FULL;3 I5 F" H2 S a8 c
/ E7 H H' z+ C% ?; {6 x
return HAL_ERROR;4 e4 ~& P& _) x0 D1 s& i6 m
}. x. K3 _. A _! a, ^- Q
else
7 k$ t( L/ s# w7 p9 E
{
3 W! e( B/ F% C3 k) A% v; t
/* 获取Tx FIFO PutIndex */
7 r. y( G8 l7 _" g0 f8 R4 U# [
PutIndex = ((hfdcan->Instance->TXFQS & FDCAN_TXFQS_TFQPI) >> FDCAN_TXFQS_TFQPI_Pos);# e0 i/ ]" y6 ^0 f9 @+ d5 h9 t7 Q
, d& B1 u4 o- k4 b6 z
/* 添加消息到Tx FIFO/Queue */
1 y7 E1 |4 q- O
FDCAN_CopyMessageToRAM(hfdcan, pTxHeader, pTxData, PutIndex);: d1 H5 \! \! @# C
# D$ G* V Q8 U P0 x0 E8 [2 M
/* 激活相应的传输请求 */
3 f3 L+ E0 k5 }6 J; v) K1 N
hfdcan->Instance->TXBAR = ((uint32_t)1 << PutIndex);
4 W# F& w, E# s0 c7 Y
/ K: B9 h8 }. z1 X' d5 k/ ^
/* 存储最近的Tx FIFO/Queue Request Buffer Index */
5 f% f+ J+ Q1 n# V; g& _
hfdcan->LatestTxFifoQRequest = ((uint32_t)1 << PutIndex);
9 i Y8 d' `* m
}
4 ^% [% b( m# F% G- n: R! o
5 G- E3 Y4 f) |9 {9 U" P
/* 返回错误状态 */) R7 y$ ^% a+ b2 ^- `
return HAL_OK;
2 z) F5 t' E6 t2 r; n |2 `- y ]
}
: [5 H8 }1 [+ O" f, m* A
else
: k5 A: }" K- ]. N. d$ M8 @' P" [
{' K. n' c6 e* m4 n9 Y
/* 更新错误码 */
1 U$ d7 M3 E/ @3 W& q# r, ]
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_STARTED;
. P7 E9 @, q$ y# I
0 P; E' _$ P0 p, j4 V
return HAL_ERROR;
) R3 Q3 I6 ~! {5 o! }
}
5 }% L, B2 i0 ?6 W
}

复制代码

函数描述：

此函数用于添加消息到Tx FIFO/Queue并激活相应的传输请求。

函数参数：

  第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
  第2个参数是FDCAN_TxHeaderTypeDef类型结构体变量，用于消息发送。
  第3个参数是要发送的数据地址。程序里面会将数据复制到发送缓冲区。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

/*$ k( p- H& R- G T# \: y# C
*********************************************************************************************************
% h' x: }, c2 N) R$ i
* 函数名: can1_SendPacket
, s+ n0 t& ~. R
* 功能说明: 发送一包数据
/ z8 N1 Z7 d$ S5 p4 b
* 形参：_DataBuf 数据缓冲区
7 p0 }; P. ~. g6 w5 t5 I: x# T
* _Len 数据长度, 支持8,12,16,20,24,32,48或者64字节
9 C, o1 Y8 r- F2 y5 a6 f( ?0 [: n
* 返回值: 无& p ~2 a$ b$ P, ]5 P
*********************************************************************************************************4 _5 L1 s. V2 s
*/
4 b) p5 {" D' N0 B1 j
void can1_SendPacket(uint8_t *_DataBuf, uint8_t _Len)
( D$ u3 Q4 C$ G2 D9 R; o
{ ! e0 N ~3 k# Y$ T
FDCAN_TxHeaderTypeDef TxHeader = {0};
3 L; H7 O& ~4 |& m7 h" z, O* w
; g5 c2 L, z9 m; n/ C0 P6 z) |
/* 配置发送参数 */% s6 V9 h- Q1 _- e
TxHeader.Identifier = 0x222; /* 设置接收帧消息的ID */
. {5 P4 ]1 ?1 l: S
TxHeader.IdType = FDCAN_STANDARD_ID; /* 标准ID */
& J5 N1 H5 @; ?4 E& g
TxHeader.TxFrameType = FDCAN_DATA_FRAME; /* 数据帧 */+ A0 ?! N9 z7 s0 k x, K4 m
TxHeader.DataLength = (uint32_t)_Len << 16; /* 发送数据长度 */3 D& b, Z9 @$ H& I4 q2 r
TxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE; /* 设置错误状态指示 */4 Q0 W R, N7 @' T9 ^. I
TxHeader.BitRateSwitch = FDCAN_BRS_ON; /* 开启可变波特率 */9 P# N$ a+ r8 X. R
TxHeader.FDFormat = FDCAN_FD_CAN; /* FDCAN格式 */4 m0 j5 a2 N/ [# w
TxHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;/* 用于发送事件FIFO控制, 不存储 */! f. ]2 ]( K& _& Z- s9 q5 ?
TxHeader.MessageMarker = 0; /* 用于复制到TX EVENT FIFO的消息Maker来识别消息状态，范围0到0xFF */
- H2 y7 j0 N3 ~: e m! K7 ]
( a1 e, f9 y! B; M0 U6 H
/* 添加数据到TX FIFO */
7 r5 z' f4 ?' g7 D8 C
HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1, &TxHeader, _DataBuf);
8 J& v( A% Y: `6 b) C
}

复制代码

91.4.8 函数HAL_FDCAN_GetRxMessage
函数原型：

HAL_StatusTypeDef HAL_FDCAN_GetRxMessage(FDCAN_HandleTypeDef *hfdcan, uint32_t RxLocation, FDCAN_RxHeaderTypeDef *pRxHeader, uint8_t *pRxData)
1 {! P' @" m; G8 v* p% i
{
, v3 }" e2 ~9 D/ c: V& K8 b
uint32_t *RxAddress;, t6 J+ ~ u' q0 R0 }" w
uint8_t *pData;! ^) y* M- h0 ~4 S1 n! R2 L; S
uint32_t ByteCounter;
9 m. |0 w- v7 l; ~' ^9 ]% y$ z8 A
uint32_t GetIndex = 0;
5 M! f+ {7 E, H$ z
HAL_FDCAN_StateTypeDef state = hfdcan->State;
' J/ U/ h* T" d& m: v# S+ x( d2 V
: |+ S @( B! j$ H
if (state == HAL_FDCAN_STATE_BUSY)
6 I( b6 I+ N! R! M
{
$ h) D% m C! ^1 \7 ^* q
if (RxLocation == FDCAN_RX_FIFO0) /* Rx element分配到 Rx FIFO 0 */
* A# T8 E# c+ l6 ~! d
{
$ e3 i" c( I( S H* q
/* 检查Rx FIFO 0 分配了RAM空间 */
% S9 t/ n1 U/ w$ c) y5 A
if ((hfdcan->Instance->RXF0C & FDCAN_RXF0C_F0S) == 0U)7 d/ S& }0 J+ P0 c* D8 X% z# r7 G
{. n! I" ?- v3 K4 g
/* 更新错误码*/
0 v+ q- Q6 z6 }5 h K
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
- k! L, K6 d/ Q+ r
) ^) \% C, N. k. x' Q
return HAL_ERROR;4 M4 v9 E) ]% T( o9 i" x6 O* N' f2 m
}
+ W# g' R: P# L8 E
' B$ P& V6 i" e. Q$ ` k" A
/* 检查Rx FIFO 0 非空 */
3 m3 Q( V' n T! d: E& H! Z: T) @
if ((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0FL) == 0U)- e3 q6 ~8 G9 Q4 d
{4 A% [) s: b: ~: `: N$ @( J
/* 更新错误码*/1 {" M. I5 p/ B4 Y5 P2 }: R7 m
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_EMPTY;4 {* t4 u3 i8 P* h( x. d7 H. \) L
6 v4 O& W! i8 ?7 D- z
return HAL_ERROR;
, J" o2 R1 { a1 S. Q1 a, z
}& z; l' v; x! k' R) u4 M
else
; x8 L; x' G& {5 J9 b! |* v1 u
{
1 E, X6 p7 Z V" i( `' o
/* 检查Rx FIFO 0 满且开了覆盖模式 */8 b/ E; p9 o: |: `: |
if(((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0F) >> FDCAN_RXF0S_F0F_Pos) == 1U)
5 x9 l. {+ ~% O5 `' G1 W
{% p7 E$ L; K- v+ q$ g
if(((hfdcan->Instance->RXF0C & FDCAN_RXF0C_F0OM) >> FDCAN_RXF0C_F0OM_Pos) == FDCAN_RX_FIFO_OVERWRITE)
7 n0 Z& e0 g! T, S4 y
{
8 W o2 u8 P' ? Q" x
/* 开启了覆盖模式，丢弃第1个数据 */
0 a7 C5 [( w8 P, k6 U. C3 L
GetIndex = 1U;
, [4 Y: r% u) F. n9 R
}
" j% @! F4 t# r5 Y* l9 D# n
}
: r+ }5 j& { J. w3 f
1 f- x) ], Z" N
/* 计算Rx FIFO 0 element 索引 */+ M2 R [( ~) S8 V
GetIndex += ((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0GI) >> FDCAN_RXF0S_F0GI_Pos);
, P2 ]3 m) T N4 V [
9 R- G1 s/ J7 u
/* 计算 Rx FIFO 0 element 地址 */6 \9 l. i! d- o7 R
RxAddress = (uint32_t *)(hfdcan->msgRam.RxFIFO0SA + (GetIndex * hfdcan->Init.RxFifo0ElmtSize * 4U));
. Y# w6 K( R- E) h% M# n, ^: q* j
}- J6 }, w1 t. N& C/ ~9 ?
}
2 z, ~: Z+ K, g
else if (RxLocation == FDCAN_RX_FIFO1) /* Rx element is assigned to the Rx FIFO 1 */) z9 m) C7 s+ F
{, I! q2 N) V/ z$ n& [+ B3 O& B. _* s( l
/* 检查Rx FIFO 1 分配了RAM空间 */
& ]( D. U1 z$ M
if ((hfdcan->Instance->RXF1C & FDCAN_RXF1C_F1S) == 0U)
$ I: \6 h- r! t8 b* Z. _
{2 q# i6 [3 `" o: u/ }. V" O4 G
/* 更新错误码 */
) j3 r1 j" U( a: u, I9 t3 ?
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
, |* {5 }5 C$ ?, x9 ~9 O
% `$ g+ B; J8 z% f0 y: Z
return HAL_ERROR;
+ a+ g+ E/ V/ t+ S: Q
}* E% @+ D+ c' a* c- n/ Q6 m
) ]& c i& a& l% b/ D
/* 检查 Rx FIFO 0 非空 */
" P1 n. |8 ^2 w% l8 r5 L- O; a
if ((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1FL) == 0U)
; N" Q" d, O1 G; J Q
{
* f; ~& E# Q! i. c
/* 更新错误码 */: G6 M/ F" `6 I4 Q5 ^
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_EMPTY;3 H' g, ?. p3 l9 m2 M: N# g
5 O+ f" {4 {, e
return HAL_ERROR;
8 ^& N# k0 C" m1 B+ v4 H: P' _
}
# T; m+ ]# |* v4 t) ?
else
- q! e ?! g5 p2 W
{
. [& P! C$ A5 ?4 [, x( ]( m
/* 检查Rx FIFO 1 满且开了覆盖模式 */
2 @! |( k$ `) F3 U2 K
if(((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1F) >> FDCAN_RXF1S_F1F_Pos) == 1U)
) d0 D4 Z. t" F* w c
{
/ y6 C* J( B+ Z) b- s& n
if(((hfdcan->Instance->RXF1C & FDCAN_RXF1C_F1OM) >> FDCAN_RXF1C_F1OM_Pos) == FDCAN_RX_FIFO_OVERWRITE)6 G& u* }. g5 B+ t) ^6 D3 V5 E7 N) W
{
) [+ a7 g0 m' L2 M: \
/* 开启了覆盖模式，丢弃第1个数据 */
( O# u3 Z* r" q, I/ X
GetIndex = 1U;+ X2 J8 a* Q4 p$ j# ?, B" U1 r3 H
}
# u& R$ Z) I" n0 R2 d
}
: E" Z1 @+ [8 V' _' L* r5 N( `& S
; t1 t* P! V5 i0 C5 A1 a" e7 f
/* 计算 Rx FIFO 1 element 索引 */* B% r4 H; r( `6 U3 s8 g
GetIndex += ((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1GI) >> FDCAN_RXF1S_F1GI_Pos);
) L( N; S: M' X
$ R) K$ b e$ |4 i1 D
/* 计算 Rx FIFO 1 element 地址 */
9 P. \# q P% I6 |5 I
RxAddress = (uint32_t *)(hfdcan->msgRam.RxFIFO1SA + (GetIndex * hfdcan->Init.RxFifo1ElmtSize * 4U));
4 m7 {- i$ V) r/ f: D
}
8 t# h7 c7 f& @$ W1 _, P$ {
}
; p8 e9 p: Z y) F( \
else /* Rx element 分配了专用 Rx buffer */
% G" E& G/ f) C! {8 j/ k
{
' |+ z' M) v- |( N6 {3 U- G
/* 检查选择的buffer分配了RAM空间 */
6 W+ n u6 k: @: J9 R! Q- F' ^
if (RxLocation >= hfdcan->Init.RxBuffersNbr)' Q! i! g, l! p6 V+ x- x u
{8 Q( O2 v# _3 Y1 ?: h
/* 更新错误码 */
, g$ N$ q- e" J# b8 P: D' |
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
$ B+ i# O0 W$ k
* D6 v3 V6 [ N/ S8 J+ H
return HAL_ERROR;
) }: H0 X# i2 u' e, J, r5 I- B
}: {4 p+ Z# f t/ w/ O
else
2 u1 i) [) B: i% U& s
{ W4 D* q/ h5 q( I7 Z
/* 计算Rx buffer 地址 */
* B& w: |1 P3 p. `! \) i' O# N5 Z
RxAddress = (uint32_t *)(hfdcan->msgRam.RxBufferSA + (RxLocation * hfdcan->Init.RxBufferSize * 4U));; _( U3 `! T" Y5 P$ h7 f; J
}) ]- F# |) \6 |! P% w0 c8 O
}
& B1 q: P. {1 K: @8 [
3 s1 I- x; s8 J0 A7 X y
/* 接收IdType */6 _$ b, c/ ]) d- T9 v2 L
pRxHeader->IdType = *RxAddress & FDCAN_ELEMENT_MASK_XTD;, ?- s* n! Z+ ?( \4 b6 b1 Z T% F
! T& `# r A! O: [" ^
/* 接收Identifier */
. Y: P- q9 S* C7 s
if (pRxHeader->IdType == FDCAN_STANDARD_ID) /* Standard ID element */; d/ H2 L8 ?1 i& u# w1 M" w8 A5 E
{/ d9 T6 u2 u9 Q. P% ^
pRxHeader->Identifier = ((*RxAddress & FDCAN_ELEMENT_MASK_STDID) >> 18);
; L* |0 ]: y* C* k
}! t- z* t* |5 {) C+ ^
else /* Extended ID element */
3 {) ~1 E8 t( R5 m- f4 n1 C- {
{
9 A% y: [4 ?1 U( v
pRxHeader->Identifier = (*RxAddress & FDCAN_ELEMENT_MASK_EXTID);
" `" o! q: |% V
} l0 n7 H5 M! a4 ?; F. |' C) O
- F( s6 c8 k1 O, z
/* 接收RxFrameType */
/ l* }$ h8 \3 A) M* Y0 ?; ?# @5 Y2 B
pRxHeader->RxFrameType = (*RxAddress & FDCAN_ELEMENT_MASK_RTR);
3 d5 |9 m% w% @ f, ^! L$ Q
$ B: L: l9 [, L& ~# }7 X T
/* 接收ErrorStateIndicator */
# X0 s Q. |0 f; ` z( ~0 ~% u
pRxHeader->ErrorStateIndicator = (*RxAddress & FDCAN_ELEMENT_MASK_ESI);
! r2 \! Q4 N% P$ \/ G; [- d
: P( ~; V1 S8 w6 L
/* Increment RxAddress pointer to second word of Rx FIFO element */9 E" {3 ? |4 x' k, K, D- v& N
RxAddress++;
# c* s. ]& C" Q# Z0 C8 } g2 k
% o% o& {0 Y, V& c
/* 接收RxTimestamp */
+ h1 S8 x- ^; P! ]3 o+ a: r
pRxHeader->RxTimestamp = (*RxAddress & FDCAN_ELEMENT_MASK_TS);* Y1 x5 Q: E1 Z% t8 Q8 i+ `
* m- N$ _: m- y- S! Z
/* 接收DataLength */
) {4 i2 S, M' ~1 F7 ^. w) O7 U
pRxHeader->DataLength = (*RxAddress & FDCAN_ELEMENT_MASK_DLC);
^$ y9 x( `- O" ~' {
2 o/ S8 D* A8 N8 c: ^
/* 接收BitRateSwitch */2 X3 i9 K a, I, C4 m) I* _1 f( u1 z$ H
pRxHeader->BitRateSwitch = (*RxAddress & FDCAN_ELEMENT_MASK_BRS);
5 B5 c# i+ S6 N U+ w
5 ^! w2 H# x% r6 Z7 A
/* 接收FDFormat */
; D& e$ X: ^8 }2 A# D- |7 g0 H, p- q
pRxHeader->FDFormat = (*RxAddress & FDCAN_ELEMENT_MASK_FDF);
& H' x( ^/ D9 c1 e) j0 w/ L7 R
2 u; _# d. Z8 T, A
/* 接收FilterIndex */% R* \+ T7 _0 ]4 h+ M" X( {( k6 X8 R
pRxHeader->FilterIndex = ((*RxAddress & FDCAN_ELEMENT_MASK_FIDX) >> 24);$ `/ }- l$ R" F
; I. t- `2 H" D0 d
/* 接收NonMatchingFrame */4 Y t0 b* y1 I3 H1 i
pRxHeader->IsFilterMatchingFrame = ((*RxAddress & FDCAN_ELEMENT_MASK_ANMF) >> 31);
3 u* y) z& N4 s/ m) c/ s
, J+ N* F6 Q; a7 `! {3 n7 \6 L; k& R
/* 增加地址，指向Rx FIFO element的payload */
9 ?2 @$ ^$ E7 }5 Z6 R! [2 e M
RxAddress++;
2 ?; A6 ^3 H; l+ T! v- C& A
4 c; g/ d4 a; Y" U2 {
/* 接收 Rx payload */
9 L8 d- A$ f3 o0 p0 r' E- k& \. k
pData = (uint8_t *)RxAddress;7 y2 Z7 q9 W+ b* C' v
for (ByteCounter = 0; ByteCounter < DLCtoBytes[pRxHeader->DataLength >> 16]; ByteCounter++)
4 h0 ?2 l# O0 Z0 f5 V$ n8 _$ ~
{
$ K) Z8 n. o( C
pRxData[ByteCounter] = pData[ByteCounter];
/ j6 @2 l& Z% ? L5 z
}
( u4 `. u s( K7 n: q7 H. D3 d
2 T' @9 K! U2 x K7 o/ `
if (RxLocation == FDCAN_RX_FIFO0) /* Rx element is assigned to the Rx FIFO 0 */* l; T. O5 D5 l( x
{
: N! Y4 s3 D& ^, b, l
/* 确认Rx FIFO 0先进的数据已经读出 */
6 {: X) L7 I! J1 p u; k7 f; T
hfdcan->Instance->RXF0A = GetIndex;
% }' D% J% U: a* A2 M' b5 ?
}
3 ~8 V+ \* S/ E" M- _; D
else if (RxLocation == FDCAN_RX_FIFO1) /* Rx element is assigned to the Rx FIFO 1 */+ ?* R* o% }' d
{
5 N \# I" q* Z0 j8 l, R
/* 确认Rx FIFO 1先进的数据已经读出 */0 V; W, I. ~* |8 O# K
hfdcan->Instance->RXF1A = GetIndex;
- Z' K% v- Z' v
}
" Z1 j* q% ?' X/ r R
else /* Rx element is assigned to a dedicated Rx buffer */+ l" T1 T' T, V* @/ s& g) s
{8 v( x% O2 `2 D' B6 h( y
/* 清除当前Rx buffer的新数据标志 */1 W3 U& v1 E5 @$ G
if (RxLocation < FDCAN_RX_BUFFER32)) w7 f1 P" M$ k2 s* O
{, t& W) b3 `# L1 C5 u
hfdcan->Instance->NDAT1 = ((uint32_t)1 << RxLocation);% f. l' I, W; O5 j2 o9 V; \: u0 J% F
}
: T& |! E& F, z% X
else /* FDCAN_RX_BUFFER32 <= RxLocation <= FDCAN_RX_BUFFER63 */
/ U+ Q* x5 J" K
{4 X3 _4 `( s4 K' `; N
hfdcan->Instance->NDAT2 = ((uint32_t)1 << (RxLocation & 0x1FU));
; R1 j9 M2 L: ~, W/ C: C7 M
}
, j M, @, |1 t v
}
4 y5 F* o2 ^6 i, U; ^
2 O! c* ~% ?. P! G8 S" O
/* 返回状态 */
" z! P1 v# S8 Q" n4 r
return HAL_OK;2 y. p0 U! R l/ `: \" ]8 B
}1 b, {# S. V1 |
else
& r0 ~3 Y! G( {0 u m0 m% o
{
" Y- Q" C2 |( U7 K4 j$ X
/* 更新错误码 */
! t) P; z/ e$ f
hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_STARTED;% f; q, O2 n6 w: w; V# |" [
5 J4 w( p+ m( K& E. E( o8 l1 j
return HAL_ERROR;
2 [9 z: w9 ^% R ?- q3 K( P. K
}" @4 k# G- T0 i. ]8 g5 z
}

复制代码

函数描述：

此函数主要用于获取接收到的数据。

函数参数：

第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
第2个参数是读取位置，支持如下几种参数：

#define FDCAN_RX_FIFO0 ((uint32_t)0x00000040U) /*!< Get received message from Rx FIFO 0 */
$ Y6 |) _1 i0 |1 S! k" H/ C
#define FDCAN_RX_FIFO1 ((uint32_t)0x00000041U) /*!< Get received message from Rx FIFO 1 */
( y8 ?- \7 Q- P
#define FDCAN_RX_BUFFER0 ((uint32_t)0x00000000U) /*!< Get received message from Rx Buffer 0 */. Q' d$ ?) X& I2 l; W( j) C$ J2 O
#define FDCAN_RX_BUFFER1 ((uint32_t)0x00000001U) /*!< Get received message from Rx Buffer 1 */: O0 N$ O. t r. w# a2 y. v
#define FDCAN_RX_BUFFER2 ((uint32_t)0x00000002U) /*!< Get received message from Rx Buffer 2 */+ m7 a# K _" s, z- u \; P
#define FDCAN_RX_BUFFER3 ((uint32_t)0x00000003U) /*!< Get received message from Rx Buffer 3 */7 j4 w& T! I$ x! F+ v; ]) A: Q/ o
#define FDCAN_RX_BUFFER4 ((uint32_t)0x00000004U) /*!< Get received message from Rx Buffer 4 */
+ Y* m6 y( p {& h# ?+ P8 e
#define FDCAN_RX_BUFFER5 ((uint32_t)0x00000005U) /*!< Get received message from Rx Buffer 5 */
7 Z# ^( Z6 K! I# q
#define FDCAN_RX_BUFFER6 ((uint32_t)0x00000006U) /*!< Get received message from Rx Buffer 6 */
* G. o3 V# q3 y. B( P
#define FDCAN_RX_BUFFER7 ((uint32_t)0x00000007U) /*!< Get received message from Rx Buffer 7 */
. b& l2 b( ~3 C& _7 b% ~& W
#define FDCAN_RX_BUFFER8 ((uint32_t)0x00000008U) /*!< Get received message from Rx Buffer 8 */+ R! a" l2 n% |) K& L2 o
#define FDCAN_RX_BUFFER9 ((uint32_t)0x00000009U) /*!< Get received message from Rx Buffer 9 */1 j \6 f% c8 Z; t/ ^; i! {
#define FDCAN_RX_BUFFER10 ((uint32_t)0x0000000AU) /*!< Get received message from Rx Buffer 10 */
; \9 w3 W- x* E ?: H. r8 n- s( o% D
#define FDCAN_RX_BUFFER11 ((uint32_t)0x0000000BU) /*!< Get received message from Rx Buffer 11 */) D( g' o, s1 G7 u; k# O* W
#define FDCAN_RX_BUFFER12 ((uint32_t)0x0000000CU) /*!< Get received message from Rx Buffer 12 */" D+ ?4 e! F: r) o
#define FDCAN_RX_BUFFER13 ((uint32_t)0x0000000DU) /*!< Get received message from Rx Buffer 13 */
3 r' b7 W- _' O5 l
#define FDCAN_RX_BUFFER14 ((uint32_t)0x0000000EU) /*!< Get received message from Rx Buffer 14 */
7 }$ l' }. z0 M6 |" k/ u
#define FDCAN_RX_BUFFER15 ((uint32_t)0x0000000FU) /*!< Get received message from Rx Buffer 15 */
* J! u2 g) E4 u6 m' [
#define FDCAN_RX_BUFFER16 ((uint32_t)0x00000010U) /*!< Get received message from Rx Buffer 16 */7 g5 H; v/ x' G: q% B4 ~
#define FDCAN_RX_BUFFER17 ((uint32_t)0x00000011U) /*!< Get received message from Rx Buffer 17 */' q. W& x& x8 a: q" i- I* u
#define FDCAN_RX_BUFFER18 ((uint32_t)0x00000012U) /*!< Get received message from Rx Buffer 18 */: I, K- B. Z% W- n5 V
#define FDCAN_RX_BUFFER19 ((uint32_t)0x00000013U) /*!< Get received message from Rx Buffer 19 */& m' V6 q+ ^* G
#define FDCAN_RX_BUFFER20 ((uint32_t)0x00000014U) /*!< Get received message from Rx Buffer 20 */% m. ~7 d) G1 R0 d5 n/ Z2 x
#define FDCAN_RX_BUFFER21 ((uint32_t)0x00000015U) /*!< Get received message from Rx Buffer 21 */' {6 a q9 g1 E7 C* U
#define FDCAN_RX_BUFFER22 ((uint32_t)0x00000016U) /*!< Get received message from Rx Buffer 22 */" r; m d( \3 Z" E. ^1 X
#define FDCAN_RX_BUFFER23 ((uint32_t)0x00000017U) /*!< Get received message from Rx Buffer 23 */- p, g& k( C" u' s6 Q5 Z/ e% u2 `" p
#define FDCAN_RX_BUFFER24 ((uint32_t)0x00000018U) /*!< Get received message from Rx Buffer 24 */. F7 ~) E; H( b$ }
#define FDCAN_RX_BUFFER25 ((uint32_t)0x00000019U) /*!< Get received message from Rx Buffer 25 */
: s6 F3 u- y/ v0 Z/ j
#define FDCAN_RX_BUFFER26 ((uint32_t)0x0000001AU) /*!< Get received message from Rx Buffer 26 */ X1 h' h1 @0 {
#define FDCAN_RX_BUFFER27 ((uint32_t)0x0000001BU) /*!< Get received message from Rx Buffer 27 */* C+ J: j, |5 D- z& T0 I! L" u) x
#define FDCAN_RX_BUFFER28 ((uint32_t)0x0000001CU) /*!< Get received message from Rx Buffer 28 */
/ w- y& j8 ?! ?
#define FDCAN_RX_BUFFER29 ((uint32_t)0x0000001DU) /*!< Get received message from Rx Buffer 29 */3 W5 u" ~! ?2 |& W6 ~5 ?
#define FDCAN_RX_BUFFER30 ((uint32_t)0x0000001EU) /*!< Get received message from Rx Buffer 30 */
8 r% ?0 O- F/ P& Z/ c
#define FDCAN_RX_BUFFER31 ((uint32_t)0x0000001FU) /*!< Get received message from Rx Buffer 31 */- ^/ a0 |, J5 e6 m! h. M0 v& ?
#define FDCAN_RX_BUFFER32 ((uint32_t)0x00000020U) /*!< Get received message from Rx Buffer 32 */$ R% ? P. r% L0 w7 y- s
#define FDCAN_RX_BUFFER33 ((uint32_t)0x00000021U) /*!< Get received message from Rx Buffer 33 */* h9 M; l, }/ L9 U' k$ @6 {
#define FDCAN_RX_BUFFER34 ((uint32_t)0x00000022U) /*!< Get received message from Rx Buffer 34 */
5 l) I. S, k$ Y8 k3 [" v& c3 l! Q
#define FDCAN_RX_BUFFER35 ((uint32_t)0x00000023U) /*!< Get received message from Rx Buffer 35 */1 ]$ n+ [/ Q# P. D8 n* k+ y0 d
#define FDCAN_RX_BUFFER36 ((uint32_t)0x00000024U) /*!< Get received message from Rx Buffer 36 */
) W8 k; H9 S7 D' R5 p
#define FDCAN_RX_BUFFER37 ((uint32_t)0x00000025U) /*!< Get received message from Rx Buffer 37 */" x7 e* z) M6 H1 c5 C( @
#define FDCAN_RX_BUFFER38 ((uint32_t)0x00000026U) /*!< Get received message from Rx Buffer 38 */
3 H7 b+ A, f# I+ [. P m. t$ y& Q
#define FDCAN_RX_BUFFER39 ((uint32_t)0x00000027U) /*!< Get received message from Rx Buffer 39 */
0 k. O+ M6 b8 \
#define FDCAN_RX_BUFFER40 ((uint32_t)0x00000028U) /*!< Get received message from Rx Buffer 40 */7 l4 g7 s/ {+ F- V) f5 _$ g; ^; I5 C
#define FDCAN_RX_BUFFER41 ((uint32_t)0x00000029U) /*!< Get received message from Rx Buffer 41 */
4 n# u' n' @/ W5 {
#define FDCAN_RX_BUFFER42 ((uint32_t)0x0000002AU) /*!< Get received message from Rx Buffer 42 */
9 i: _+ p! f9 N5 Y& n( y U
#define FDCAN_RX_BUFFER43 ((uint32_t)0x0000002BU) /*!< Get received message from Rx Buffer 43 */
7 n" \9 E9 g4 U
#define FDCAN_RX_BUFFER44 ((uint32_t)0x0000002CU) /*!< Get received message from Rx Buffer 44 */8 d( g2 j6 T6 |( O; @! Z0 e
#define FDCAN_RX_BUFFER45 ((uint32_t)0x0000002DU) /*!< Get received message from Rx Buffer 45 */& p0 W: I5 N* R# W8 j" J
#define FDCAN_RX_BUFFER46 ((uint32_t)0x0000002EU) /*!< Get received message from Rx Buffer 46 */
2 x0 D: L7 n/ [- `5 {2 G+ k: Y
#define FDCAN_RX_BUFFER47 ((uint32_t)0x0000002FU) /*!< Get received message from Rx Buffer 47 */6 e1 C) R K2 N% p
#define FDCAN_RX_BUFFER48 ((uint32_t)0x00000030U) /*!< Get received message from Rx Buffer 48 */
9 X+ R3 t2 `$ Z$ |9 K, ~7 D
#define FDCAN_RX_BUFFER49 ((uint32_t)0x00000031U) /*!< Get received message from Rx Buffer 49 */7 T P; H) }5 x7 s5 n
#define FDCAN_RX_BUFFER50 ((uint32_t)0x00000032U) /*!< Get received message from Rx Buffer 50 */- Z/ ]/ a9 X3 m! j
#define FDCAN_RX_BUFFER51 ((uint32_t)0x00000033U) /*!< Get received message from Rx Buffer 51 */
8 n: l* S# F5 D) c* ^4 u4 U2 U. E: e
#define FDCAN_RX_BUFFER52 ((uint32_t)0x00000034U) /*!< Get received message from Rx Buffer 52 */ [7 n- F$ |$ M! `
#define FDCAN_RX_BUFFER53 ((uint32_t)0x00000035U) /*!< Get received message from Rx Buffer 53 */
9 W& O/ l8 C, ~3 C3 `" _
#define FDCAN_RX_BUFFER54 ((uint32_t)0x00000036U) /*!< Get received message from Rx Buffer 54 */
3 y3 M9 d7 y8 ~: D, r
#define FDCAN_RX_BUFFER55 ((uint32_t)0x00000037U) /*!< Get received message from Rx Buffer 55 */
! W8 `2 G/ T! H
#define FDCAN_RX_BUFFER56 ((uint32_t)0x00000038U) /*!< Get received message from Rx Buffer 56 */. u# O2 B6 f# A
#define FDCAN_RX_BUFFER57 ((uint32_t)0x00000039U) /*!< Get received message from Rx Buffer 57 */- E7 A- F1 i8 M2 _6 g! Z
#define FDCAN_RX_BUFFER58 ((uint32_t)0x0000003AU) /*!< Get received message from Rx Buffer 58 */
0 J. O6 l$ L9 L2 u3 l8 e
#define FDCAN_RX_BUFFER59 ((uint32_t)0x0000003BU) /*!< Get received message from Rx Buffer 59 */1 ~# C' B# p, h! L
#define FDCAN_RX_BUFFER60 ((uint32_t)0x0000003CU) /*!< Get received message from Rx Buffer 60 */
) K2 t3 c; [2 ~, ]4 G
#define FDCAN_RX_BUFFER61 ((uint32_t)0x0000003DU) /*!< Get received message from Rx Buffer 61 */
. n9 ]- p5 w- k* h& |
#define FDCAN_RX_BUFFER62 ((uint32_t)0x0000003EU) /*!< Get received message from Rx Buffer 62 */5 y' i, ]' a& r1 V1 t' N, s
#define FDCAN_RX_BUFFER63 ((uint32_t)0x0000003FU) /*!< Get received message from Rx Buffer 63 */

复制代码

  第3个参数是FDCAN_RxHeaderTypeDef类型结构体变量，主要用于消息接收。
  第4个参数是数据接收缓冲地址。
  返回值，返回HAL_TIMEOUT表示超时，HAL_ERROR表示参数错误，HAL_OK表示发送成功，HAL_BUSY表示忙，正在使用中。
使用举例：

/* q O- \' Q4 C$ @0 i' f" n; F
*********************************************************************************************************
% c( @5 d3 O7 Z/ A" s
* 函数名: HAL_FDCAN_RxFifo0Callback
& U/ K/ @* k" B
* 功能说明: CAN中断服务程序-回调函数
9 B& ^, h: ^3 D, C8 _
* 形参: hfdcan7 b* B5 d7 B8 j) j+ ?5 Y) O |
* 返回值: 无
1 z0 ]+ D; P' D6 A+ ]9 t9 L
*********************************************************************************************************6 ~ m$ E" o/ v) r
*/3 J4 Q' x% [5 b6 y5 R* _$ C( f' a
void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)/ ^. p, ^* b! ~2 e6 q
{* E, s, v' p0 H6 t
if (hfdcan == &hfdcan1)
L% ~4 \) {! J- U3 H4 I
{; m) l) Z, R) O/ Y. g
if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_WATERMARK) != RESET)
0 u6 M+ C3 e; R2 [3 w
{
( Q+ T- C) D# P2 G3 h: |" g4 v
/* 从RX FIFO0读取数据 */
$ |4 b3 m1 \1 n4 ?6 n
HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &g_Can1RxHeader, g_Can1RxData);0 B* X+ ]: t: g7 e* g# ]+ |' K
. F& T9 ^, S8 G; T) `* Q
/* 激活Rx FIFO0 watermark notification */# z% b% |/ a* O1 D' S
HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_WATERMARK, 0);
]5 o A% _6 I6 F" ?
$ P [4 A3 i+ U1 J7 ^% C
if (g_Can1RxHeader.Identifier == 0x111 && g_Can1RxHeader.IdType == FDCAN_STANDARD_ID)
) n$ s9 q& V4 g! i9 r
{
% C8 ^4 }% B: A2 Z+ d
bsp_PutMsg(MSG_CAN1_RX, 0); /* 发消息收到数据包，结果在g_Can1RxHeader， g_Can1RxData */, w& L( ?" r" q1 A! y' z( `! h
}
: W$ M1 U9 B! r/ s2 k q
}
0 _" l( W: h- P, f- d
}
& U) ^; Z( j! _, ~( d6 B' J
}

复制代码

91.5 总结
本章节就为大家讲解这么多，更多FDCAN知识可以看本教程的第90章。

赞收藏评论0 发布时间：2021-11-6 23:50

0个回答

【经验分享】STM32H7的FDCAN总线基础知识和HAL库API

所属标签

相似分享