FDCAN 与 经典CAN 的最直观差别就是数据帧部分，FDCAN的数据帧波特率可变，并且数据大小不局限于 8 Bytes ，最高支持 64 Bytes 的数据传输。详细差别见 传送门： CAN FD 与 CAN协议区别–简单易懂协议详解 。
5 f! N6 O" _& y0 G
2 }2 y: y4 O8 z1. FDCAN的框图

$ b3 W8 M9 ^( p
% r9 ?6 A4 R, \9 m( n# B
) f# |. g% {6 Q, @" [/ Z+ {$ A根据上图可以看到，FDCAN 有两个时钟域，APB总线接口和CAN内核时钟。FDCAN的波特率取决于内核时钟；寄存器的配置、消息RAM等，走的是APB时钟。FDCAN的APB时钟在RCC_APB寄存器中配置，内核时钟在RCC_CCIPR寄存器中配置（下一章）。
" @( _0 Z& S) i* l+ l: ZFDCAN有两个中断线，这两个中断线可以单独的打开或关闭，在FDCAN_ILE寄存器中配置。
" a, ?' k6 F% y* u2 t9 V8 J  _其他具体介绍参考DM00355726_ENV4手册的1947页（RM0440手册官方下载传送门）。

2. FDCAN的时钟与波特率
: ^# \5 R' v; V8 ~( B2.1 fdcan_clk
  @& p! e5 m* d1 x9 Z) g* ~几乎所有通信都可在RCC中配置时钟选择，FDCAN的时钟（fdcan_clk）可在RCC_CCIPR寄存器中进行配置。

2 @& z7 M; O/ m2 v8 Z
  B2 a0 s" m& T0 v
FDCAN1/2/3 的内核时钟是通用的，可以在配置FDCAN1的时候，配置 CKDIV 寄存器进行进一步的分频（INIT标志位置位才可配置该寄存器），这里配置的CKDIV影响到 FDCAN2 和 FDCAN3。

2.2 fdcan_tq_ck
根据系统框图可看到，系统输入的时钟可通过 fdcan_clk 分频得到 fdcan_tq_ck ，在 FDCAN_CKDIV 寄存器中配置分频系数。


- a' ~  |0 |8 @! W4 j% `
+ F. D" }! ]6 l$ K& @2 R5 p可以认为FDCAN内核用的时钟都是fdcan_tq_ck ，只不过 fdcan_tq_ck 为1分频时候认为是fdcan_clk 。
; S7 L, M- e; G) w7 k! Y  t
2.3 波特率
FDCAN模块的bit采样分三段：

$ \: ~. B; N9 l9 H
* t5 J+ U' G9 `' H+ ~+ T

; M) y8 t  m' M# }; U2 l9 O波特率公式如下：
5 L1 x/ l! d# l( q9 X% _& g6 g) a
, x* `2 w$ x( V/ u

$ R; D+ d1 n3 m) W# y注意：
1、由于 FDCAN 与 经典CAN 的帧格式有点差异，其数据帧波特率可变，因此在这里分出普通CAN和数据bit时间
( g2 W! g' v( k9 e/ s2、数据 和 普通 bit 时间寄存器名称不一样，数据波特率寄存器 FDCAN_DBTP ，一般帧波特率寄存器为 FDCAN_NBTP 。当使用经典模式CAN时， FDCAN_DBTP 配置被忽略
% |4 U, E8 n2 m' ]1 [6 K5 f; D
; A+ b2 B1 s/ Q6 |" F& B8 H3. FDCAN的地址分布
3.1 总体分布

' o2 M! j4 a: W5 Z! O' T" c0 I
! @- k3 q6 m1 D4 t3 p" q7 e: v
: C1 I3 E, Y! @, b0 B8 e' J8 J由于头文件中没有该寄存器的宏定义，因此需要自己建立宏定义。
) J$ ~# w1 K% |7 w7 I  b, ]G474的FDCAN外设一共有3组（FDCAN1，FDCAN2，FDCAN3），寄存器配置分为3个，消息RAM也分为3组。
: j6 R3 t# e3 j! N* i# d+ B" y1 K
* G  I& y5 m& j$ w* S* c' V# J, }3.2 Message RAM


7 E& M/ A5 L" ?6 K+ B' _
; ?! h# n) L+ n# ^( }( W1个 信息RAM 有 212 words 的大小，即 212 × 4 = 848 Bytes 。

根据3.1和3.2可以先把 消息RAM 的宏定义写好
" x% p. H; E& _# c; d* s
4 [0 O: ^1 @- O0 S

1. #define FDCANs_MESSAGE_RAM_BASE                                        0x4000A400
   ! @: H/ x+ L" a  M" H5 a
2. #define FDCAN1_RAM_BASE                                                        (FDCANs_MESSAGE_RAM_BASE)
   
3. #define FDCAN2_RAM_BASE                                                        (FDCAN1_RAM_BASE + 0x00000350)
   
4. #define FDCAN3_RAM_BASE                                                        (FDCAN2_RAM_BASE + 0x00000350)
   
5. 
   6 h3 G1 g7 c& x8 T! g
6. typedef struct
   
7. {
   - B2 h1 s2 O9 m1 S% ?7 z, l/ g
8.         uint32_t FILTER_11BIT[28];                //0x4000A400 ~ 0x4000A470
   1 e5 p3 v# O* ?0 j  ]( C
9.         uint32_t FILTER_29BIT[8][2];        //0x4000A470 ~ 0x4000A4B0
   
10.         uint32_t Rx_FIFO_0[3][18];                //0x4000A4B0 ~ 0x4000A588
    
11.         uint32_t Rx_FIFO_1[3][18];                //0x4000A588 ~ 0x4000A660
    
12.         uint32_t Tx_FIFO[6];                        //0x4000A660 ~ 0x4000A678
    4 F0 I3 g" N, V& S$ V7 I3 K
13.         uint32_t Tx_BUFFER[3][18];                //0x4000A678 ~ 0x4000A750
    
14. }FDCAN_RAM_Struct;
    / a# e6 \# D1 L- V( b' K% `
15. 
    
16. #define FDCAN1_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN1_RAM_BASE)
    
17. #define FDCAN2_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN2_RAM_BASE)
    
18. #define FDCAN3_RAM                                                                ((FDCAN_RAM_Struct *)FDCAN3_RAM_BASE)

复制代码

0 f: |* O2 X) c( K- r7 {注意！！！ 上面的代码第1行的宏定义部分，偏移为 0x350 而不是 0x400。
' [, K; |1 y+ y* b! C9 [- f曾经我根据 3.1里面的图片进行配置（0x400也就是1KB），结果只有FDCAN1好用，FDCAN2和FDCAN3都不能使用，困扰了我一天来找这个问题，后来使用 0x350 就可以了，可能是手册写错了，也可能是我的理解与有误。
* Z4 R9 m9 y- ^; C: s这里是个坑，希望大家能够规避一下。

4. FDCAN中断配置
8 T1 T* N- f# Q* k/ w4.1 中断寄存器
FDCAN中断配置中，涉及的寄存器为

! a' w. G( m4 V2 d' H( i; H) r; SFDCAN_IE 与其他外设的IE一样，中断使能寄存器，在这里选择使用的中断，在代码中会注释
" ?* C$ o5 b. _: \6 \FDCAN_ILE 中断总线使能。FDCAN中将中断分为了两个分支，即有两个中断函数
/ |1 Z; p, P/ \6 [' q* n+ G6 E/ OFDCAN_ILS 中断总线选择。在这个寄存器中配置哪个中断归属于哪个中断分支，默认都为分支0.
: y6 N4 z' _3 I

5. FDCAN的筛选器
# R! q' O# I4 O& l- U& j# W5.1 筛选器的特征
4 E5 B' V- ^8 D# X# r) s. ?, g; g每个筛选器可配置为
; |: z% S3 }4 ]  C2 Z, \9 ]; R• 范围筛选
2 g" {( ~- V6 x$ K# q& u$ ~, ^4 W• 指定ID筛选
0 |% {+ [- Z) W* P; L+ F• 屏蔽典型bit筛选
8 ?; f: h$ |: ~. k每个过滤器元件可配置为接受或拒绝过滤
! f: u. {: ]+ F3 @每个过滤器元素可以单独启用/禁用
过滤器是按顺序检查的，执行在第一个匹配的过滤器元素时停止
相关的寄存器：全局筛选配置（RXGFC）、拓展ID和掩码（XIDAM）

如果需要接收数据，一定要配置筛选器，否则会什么也接受不到。

5.2 11-bit 筛选器的格式

0 e7 [3 {' L2 u
! x! ?2 C1 R- U$ a3 X
- w* V" b7 N0 s$ @4 k# g这里根据手册的翻译进行配置就好，29-bit 的筛选器也是如此，手册里全有，我就不放图片了，太占地方。
! K+ e; _' b0 w/ ]
对于筛选器的掩码模式，可通过传送门了解到：CAN通讯难点———验收筛选器

通过配置筛选器，可以使FDCAN外设接收其他模块发来的信息，在筛选器中配置接收消息的FIFO或者拒收消息。配置筛选器是FDCAN接收的关键。
* v' N& l! D3 H" I筛选器的配置不受 INIT 和 CCE 标志位的限制，可随时配置。
( `% _0 ]+ q4 b* I8 W; ^
1 a1 `8 S* r. T; r; O+ ?6. FIFO模式与Queue模式
FIFO模式与队列模式的区别为：
( B4 M; k6 M/ a7 c- [队列模式的优先级遵循邮箱0优先级最高，其次是1，最后是2，如果当前3个邮箱全有数据，优先发送邮箱0的数据
+ i% u8 B8 p; F# ^. z7 l0 G. p% {FIFO模式的优先级是遵循哪个数据先进入的邮箱，与其所在的索引地址无关，即：如果当前3个邮箱全有数据，邮箱2被最先写入，则优先发送邮箱2的数据。

6.1 TX FIFO 的寄存器格式
8 v7 H4 t7 y2 _


& k+ g, ]# y  F* _具体说明见手册1969页，我就不复制了，翻一下就能懂每个BIT代表的意思。
根据上表，我们就可以写出对应各个标志位的结构体，方便后期指针使用。
由于其buffer支持 11-bit ID 和 29-bit ID

7. FDCAN的初始化
7 e+ H' f; F& _  f! ^: f, h  k$ B9 q# t2 XIO口配置我就不介绍了，想必大家都会配置IO。
7 ^( o! i' D6 u6 N- K, |9 Q
1.首先在RCC->APB1RSTR1寄存器中使能RCC_APB1ENR1_FDCANEN，这样FDCAN的寄存器就可以配置了。
" X! s7 b1 }8 E+ I& d2.然后选择FDCAN内核时钟的时钟源，在RCC->CCIPR寄存器的RCC_CCIPR_FDCANSEL中配置。
4 j9 s& Q2 `8 F$ @$ {/ j( M0 o$ f3.置位INIT标志位，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
4.等待INIT标志位置位
8 s9 Q0 V) c: P5.置位CCE标志位，解锁受保护的寄存器
" G7 H8 j3 c. K2 F, j6.等待CCE标志位置位
7.配置时钟分频 （FDCAN_CKDIV 寄存器）
8.配置波特率
9.配置中断
10.使能筛选器
" `5 Y) t+ N# q$ |+ B4 q11.配置筛选器
12.清除INIT标志位

到此，FDCAN就配置完了，具体操作见代码
初始化代码见
+ B) A' \# I# j
" ]8 q8 O% c* C( ?5 \+ `8 W8. 发送操作
8.1 FDCAN帧模式
0 Z5 n( |  w7 j$ `+ `1 I( sFDCAN帧模式由下表各个标志位配置：
8 d( ]2 y& H! `8 z* ?/ M
* a( A+ y# {. `/ Y

: L( w+ ]0 G$ r' z7 m& Y根据上表所示，可以通过 CCCR寄存器 和 Tx Buffer 内部的标志位 配合，实现不同模式的CAN。
由于鄙人只想使用 经典CAN，因此将 CCCR寄存器 中的 FDOE 配置为 0，其他标志位我就不管了。

; H+ a1 ^5 W' Q0 _8 z2 J% C8.2 发送步骤
* D+ i) H! Q9 A1.读取 FDCAN1->TXFQS 是否有可用信箱（ FDCAN_TXFQS_TFQF 是否置位）
, O: S9 _9 O2 E' f- O& `, z2.如果没置位邮箱满标志，则查询 FDCAN_TXFQS_TFQPI 索引，获得的索引就是可以写入的邮箱
, _+ c# [' }8 _3.将要发送的数据写入刚才读取的索引的 Tx Buffer 中（在这里可以配置发送长度、ID等信息）
! F9 S5 t) H5 x2 G5 u, j; z6 J4.置位发送请求
3 o1 \+ [6 Z  P! x5 Q. [5.等待发送完成（可以不等待，配置发送完成中断使能后，在中断中置位发送完成标志来判断是否发送完毕）


* u! [) A; E+ v/ ^代码中的部分宏定义是根据手册定义的，由于太长就不放在这里了，完整代码在 代码下载

  o( B+ @; K$ J! H8 `4 g9. 接收操作
: [7 P# F) y  E  n8 Q3 v1 ]首先配置筛选器来选择接收的消息和接收后存放的FIFO。

. [  i. Y( U7 t8 D3 {# x接收分为 覆盖模式 和 阻塞模式 。
4 k" n& s+ c" u+ E; g1 g覆盖模式 顾名思义，就是当FIFO满了以后，接收到新消息后覆盖老消息。
% J$ ~3 `, J9 K) d3 a7 U" T2 U阻塞模式 就是当FIFO满了之后，忽略新消息，保留老消息。

当 Rx FIFO 0 接收到消息后，将会在 FDCAN_RXF0S 寄存器中 F0GI 标志位指示新消息存储索引，当 CPU 读取这些消息后，务必将最后 F0GI 的值写入到 FDCAN_RXF0A 的 F0AI 标志位，来确认来读取完毕，这会将 FDCAN_RXF0S寄存器中的索引标志位 F0GI 设置为 F0AI + 1 并更新 FIFO 0 的存储计数 （FDCAN_RXF0S 寄存器中 F0FL 标志位，范围0~3），如果不确认读取完毕，将会导致指示索引 F0GI 失效。

# B* Q; P) s4 ~' \: L, P2 t. _接收操作可以在中断中进行，通过配置 FDCAN_IE 寄存器中的相应 中断使能标志位 来开启中断，具体示例见初始化代码。如：使能 FIFO0 接收新消息中断就置位 FDCAN_IE_RF0NE 标志位。

因此，接收操作的步骤为：
读取接收的数据
/ R9 N% J2 L6 O! G确认读取完毕
% K9 w% y; U% N- v; K' }: L9 a
10. 故障
故障处理这里就不介绍了，值得注意的是：
当CAN两个总线短接，超过一定时间后，FDCAN会因为不能检测到有效电平而置位故障标志，同时置位初始化 INIT 标志，导致CAN关闭，排除硬件故障后可直接复位 INIT 标志来恢复故障前的运行状态（也就是说可以正常收发数据了）。

; T8 {1 f! e; e+ b

1. /**
   
2. * @description: FDCAN1 初始化
   2 E/ Q3 \6 o! O( a3 K- B: l
3. * @param {*}
   
4. * @return {*}
   
5. * @author: XL
   
6. */
   
7. void FDCAN1_Function_Init(void)
   5 A+ u6 Y% a6 L: H
8. {
   
9.         //在RCC_CCIPR寄存器中选择FDCAN时钟为HSE，即8MHz
   ' R) R7 u. _" P7 k/ l
10.         //
    
11.         FDCAN1->CCCR |= FDCAN_CCCR_INIT;                                //步骤3 置位INIT标志，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
    6 ~2 D0 B. ^! e' T
12.         while (!(FDCAN1->CCCR & FDCAN_CCCR_INIT));                //步骤4 等待INIT标志位置位
    6 g( l) h5 r% t" q3 A* c) t
13.         FDCAN1->CCCR |= FDCAN_CCCR_CCE;                                        //步骤5 置位CCE标志位，解锁受保护的寄存器
    % b5 C0 j" s, u1 K% ]% |8 ?3 a
14.         while (!(FDCAN1->CCCR & FDCAN_CCCR_CCE));                //步骤6 等待CCE标志位置位
    6 w0 w$ N" m0 L$ L6 ?% X% e& V
15.         FDCAN_CONFIG->CKDIV = 0x0;                                                //步骤7 配置时钟分频
    7 \; _2 h# p- Q7 r$ c
16.                                                                                                 //只允许在FDCAN1初始化中配置
    
17.                                                                                                 //fdcan_clk = 168 / 1 = 168 MHz,影响到FDCAN2、3（FDCAN_CONFIG地址上来说，还是属于FDCAN1）
    
18.         FDCAN1->CCCR |= 0
    
19.                                         // |FDCAN_CCCR_NISO                                //bit15: 【0|ISO11898-1】【1|CANFD v1.0】
    3 l3 u1 Q! b9 x" D) [$ f' Z$ ]
20.                                         // |FDCAN_CCCR_TXP                                        //bit14: 【1|在下上一个成功帧后暂停两个bit再起始】
    ( c( R  m* a7 m' N0 }
21.                                         // |FDCAN_CCCR_EFBI                                //bit13: 【1|同步检测边沿需要两个显性tq】
    6 f  w' w, e8 H% ^" Z' W
22.                                         // |FDCAN_CCCR_PXHD                                //bit12: 【0|启动协议异常处理】【1|禁用协议异常处理】
    ( [6 W/ @8 c" ^, K' N, p- N+ S+ e5 B
23.                                         // |FDCAN_CCCR_BRSE                                //bit09: 【1|启用波特率切换】
    
24.                                         // |FDCAN_CCCR_FDOE                                //bit08: 【0|FD操作禁止】【1|FD操作使能】
    
25.                                         // |FDCAN_CCCR_TEST                                //bit07: 【1|测试模式使能】
    6 `  b4 r6 T2 H" h
26.                                         |FDCAN_CCCR_DAR                                        //bit06: 【0|启用发送失败后自动重传】【1|禁止自动重传】
    2 K: X. @, t1 }& N3 G
27.                                         // |FDCAN_CCCR_MON                                        //bit05: 【0|总线监控模式禁止】【1|总线监控模式使能】
    7 |. P: q( m4 w: Q& b$ ?/ Y  i, _8 j
28.                                         // |FDCAN_CCCR_CSR                                        //bit04: 【0|无时钟停止请求】【1|时钟停止请求，当时钟停止请求发生，先置位INIT在置位CSA在所有传输请求完成并且CAN总线空闲】
    
29.                                         // |FDCAN_CCCR_CSA                                        //bit03: 【0|没有时钟停止】【1|FDCAN可通过停止APB时钟和内核时钟来进行掉电】
    1 w9 L" G' S: c( f2 W
30.                                         // |FDCAN_CCCR_ASM                                        //bit02: 【1|启用限制模式，限制模式下不会主动发送数据】
    7 h4 _6 `5 K# B+ M  n
31.                                         // |FDCAN_CCCR_CCE                                        //bit01: 【1|允许配置受保护的寄存器，INIT标志位必须置位】
    
32.                                         // |FDCAN_CCCR_INIT                                //bit00: 【1|初始化开始】
    % B2 B6 P/ V. E* {
33.                                         ;
    
34.         // FDCAN1->DBTP = 0                                                                //数据帧的波特率（FDCAN模式需要配置，经典CAN不需要配置）
    6 Z# E' r( r& V& v( t
35.         //                                 |FDCAN_DBTP_TDC                                        //bit23: 【1|收发延时补偿使能】
    
36.         //                                 |(0 << FDCAN_DBTP_DBRP_Pos)                //bit[20:16]: tq = (BRP + 1)*fdcan_clk
    $ E' |0 J% S# S9 [& Q
37.         //                                 |(22 << FDCAN_DBTP_DTSEG1_Pos)        //bit[12:08]: 一阶段采样                        8000000
    / h5 n- ?) m; v2 y2 {. W1 v
38.         //                                 |(7 << FDCAN_DBTP_DTSEG2_Pos)        //bit[07:04]: 二阶段采样 波特率 = 8000000/(3+DTSEG1+DTSEG2) = 8000000/32 = 250k
    + ~/ I( T' ~: K% l& k1 \
39.         //                                 |(4 << FDCAN_DBTP_DSJW_Pos)                //bit[03:00]: 同步脉宽
    4 A, O  n5 B- v" `
40.         //                                 ;
    
41.         FDCAN1->NBTP = 0                                                                        //步骤8 配置波特率
    
42.                                         |(4 << FDCAN_NBTP_NSJW_Pos)                //bit[31:25]: 同步脉宽 必须小于SEG2
    5 L4 i7 w; B& r) X! I3 l
43.                                         |(0 << FDCAN_NBTP_NBRP_Pos)                //bit[24:16]: BRP   tq = (BRP + 1)*fdcan_clk
    5 {7 }* @4 J; u: s5 G2 z" w6 A) Z
44.                                         |(22 << FDCAN_NBTP_NTSEG1_Pos)        //bit[15:08]: 一阶段采样
    
45.                                         |(7 << FDCAN_NBTP_NTSEG2_Pos)        //bit[06:00]: 二阶段采样 波特率 = 8000000/(3+DTSEG1+DTSEG2) = 8000000/32 = 250k
    
46.                                         ;
    5 i, v6 L: Z8 q
47.         //步骤9 配置中断
    
48.         FDCAN1->IE |= 0
    . S* L$ E: S7 v2 b. a7 ?
49.                                         // |FDCAN_IE_ARAE                                        //bit23: 访问保留地址使能
    $ I; ^" W, u2 }" C6 k4 |' ^
50.                                         // |FDCAN_IE_PEDE                                        //bit22: 数据阶段协议错误
    
51.                                         // |FDCAN_IE_PEAE                                        //bit21: 仲裁阶段协议错误
    
52.                                         // |FDCAN_IE_WDIE                                        //bit20: 看门狗使能
    
53.                                         // |FDCAN_IE_BOE                                        //bit19: 总线关闭使能
    
54.                                         // |FDCAN_IE_EWE                                        //bit18: 警告状态中断使能
    6 E! ^& f: I# J  i' m
55.                                         // |FDCAN_IE_EPE                                        //bit17: 错误被动中断使能
    
56.                                         // |FDCAN_IE_ELOE                                        //bit16: 错误记录语出中断使能
    
57.                                         // |FDCAN_IE_TOOE                                        //bit15: 超时中断使能
    
58.                                         // |FDCAN_IE_MRAFE                                        //bit14: 信息RAM访问失败中断使能
    ( z. R9 H1 `8 B# c3 P
59.                                         // |FDCAN_IE_TSWE                                        //bit13: 时间戳重复中断使能
    
60.                                         // |FDCAN_IE_TEFLE                                        //bit12: TX事件FIFO元素丢失中断使能
    
61.                                         // |FDCAN_IE_TEFFE                                        //bit11: TX时间FIFO满中断使能
    # w3 ?, ^8 |0 F
62.                                         // |FDCAN_IE_TEFNE                                        //bit10: TX事件FIFO新元素进入中断使能
    6 C# G5 R4 U8 @6 ?4 s2 ^+ {. S9 |, G
63.                                         // |FDCAN_IE_TFEE                                        //bit09: TXFIFO空中断使能
    
64.                                         // |FDCAN_IE_TCFE                                        //bit08: 发送取消完成中断使能
    
65.                                         // |FDCAN_IE_TCE                                        //bit07: 传输完成中断使能
    
66.                                         // |FDCAN_IE_HPME                                        //bit06: 高优先级消息中断使能
    6 _4 x; c6 U# \6 h# j+ F; z" {- w% f% D
67.                                         // |FDCAN_IE_RF1LE                                        //bit05: RXFIFO1报文丢失中断使能
    ) S: S% U) U7 D1 Q
68.                                         // |FDCAN_IE_RF1FE                                        //bit04: RXFIFO1消息满中断使能
    
69.                                         |FDCAN_IE_RF1NE                                        //bit03: RXFIFO1新消息中断使能
    
70.                                         // |FDCAN_IE_RF0LE                                        //bit02: RXFIFO0报文丢失中断使能
    5 U$ o/ O) ]; ]& e
71.                                         // |FDCAN_IE_RF0FE                                        //bit01: RXFIFO0消息满中断使能
    
72.                                         |FDCAN_IE_RF0NE                                        //bit00: RXFIFO0新消息中断使能
    
73.                                         ;
    . h7 y5 x1 |- j& j2 x) w
74.         FDCAN1->ILE = 0x00000000
    
75.                                         |FDCAN_ILE_EINT1                                        //bit01: 中断总线 fdcan_intr1_it 使能
    
76.                                         |FDCAN_ILE_EINT0                                        //bit00: 中断总线 fdcan_intr0_it 使能
    . [/ Q9 J( ~; o% |& k* a
77.                                         ;
    
78.         FDCAN1->ILS = 0x00000000                                                //中断总线选择
    
79.                                         // |FDCAN_ILS_PERR                                //bit06:
    / I: b; n) g; `* m1 f; a
80.                                                                                                                 // ARAL: Access to reserved address line
    ! |$ E' q3 x0 M# e
81.                                                                                                                 // PEDL: Protocol error in data phase line
    
82.                                                                                                                 // PEAL: Protocol error in arbitration phase line
    . L  z3 U! e3 S" z: ~& L& |1 Q
83.                                                                                                                 // WDIL: Watchdog interrupt line
    
84.                                                                                                                 // BOL: Bus_Off status
    
85.                                                                                                                 // EWL: Warning status interrupt line
    % }8 ~6 n7 J# _& c0 q  n
86.                                         // |FDCAN_ILS_BERR                                //bit05:
    
87.                                                                                                                 // ELOL: Error logging overflow interrupt line
    8 r1 w' Y7 T( Q* I
88.                                         // |FDCAN_ILS_MISC                                //bit04:
    5 j2 k' w# p8 o8 Q
89.                                                                                                                 // TOOL: Timeout occurred interrupt line
    ) L* P: @3 p$ [' i* l$ x
90.                                                                                                                 // MRAFL: Message RAM access failure interrupt line
    3 w, `- N4 Z& w
91.                                                                                                                 // TSWL: Timestamp wraparound interrupt line
    
92.                                         // |FDCAN_ILS_TFERR                                //bit03:
    6 Z4 t0 t, d# ]: h; U! T' s3 s% J
93.                                                                                                                 // TEFLL: Tx event FIFO element lost interrupt line
    # z/ N" j2 R8 u/ s$ w. P* h7 c0 m
94.                                                                                                                 // TEFFL: Tx event FIFO full interrupt line
    3 q9 _- |4 ^$ H* Z% R5 o
95.                                                                                                                 // TEFNL: Tx event FIFO new entry interrupt line
    
96.                                                                                                                 // TFEL: Tx FIFO empty interrupt line
    
97.                                         // |FDCAN_ILS_SMSG                                //bit02:
      \2 H, V0 Y! \+ y& h  `, t  i
98.                                                                                                                 // TCFL: Transmission cancellation finished interrupt line
    
99.                                                                                                                 // TCL: Transmission completed interrupt line
    5 o6 M& h' U0 x9 |; \
100.                                                                                                                 // HPML: High-priority message interrupt line
     ; ~. F2 a0 ~" Z2 e$ k
101.                                         |FDCAN_ILS_RXFIFO1                                //bit01:当邮箱1的事件在 fdcan1_intr1_it 中断分支中处理
     
102.                                                                                                                 // RF1LL: Rx FIFO 1 message lost interrupt line
     
103.                                                                                                                 // RF1FL: Rx FIFO 1 full Interrupt line
     . L3 k) |1 Z" @( r' {& y" _7 D" I
104.                                                                                                                 // RF1NL: Rx FIFO 1 new message interrupt line
     1 z) ~/ @0 _. a- s" [
105.                                         // |FDCAN_ILS_RXFIFO0                        //bit00:当邮箱0的事件在 fdcan1_intr0_it 中断分支中处理
     : b9 ]8 i2 H  j1 _# [% Q  @
106.                                                                                                                 // RF0LL: Rx FIFO 0 message lost interrupt line
     ' M6 [8 x9 Q0 }$ o5 E: s1 E
107.                                                                                                                 // RF0FL: Rx FIFO 0 full interrupt line
     
108.                                                                                                                 // RF0NL: Rx FIFO 0 new message interrupt line
     1 h/ a  M; f% Q3 r8 ^2 X! a
109.                                         ;
     / z9 Y$ |9 Q6 B8 c& V- J4 T* k+ ?
110.         //步骤9 结束
     ' ?4 d8 D0 {4 Q  m6 c
111. 
     * p( I  B$ Q6 n* k; W
112.         //步骤10 使能筛选器
     . Z7 s$ G7 E9 k
113.         FDCAN1->RXGFC |= 0
     $ \/ e1 t" C, ]
114.                                         |(1 << FDCAN_RXGFC_LSE_Pos)                //bit[27:24]: 列表信息拓展【0|无拓展消息过滤】【1|1~8拓展消息】【>8|被解释为8】
     
115.                                         |(2 << FDCAN_RXGFC_LSS_Pos)                //bit[20:16]: 【0|无标准消息ID过滤】【1~28|标准消息ID元素过滤数量】【>28|被解释为28】
     
116.                                         // |FDCAN_RXGFC_F0OM                                //bit09: FIFO0模式：覆盖或者堵塞【0|阻塞模式】【1|覆盖模式】
     
117.                                         // |FDCAN_RXGFC_F1OM                                //bit08: FIFO1模式：覆盖或者堵塞【0|阻塞模式】【1|覆盖模式】
     
118.                                         |(2 << FDCAN_RXGFC_ANFS_Pos)        //bit[05:04]: 定义如何处理接收到的id为11位且与筛选器列表中的任何元素不匹配的消息。【0|在FIFO0中接收】【1|在FIFO1中接收】【2~3|拒绝】
     : |+ ?1 S, e) }7 |" M
119.                                         |(2 << FDCAN_RXGFC_ANFE_Pos)        //bit[03:02]: 定义如何处理接收到的id为29位且与筛选器列表中的任何元素不匹配的消息。【0|在FIFO0中接收】【1|在FIFO1中接收】【2~3|拒绝】
     * |9 T" j* p; B7 P1 @5 j/ f3 R
120.                                         |FDCAN_RXGFC_RRFS                                //bit01: 【1|拒绝所有11位ID远程标准帧】
     6 S4 p: e2 m5 Z2 h
121.                                         |FDCAN_RXGFC_RRFE                                //bit00: 【1|拒绝所有29位ID远程标准帧】
     
122.                                         ;
     
123.         // FDCAN1->XIDAM = 0x1FFFFFFF;                                                //FDCAN 扩展 ID 和屏蔽寄存器
     3 U# f$ G1 o+ D5 \8 |5 A
124.         // FDCAN1->TXBTIE = 0
     
125.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|发送中断使能】
     * x9 A8 k+ W* X9 w) u1 D
126.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|发送中断使能】
     5 K) c& z" j. i1 @7 T9 c3 ^
127.         //                                  |0x00000001                                                //bit00: TxBuffer【1|发送中断使能】
     & c0 U, }6 A! M2 Z. G7 [9 f$ h
128.         //                                 ;
     # t8 u2 O7 y1 |0 t
129.         // FDCAN1->TXBCIE = 0
     4 {2 _7 r& q$ x- G
130.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|取消中断使能】
     1 o+ z1 Y) n! Z% v9 U4 m
131.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|取消中断使能】
     
132.         //                                 // |0x00000001                                                //bit00: TxBuffer【1|取消中断使能】
     
133.         //                                 ;
     
134.         //步骤11 配置筛选器
     5 }% t  |6 S7 T) s& ^
135.         FDCAN1_RAM->FILTER_11BIT[0] = 0x00000000
     
136.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFT_Pos)                                //【0|范围过滤，从SFID1~SFID2】【1|单独滤波SFID1和SFID2】【2|经典滤波】【3|禁用过滤】
     
137.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFEC_Pos)                                //【0|禁用过滤元件】【1|匹配存储在FIFO0】【2|匹配存储在FIFO1】【3|匹配存就拒绝】【4|匹配设置优先级】【5|匹配设置优先级并存储到FIFO0中】【6|匹配设置优先级并存储到FIFO1中】【7|保留】
     ' L3 m6 P: N6 |9 {
138.                                                                 |(0x600 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     
139.                                                                 |(0x609 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
140.                                                                 ;//列表滤波，只接收 ID为0x600和0x609 的数据，并且这两个ID放入FIFO0中
     
141.         FDCAN1_RAM->FILTER_11BIT[1] = 0x00000000
     
142.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFT_Pos)                                //【0|范围过滤，从SFID1~SFID2】【1|单独滤波SFID1和SFID2】【2|经典滤波】【3|禁用过滤】
     - w5 t% r9 j& v+ |$ Q: F3 [
143.                                                                 |(2 << FDCANx_RAM_FILTER11_S0_SFEC_Pos)                                //【0|禁用过滤元件】【1|匹配存储在FIFO0】【2|匹配存储在FIFO1】【3|匹配存就拒绝】【4|匹配设置优先级】【5|匹配设置优先级并存储到FIFO0中】【6|匹配设置优先级并存储到FIFO1中】【7|保留】
     8 L! _6 k9 f9 K* h+ f6 J, J
144.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     8 w2 b$ t! s2 y; P  d" P3 S
145.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
146.                                                                 ;//列表滤波，只接收 ID为0x209 的数据，并且这个ID放入FIFO1中
     
147. 
     
148.         FDCAN1_RAM->FILTER_29BIT[0][0] = 0x00000000
     . G; |  q" ^! E
149.                                                                         |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     
150.                                                                         |(0x0CCCCCCC << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
151.                                                                         ;
     
152.         // FDCAN1_RAM->FILTER_29BIT[0][1] = 0x00000000
     
153.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
154.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     $ T& C7 ~- _( G, s- n  T2 M
155.         //                                                                 ;
     
156.         // FDCAN1_RAM->FILTER_29BIT[1][0] = 0x00000000
     ( S" b3 U3 ~- x4 @
157.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     
158.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     " T4 A/ e0 U$ z( a
159.         //                                                                 ;
     6 B9 y9 [0 H5 B8 Y0 X& |
160.         // FDCAN1_RAM->FILTER_29BIT[1][1] = 0x00000000
     3 h, y& N7 b0 E# f- z# l4 a
161.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
162.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     $ b. [: q' O$ V' p" R6 y1 d
163.         //                                                                 ;
     ) y; b" n* S0 M
164.         // FDCAN1_RAM->FILTER_29BIT[2][0] = 0x00000000
     0 e9 R( g& H$ h  X3 A$ B
165.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     
166.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     9 f& ~: x9 m0 \: x/ o
167.         //                                                                 ;
     
168.         // FDCAN1_RAM->FILTER_29BIT[2][1] = 0x00000000
     : O. F: y% C8 R- V- H8 m
169.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     : m$ q1 i  W! R! T9 K
170.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
171.         //                                                                 ;
       V: k# T( n9 `5 M& ?. Q9 i7 Q  |- n
172. 
     
173.         // FDCAN1_RAM->FILTER_29BIT[3][0] = 0x00000000
     # @. W2 b. T4 a
174.         //                                                                 |(2 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     
175.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
176.         //                                                                 ;
     
177.         // FDCAN1_RAM->FILTER_29BIT[3][1] = 0x00000000
       H0 K! s( B1 r8 k, A0 x7 D
178.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
179.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     0 q5 v- L  x' H
180.         //                                                                 ;
     
181.         // FDCAN1_RAM->FILTER_29BIT[4][0] = 0x00000000
     1 W0 E# B0 e4 w" f' S
182.         //                                                                 |(2 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     
183.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     : g( P, y# M- ]4 G5 `8 @) y
184.         //                                                                 ;
     
185.         // FDCAN1_RAM->FILTER_29BIT[4][1] = 0x00000000
     0 X* v0 y! D5 X" e: ?  t
186.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
187.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     ( z; ^  [4 m; X; D7 Q' x+ p
188.         //                                                                 ;
     , z/ b% d. Y; K' G) T5 j
189. 
     5 j- z+ x9 F7 [  `
190.         //步骤12 清除INIT标志位
     4 n8 j" C4 I( ?, k
191.         FDCAN1->CCCR &= ~FDCAN_CCCR_INIT;//退出初始化模式，CCE会自动清除
       A, l+ w0 S! Z- w; u" O
192.         while (FDCAN1->CCCR & FDCAN_CCCR_INIT);//等待退出
     
193. }

复制代码

返回第7章 FDCAN的初始化
返回第9章 接收操作

附录2 发送函数
) e2 ^" o. J0 B2 f( j2 G

1. /**
   , @4 @  C" C' R" d. t- j6 J
2. * @description: 发送11位地址的报文
   
3. * @param {uint8_t} FDCAN_Index                FDCANx 1~3 FDCAN外设索引使用FDCAN1/2/3
   0 [7 A6 R4 K. ?5 H! a' k' `# B
4. * @param {uint16_t} ID                                11位ID发送
   3 E0 J7 p0 Q8 M8 P8 A. Y5 _# R5 D, ?4 m
5. * @param {uint8_t} RTR                                0-数据帧        1-远程帧
   
6. * @param {uint8_t} DLC                                数据长度 0~8
   
7. * @param {Buffer_72Byte_Struct}         *buffer 发送数组地址
   
8. * @return {uint8_t}                                SUCCEED/FAILED/ERROR
   # o# b, x- x  S8 U% w* g
9. * @author: XL
   % Y- t; \- N) \0 x9 ?7 ]& n. B
10. */
    
11. uint8_t FDCAN_11ID_SendData(uint8_t FDCAN_Index, uint16_t ID,uint8_t RTR,uint8_t DLC,Buffer_72Byte_Struct *buffer)
    
12. {
    
13.         uint8_t Free_Mailbox;//空闲邮箱索引
    
14.         FDCAN_RAM_Struct* FDCAN_RAM;//FDCANx_RAM指针
    
15.         FDCAN_GlobalTypeDef* FDCAN;//FDCANx指针
    
16.         switch (FDCAN_Index)//根据索引确定使用FDCANx
    
17.         {
    . @: h; `9 m% u+ g, k( V
18.         case 1:
    
19.                 FDCAN_RAM = FDCAN1_RAM;
    
20.                 FDCAN = FDCAN1;
    & N+ p& S' a2 X: A( B1 Z4 K
21.                 break;
    " l+ r8 a/ [/ I# D0 F9 i9 W; ?# j
22.         case 2:
    5 E, }5 D6 j7 d$ n
23.                 FDCAN_RAM = FDCAN2_RAM;
    3 x: a3 @4 N6 d' q# W
24.                 FDCAN = FDCAN2;
    
25.                 break;
    
26.         case 3:
      A5 y" H* h) a2 ?
27.                 FDCAN_RAM = FDCAN3_RAM;
    
28.                 FDCAN = FDCAN3;
    $ j  i5 p/ D5 m+ m3 n; v
29.                 break;
    
30.         default:
    
31.                 return ERROR;//输入索引错误，无效
    8 L: _9 u! u3 l/ x/ g/ {
32.                 break;
    + y$ k$ \+ m1 K+ P! k! F
33.         }
    
34.         if(FDCAN->TXFQS & FDCAN_TXFQS_TFQF)
    
35.         {                                                                                        //CanBus判断是否有空闲的发送寄存器，然后发送，否则等待
    
36.                 return FAILED;//没有空闲邮箱
    
37.         }
    
38.         else
    
39.         {                                                                                        //只要第一个邮箱空闲，始终先使用第一个，然后是第二个，第三个邮箱
    . E5 H; p. p# C! s. U, |. s3 [
40.                 Free_Mailbox = ((uint8_t)(FDCAN->TXFQS >> 16)) & 0x03;//获取空闲邮箱
    ! V. [8 s" T: U5 \9 C, x) }4 W
41.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][0] = ((uint32_t)ID << FDCANx_RAM_TxBuffer_T0_11ID_Pos);//写入地址
    / J4 _( j* s6 m+ ]2 ~4 l
42.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][1] = (DLC << FDCANx_RAM_TxBuffer_T1_DLC_Pos);//发送长度
    / ]3 k0 _1 G  h$ F* _8 J
43.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][2] = buffer->DataWord[0];//发送的数据
    ; {9 S+ r& M' Q. w. G
44.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][3] = buffer->DataWord[1];//发送的数据
    0 x: T1 s. L$ U% p# k
45.                 FDCAN->TXBAR |= (0x0001 << Free_Mailbox);//置位发送请求
    
46.                 return SUCCEED;//返回成功
    5 ?: V. D/ t& v, a0 T7 y2 M
47.         }
    % `5 R1 T2 ?$ u# l
48. }

复制代码

1 r+ i" p% ^8 M+ v返回第8章 发送操作

1 i5 P( m. ~2 h' M附录3 接收中断程序
/ [7 I- Q0 L# P  T) n返回第9章 接收操作
4 Z  l, }8 Q/ A6 ^% j" ~4 U
2 U4 a$ N3 s9 p: ^# ?, q

1. /**
   
2. * @description: fdcan1_intr0_it 中断分支
   * M" G$ Z, H$ Q" A# n
3. * @param {*}
   
4. * @return {*}
   % _+ M9 A6 ^3 \! k- ]: c
5. * @author: XL
   
6. */
   - @: G/ R1 O/ P% I+ {+ h" A& L
7. void FDCAN1_IT0_IRQHandler(void)
   
8. {
   
9.         if(FDCAN1->IR & FDCAN_IR_RF0N)//邮箱0有新消息
   $ j7 a8 m3 E! S! }6 l
10.         {
    
11.                 FDCAN1->IR |= FDCAN_IR_RF0N;//清除新消息状态标志
    
12.                 switch((FDCAN1->RXF0S & FDCAN_RXF0S_F0GI) >> FDCAN_RXF0S_F0GI_Pos)//获取索引
    
13.                 {
    . X, q8 b  j) m/ l1 c1 j( ]
14.                         case 0:
    
15.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[0][0];//获取数据
    
16.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[0][1];//获取数据
    
17.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[0][2];//获取数据
    7 A: u% v9 G* t) Y+ G+ H$ t
18.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[0][3];//获取数据
    
19.                                 FDCAN1->RXF0A = 0;//确认接收完毕
    
20.                                 break;
    
21.                         case 1:
    * y0 O7 _! |$ k4 q4 [/ ~  s
22.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[1][0];
    
23.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[1][1];
    
24.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[1][2];
    
25.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[1][3];
    
26.                                 FDCAN1->RXF0A = 1;
    
27.                                 break;
    
28.                         case 2:
    
29.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[2][0];
    
30.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[2][1];
    
31.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[2][2];
    
32.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[2][3];
    
33.                                 FDCAN1->RXF0A = 2;
    
34.                                 break;
    ! @" O  t6 \: o' S# M; b
35.                         default:break;
    
36.                 }
      p6 E7 s$ _  r' |
37.         }
    5 F! v+ D7 g" Q. F
38. }
    " H3 _( e8 h) G' y% k& b
39. 
    ! _$ z. F+ \5 x2 Q7 |
40. /**
      ^/ W8 U6 {6 j) a3 i
41. * @description: fdcan1_intr1_it 中断分支
    * j) M. F* R, Y
42. * @param {*}
    0 {1 D2 h$ g) R% H( I2 O
43. * @return {*}
    
44. * @author: XL
    . V) z" i) F$ }: W  q
45. */
    ( ?! X& v/ `) b
46. void FDCAN1_IT1_IRQHandler(void)
    
47. {
    
48.         if(FDCAN1->IR & FDCAN_IR_RF1N)//邮箱1有新消息
    : k  D* W4 L7 Y" q' c+ ]9 R& d& G
49.         {
    
50.                 FDCAN1->IR |= FDCAN_IR_RF1N;//清除新消息状态标志
    5 A+ x# I. e  x3 w# t! h! |
51.                 switch((FDCAN1->RXF1S & FDCAN_RXF1S_F1GI) >> FDCAN_RXF1S_F1GI_Pos)//获取索引
    . J4 `. C5 `9 [6 T9 `$ f
52.                 {
    
53.                         case 0:
    * j3 C5 \# [; j* b
54.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[0][0];//获取数据
    
55.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[0][1];//获取数据
    
56.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[0][2];//获取数据
    " ~0 y" V5 S' A4 Y
57.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[0][3];//获取数据
    3 h3 k$ I" ^) W& `5 F
58.                                 FDCAN1->RXF1A = 0;//确认接收完毕
    ( i" A: l/ l1 ]8 s8 |$ L
59.                                 break;
    
60.                         case 1:
    # |' ], F9 `! P0 L
61.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[1][0];
    
62.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[1][1];
    
63.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[1][2];
    $ H' [* E4 X* {5 ~6 W. @) e
64.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[1][3];
    
65.                                 FDCAN1->RXF1A = 1;
    
66.                                 break;
    
67.                         case 2:
    ( f/ b- c9 r, M. L0 E
68.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[2][0];
    
69.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[2][1];
    # P; {  d9 f" t4 [6 K! O/ @- M
70.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[2][2];
    ) B3 _' C; C' w9 g9 h
71.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[2][3];
    7 `  I6 |2 L1 F$ R8 v2 G. P1 {: ?- R
72.                                 FDCAN1->RXF1A = 2;
    
73.                                 break;
    2 G: j* w" r2 E( A$ F8 r! H; C9 T
74.                         default:break;
    
75.                 }
    : o' [) Q, s# m. V% A
76.         }
    
77. }

复制代码

) F0 j- M" _% O6 G: t$ m
————————————————
转载：Vice Versa XL