一、介绍
4 P% `, z2 e/ _1 V6 d' A
2 d$ @0 a; f1 {# h- i        FDCAN（Flexible Data-Rate CAN）是CAN的升级版。特点包括：

4 v7 j+ l; L2 ?; R# t3 Q3 G       1、每帧数据段最大长度由8字节上升到64字节。
: z* P* D6 E9 X9 A4 _! z2 b
& W: ~$ X% H$ P* K) W+ l        2、速度由1Mbps上升到5Mbps，甚至还可以更高。在一个数据帧中仲裁段（ID和ACK）的速率和CAN一样最高1Mbps，这样可以保证总线的健壮可靠，但是数据段可以5Mbps甚至更高，一个数据帧中使用不同的波特率，这就是FD（Flexible Data-Rate）的由来。
0 O0 M0 u: H8 J5 z  o/ |
; `6 A4 R$ }9 D" t/ M        3、向下兼容CAN。
, E4 [2 A# ~$ C4 ~* w% K
* x2 c$ t/ P' ~& e; T% D  G        H7的FDCAN包含2个可配置接收FIFO。多达64个专用接收buffer，多达32个专用发送buffer。可配置发送FIFO/队列，可配置发送事件FIFO。

二、结构

7 Z- h2 [# ~; U  X( ?9 Q6 \        先看结构框图：
! C% O0 K+ A; J% d) b
" m: O; {. ~9 [  W$ l

8 F+ o8 g, c# |2 c1、两条中断线：fdcan_intr0_it和fdcan_intr1_it。可以通过FDCAN_ILE寄存器的 EINT0和 EINT1这两个位来使能或者关闭。

        可以通过FDCAN_ILS寄存器来选择FDCAN的中断是在fdcan_intr0_it上触发，还是在fdcan_intr1_it上触发，默认所有中断都在fdcan_intr0_it上触发，没有特殊的要求，只需要用一条中断线就可以了。

4 V  k% S& _2 q+ u- M2 ~, N2、TX Handler：负责将消息RAM中的数据发送到CAN内核，最多可配置32个发送buffer进行发送。发送buffer可用作专用发送buffer、发送FIFO（发送队列的组成部分）或二者的组合。发送事件FIFO会将发送时间戳与相应的消息ID存储在一起，另外还支持取消发送。
/ d3 p' N+ W+ s  H
3、RX Handler：负责将CAN内核的数据传输到消息RAM，支持两个接收FIFO（每个FIFO的大小均可配置）以及最多64个专用接收buffer（用于存储所有通过验收过滤的消息）。专用接收buffer仅用于存储具有特定标识符的消息，与接收FIFO有所不同。每条消息均与其接收时间戳存储在一起。
3 _* Y1 p/ W% y2 ?" [5 G
+ W. K& K% b& a6 V4 r( Y4、CAN core：CAN内核，读RX引脚数据处理后给RX Handler，接收TX Handler处理后控制TX引脚。

) V* J( x/ _& D* x6 S7 R5、Message RAM interface：消息RAM接口，外面连接着消息RAM。消息RAM是FDCAN的核心，本质是一段最大10KB的内存，把这段内存分成不同的区域，每个区域的作用不同，可以实现：过滤器、接收FIFO、接收buffer、发送事件FIFO、发送buffer。内存分配如下：

5 d+ v0 q& k0 r3 @4 S) n
        10KB的消息RAM中，是以32位为最小单位来操作的（因此消息RAM的起始地址要32位对齐），即字(word)，因此10KB共有10*1024/4=2560个字。2560个字被分成了8个功能区，从上到下为：SIDFC.FLSSA、XIDFC.FLESA、RXF0C.F0SA......每个功能区中的条目又定义为元素(element)，每个元素可以占用多个字，但是同一个功能区中的元素大小是相同的。比如Rx FIFO0是接收FIFO0，消息通过过滤器后被保存到这里，它最多占用1152个字的空间，有64个元素，也就是可以保存64条消息，这64个元素的大小都相同，每个元素的大小最大为1152/64=18字。
8 q9 x, z! Z0 a
" |, Z' t7 p* k4 R; P, @" F( f        1）、SIDFC.FLSSA：这个区域用来存放11位过滤ID，最多可以有128个元素。
4 L/ l5 R4 `( Z- d" X. o2 _3 m
        2）、XIDFC.FLESA：这个区域用来存放29位过滤ID，最多可以有64个元素。（F1配置寄存器来设置过滤ID，H7直接划了个内存区来设置过滤ID）
' L; P6 F0 a% R- B
        3）、RXF0C.F0SA：接收FIFO0，最多可以有64个元素，可以接收64条消息。
# s5 j& G) I5 k$ _  S% `$ F
        4）、RXF1C.F1SA：接收FIFO1，最多可以有64个元素，可以接收64条消息。

' W) ?- p. x4 G% F2 a: O        5）、RXBC.RBSA：接收buffer，最多可以有64个元素。

- W, E/ t* B9 d. b' b+ T6 \" p2 n        6）、TXEFC.EFSA：发送事件FIFO，最多可以有32个元素。（不是发送FIFO）

        7）、TXBC.TBSA：发送buffer，最多可以有32个元素。
/ I) t: H0 E' {2 E
        8）、TMC.TMSA：触发存储器，最多可以有64个元素。

2 Y7 n9 G5 q, S6 V4 ~1 c6 E; K% ~《注：这8个区域的元素个数和元素大小都是可以配置的，但是这8个区域的地址又是连续的。因此在初始化的时候，会根据每个区域的元素个数和大小来计算下一个区域的起始地址，并保存到相应的寄存器中》
5 W9 v! t7 z6 A
        下面来详细介绍这几个功能区域：

' V/ S% o: K* n1）、SIDFC.FLSSA：这个区域用来存放11位过滤ID，有128个元素，每个元素占一个字，定义为：

9 i/ d; G, S" {* p
. E; b0 Y/ O1 I: h  H0 }2 S6 USFT[1：0]（bit31：30）：这两位用来表示过滤类型，一共有四种：
3 F  R0 {- F' R* b& n1 c, g6 ~    00：范围过滤，过滤到SFID1到SFID2中的所有信息。
$ e" S* ?8 ]. I$ U2 Y' q    01：双过滤，过滤到SFID1和SFID2中的信息。
    10：传统位过滤，SFID1 是过滤值，SFID2 是掩码。
2 N( v: g& ?4 Y9 H# f. M6 F3 h9 j    11：禁止过滤器元素
SFEC[2：0]（bit29：27）：标准过滤配置
    000：禁止过滤器元素
    001：当过滤匹配以后存储在Rx FIFO0中。
2 u/ z5 H: R: f$ Q; a    010：当过滤匹配以后存储在Rx FIFO1中。
    011：当过滤匹配以后丢弃。
    100：当过滤匹配以后设置IR寄存器的HPM位，触发高优先级中断。
    101：当过滤匹配以后存储在Rx FIFO0中并设置IR寄存器的HPM位，触发高优先级中断。
    110：当过滤匹配以后存储在Rx FIFO1中并设置IR寄存器的HPM位，触发高优先级中断。
) i$ }# P( A( P& C) x# E: H* r    111：存储到Rx buffer中或者作为debug消息，FDCAN SFT[1：0]忽略。
SFID1[10：0]（bit26：16）：标准过滤ID1，第一个要过滤的ID。
SFID2[15：10]（bit15：10）：标准过滤ID2，此位根据SFEC的配置不同而不同，当SFEC=001~110的时候此位域表示标准过滤ID。当SFEC=111的时候此位域表示Rx buffer或者debug消息。

SFID2[10：9]（bit10：9）：设置接收到的消息是存放在Rxbuffer中还是处理为debug消息的消息A、B或C。
( d# t* B7 C( o! z8 X# O/ }& b    00：将消息存储在Rx Buffer中。
, Y! |4 F4 B+ d
6 H* _6 L2 R" g  x    01：debug消息A。   
8 f+ y9 o+ j+ y7 W" D
# _' C) T8 E; a+ }8 }% n7 z    10：debug消息B。
* i* j/ {% ^  \; X3 y; }
    11：debug消息C。

  q; l" M4 Q( e, E8 b8 O, ESFID2[8：6]（bit8：6）：确定是否将滤波器事件引脚作为外部接口。
( s: E! K  X7 o0 v- p# u' x7 f
SFID2[5：0]（bit5：0）：定义当匹配以后存储消息的区域相对于Rx buffer 的开始地址RXBC.RBSA的偏移。

2）、XIDFC.FLESA：这个区域用来存放29位过滤ID，有64个元素，每个元素占2个字，定义为：

: x. [4 s2 f! s6 _" R

$ x, u1 d, Z8 K# ?
0 l% c* n! [  X  i6 g/ E. n$ GF0 EFEC[2：0]（bit31：29）：扩展过滤配置
. |& r7 {9 q6 a/ u5 l$ v4 h    000：禁止过滤器元素
    001：当过滤匹配以后存储在Rx FIFO0中。
( q" p: J1 p4 L' _4 M1 k7 b  k    010：当过滤匹配以后存储在Rx FIFO1中
9 ]3 S/ U) v( ]! g7 d3 f- t0 E5 r9 {    011：当过滤匹配以后丢弃。
    100：当过滤匹配以后设置IR寄存器的HPM位，触发高优先级中断。
    101：当过滤匹配以后存储在Rx FIFO0中并设置IR寄存器的HPM位，触发高优先级中断。
: M3 X  Y# x# s! X    110：当过滤匹配以后存储在Rx FIFO1中并设置IR寄存器的HPM位，触发高优先级中断。
    111：存储到Rx buffer中，EFT[1：0]忽略。
F0 EFID1[28：0]（bit28：0）：扩展过滤ID1。
: ^, s5 l1 i2 K+ g$ L) KF1 EFTI[1：0]（bit31：30）：扩展过滤类型
    00：范围过滤，过滤到EF1ID到EF2ID中的所有信息。
    01：双过滤，过滤到EF1ID和EF2ID中的信息。
8 o6 }6 i2 z+ ~. n" }8 V& v    10：传统位过滤，EF1ID 是过滤值，EF2ID 是掩码。
+ F; I  a# M& m! h) `; G$ k: L    11：范围过滤，过滤到ED1ID到ED2ID中的所有信息，没有使用FDCAN XIDAM的掩码
) e, B2 a9 M% d( Z+ gF1 EFID2[10：9]（bit10：9）：设置接收到的消息是存放在Rx buffer中还是处理为debug消息的消息A、B或C。
    00将消息存储在Rx Buffer中。
    01：debug消息A。
    10：debug消息B。
- S: X  P2 x7 k4 v) p* T    11：debug消息C.
) _- t: V4 o: m+ W- \F1 EFD2[8：6]bit8：6）：确定是否将滤波器事件引脚作为外部接口。
% }- T8 j, u, F5 h) fF1EDIF2[5：0]（bit5：0）：定义当匹配以后存储消息的区域相对于Rx buffer的开始地址RXBC.RBSA的偏移。
$ }7 \! s8 o' X3 G
3）、RXF0C.F0SA、RXF1C.F1SA和 RXBC.RBSA分别为Rx FIFO0、Rx FIFO1、Rx buffer，它们都有64个元素，元素的大小根据数据长度不同而不同，范围为4-18字，它们的位定义相同：
# S' F, r* \5 [# ~) H( d
& e+ R, t* ^' B7 @- R

4 i2 t4 X, ^# y
& N) V! j; G8 L9 I) W9 q- wR0 ESI（bit31）：错误状态标志
    0：传输节点显性错误。
# A/ J0 \! E  _) [6 Z+ |! m' b    1：传输节点隐形错误
1 r4 W1 H: n$ m3 y7 y* ER0 XTD（bit30）：标记是标准ID还是扩展ID
. D, t4 {& O; y- w8 L" L  e9 B    0：11位标准ID
4 V/ J  X0 k( }0 v; V6 c9 T: [
+ _4 Y) V- ?) R$ D! K$ c% x    1：29位扩展ID
0 Q$ C4 E4 Z1 V5 `0 }1 c3 w! V9 T
' I# c( I6 W0 o8 s& r% x' AR0 RTR（bit29）：遥控传输请求，标记当前帧是数据帧还是遥控帧。
1 i0 D' {% I9 g) C3 e0 t    0：接收到的帧是数据帧
9 F( S6 y. a( o: L% q+ w9 F6 \
4 `/ L2 G2 v" N2 `$ B' {    1：接收到的帧是遥控帧
R0 ID[28：0]（bit28：0）：帧ID，根据XTD位决定是11位ID还是29位ID。
R1 ANMF（bit31）：

0 d* l5 Z6 n  X5 X, G) ]    0：接收到的帧和FIDX中的过滤帧匹配
$ V; b& s3 b& Y: r( |3 p
4 s, Q" y7 J5 W( G5 O    1：接收到的帧和Rx滤波器中的任何元素都不匹配
R1 FIDX[6：0]bit30：24）：过滤器索引，0~127，表示和Rx滤波器中的哪个元素匹配。
" |- V# Z  M2 N, v1 ZR1 FDF（bit21）：帧格式
* X# X* a6 Q* T4 r2 e$ v    0：标准帧格式
  t6 k4 I2 U. @# G+ P6 A" c7 k    1：FDCAN帧格式。
R1 BRS（bit20）：比特率切换
    0：接收到的帧没有比特率切换

3 ^5 ]# P& ^4 {- S8 h" v) j/ [    1：接收到的帧带有比特率切换
R1 DLC[3：0]（bit）：数据长度。
7 o  q1 L0 h0 G" M1 y    0-8：传统CAN+CAN FD，接收帧长度为0~8字节。
    9-15：如果是传统CAN，接收帧长度为8字节。
    9-15：如果是 CAN FD模式的话表示接收到的长度12/16/20/24/32/48/64 字节。
R1 RXTS[15：0]（bit15：0）：接收时间戳。
! i: ?) n0 g5 J2 L0 q" _4 R0 p3 s) mR2-Rn：接收到的数据。

3 D/ `" E) `9 |& U4）、TXEFC.EFSA：发送事件FIFO，有32个元素，每个元素两个字。
% ~7 c2 h, {' o  O. c* R( Q& F! _" v
( x2 m  [2 y) L$ S0 N

8 v1 }6 p. [  ]) e: V) v! A
! e$ h9 s9 Q' CE0 ESI (bit31)： 错误状态标志
2 H$ o( M3 y2 Y* d
    0：传输节点显性错误
# Y* z9 A1 x$ b" T" R    1：传输节点隐形错误。
+ t; D" q" c/ m4 }$ BE0 XTD（bit30）：标记是标准D还是扩展ID
    0：11位标准ID.
    1：29位扩展ID

+ v4 z3 w8 Q. h, ?2 kE0RTR（bit29）：遥控传输请求，标记当前帧是数据帧还是遥控帧。
    0：发送的帧是数据帧
    1：发送到的帧是遥控帧
E0 ID[28：0]（bit28：0）：帧ID，根据XTD位决定是11 位ID还是29位ID。
0 w1 h0 J* F0 j/ rE1 MM[7：0]（bit31：24）：消息掩码，从Tx buffer拷贝到Tx Event FIFO中。
2 A7 W5 ^' a2 B# C/ C8 KE1 EFC（bit23：22）：事件类型
    00：保留。
    01：发送事件。
. z6 U8 S3 x# T! ]- n6 G    10：发送取消。
    11 ：保留。
. c. c* J/ L0 I  ~% n; E' c1 D4 FE1 EDL（bit21）：扩展数据长度
% F( g# N& B' V) |5 X# g    0：标准帧格式
    1：FDCAN帧格式。
E1 BRS（bit20）：比特率切换
; N8 c6 z5 F  V* ?8 E    0：发送的帧没有比特率切换
% j0 R5 ?& K& i+ _. Y; [- {; x* R
    1：发送的帧带有比特率切换
E1 DLC[19：16]（bit）：数据长度。
    0-8：传统CAN+CANFD，长度为0~8字节。
    9-15：长度为8字节。
; z; s" p1 }& _* sE1 TXTS[15：0]bit15：0）：时间戳。

/ ?( W# a* f* w& G9 v5）、TXBC.TBSA：发送buffer，有32个元素。

8 v+ c" ]7 ]0 L* t& ]2 F% ET0 ESI（bit31）：错误状态标志
    0：CANFD帧中取决于被动错误标志。
$ `3 I5 f1 l% M! t    1：CANFD帧中隐形错误。
3 U8 V  Z1 J* @5 |6 pT0 XTD（bit30）：标记是标准ID还是扩展ID
    0：11位标准ID
( ]! r# d% e) V
    1：29位扩展ID
; e9 R7 r* m0 P* k6 U
T0RTR（bit29）：遥控传输请求，标记当前帧是数据帧还是遥控帧。
    0：发送的帧是数据帧
! [; }. f$ X! {: o$ y    1：发送到的帧是遥控帧
T0 ID[28：0]（bit28：0）：帧ID，根据XTD位决定是11位ID还是29位ID。
T1 MM[7：0]（bit31：24）：消息掩码，配置Tx buffer的时候由CPU写入。
5 t4 {% c8 x: T0 b4 [; DT1 EFC（bit23）：事件FIFO控制
    0：不存储发送事件。
5 a) J# A+ @7 f0 E    1：存储发送事件。
. z6 o) L( `3 {4 ET1 FDF（bit1）：帧格式
    0：标准帧格式
7 u1 s0 |4 G5 `& ?    1：FDCAN帧格式。
T1 BRS（bit20）：比特率切换
' ^1 G( ^% w/ ]" b8 n0 y    0：发送的帧没有比特率切换

' N9 f0 u1 a( q* r, E% ^    1：发送的帧带有比特率切换
T1 DLC[19：16]（bit）：数据长度。
' Q3 L# h1 y' t: s( C    0-8：传统CAN+CAN FD，接收帧长度为0~8字节。
    9-15：传统CAN，接收帧长度为8字节。
    9-15：CAN FD模式的话表示接收到的长度12/16/20/24/32/48/64字节。
' f! Z  i& [# ^1 m* f1 v( V' ^T2-Tn：发送的数据。
1 x* V& G$ y. i. [: e
三、过滤器设置

2 {. L) ?8 f, j4 X        标准帧和扩展帧过滤器的设置分别往SIDFC.FLSSA和 XIDFC.FLESA区域写数据即可，下面以标准帧为例，标准帧过滤器共有3种过滤模式：
" L6 Q4 `% U. ?; A2 |7 G
        1、指定范围过滤
. o: a( d3 X5 h6 q( b" A        通过SIDFC.FLSSA的SFID1和SFID2来设置需要过滤的ID范围，其中SFID2的值要大于SFID1，这样只有ID值在SFID1~SFID2之内的消息才能被接收到。比如我们现在要设置只接收ID在0X123~0X321范围内的消息，使用标准滤波器n，SIDFC.FLSSAn（n=0~128）的各个位设置如下：
, s/ [% o! L" E# o, j
+ ?" h4 |; y( Z

1. SIDFC.FLSSAn.SFT=0        //范围滤波
   
2. SDIFC.FLSSAn.SFEC=1       //如果滤波匹配成功的话将消息保存到RxFIFO中
   
3. SDIFC.FLSSAn.SFID1=0x123  //ID1
   3 d+ {* K- \8 l/ {$ h
4. SDIFC.FLSSAn.SFID2=0X321  //ID2

复制代码

        2、指定ID过滤
8 Y, N2 T) M8 m/ r: I
( w# l: I$ L" t  @6 i! Y        我们也可以设置只接收指定的一个或者两个ID的消息，如果只接收指定的一个ID消息的话SFID1=SFID2。比如我们要设置只接收ID为0X123的消息，设置如下：
; F( u% h3 q) E; o2 O" W

1. SIDFC.FLSSAn.SFT=1        //指定D过滤
   
2. SDIFC.FLSSAn.SFEC=1       //如果滤波匹配成功的话将消息保存到Rx FIFO中
   
3. SDIFC.FLSSAn.SFID1=0x123  //ID1
   0 L$ c, s5 e) V6 J
4. SDIFC.FLSSAn.SFID2=0X123  //ID2

复制代码

        3、传统的位过滤
) Y& P( J. E* y0 S( y, K3 G) O( Q. P        第3种过滤模式就是以前STM32的CAN上存在的位过滤模式，在屏蔽位模式下，过滤消息D和过滤掩码一起工作决定接收哪些消息，其中SFID1为过滤的消息ID，SFID2 为过滤掩码。举个简单的例子，我们设置过滤器SIDFC.FLSSAn工作在：传统位过滤模式，然后设置如下：

1. SIDFC.FLSSAn.SFT=2          //传统位过滤
   4 h% h; {6 g/ W- b$ ?
2. SDIFC.FLSSAn.SFEC=1         //如果滤波匹配成功的话将消息保存到Rx FIFO中
   ) l& e1 S0 {, J) S2 @
3. SDIFC.FL SSAn.SFID1=0xFF00  //ID1
   
4. SDIFC.FLSSAn.SFID2=0xF00    //掩码

复制代码

, D0 T  s1 n' q; E% g        其中SFID1是我们期望接收到的消息ID，我们希望最好接收到ID=0xFF00的消息。SFID2的0xF000规定了我们必须关心的ID，也就是接收到的消息ID其位[15：12]必须和SFID1中的位[15：12]完全一样，其他的位不关心。也即是说接收到的消息ID必须是0XxFxx这样的才算正确（x表示不关心）。
& S; h* T1 n! D" p7 h, H; Q  z3 Q
$ M' @/ x! o. o2 G四、CAN的收发过程
: j  U  ^! E& V. g
, T; y8 @7 B" b6 U7 J        1、CAN接收过程

        CAN接收到消息后会进行过滤，过滤时会从SIDFC.FLSSA或XIDFC.FLESA区域的第0个元素开始匹配，直至符合过滤器中的某个元素的规则，则过滤完成，过滤完成的消息会按照过滤器元素的配置进行处理。比如过滤器元素的SFEC/EFEC位决定过滤后的消息是放入接收FIFO0、接收FIFO1还是专用的接收buffer中。

4 L# G7 R* M* C" ~( S6 G" q& ]        接收FIFO 0 和接收FIFO 1 最多可分别保存64个元素。两个接收FIFO的配置是通过寄存器RXF0C和RXF1C完成的。
; P$ N2 ]- F. ~' C! d  Y
( d7 x2 J7 `8 E1 \

+ E& h/ {' H9 p) q
        当IR寄存器的RFnF(n为0或1，代表接收FIFO0或接收FIFO1)指示接收FIFO已满条件时，在至少已读取一条消息且接收FIFO 获取索引递增之前，不会继续向相应的接收 FIFO 写入消息。如果在相应的接收 FIFO 已满时收到消息， 此消息会被丢弃，中断标志IR[RFnL]会置 1。也就是说，接收FIFO满了后会触发RFnF中断，如果继续接收，消息会被丢弃，并触发RFnL中断。

, p: S8 C  _' R1 d
        为了避免接收FIFO溢出，可使用接收FIFO水印。当接收FIFO填充级别达到由RXFnC[FnWM] 配置的接收FIFO水印时，中断标志IR[RFnW]会置 1。比如接收FIFO0大小配置为64，水印值配置为60，当接收了60条消息时会触发水印中断，提前进行处理，这样就避免了FIFO溢出。
        读取消息就是直接从RXF0C.F0SAn或RXF1C.F1SAn(n为索引号 0~64)中读，消息的组成结构在上面已经说过了，比如HAL库HAL_FDCAN_GetRxMessage函数读数据过程（假定从FIFO0中读）：
' H3 I4 {3 y0 ~' }/ [( C% H% b
# c/ v- [- f) V( ?. X$ k8 M

1. /* Calculate Rx FIFO 0 element address */
   5 u5 P: g# s; C) s
2. GetIndex = ((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0GI) >> 8);
   
3. RxAddress = (uint32_t *)(hfdcan->msgRam.RxFIFO0SA + (GetIndex * hfdcan->Init.RxFifo0ElmtSize * 4));

复制代码

1）、((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0GI) >> 8)：作用是获得FIFO0状态寄存器FDCAN_RXF0S的bit[13:8]，读这里可以知道接收到的数据保存在FIFO0中的第几个元素中，GetIndex的范围是0-63，刚好对应64个元素。当FIFO接收到一条消息，GetIndex会加一，当从FIFO中取出一条消息，GetIndex会减一。

0 O  |7 Z! ]2 u& d" v9 w

" R8 V& ?% U: R/ o& J6 q2）、hfdcan->msgRam.RxFIFO0SA：是RXF0C.F0SA区域的开始地址。

6 B2 W; \# R0 e5 c; g. ~& e# t3）、hfdcan->Init.RxFifo0ElmtSize：是接收FIFO0的元素大小，根据数据长度不同而不同
/ l5 ~/ r" g; E6 p# P
6 @( L$ Z+ i# t" K, W

如果消息长度是8个字节，那么算上固定的R0、R1，元素大小就是4个字。
1 c; |$ h4 @6 ?2 G5 V
9 x) I; Z0 ?! _- Y如果消息长度是64个字节，那么元素大小就是64/4+2=18个字。
( I. B8 L; w% e8 f& _# z
& @  C) O1 h6 x" O        计算出了元素在FIFO0中的地址，直接按数据结构读数据就可以了：
. ]9 L3 Q: Y4 T: u, w

1. pRxHeader->IdType = *RxAddress & FDCAN_ELEMENT_MASK_XTD;
   % o3 f) D& j; Y6 [
2. pRxHeader->Identifier = ((*RxAddress & FDCAN_ELEMENT_MASK_STDID) >> 18);
   0 j6 g. y& [  \/ {3 z
3. pRxHeader->RxFrameType = (*RxAddress & FDCAN_ELEMENT_MASK_RTR);
   
4. pRxHeader->ErrorStateIndicator = (*RxAddress++ & FDCAN_ELEMENT_MASK_ESI);  //这里地址自加了一次
   5 y8 s! C! M9 `4 u' @2 L$ B
5. pRxHeader->RxTimestamp = (*RxAddress & FDCAN_ELEMENT_MASK_TS);
   
6. pRxHeader->DataLength = (*RxAddress & FDCAN_ELEMENT_MASK_DLC);
   9 E/ ~: b- p( B, I) z
7. pRxHeader->IsFilterMatchingFrame = ((*RxAddress++ & FDCAN_ELEMENT_MASK_ANMF) >> 31); //这里地址又自加了一次
   5 f0 K: M1 Z* u4 n" L' D6 s
8. ......
   
9. pData = (uint8_t *)RxAddress;
   , ]" ]7 j+ k- J2 _0 K) u% o6 t
10. for(ByteCounter = 0; ByteCounter < DLCtoBytes[pRxHeader->DataLength >> 16]; ByteCounter++)
    
11. {
    " t# I1 M, v+ B$ _; r8 Q% R
12.     *pRxData++ = *pData++;
    . h, y: T9 ^5 R/ Z2 Y
13. }

复制代码

( g2 q! J2 c! G, v8 t        2、CAN发送流程

        在消息RAM中TXBC.TBSA是发送buffer，最多有32个元素。发送buffer可以配置为专用发送buffer和发送FIFO/队列。发送FIFO/队列是指要么是发送FIFO，要么是发送队列，即发送FIFO模式或发送队列模式，由TXBC[TFQM]决定：
: s1 [# a& [9 j7 w7 r

6 t+ f/ g* X' t( V0 H) n0 k
        因此发送buffer可以有三种组合：全部是专用发送buffer、专用发送buffer加发送FIFO、专用发送buffer加发送队列。
) A  @6 `5 h, a' d
        下面来介绍一下专用发送buffer、发送FIFO、发送队列的情况：

" T* R4 r1 f8 d9 Y" i        1）、专用发送buffer

         专用发送buffer可完全在CPU的控制下发送消息。每个专用发送buffer都配置了特定的消息ID。如果多个发送buffer配置为使用同一消息ID，则会先发送buffer编号最小的发送buffer中的消息。
        如果数据部分已更新，则会通过添加请求的TXBAR[ARn] 位请求发送。请求的消息在内部会与发送FIFO/队列中的消息进行仲裁，在外部会与CAN总线上的消息进行仲裁， 并会根据其消息ID发送出去。

( N  W; f# o: Z1 c# Q: Z; t

  R/ e& _$ |$ z4 `5 w" U        专用发送buffer会在消息RAM中分配四个32位字(元素大小为4个字)。因此消息RAM中专用发送buffer的起始地址是：

# O1 i& q) P: t发送buffer索引 (0…31) *4+发送buffer起始地址。


. C. e+ B# d! y2 }. T
        2）、发送FIFO
! `/ \% }1 x0 H4 ]5 J8 t* l
        发送FIFO中存储的消息是先从获取索引TXFQS[TFGI] 引用的消息开始发送的。每次发送后，获取索引会循环递增，直至发送FIFO为空。发送FIFO可按消息写入发送FIFO的顺序发送来自不同发送buffer但消息ID相同的消息。FDCAN会计算获取索引和放入索引之差作为发送FIFO空闲级别TXFQS[TFFL]，用于指示可用（空闲）的发送 FIFO 元素数。
        新的发送消息必须写入以放入索引 TXFQS[TFQPI] 引用的发送buffer开始的发送FIFO中。 添加请求会将放入索引增加到下一空闲发送FIFO元素。放入索引达到获取索引后，会指示发送FIFO已满（TXFQS[TFQF]=“1”）。在这种情况下，下一条消息已发送且获取索引已递增之前，不应继续向发送FIFO写入消息。

        发送FIFO其实就是个环形队列，放入索引是队头，获取索引是队尾，队头和队尾之间保存着消息，相减当然就是待发送消息个数。当从发送FIFO取出数据，获取索引会自加，自加到等于放入索引时，表示发送FIFO为空。当放入数据到发送FIFO，放入索引自加，当绕了一圈自加到等于获取索引时，表示发送FIFO满了。
  W& @8 W. i/ U8 s3 K8 a9 R' n/ f
% O9 ]# ~. g4 ?        如果有一条消息添加到发送FIFO，则会通过向与发送FIFO放入索引引用的发送buffer相关的TXBAR位写入“1”来请求消息的发送。
/ ~1 E4 {7 p; J% i" p5 W! m* E        如果有多条 (n条) 消息添加到发送FIFO，则会写入以放入索引开始的n个连续发送buffer中。 随后会通过TXBAR请求发送。放入索引随后会循环递增n。请求的发送buffer数不应超过发送FIFO空闲级别指示的空闲发送buffer数。
/ R' O7 b- G5 w2 m        如果获取索引引用的发送buffer的发送请求取消，获取索引会增加到下一个具有挂起发送请求的发送buffer，并会重新计算发送FIFO空闲级别。如果取消对其他任何发送buffer的发送，获取索引和FIFO空闲级别保持不变。
6 L7 v( _/ q% c, P  s        发送FIFO元素会在消息RAM中分配4个32位字。因此下一可用（空闲）发送FIFO 缓冲区的起始地址是：

2 Q* m# n2 R, Q8 c放入索引 TXFQS[TFQPI] (0…31)的值*4+发送buffer起始地址。
8 A: m8 L# @  E3 |9 w
        3）、发送队列
8 d; n% J0 I' G# F' {+ c+ x# Q4 T        发送队列中存储的消息是先从消 息ID最小（优先级最高）的消息开始发送的。如果多个队列缓冲区配置为使用同一消息 ID，则会先发送缓冲区编号最小的队列缓冲区。
, A+ s* X* J- R) j8 `4 n2 O        新消息必须写入放入索引 TXFQS[TFQPI] 引用的发送buffer中（放入索引 TXFQS[TFQPI] 只是队列头的数字）。添加请求会将放入索引循环增加到下一空闲发送buffer。如果发送队列已满（TXFQS[TFQF]=“1”），则放入索引无效，并且在至少有一个请求的消息已发出或挂起的发送请求已取消之前，不应继续向发送队列写入消息。
        应用可使用寄存器 TXBRP来代替放入索引，并可将消息放入任何没有挂起传输请求的发送缓冲区中。
" `4 M5 ]# L: }- i/ i% ^& x        发送队列缓冲区会在消息 RAM 中分配四个 32 位字。因此下一可用（空闲）发送队列缓冲区 的起始地址是：
6 C7 b' o3 G# [7 `# k4 p1 }/ C' a
+ f. l2 U! D1 _. x$ K! L4 g- e# I发送队列放入索引 TXFQS[TFQPI] (0…31) 的值*4+发送buffer的起始地址。
/ _; `, \. J6 F0 n
/ e2 f/ }1 j5 @$ ?3 T        因此可以知道专用发送buffer、发送FIFO、发送队列的区别是对放入其中的多条消息的发送顺序不同：
; h# {7 f% N3 u% C  C# w, B
        1）、发送buffer全部配置为专用发送buffer

  |1 y; N8 x/ R  ]6 X5 o1 x        每个专用发送buffer都配置了特定的消息ID。如果多个发送buffer配置为使用同一消息ID，则会先发送buffer编号最小的发送buffer中的消息。
6 ^1 E, w1 y4 Z% G6 P0 B
8 e6 s) ~; s, H        2）、混合专用发送buffer和发送FIFO
9 b$ N$ |' J" |7 [; X* M
        在这种情况下，消息RAM中的发送buffer部分会被划分为一组专用发送buffer和一个发送FIFO。专用发送buffer的数量是通过 TXBC[NDTB] 配置的。分配给发送FIFO的发送buffer数量是通过 TXBC[TFQS] 配置的。如果 TXBC[TFQS] 编程为 0，则仅会使用专用发送buffer。
; H& T/ u/ z% o" i8 q

0 f* m+ Y! j2 q- o0 L
) F: [. m% L5 k" ?' N3 n' A% m2 Y        发送优先次序：
A、扫描专用发送缓冲区和时间最久的挂起发送FIFO缓冲区（TXFS[TFGI] 引用的缓冲区）
B、消息ID最小的缓冲区优先级最高，下次将发送该缓冲区的数据

. v7 i7 c" [: B/ O* ~8 d0 Z1 Z6 e        3）、混合专用发送buffer和发送队列

        在这种情况下，消息 RAM 中的发送缓冲区会被划分为一组专用发送缓冲区和一个发送队 列。专用发送缓冲区的数量是通过 TXBC[NDTB] 配置的。发送队列缓冲区的数量是通过 TXBC[TFQS] 配置的。如果 TXBC[TFQS] 编程为 0，则仅会使用专用发送缓冲区。
8 E: `+ v, R' O4 c

        发送优先级设置：
9 V3 ^" N7 V4 Z: \: b$ W- MA、扫描所有激活了发送请求的发送缓冲区
: J) D$ A$ d$ U; G5 i+ ^, l2 b! WB、消息 ID 最小的发送缓冲区优先级最高，下次将发送该缓冲区的数据
/ u+ G2 i4 J5 ^, Z1 U" a% t
        再来介绍一下发送事件FIFO，它并不是发送FIFO，不是用来存储发送消息的，而是用来存储发送消息的状态的。

        FDCAN 在 CAN 总线上发送消息 后，消息 ID 和时间戳会存储在发送事件 FIFO 元素中。为了将发送事件关联到发送事件 FIFO 元素，已发送的发送缓冲区中的消息标志会被复制到发送事件 FIFO 元素中。
        发送事件 FIFO 最多可配置为 32 个元素。发送 FIFO 中介绍了发送事件 FIFO 元素。根据元素 大小 (TXESC) 的配置，会使用 2 到 16 个 32 位字 (Tn = 3 ..17) 来存储 CAN 消息数据字段。
        发送事件 FIFO 的用途是将处理发送状态信息与处理发送消息分开，也就是让发送缓冲区仅 保存要发送的消息，而将发送状态单独存储在发送事件 FIFO 中。这样做有很大的优势，尤 其是在处理动态管理的发送队列时，发送缓冲区可在发送成功后立即用于新消息。覆盖发送缓冲区之前，不需要保存该发送缓冲区的发送状态信息。

        为了防止发送事件FIFO溢出，发送事件FIFO仍然支持水印功能。

, t8 q* E0 Q+ r- d+ T        CAN发送消息的代码实现：
1 {# B! L6 h! y- w# S. a% R
# n: T8 ^. y1 Y; L& A        发送流程与接收流程刚好相反，只需要把消息按照TXBC.TBSA格式构建好，然后写入发送buffer，写进去后设置FDCAN_TXBAR寄存器的指定位为1来请求传输即可。如HAL库函数HAL_FDCAN_AddMessageToTxFifoQ：

9 U/ \; R/ c. M, o

1. PutIndex = ((hfdcan->Instance->TXFQS & FDCAN_TXFQS_TFQPI) >> 16); //获取元素编号
   ) d, o7 b' j& s; |% E1 D+ i9 E) _
2. FDCAN_CopyMessageToRAM(hfdcan, pTxHeader, pTxData, PutIndex); //复制消息到Tx buffer
   7 \. E$ R# i8 `, q  j
3. hfdcan->Instance->TXBAR = (1 << PutIndex); //发出传输请求

复制代码

, f* B& j3 R! u5 q: U$ Q3 ?        发送buffer请求寄存器FDCAN_TXBAR，描述为：
! u4 [5 S& ?' }8 @8 h
$ R& R: Z4 c: v9 S! [; j

8 E, E: l9 ]8 o! o5 W/ M1 o) |& x4 f8 g        此寄存器用来设置FDCAN的哪个发送buffer可以发送数据，FDCAN有32个发送buffer，当把消息复制到这些buffer中后，就需要设置此寄存器来标记此buffer可以发送。



五、初始化

. b' G+ b7 |* m        初始化可以直接使用HAL库，

% i- a1 N7 j3 z9 Z9 U

1. u8 FDCAN1_Mode_Init(void)
   
2. {
   " x: |) q) z  U  L! ~# a
3.     FDCAN_FilterTypeDef FDCAN1_RXFilter;
   
4. 
   # x7 r/ b1 R0 A1 N% y
5.     HAL_FDCAN_DeInit(&FDCAN1_Handler);                              //先清除以前的设置
   : d/ H1 I6 x( U, e  i4 \
6.     FDCAN1_Handler.Instance=FDCAN1;
   
7.     FDCAN1_Handler.Init.FrameFormat=FDCAN_FRAME_CLASSIC;            //传统模式
   
8.     FDCAN1_Handler.Init.Mode=FDCAN_MODE_NORMAL;                     //正常模式
   . B& Y9 c  D1 _; A" k
9.     FDCAN1_Handler.Init.AutoRetransmission=DISABLE;                 //关闭自动重传
   
10.     FDCAN1_Handler.Init.TransmitPause=DISABLE;                      //关闭传输暂停           
    3 {" B) [  b+ G/ }( `" R
11.     FDCAN1_Handler.Init.ProtocolException=DISABLE;                  //关闭协议异常处理
    
12.         
    
13.         //时钟为200M，baudrate=200M/(NominalTimeSeg1+NominalTimeSeg2+1)/NominalPrescaler，这里配置为1M
    
14.     FDCAN1_Handler.Init.NominalPrescaler=10;                        //分频系数
    ! x! F* t2 A& R+ b+ A3 F0 V, A- ^
15.     FDCAN1_Handler.Init.NominalSyncJumpWidth=8;                     //重新同步跳跃宽度
    / V6 @/ j6 ^1 a9 C
16.     FDCAN1_Handler.Init.NominalTimeSeg1=11;                         //tsg1范围:2~256
    1 n/ B4 K5 C5 Y0 d* d+ T
17.     FDCAN1_Handler.Init.NominalTimeSeg2=8;                          //tsg2范围:2~128
    ! K! L1 ~; y% Q6 q
18.         
    ' X- A- g+ y8 z$ T* u0 ^4 R" \
19.     FDCAN1_Handler.Init.MessageRAMOffset=0;                         //信息RAM偏移，10KB消息RAM共有2560字，故可以偏移0~2560
    ( j4 L* D5 K# ~% n
20.         //使用了多少个滤波器就要设置为多少
    7 ?: t; z" b8 c
21.     FDCAN1_Handler.Init.StdFiltersNbr=3;                            //标准帧滤波器个数，0~128
    & B6 a% g# ~0 f! F
22.     FDCAN1_Handler.Init.ExtFiltersNbr=2;                            //扩展帧滤波器个数，0~64
    0 U5 b5 N  Q$ q4 \# n/ w+ Y3 W
23.         
    
24.         //接收FIFO0、FIFO1和buffer配置，此处没有使用FIFO1故个数设置为0
    
25.     FDCAN1_Handler.Init.RxFifo0ElmtsNbr=64;                         //设置接收FIFO0元素个数，0-64
    
26.     FDCAN1_Handler.Init.RxFifo0ElmtSize=FDCAN_DATA_BYTES_8;         //接收FIFO0元素的数据域大小:8字节        
    7 t: j* ^1 {) ?" ]$ b7 W4 F* P  X
27.     FDCAN1_Handler.Init.RxFifo1ElmtsNbr=0;                          //设置接收FIFO1元素个数，0-64
    
28.     FDCAN1_Handler.Init.RxFifo1ElmtSize=FDCAN_DATA_BYTES_8;         //接收FIFO1元素的数据域大小:8字节               
    
29.     FDCAN1_Handler.Init.RxBuffersNbr=64;                            //接收buffer元素个数，0~64
    ( T8 O: G' ~7 k
30.         FDCAN1_Handler.Init.RxBufferSize=FDCAN_DATA_BYTES_8;            //接收buffer元素的数据域大小:8字节        
    ) e' a+ b% N! p4 ~- N# S, U
31.         
    * M8 f+ ?  G1 b% J, \. M
32.         //没有使用发送事件FIFO功能，故TxEventsNbr设置为0。把发送buffer全部作为专用发送buffer使用，故TxFifoQueueElmtsNbr设为0.
    
33.     FDCAN1_Handler.Init.TxEventsNbr=0;                              //发送事件FIFO元素个数，0~32
    6 |1 _4 o' G6 h# Z/ Q- O
34.     FDCAN1_Handler.Init.TxBuffersNbr=32;                            //发送buffer元素个数，0~32
    
35.     FDCAN1_Handler.Init.TxFifoQueueElmtsNbr=0;                      //发送Buffer被用作发送FIFO/队列的元素个数，0~32
    3 b% t# H+ j3 N, A
36.     FDCAN1_Handler.Init.TxFifoQueueMode=FDCAN_TX_FIFO_OPERATION;    //发送FIFO模式选择，可以选择FIFO模式或队列模式
    $ f8 ]' k* v' u3 k) o6 s. q% F! r; q
37.     FDCAN1_Handler.Init.TxElmtSize=FDCAN_DATA_BYTES_8;              //发送元素的数据域大小:8字节
    * i: s9 b2 s9 c/ {! `1 C$ g
38.         
    
39.     if(HAL_FDCAN_Init(&FDCAN1_Handler)!=HAL_OK) return 1;          //初始化FDCAN
    
40. 
    , n9 }$ q) X+ \; J! v
41.     //配置RX滤波器，标准帧   
    
42.     FDCAN1_RXFilter.IdType=FDCAN_STANDARD_ID;                       //标准ID
    0 a' ?3 z: b% G. k
43.     FDCAN1_RXFilter.FilterIndex=0;                                  //滤波器索引                  
    2 R7 r& c" f; R' B% {
44.     FDCAN1_RXFilter.FilterType=FDCAN_FILTER_MASK;                   //滤波器类型
    5 C9 ]0 L! D$ R, [' ]3 Z9 A+ j+ r
45.     FDCAN1_RXFilter.FilterConfig=FDCAN_FILTER_TO_RXFIFO0;           //过滤器0关联到FIFO0  
    
46.     FDCAN1_RXFilter.FilterID1=0x112;                                //11位ID
    
47.     FDCAN1_RXFilter.FilterID2=0x7FF;                                //11位掩码
    $ f( Q6 `9 K. Z/ }2 @: B2 |6 [1 h6 N
48.     if(HAL_FDCAN_ConfigFilter(&FDCAN1_Handler,&FDCAN1_RXFilter)!=HAL_OK) return 2;//滤波器初始化
    * A/ K  ]0 M/ S$ C! e) o' |
49. 
    
50.     FDCAN1_RXFilter.IdType=FDCAN_STANDARD_ID;                       //标准ID
    
51.     FDCAN1_RXFilter.FilterIndex=1;                                  //滤波器索引                  
      m  h7 m9 N* V5 w
52.     FDCAN1_RXFilter.FilterType=FDCAN_FILTER_MASK;                   //滤波器类型
    
53.     FDCAN1_RXFilter.FilterConfig=FDCAN_FILTER_TO_RXFIFO0;           //过滤器0关联到FIFO0  
    * \, u( o, X' `# J/ A  Y* b- Y
54.     FDCAN1_RXFilter.FilterID1=0x113;                                //11位ID
    " s) x6 b' w$ |! v; W, D
55.     FDCAN1_RXFilter.FilterID2=0x7FF;                                //11位掩码
    
56.     if(HAL_FDCAN_ConfigFilter(&FDCAN1_Handler,&FDCAN1_RXFilter)!=HAL_OK) return 2;//滤波器初始化
    
57.         
    
58.     FDCAN1_RXFilter.IdType=FDCAN_STANDARD_ID;                       //标准ID
    
59.     FDCAN1_RXFilter.FilterIndex=2;                                  //滤波器索引                  
    
60.     FDCAN1_RXFilter.FilterType=FDCAN_FILTER_MASK;                   //滤波器类型
    
61.     FDCAN1_RXFilter.FilterConfig=FDCAN_FILTER_TO_RXFIFO0;           //过滤器0关联到FIFO0  
    
62.     FDCAN1_RXFilter.FilterID1=0x114;                                //11位ID
    3 ^6 G6 H8 G4 ^0 D& c$ E
63.     FDCAN1_RXFilter.FilterID2=0x7FF;                                //11位掩码
    
64.     if(HAL_FDCAN_ConfigFilter(&FDCAN1_Handler,&FDCAN1_RXFilter)!=HAL_OK) return 2;//滤波器初始化
    6 l! N3 K5 x' V* t
65.         
    4 \; b' Q7 b2 A. a- L6 I) `
66.         //配置RX滤波器，扩展帧。标准帧和扩展帧的滤波器索引是分开的   
    
67.     FDCAN1_RXFilter.IdType=FDCAN_EXTENDED_ID;                       //扩展ID
    
68.     FDCAN1_RXFilter.FilterIndex=0;                                  //滤波器索引                  
    9 k$ g3 B( d+ N) n' z
69.     FDCAN1_RXFilter.FilterType=FDCAN_FILTER_MASK;                   //滤波器类型
    
70.     FDCAN1_RXFilter.FilterConfig=FDCAN_FILTER_TO_RXFIFO0;           //过滤器0关联到FIFO0  
    
71.     FDCAN1_RXFilter.FilterID1=(1 << 20)|(2 << 12);                  //32位ID
    
72.     FDCAN1_RXFilter.FilterID2=0x1FFFF000;                           //32位掩码
    6 [; @9 O+ m- V) z; P. ]6 C
73.     if(HAL_FDCAN_ConfigFilter(&FDCAN1_Handler,&FDCAN1_RXFilter)!=HAL_OK) return 2;//滤波器初始化
    
74. 
    
75.     FDCAN1_RXFilter.IdType=FDCAN_EXTENDED_ID;                       //扩展ID
    & h  e$ u  \" l" L) ]
76.     FDCAN1_RXFilter.FilterIndex=1;                                  //滤波器索引                  
    
77.     FDCAN1_RXFilter.FilterType=FDCAN_FILTER_MASK;                   //滤波器类型
    2 K" o# C# ]. i  R2 x
78.     FDCAN1_RXFilter.FilterConfig=FDCAN_FILTER_TO_RXFIFO0;           //过滤器0关联到FIFO0  
    
79.     FDCAN1_RXFilter.FilterID1=(1 << 20)|(3 << 12);                  //32位ID
    7 V  c) {9 A4 ?0 a% i  F' \, Q2 |5 }
80.     FDCAN1_RXFilter.FilterID2=0x1FFFF000;                           //32位掩码
    ) ~9 ^9 v/ |( I  n
81.     if(HAL_FDCAN_ConfigFilter(&FDCAN1_Handler,&FDCAN1_RXFilter)!=HAL_OK) return 2;    //滤波器初始化
    / }, C$ E6 A- j- y7 U; U) l
82.         
    
83.         //滤除的消息直接丢弃
    
84.         HAL_FDCAN_ConfigGlobalFilter(&FDCAN1_Handler,FDCAN_REJECT, FDCAN_REJECT, DISABLE, DISABLE);  //设置被滤除掉的消息的处理方式
    7 h4 x' B5 C* E8 U$ e
85.         
    & T4 {8 P0 Z  {4 C
86.         HAL_FDCAN_ActivateNotification(&FDCAN1_Handler,FDCAN_IT_RX_FIFO0_NEW_MESSAGE,0);   //使能新消息接收中断
    1 ~' Z# h4 o. m7 e6 Z" ?, c5 B0 v
87.         HAL_FDCAN_ActivateNotification(&FDCAN1_Handler,FDCAN_IT_TX_COMPLETE,0xffffffff);   //使能消息发送中断，0xffffffff表示所有的发送buffer都触发中断        
    8 N/ h6 _$ ^! W' H, ]
88.         
    ! W7 N/ H( f+ Z% J5 L5 a/ P" v) y2 E
89.     HAL_FDCAN_Start(&FDCAN1_Handler);                               //开启FDCAN
    + ~6 A$ S9 o- I9 T$ p9 g" E3 \* T
90.     return 0;
    0 I# m) ~6 {% f' X. n3 o% U
91. }

复制代码

六、CAN发送示例（来自正点原子）
/ H$ R; n0 Q' [/ H

1. //can发送一组数据(固定格式:ID为0X12,标准帧,数据帧)        
   ; N2 d! @9 U6 i  b" M
2. //len:数据长度(最大为8),可设置为FDCAN_DLC_BYTES_2~FDCAN_DLC_BYTES_8                                    
   2 T' Q* Q) F* L- g8 s. m
3. //msg:数据指针,最大为8个字节.
   
4. //返回值:0,成功;
   9 H6 d4 {6 Q$ H6 C/ J. }. H9 B% Q9 t- U
5. //                 其他,失败;
   # ^4 @& G; T* j  x/ Y
6. u8 FDCAN1_Send_Msg(u8* msg,u32 len)
   ' @" E- @* h) ]3 [
7. {        
   
8.     FDCAN1_TxHeader.Identifier=0x12;                           //32位ID
   # _( D+ X7 ~4 e- |0 l- _
9.     FDCAN1_TxHeader.IdType=FDCAN_STANDARD_ID;                  //标准ID
   
10.     FDCAN1_TxHeader.TxFrameType=FDCAN_DATA_FRAME;              //数据帧
    ( R3 h1 O# b& C: j% N* v% t+ M  R
11.     FDCAN1_TxHeader.DataLength=len;                            //数据长度
    * r( \. `  j2 ~. I/ J
12.     FDCAN1_TxHeader.ErrorStateIndicator=FDCAN_ESI_ACTIVE;            
    
13.     FDCAN1_TxHeader.BitRateSwitch=FDCAN_BRS_OFF;               //关闭速率切换
    
14.     FDCAN1_TxHeader.FDFormat=FDCAN_CLASSIC_CAN;                //传统的CAN模式
    
15.     FDCAN1_TxHeader.TxEventFifoControl=FDCAN_NO_TX_EVENTS;     //无发送事件
    % r7 \# s+ M( m2 I7 M( @9 S
16.     FDCAN1_TxHeader.MessageMarker=0;                           
    
17. 
    
18.     if(HAL_FDCAN_AddMessageToTxFifoQ(&FDCAN1_Handler,&FDCAN1_TxHeader,msg)!=HAL_OK) return 1;//发送
    
19.     return 0;        
    
20. }

复制代码

+ G+ N& D/ x! I' G七、CAN接收示例（来自正点原子，因为滤波器被关联到FIFO0，因此消息只会放入到FIFO0）

1. //can口接收数据查询
   ) v! W+ o& n! b2 H+ t) ^' X
2. //buf:数据缓存区;         
   * Y# O  U2 E- m
3. //返回值:0,无数据被收到;
   
4. //                 其他,接收的数据长度;
   
5. u8 FDCAN1_Receive_Msg(u8 *buf)
   ( D  E) t+ c5 r3 }6 {; _
6. {        
   , S0 v: Z2 p# G& u" W" W5 L
7.     if(HAL_FDCAN_GetRxMessage(&FDCAN1_Handler,FDCAN_RX_FIFO0,&FDCAN1_RxHeader,buf)!=HAL_OK)return 0;//接收数据
   # [# Q4 A, a8 u% N. I
8.         return FDCAN1_RxHeader.DataLength>>16;        
   # H, _; A9 [9 L8 d
9. }

复制代码

参考：《正点原子》  STM32H7开发指南-HAL库版本_V1.0 （文档中有很多错误的地方，笔者被误导了好久，阅读的时候还是要以H7官方手册为准）