FDCAN 与 经典CAN 的最直观差别就是数据帧部分，FDCAN的数据帧波特率可变，并且数据大小不局限于 8 Bytes ，最高支持 64 Bytes 的数据传输。详细差别见 传送门： CAN FD 与 CAN协议区别–简单易懂协议详解 。
" Y9 V9 \. q9 \. K( w. y3 D6 I/ f
4 m1 d$ v: V7 n( o; J  F7 H1. FDCAN的框图
' d- Y5 S" I- s


6 \' Z  M! I7 Z- F' u9 l9 P根据上图可以看到，FDCAN 有两个时钟域，APB总线接口和CAN内核时钟。FDCAN的波特率取决于内核时钟；寄存器的配置、消息RAM等，走的是APB时钟。FDCAN的APB时钟在RCC_APB寄存器中配置，内核时钟在RCC_CCIPR寄存器中配置（下一章）。
* E* L! P1 l* k1 y0 XFDCAN有两个中断线，这两个中断线可以单独的打开或关闭，在FDCAN_ILE寄存器中配置。
2 O- N3 b  A) E; p' z其他具体介绍参考DM00355726_ENV4手册的1947页（RM0440手册官方下载传送门）。
* x+ _7 y/ O- V! p- i0 X
2. FDCAN的时钟与波特率
2.1 fdcan_clk
几乎所有通信都可在RCC中配置时钟选择，FDCAN的时钟（fdcan_clk）可在RCC_CCIPR寄存器中进行配置。
' ]9 `+ X3 a, h0 {" B2 Z9 W
9 h3 s" @1 B2 p) h
5 H$ W1 K& i+ i5 J$ O! V' f3 J) D
$ T; r  M1 E6 l) ~/ g5 Q6 UFDCAN1/2/3 的内核时钟是通用的，可以在配置FDCAN1的时候，配置 CKDIV 寄存器进行进一步的分频（INIT标志位置位才可配置该寄存器），这里配置的CKDIV影响到 FDCAN2 和 FDCAN3。

2.2 fdcan_tq_ck
' Y' T% n  p& ^" A根据系统框图可看到，系统输入的时钟可通过 fdcan_clk 分频得到 fdcan_tq_ck ，在 FDCAN_CKDIV 寄存器中配置分频系数。
0 I: Q9 c: W2 D- C" V+ _


可以认为FDCAN内核用的时钟都是fdcan_tq_ck ，只不过 fdcan_tq_ck 为1分频时候认为是fdcan_clk 。
' `( D. Z4 U/ x; s5 b. E$ v; x
2.3 波特率
FDCAN模块的bit采样分三段：
' k* L! S. j8 Y: E# T: b' {



" K' \. [) Y0 h: J波特率公式如下：
3 r3 b' w! u& Y7 I) Z- B0 e/ r
. B- w: }, j6 g3 R: w

, s% o* U! l7 l  M# l0 u& P% v: n( l注意：
' P; a2 \. t( J" V( F1 G1、由于 FDCAN 与 经典CAN 的帧格式有点差异，其数据帧波特率可变，因此在这里分出普通CAN和数据bit时间
2、数据 和 普通 bit 时间寄存器名称不一样，数据波特率寄存器 FDCAN_DBTP ，一般帧波特率寄存器为 FDCAN_NBTP 。当使用经典模式CAN时， FDCAN_DBTP 配置被忽略

5 Z. Y! v4 n: @# \3. FDCAN的地址分布
3.1 总体分布
- k9 U( V5 m' k5 W' e2 g, B! R
+ \, P( Y& G- a- a2 k( c
6 y' R7 t$ o0 ?$ ]* W1 ]! T
4 G) i" |/ f* l0 c由于头文件中没有该寄存器的宏定义，因此需要自己建立宏定义。
; s. q4 k, b/ W% F1 |4 m7 IG474的FDCAN外设一共有3组（FDCAN1，FDCAN2，FDCAN3），寄存器配置分为3个，消息RAM也分为3组。
" J& |% H8 t% b7 F4 @) D+ p" o* u
8 V: f- z$ n/ z3.2 Message RAM


, Q% m: b5 ^$ X1 G
1个 信息RAM 有 212 words 的大小，即 212 × 4 = 848 Bytes 。
8 h/ @) X! ^4 T6 e0 }9 H
根据3.1和3.2可以先把 消息RAM 的宏定义写好

1. #define FDCANs_MESSAGE_RAM_BASE                                        0x4000A400
   
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)
   . u0 b) O, [( c6 y! v. f
5. 
   ) S8 @; Y/ \5 j# l
6. typedef struct
   
7. {
   9 g5 _0 b8 ~3 c( N' y; w
8.         uint32_t FILTER_11BIT[28];                //0x4000A400 ~ 0x4000A470
   
9.         uint32_t FILTER_29BIT[8][2];        //0x4000A470 ~ 0x4000A4B0
   
10.         uint32_t Rx_FIFO_0[3][18];                //0x4000A4B0 ~ 0x4000A588
    - V: M! b3 R8 C- q
11.         uint32_t Rx_FIFO_1[3][18];                //0x4000A588 ~ 0x4000A660
    
12.         uint32_t Tx_FIFO[6];                        //0x4000A660 ~ 0x4000A678
    
13.         uint32_t Tx_BUFFER[3][18];                //0x4000A678 ~ 0x4000A750
    " r% T3 d, f8 i- _" R
14. }FDCAN_RAM_Struct;
    
15. 
    3 O* k/ p+ }1 x7 L
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)

复制代码

$ i0 h- G3 S  q/ S3 M, v) C注意！！！ 上面的代码第1行的宏定义部分，偏移为 0x350 而不是 0x400。
曾经我根据 3.1里面的图片进行配置（0x400也就是1KB），结果只有FDCAN1好用，FDCAN2和FDCAN3都不能使用，困扰了我一天来找这个问题，后来使用 0x350 就可以了，可能是手册写错了，也可能是我的理解与有误。
这里是个坑，希望大家能够规避一下。

4. FDCAN中断配置
) X% j# j: o3 q1 D4.1 中断寄存器
FDCAN中断配置中，涉及的寄存器为
4 }1 m' a' w9 v* g  ^) T
2 ~8 v* P6 ?0 J$ l( T, JFDCAN_IE 与其他外设的IE一样，中断使能寄存器，在这里选择使用的中断，在代码中会注释
4 T8 A( ^% i: J% }/ T( |' fFDCAN_ILE 中断总线使能。FDCAN中将中断分为了两个分支，即有两个中断函数
FDCAN_ILS 中断总线选择。在这个寄存器中配置哪个中断归属于哪个中断分支，默认都为分支0.

( ^" x8 `7 f- R, V/ u+ w
( W. ^: F, E/ n9 P* f* j! E& D5. FDCAN的筛选器
* p1 \- E1 \" b: h5.1 筛选器的特征
每个筛选器可配置为
• 范围筛选
• 指定ID筛选
• 屏蔽典型bit筛选
每个过滤器元件可配置为接受或拒绝过滤
每个过滤器元素可以单独启用/禁用
过滤器是按顺序检查的，执行在第一个匹配的过滤器元素时停止
相关的寄存器：全局筛选配置（RXGFC）、拓展ID和掩码（XIDAM）
( B2 F' v! h2 R0 ^% N# n
如果需要接收数据，一定要配置筛选器，否则会什么也接受不到。

0 Q8 M" W# T7 ?8 P1 R- @5.2 11-bit 筛选器的格式

  o0 g# z- @* f5 f2 a2 l% L5 `
& Z5 S- F& O2 K. D6 s
2 }0 {1 V2 Q7 g3 H5 g( k- b8 V8 V! [+ `3 W这里根据手册的翻译进行配置就好，29-bit 的筛选器也是如此，手册里全有，我就不放图片了，太占地方。

对于筛选器的掩码模式，可通过传送门了解到：CAN通讯难点———验收筛选器
1 m$ S/ v) ]" J" I
6 t# M  G0 G0 @& y2 `& s* P通过配置筛选器，可以使FDCAN外设接收其他模块发来的信息，在筛选器中配置接收消息的FIFO或者拒收消息。配置筛选器是FDCAN接收的关键。
& X5 C) R2 [' F7 q. a5 x筛选器的配置不受 INIT 和 CCE 标志位的限制，可随时配置。

6. FIFO模式与Queue模式
FIFO模式与队列模式的区别为：
# D2 X8 V: y5 [4 [4 b队列模式的优先级遵循邮箱0优先级最高，其次是1，最后是2，如果当前3个邮箱全有数据，优先发送邮箱0的数据
FIFO模式的优先级是遵循哪个数据先进入的邮箱，与其所在的索引地址无关，即：如果当前3个邮箱全有数据，邮箱2被最先写入，则优先发送邮箱2的数据。
% Q! J6 d2 S6 U- X6 {
  I5 N) x" C7 T$ V5 \3 T6.1 TX FIFO 的寄存器格式
! C0 Z5 p: L2 `; O

+ p3 n6 ^' N; L8 v! z# p. F. W* g
! r0 [+ n5 h) j& P5 f具体说明见手册1969页，我就不复制了，翻一下就能懂每个BIT代表的意思。
根据上表，我们就可以写出对应各个标志位的结构体，方便后期指针使用。
0 ?0 i. z1 I8 Q: f8 m) y% f8 h由于其buffer支持 11-bit ID 和 29-bit ID
. j, G* y' b% x: e$ m9 |
7. FDCAN的初始化
3 A( u0 j( d* M1 b' V1 K0 C9 bIO口配置我就不介绍了，想必大家都会配置IO。

1.首先在RCC->APB1RSTR1寄存器中使能RCC_APB1ENR1_FDCANEN，这样FDCAN的寄存器就可以配置了。
% `1 ^( m- p: a+ l2.然后选择FDCAN内核时钟的时钟源，在RCC->CCIPR寄存器的RCC_CCIPR_FDCANSEL中配置。
3.置位INIT标志位，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
2 \5 A; y5 ~' F4.等待INIT标志位置位
5.置位CCE标志位，解锁受保护的寄存器
6.等待CCE标志位置位
7.配置时钟分频 （FDCAN_CKDIV 寄存器）
8.配置波特率
9.配置中断
. j7 @9 G. j! C4 {# k( T10.使能筛选器
11.配置筛选器
12.清除INIT标志位

到此，FDCAN就配置完了，具体操作见代码
初始化代码见
2 Z7 G2 ~( V6 M
8. 发送操作
) e7 f& ]  T4 N* c1 P8.1 FDCAN帧模式
FDCAN帧模式由下表各个标志位配置：
9 ~( J2 o0 r- K% v0 A' G0 H2 h
! S" e8 ~3 L- S& A
9 [" Q$ o' |9 U6 B. ~
, F# c& ~. Y- }根据上表所示，可以通过 CCCR寄存器 和 Tx Buffer 内部的标志位 配合，实现不同模式的CAN。
5 P1 A. Z4 X, |- H: ]# j2 ~由于鄙人只想使用 经典CAN，因此将 CCCR寄存器 中的 FDOE 配置为 0，其他标志位我就不管了。

0 X7 y1 s8 @! M! T; c4 c8.2 发送步骤
1.读取 FDCAN1->TXFQS 是否有可用信箱（ FDCAN_TXFQS_TFQF 是否置位）
, i# ^5 J2 K6 x0 R, c2.如果没置位邮箱满标志，则查询 FDCAN_TXFQS_TFQPI 索引，获得的索引就是可以写入的邮箱
3.将要发送的数据写入刚才读取的索引的 Tx Buffer 中（在这里可以配置发送长度、ID等信息）
4.置位发送请求
) B$ H0 m( ~' S: x% y* s! f5.等待发送完成（可以不等待，配置发送完成中断使能后，在中断中置位发送完成标志来判断是否发送完毕）


代码中的部分宏定义是根据手册定义的，由于太长就不放在这里了，完整代码在 代码下载

9. 接收操作
首先配置筛选器来选择接收的消息和接收后存放的FIFO。

' Q$ V& X$ L& W接收分为 覆盖模式 和 阻塞模式 。
, e+ l; A1 I8 |4 [, G覆盖模式 顾名思义，就是当FIFO满了以后，接收到新消息后覆盖老消息。
阻塞模式 就是当FIFO满了之后，忽略新消息，保留老消息。

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

8 [. M' m$ i6 S( V, Z接收操作可以在中断中进行，通过配置 FDCAN_IE 寄存器中的相应 中断使能标志位 来开启中断，具体示例见初始化代码。如：使能 FIFO0 接收新消息中断就置位 FDCAN_IE_RF0NE 标志位。
0 H, |1 _; V( M! w. _
因此，接收操作的步骤为：
读取接收的数据
确认读取完毕
/ n6 F) ^6 z9 u* @
) W, k" `+ i! d, L6 Q0 _3 L2 Q10. 故障
故障处理这里就不介绍了，值得注意的是：
当CAN两个总线短接，超过一定时间后，FDCAN会因为不能检测到有效电平而置位故障标志，同时置位初始化 INIT 标志，导致CAN关闭，排除硬件故障后可直接复位 INIT 标志来恢复故障前的运行状态（也就是说可以正常收发数据了）。
7 @: |' U4 v: i) {+ k( k% K8 w

1. /**
   
2. * @description: FDCAN1 初始化
   
3. * @param {*}
   ! M; G  d# j1 T1 I
4. * @return {*}
   2 P, B4 k" E$ d
5. * @author: XL
   
6. */
   
7. void FDCAN1_Function_Init(void)
   2 b" d. e' o7 X' S$ ]
8. {
   4 B/ V9 t$ u" n: n
9.         //在RCC_CCIPR寄存器中选择FDCAN时钟为HSE，即8MHz
   
10.         //
    
11.         FDCAN1->CCCR |= FDCAN_CCCR_INIT;                                //步骤3 置位INIT标志，开始配置寄存器（只有INIT标志位置位，才可置位CCE标志位）
    
12.         while (!(FDCAN1->CCCR & FDCAN_CCCR_INIT));                //步骤4 等待INIT标志位置位
      K* |$ b1 b/ P3 r9 t5 o, F! F& i
13.         FDCAN1->CCCR |= FDCAN_CCCR_CCE;                                        //步骤5 置位CCE标志位，解锁受保护的寄存器
    " m8 Y4 E- w  o9 @7 y4 h4 N
14.         while (!(FDCAN1->CCCR & FDCAN_CCCR_CCE));                //步骤6 等待CCE标志位置位
    
15.         FDCAN_CONFIG->CKDIV = 0x0;                                                //步骤7 配置时钟分频
    
16.                                                                                                 //只允许在FDCAN1初始化中配置
    5 g/ F" \& M9 H1 a; M! N$ H
17.                                                                                                 //fdcan_clk = 168 / 1 = 168 MHz,影响到FDCAN2、3（FDCAN_CONFIG地址上来说，还是属于FDCAN1）
    3 y4 s5 a. p! `1 q9 b* X# J* t3 o
18.         FDCAN1->CCCR |= 0
    ' [$ V) A3 Z* Z
19.                                         // |FDCAN_CCCR_NISO                                //bit15: 【0|ISO11898-1】【1|CANFD v1.0】
    
20.                                         // |FDCAN_CCCR_TXP                                        //bit14: 【1|在下上一个成功帧后暂停两个bit再起始】
    % P7 c2 Q# M' d# W
21.                                         // |FDCAN_CCCR_EFBI                                //bit13: 【1|同步检测边沿需要两个显性tq】
    
22.                                         // |FDCAN_CCCR_PXHD                                //bit12: 【0|启动协议异常处理】【1|禁用协议异常处理】
    
23.                                         // |FDCAN_CCCR_BRSE                                //bit09: 【1|启用波特率切换】
    
24.                                         // |FDCAN_CCCR_FDOE                                //bit08: 【0|FD操作禁止】【1|FD操作使能】
    
25.                                         // |FDCAN_CCCR_TEST                                //bit07: 【1|测试模式使能】
    
26.                                         |FDCAN_CCCR_DAR                                        //bit06: 【0|启用发送失败后自动重传】【1|禁止自动重传】
    
27.                                         // |FDCAN_CCCR_MON                                        //bit05: 【0|总线监控模式禁止】【1|总线监控模式使能】
    - D5 M( G: N, ^) J, J% ~
28.                                         // |FDCAN_CCCR_CSR                                        //bit04: 【0|无时钟停止请求】【1|时钟停止请求，当时钟停止请求发生，先置位INIT在置位CSA在所有传输请求完成并且CAN总线空闲】
    & K7 c& y. R& @8 Z3 _
29.                                         // |FDCAN_CCCR_CSA                                        //bit03: 【0|没有时钟停止】【1|FDCAN可通过停止APB时钟和内核时钟来进行掉电】
    
30.                                         // |FDCAN_CCCR_ASM                                        //bit02: 【1|启用限制模式，限制模式下不会主动发送数据】
    
31.                                         // |FDCAN_CCCR_CCE                                        //bit01: 【1|允许配置受保护的寄存器，INIT标志位必须置位】
    
32.                                         // |FDCAN_CCCR_INIT                                //bit00: 【1|初始化开始】
    6 |: I9 C( i5 v) K( {7 `! s
33.                                         ;
    ( x5 x" B, q% G. N9 ~: H) |0 t
34.         // FDCAN1->DBTP = 0                                                                //数据帧的波特率（FDCAN模式需要配置，经典CAN不需要配置）
    $ |5 {5 e8 L5 j& ]: L8 U4 g
35.         //                                 |FDCAN_DBTP_TDC                                        //bit23: 【1|收发延时补偿使能】
    ( a5 q; v( q2 ]9 L' u" D  b% L
36.         //                                 |(0 << FDCAN_DBTP_DBRP_Pos)                //bit[20:16]: tq = (BRP + 1)*fdcan_clk
    $ T! w8 k, e, {& Q& `, h8 X
37.         //                                 |(22 << FDCAN_DBTP_DTSEG1_Pos)        //bit[12:08]: 一阶段采样                        8000000
    * f9 Z( T' f9 G" L" x5 ?" ^# o
38.         //                                 |(7 << FDCAN_DBTP_DTSEG2_Pos)        //bit[07:04]: 二阶段采样 波特率 = 8000000/(3+DTSEG1+DTSEG2) = 8000000/32 = 250k
    
39.         //                                 |(4 << FDCAN_DBTP_DSJW_Pos)                //bit[03:00]: 同步脉宽
    
40.         //                                 ;
    
41.         FDCAN1->NBTP = 0                                                                        //步骤8 配置波特率
    
42.                                         |(4 << FDCAN_NBTP_NSJW_Pos)                //bit[31:25]: 同步脉宽 必须小于SEG2
    6 r% @3 T- [: R- B9 @" a+ u
43.                                         |(0 << FDCAN_NBTP_NBRP_Pos)                //bit[24:16]: BRP   tq = (BRP + 1)*fdcan_clk
    " E" U; z( }. J- S
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
    7 ^# p- B; |! N3 g0 Q( O: o
46.                                         ;
    
47.         //步骤9 配置中断
    
48.         FDCAN1->IE |= 0
    / b2 V9 h- @$ h8 q! @( h
49.                                         // |FDCAN_IE_ARAE                                        //bit23: 访问保留地址使能
    9 B5 u) }  w# o/ Q9 R5 t
50.                                         // |FDCAN_IE_PEDE                                        //bit22: 数据阶段协议错误
    
51.                                         // |FDCAN_IE_PEAE                                        //bit21: 仲裁阶段协议错误
    5 H- i( f" [" ?/ K- D
52.                                         // |FDCAN_IE_WDIE                                        //bit20: 看门狗使能
    
53.                                         // |FDCAN_IE_BOE                                        //bit19: 总线关闭使能
    
54.                                         // |FDCAN_IE_EWE                                        //bit18: 警告状态中断使能
    
55.                                         // |FDCAN_IE_EPE                                        //bit17: 错误被动中断使能
    
56.                                         // |FDCAN_IE_ELOE                                        //bit16: 错误记录语出中断使能
    
57.                                         // |FDCAN_IE_TOOE                                        //bit15: 超时中断使能
    
58.                                         // |FDCAN_IE_MRAFE                                        //bit14: 信息RAM访问失败中断使能
    , I0 x6 w- L  O- A% v/ h) R0 }
59.                                         // |FDCAN_IE_TSWE                                        //bit13: 时间戳重复中断使能
    
60.                                         // |FDCAN_IE_TEFLE                                        //bit12: TX事件FIFO元素丢失中断使能
    
61.                                         // |FDCAN_IE_TEFFE                                        //bit11: TX时间FIFO满中断使能
    ( g5 b; t. ]/ E* M' a3 G  W! y
62.                                         // |FDCAN_IE_TEFNE                                        //bit10: TX事件FIFO新元素进入中断使能
    
63.                                         // |FDCAN_IE_TFEE                                        //bit09: TXFIFO空中断使能
    
64.                                         // |FDCAN_IE_TCFE                                        //bit08: 发送取消完成中断使能
    
65.                                         // |FDCAN_IE_TCE                                        //bit07: 传输完成中断使能
    
66.                                         // |FDCAN_IE_HPME                                        //bit06: 高优先级消息中断使能
    
67.                                         // |FDCAN_IE_RF1LE                                        //bit05: RXFIFO1报文丢失中断使能
    
68.                                         // |FDCAN_IE_RF1FE                                        //bit04: RXFIFO1消息满中断使能
    1 E! U9 _" {: E. L, P
69.                                         |FDCAN_IE_RF1NE                                        //bit03: RXFIFO1新消息中断使能
    ; _  Q  T1 R# w* ?
70.                                         // |FDCAN_IE_RF0LE                                        //bit02: RXFIFO0报文丢失中断使能
    2 C, ]7 k+ R" u1 H) i: z7 s" l, p* a
71.                                         // |FDCAN_IE_RF0FE                                        //bit01: RXFIFO0消息满中断使能
    ) M) K' I8 v. Y9 h9 z6 Z* r& t
72.                                         |FDCAN_IE_RF0NE                                        //bit00: RXFIFO0新消息中断使能
    
73.                                         ;
    + K1 ]2 P: ^" h6 d; r
74.         FDCAN1->ILE = 0x00000000
    " l+ ]. ~- b& S4 f/ C+ n: `
75.                                         |FDCAN_ILE_EINT1                                        //bit01: 中断总线 fdcan_intr1_it 使能
    9 S- P+ `' K9 o/ r$ {/ [" j
76.                                         |FDCAN_ILE_EINT0                                        //bit00: 中断总线 fdcan_intr0_it 使能
    
77.                                         ;
    
78.         FDCAN1->ILS = 0x00000000                                                //中断总线选择
    
79.                                         // |FDCAN_ILS_PERR                                //bit06:
    3 t! ?) g" ^0 Q" R/ `
80.                                                                                                                 // ARAL: Access to reserved address line
    
81.                                                                                                                 // PEDL: Protocol error in data phase line
    
82.                                                                                                                 // PEAL: Protocol error in arbitration phase line
    
83.                                                                                                                 // WDIL: Watchdog interrupt line
    - D7 H3 A/ F' f5 P* `+ E
84.                                                                                                                 // BOL: Bus_Off status
    / \1 [4 o  u' x. Q- d
85.                                                                                                                 // EWL: Warning status interrupt line
    6 w. D8 Q6 }  [/ M$ u0 S3 Z3 l# n
86.                                         // |FDCAN_ILS_BERR                                //bit05:
    
87.                                                                                                                 // ELOL: Error logging overflow interrupt line
    
88.                                         // |FDCAN_ILS_MISC                                //bit04:
    6 Y% `% i4 E) J- l+ S
89.                                                                                                                 // TOOL: Timeout occurred interrupt line
    
90.                                                                                                                 // MRAFL: Message RAM access failure interrupt line
    
91.                                                                                                                 // TSWL: Timestamp wraparound interrupt line
    - f' L$ K  l3 y" H# }
92.                                         // |FDCAN_ILS_TFERR                                //bit03:
    
93.                                                                                                                 // TEFLL: Tx event FIFO element lost interrupt line
    
94.                                                                                                                 // TEFFL: Tx event FIFO full interrupt line
    
95.                                                                                                                 // TEFNL: Tx event FIFO new entry interrupt line
    ( M1 z6 ^- V$ A" O& w% Q- C
96.                                                                                                                 // TFEL: Tx FIFO empty interrupt line
    
97.                                         // |FDCAN_ILS_SMSG                                //bit02:
    
98.                                                                                                                 // TCFL: Transmission cancellation finished interrupt line
    
99.                                                                                                                 // TCL: Transmission completed interrupt line
    & {' Y! ^$ ^9 v" L" f
100.                                                                                                                 // HPML: High-priority message interrupt line
     
101.                                         |FDCAN_ILS_RXFIFO1                                //bit01:当邮箱1的事件在 fdcan1_intr1_it 中断分支中处理
     
102.                                                                                                                 // RF1LL: Rx FIFO 1 message lost interrupt line
     4 N0 j7 N1 A+ _& t& ~
103.                                                                                                                 // RF1FL: Rx FIFO 1 full Interrupt line
     
104.                                                                                                                 // RF1NL: Rx FIFO 1 new message interrupt line
     
105.                                         // |FDCAN_ILS_RXFIFO0                        //bit00:当邮箱0的事件在 fdcan1_intr0_it 中断分支中处理
     
106.                                                                                                                 // RF0LL: Rx FIFO 0 message lost interrupt line
       C2 ^3 W) H' s1 v& B
107.                                                                                                                 // RF0FL: Rx FIFO 0 full interrupt line
     
108.                                                                                                                 // RF0NL: Rx FIFO 0 new message interrupt line
     
109.                                         ;
     1 U8 H8 J( r* M3 M  Y5 G! A; u4 T
110.         //步骤9 结束
     % r  y5 L0 M; U  L5 T6 B
111. 
     2 X! c! [6 f( [  B, p
112.         //步骤10 使能筛选器
     
113.         FDCAN1->RXGFC |= 0
     
114.                                         |(1 << FDCAN_RXGFC_LSE_Pos)                //bit[27:24]: 列表信息拓展【0|无拓展消息过滤】【1|1~8拓展消息】【>8|被解释为8】
     ; C. C+ p$ Q" b% g
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|拒绝】
     
119.                                         |(2 << FDCAN_RXGFC_ANFE_Pos)        //bit[03:02]: 定义如何处理接收到的id为29位且与筛选器列表中的任何元素不匹配的消息。【0|在FIFO0中接收】【1|在FIFO1中接收】【2~3|拒绝】
     ' P9 I, J, b" j* `2 V& ?: }5 j
120.                                         |FDCAN_RXGFC_RRFS                                //bit01: 【1|拒绝所有11位ID远程标准帧】
     " C$ x* A7 p9 Y/ b  Z, h
121.                                         |FDCAN_RXGFC_RRFE                                //bit00: 【1|拒绝所有29位ID远程标准帧】
     
122.                                         ;
     
123.         // FDCAN1->XIDAM = 0x1FFFFFFF;                                                //FDCAN 扩展 ID 和屏蔽寄存器
     
124.         // FDCAN1->TXBTIE = 0
     
125.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|发送中断使能】
     
126.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|发送中断使能】
     
127.         //                                  |0x00000001                                                //bit00: TxBuffer【1|发送中断使能】
     + a: F9 x3 T' J" @5 Y, P0 O
128.         //                                 ;
     
129.         // FDCAN1->TXBCIE = 0
     6 E+ m+ v, E8 k4 x+ ^
130.         //                                 // |0x00000004                                                //bit02: TxBuffer【1|取消中断使能】
     
131.         //                                 // |0x00000002                                                //bit01: TxBuffer【1|取消中断使能】
     # D/ w! n7 H6 D% T
132.         //                                 // |0x00000001                                                //bit00: TxBuffer【1|取消中断使能】
     ! @5 y  i/ y: K- y' K9 @
133.         //                                 ;
     . Y7 k* I  w6 O, Q# V1 {" w) O7 w
134.         //步骤11 配置筛选器
     
135.         FDCAN1_RAM->FILTER_11BIT[0] = 0x00000000
     ) u) }- |) Y, p. `+ D- d- [
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|保留】
     3 s' Y, N9 w1 p+ D
138.                                                                 |(0x600 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     3 [2 d) e# S0 L) K, t( k' o
139.                                                                 |(0x609 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
140.                                                                 ;//列表滤波，只接收 ID为0x600和0x609 的数据，并且这两个ID放入FIFO0中
     % ?/ |/ C9 L% K
141.         FDCAN1_RAM->FILTER_11BIT[1] = 0x00000000
     
142.                                                                 |(1 << FDCANx_RAM_FILTER11_S0_SFT_Pos)                                //【0|范围过滤，从SFID1~SFID2】【1|单独滤波SFID1和SFID2】【2|经典滤波】【3|禁用过滤】
     ' K) O" l2 p, P0 w& n$ @7 w
143.                                                                 |(2 << FDCANx_RAM_FILTER11_S0_SFEC_Pos)                                //【0|禁用过滤元件】【1|匹配存储在FIFO0】【2|匹配存储在FIFO1】【3|匹配存就拒绝】【4|匹配设置优先级】【5|匹配设置优先级并存储到FIFO0中】【6|匹配设置优先级并存储到FIFO1中】【7|保留】
     # l  _" j- ^7 t5 |4 A+ ?! r/ A
144.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID1_Pos)                //【SFID1】
     5 X2 a; j( D" [9 Q) }0 j8 N4 z: O
145.                                                                 |(0x209 << FDCANx_RAM_FILTER11_S0_SFID2_Pos)                //【SFID2】
     
146.                                                                 ;//列表滤波，只接收 ID为0x209 的数据，并且这个ID放入FIFO1中
     
147. 
     
148.         FDCAN1_RAM->FILTER_29BIT[0][0] = 0x00000000
     . s" e* U: n( J" X1 O. U
149.                                                                         |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     ) s* H3 k9 E: N
150.                                                                         |(0x0CCCCCCC << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     ) v5 ^$ N5 M( k' T
151.                                                                         ;
     9 w5 p, x* [: F2 {$ B) V! u
152.         // FDCAN1_RAM->FILTER_29BIT[0][1] = 0x00000000
     7 \5 P* [. O% r  f
153.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     % K, K: b: Y" }: L9 v3 J
154.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
155.         //                                                                 ;
     
156.         // FDCAN1_RAM->FILTER_29BIT[1][0] = 0x00000000
     ) e) t8 L5 c3 \- f4 x* y- e. [  x  Y( q
157.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     - I+ m9 ~. _9 h  Y, {4 \- @: A
158.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
159.         //                                                                 ;
     
160.         // FDCAN1_RAM->FILTER_29BIT[1][1] = 0x00000000
     
161.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     : x0 \' N/ R( x
162.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
163.         //                                                                 ;
     
164.         // FDCAN1_RAM->FILTER_29BIT[2][0] = 0x00000000
     , \* A+ c* }. ], a
165.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
       L  c  N9 B" i8 j0 I% g
166.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
167.         //                                                                 ;
     
168.         // FDCAN1_RAM->FILTER_29BIT[2][1] = 0x00000000
     
169.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     
170.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     7 L& h3 i% J( O1 g, y. f- T
171.         //                                                                 ;
     
172. 
     
173.         // FDCAN1_RAM->FILTER_29BIT[3][0] = 0x00000000
     2 Q/ F/ r4 k' P5 j
174.         //                                                                 |(2 << FDCANx_RAM_FILTER29_F0_EFEC_Pos)                                //【0|禁止滤波】【1|匹配就保存FIFO1中】【2|匹配就保存FIFO2中】【3|拒绝匹配ID】【4|如果过滤器匹配，则设置优先级】【5|如果过滤器匹配，则设置优先级并存储在 FIFO 0 中】【6|如果过滤器匹配，则设置优先级并存储在 FIFO 1 中】【7|Reserve】
     & ?3 w% Y9 }( q, S  K
175.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F0_EFID1_Pos)        //【EFID1】
     
176.         //                                                                 ;
     " F5 Z5 Z" B3 J) E1 x" D9 b- D
177.         // FDCAN1_RAM->FILTER_29BIT[3][1] = 0x00000000
     
178.         //                                                                 |(1 << FDCANx_RAM_FILTER29_F1_EFTI_Pos)                                //【0|EFID1到EFID2(EFID2>=EFID1)】【1|单独SFID1或者SFID2】【2|经典滤波】【3|EFID1到EFID2(EFID2>=EFID1),未使用XIDAM寄存器的掩码】
     8 Q3 j  k2 V: y) h$ ?8 Y2 G
179.         //                                                                 |(0x00000000 << FDCANx_RAM_FILTER29_F1_EFID2_Pos)        //【EFID2】
     
180.         //                                                                 ;
     
181.         // FDCAN1_RAM->FILTER_29BIT[4][0] = 0x00000000
     
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】
     & n- L0 I9 z) b* W8 @1 E+ q; v( Y
184.         //                                                                 ;
     
185.         // FDCAN1_RAM->FILTER_29BIT[4][1] = 0x00000000
     
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】
     
188.         //                                                                 ;
     9 y3 i. S% a% \; k" |
189. 
     
190.         //步骤12 清除INIT标志位
     ! e# K0 Z6 U+ p& z4 y
191.         FDCAN1->CCCR &= ~FDCAN_CCCR_INIT;//退出初始化模式，CCE会自动清除
     2 z$ I8 n3 J4 M. e9 E3 w
192.         while (FDCAN1->CCCR & FDCAN_CCCR_INIT);//等待退出
     1 w9 N/ I! n/ ~2 S) g8 e
193. }

复制代码

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

附录2 发送函数

1. /**
   4 c% J6 U7 X+ c1 @
2. * @description: 发送11位地址的报文
   : y5 H; R. _  N  t
3. * @param {uint8_t} FDCAN_Index                FDCANx 1~3 FDCAN外设索引使用FDCAN1/2/3
   
4. * @param {uint16_t} ID                                11位ID发送
   - T* ~% ~. V6 w
5. * @param {uint8_t} RTR                                0-数据帧        1-远程帧
   4 C; V) b6 J0 `  O
6. * @param {uint8_t} DLC                                数据长度 0~8
   , V0 {, ~; p0 h  O( q
7. * @param {Buffer_72Byte_Struct}         *buffer 发送数组地址
   , p0 v; |3 k9 I' a
8. * @return {uint8_t}                                SUCCEED/FAILED/ERROR
   8 D  W, s3 u1 U# i
9. * @author: XL
   
10. */
    
11. uint8_t FDCAN_11ID_SendData(uint8_t FDCAN_Index, uint16_t ID,uint8_t RTR,uint8_t DLC,Buffer_72Byte_Struct *buffer)
    6 [0 D' W: ^3 y3 A
12. {
    ) |& S& i/ c, j2 B
13.         uint8_t Free_Mailbox;//空闲邮箱索引
    7 A( O/ I) c% `# m2 G" @, r
14.         FDCAN_RAM_Struct* FDCAN_RAM;//FDCANx_RAM指针
    / ^: M* E' W& {7 }9 _
15.         FDCAN_GlobalTypeDef* FDCAN;//FDCANx指针
    & M/ l1 D  ?; H0 o: r2 t0 F
16.         switch (FDCAN_Index)//根据索引确定使用FDCANx
    
17.         {
    
18.         case 1:
    
19.                 FDCAN_RAM = FDCAN1_RAM;
    
20.                 FDCAN = FDCAN1;
    
21.                 break;
    
22.         case 2:
    
23.                 FDCAN_RAM = FDCAN2_RAM;
    
24.                 FDCAN = FDCAN2;
    + o( r9 k5 G/ Y4 C6 e* F1 g2 d) m- c- T
25.                 break;
    / X4 t+ `6 m; V7 k. S! y/ J
26.         case 3:
    
27.                 FDCAN_RAM = FDCAN3_RAM;
    8 j. R9 U3 n3 s7 w
28.                 FDCAN = FDCAN3;
    
29.                 break;
    
30.         default:
    
31.                 return ERROR;//输入索引错误，无效
    
32.                 break;
    $ i2 f/ D: |- I3 j. j8 Z
33.         }
    
34.         if(FDCAN->TXFQS & FDCAN_TXFQS_TFQF)
      F, O7 V8 P# D" t' T( j  v
35.         {                                                                                        //CanBus判断是否有空闲的发送寄存器，然后发送，否则等待
    ! l: M: W' F4 R, X8 \4 X; Y
36.                 return FAILED;//没有空闲邮箱
    
37.         }
    % V' M; S$ l) I+ S, g+ e% [% s
38.         else
    
39.         {                                                                                        //只要第一个邮箱空闲，始终先使用第一个，然后是第二个，第三个邮箱
    - J! A8 e8 E/ _/ z" R; R
40.                 Free_Mailbox = ((uint8_t)(FDCAN->TXFQS >> 16)) & 0x03;//获取空闲邮箱
    , b8 K+ m, t; Y  O
41.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][0] = ((uint32_t)ID << FDCANx_RAM_TxBuffer_T0_11ID_Pos);//写入地址
    # t( L, K% `; D
42.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][1] = (DLC << FDCANx_RAM_TxBuffer_T1_DLC_Pos);//发送长度
    ( D, C  \7 O9 h8 `" ]  n( E
43.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][2] = buffer->DataWord[0];//发送的数据
    % E% k& k4 |5 d5 b
44.                 FDCAN_RAM->Tx_BUFFER[Free_Mailbox][3] = buffer->DataWord[1];//发送的数据
    6 k+ I  h6 m5 p9 O) Q/ d0 P
45.                 FDCAN->TXBAR |= (0x0001 << Free_Mailbox);//置位发送请求
    4 y. G3 o2 [" R2 P+ ^: ]0 i
46.                 return SUCCEED;//返回成功
    
47.         }
    / b" `, q; q) ?) f
48. }

复制代码

返回第8章 发送操作

附录3 接收中断程序
! D9 z$ A. p1 N! T返回第9章 接收操作
) [! j' B+ F; j! ?* \* i. m! o
1 Y. }2 x; A: f

1. /**
   
2. * @description: fdcan1_intr0_it 中断分支
   - N& ~1 u6 l' ^* O
3. * @param {*}
   
4. * @return {*}
   
5. * @author: XL
   
6. */
   4 D8 ~/ j  i( S1 K% l, C7 m
7. void FDCAN1_IT0_IRQHandler(void)
   
8. {
   ! t/ M- g& v. c; M" ^
9.         if(FDCAN1->IR & FDCAN_IR_RF0N)//邮箱0有新消息
   3 [3 w8 \* j4 J' K9 H; r, ?
10.         {
    
11.                 FDCAN1->IR |= FDCAN_IR_RF0N;//清除新消息状态标志
    7 ]  `: g% y" e
12.                 switch((FDCAN1->RXF0S & FDCAN_RXF0S_F0GI) >> FDCAN_RXF0S_F0GI_Pos)//获取索引
      V' n& s2 c2 ?, D( w, a
13.                 {
    & U, L- T' K. u' i
14.                         case 0:
    
15.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[0][0];//获取数据
    $ F$ F3 l3 y0 T
16.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[0][1];//获取数据
    
17.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[0][2];//获取数据
    
18.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[0][3];//获取数据
    
19.                                 FDCAN1->RXF0A = 0;//确认接收完毕
    
20.                                 break;
    $ f: @" ]8 S" P# N+ X" x2 v7 ?
21.                         case 1:
    
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];
    ! D4 l& l* n4 m0 G$ q
25.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[1][3];
    8 i& s/ |( {$ ]- o4 I% a4 ?
26.                                 FDCAN1->RXF0A = 1;
    & Y( w9 l2 f( o1 z
27.                                 break;
    % I/ N5 s7 H" i2 z" c
28.                         case 2:
    , V; s/ @1 x3 |& c
29.                                 FDCAN1_Rxbuffer0.DataWord[0] = FDCAN1_RAM->Rx_FIFO_0[2][0];
    * o9 @* b% W/ U& B2 z# L% u. [
30.                                 FDCAN1_Rxbuffer0.DataWord[1] = FDCAN1_RAM->Rx_FIFO_0[2][1];
    
31.                                 FDCAN1_Rxbuffer0.DataWord[2] = FDCAN1_RAM->Rx_FIFO_0[2][2];
    / P, ?- i" ~' y& b1 Q
32.                                 FDCAN1_Rxbuffer0.DataWord[3] = FDCAN1_RAM->Rx_FIFO_0[2][3];
    
33.                                 FDCAN1->RXF0A = 2;
    + T( w, w* W( n$ d& o+ l; Q* W: h
34.                                 break;
    
35.                         default:break;
    
36.                 }
    
37.         }
    
38. }
    
39. 
    ' J9 C' E% W* d7 C$ b4 a; O/ C: h
40. /**
    
41. * @description: fdcan1_intr1_it 中断分支
    
42. * @param {*}
    
43. * @return {*}
    
44. * @author: XL
    
45. */
    
46. void FDCAN1_IT1_IRQHandler(void)
    
47. {
      m- D! U% ^3 ?. F/ ]8 P
48.         if(FDCAN1->IR & FDCAN_IR_RF1N)//邮箱1有新消息
    + O" e# P+ }9 }) I0 k
49.         {
    
50.                 FDCAN1->IR |= FDCAN_IR_RF1N;//清除新消息状态标志
    
51.                 switch((FDCAN1->RXF1S & FDCAN_RXF1S_F1GI) >> FDCAN_RXF1S_F1GI_Pos)//获取索引
    
52.                 {
    ! }& H, z8 _! p
53.                         case 0:
    
54.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[0][0];//获取数据
    $ F- g) a. ~$ o$ E  Y+ n+ m9 |
55.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[0][1];//获取数据
    , S- Z# |5 w) g& b% v
56.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[0][2];//获取数据
    9 Y* j$ n. n' W( e! l1 \/ [: R. P5 ?
57.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[0][3];//获取数据
    7 o. V- \! t5 ~$ |6 X, P  {2 V
58.                                 FDCAN1->RXF1A = 0;//确认接收完毕
    
59.                                 break;
    
60.                         case 1:
    
61.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[1][0];
    2 t  k* {. }; \, P8 f
62.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[1][1];
    / {! ^+ Z3 X, d0 P, `
63.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[1][2];
    - f; |  g0 Q! S9 H5 m2 ]
64.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[1][3];
    
65.                                 FDCAN1->RXF1A = 1;
    
66.                                 break;
    
67.                         case 2:
    3 r/ @) B! V/ D( M1 i
68.                                 FDCAN1_Rxbuffer1.DataWord[0] = FDCAN1_RAM->Rx_FIFO_1[2][0];
    . y) P0 ?* Q* z( i' e) U1 w* H6 t
69.                                 FDCAN1_Rxbuffer1.DataWord[1] = FDCAN1_RAM->Rx_FIFO_1[2][1];
    4 V+ W+ P  b3 X1 }& z4 n' k
70.                                 FDCAN1_Rxbuffer1.DataWord[2] = FDCAN1_RAM->Rx_FIFO_1[2][2];
    ! b+ X5 C9 Z8 Y9 b& q
71.                                 FDCAN1_Rxbuffer1.DataWord[3] = FDCAN1_RAM->Rx_FIFO_1[2][3];
    
72.                                 FDCAN1->RXF1A = 2;
    
73.                                 break;
    ! |$ `0 }( c  Y( u! z9 _% f- z0 `
74.                         default:break;
    
75.                 }
    
76.         }
    
77. }

复制代码

* o+ i3 z* q5 S* j: J" R————————————————
转载：Vice Versa XL
+ J( `; E$ D9 j/ d# r4 \