91.1 初学者重要提示
7 R+ W' F& S' O( J/ H- s9 d FDCAN基础知识点可以看第90章,已经进行了详细说明) o) D$ i. G, B
特别推荐瑞萨的CAN入门中英文手册,做的非常好:地址链接( z! Z" C- i& H: y D0 N0 M
91.2 FDCAN基础知识
) L4 c6 z2 J& P6 g; MFDCAN的基础知识在本教程的第90章进行了非常详细的说明。我们这里将本章用到的几个知识点再做个说明,详情推荐看第90章。
0 z4 [6 m' i- I6 d
3 \& s1 a6 \9 g' M91.2.1 CAN FD协议介绍
# {$ K1 ]" s! |1 V( K1 @: TSTM32H7的CAN FD符合ISO 11898-12015标准。STM32器件上的FDCAN的功能如下所示:7 M3 F' ]* u+ y9 I4 j, [5 {
( b, d" d' D. U& k2 {(1)符合CAN协议2.0版A,B和ISO 11898-1:2015,-4。) ?0 [+ m7 O$ Z( C. X. H
! R0 a" N6 V, N& `6 E
(2)可访问的10 KB RAM内存,最多可分配2560个字。9 `4 i4 @2 _+ u% {9 H
# s6 f! u$ n& a! n& m(3)改进了接收过滤。
- T3 s3 [) v- A. z$ ^- d, k* b- {& @; @2 e8 r$ a
(4)两个可配置的接收FIFO。
8 b. Z) y0 Z* y' F6 i6 K/ I w4 l$ ~$ n, m
(5)多达64个专用接收缓冲区。
0 h: v N) b) `( M/ N
* G' P! R- B0 B0 C2 `(6)接收高优先级消息时的单独信令。. D' }0 u S6 \2 u7 x
, x) J7 ^! k0 ^5 Y p( \% E2 O5 ^8 _
(7)多达32个专用发送缓冲区。- ]8 m7 J; E9 e0 I8 M- p3 h
# A/ S$ e- T4 R1 Y(8)可配置的发送FIFO和发送队列。
! y8 |- @2 e! Y' q
; {" d$ M4 B# b# c(9)可配置的发送事件FIFO。. J% g: X/ e2 V2 U0 t+ y: ]: v
) e- y- _; C/ w2 S3 T# B(10)时钟校准单元。5 q, t ^3 n! q) t' h0 f( o3 t
9 |; w& G. F' f" m% K( }9 u(11)收发器延迟补偿。# _* n0 @0 x$ g1 V5 u" W
7 L9 O! S# d( v, w3 `& i
下图说明了FDCAN框图。4 f/ y! h! c5 v
6 h/ {: x" l9 |: W4 _0 P% G& U+ D- k+ H" l) B9 }* z/ L
& v' `0 {5 v3 o S) z* c: q+ B
# G# w* n2 Y7 k2 [9 k5 O1 u
7 Q* Y. A0 T ~ U/ G7 J' x# T, S" H; o通过这个框图要了解到以下信息:
5 v" t- s" U0 @. b5 Z' ]+ I1 K$ a
(1)CANFD1和CANFD2共用一个RAM空间。
* M; {: G7 N% u+ x1 Q* P& r: ]$ s: S( y- M
(2)每个CANFD都有自己的内核。
9 _! d4 i# M- N% i& P/ |1 `9 i
( ~* E; z% M+ ~2 I5 I(3)CAN内核实现协议控制和收发移位寄存器。
& Y# B7 h( d1 e& t; X T9 u! u% p, z
(4)Tx handler控制消息从CAN消息RAM到CAN内核。
% }/ ^# Y& |7 x& M
4 j! g, _5 O% D# X8 ?. E g(5)Rx handler控制CAN内核到CAN消息RAM。
9 _6 \; p# Q- G
6 ~6 \- M( V8 U& W, M# E* k91.2.2 CAN FD特性 f: ?4 a. e v' L+ p
(1)兼容经典CAN,可以遵循ISO 11898-1做数据收发。! {+ P$ Y& @2 w. {
& g( i, Z9 A; V, B(2)提升错误检测,支持高达CRC 21位的校验和。
: Q' V/ p W) j; g. K! Z* |9 n5 C8 z3 P# M; Q, s% }2 D# w
(3)消息优先级。5 J1 \- ?( y _1 b3 w2 r
% g0 E' T& N* h: T1 l Y* S6 w1 f
(4)保证延迟时间。: A% H& |& `/ {6 x6 C
' d$ [+ H6 Q$ m(5)配置灵活性。+ U5 p0 ^; `3 \; y' y
, E! T8 I E5 ]5 `& E
(6)具有时间同步的组播接收。
3 Q7 R$ E. `5 T9 f. l
; v5 L5 ~2 T- N) N) `0 E* \; L(7)系统范围内的数据一致性,每条消息最多64个字节。7 C+ H5 M9 l' u& u' u% i# M
7 i/ ]3 O& H+ d: `. Q, D
(8)多主机。
5 L9 [1 p4 N( K4 W' i+ L5 X! }4 ?8 X3 p! t0 U. C; P
(9)错误检测和信号。
/ p( j+ ~8 C% D5 x! n! ?5 i" @+ e: B0 Y1 z0 T `2 {
(10)区分节点的临时错误和永久性故障以及自动关闭缺陷节点。8 B* m9 n8 s! V/ Y
8 y+ \$ q) w# |. V0 ~91.2.3 CAN FD格式
9 b' \* e, _9 z# l _/ U9 S8 N
. v, S0 r3 r! C) h2 {$ ~
: T9 w. v; r/ E% `. b9 i, |
& F6 S6 u7 C2 a; b6 a. h: z, m, g0 ?7 Z$ ~0 x5 D
第一个仲裁阶段(The first arbitration phase)是一条消息,其中包含:
$ R$ h. G7 [& g ]' L
, N9 U6 Q8 z. } L O(1)帧开始(SOF)。2 N" k6 |- m6 U2 h5 x
) A, m- I% i! F" s+ @2 j(2)ID号和其他位,指示消息的目的(提供或请求数据),以及速度和格式配置(CAN或CAN-FD)。
+ d6 M E% N% h, j5 @4 E: R3 K4 ~' z, N0 l
0 q& c& K% s) X/ [数据传输阶段(The data transmission phase)包括:
$ d, W% j8 X" T z s7 y9 g+ j9 G: ]8 v$ Y2 h& ]
(1)数据长度代码(DLC),指示消息包含多少数据字节。
* b" C: }% U4 W+ [. s4 C. q C, k" d& e& w0 R; u
(2)用户希望发送的数据。
; Z* p- x& e$ ~, H
' A( A' F9 E" T) K. W' W9 y4 |8 e1 `9 M(3)检查循环冗余序列(CRC)。
6 f. T0 O# j4 M1 n+ |
& S/ J8 ]$ a- L1 V) c(4)显性位。6 j( r5 ~4 T. p# L* S
# W% h; m5 h m
第二个仲裁阶段(The second arbitration phase)包含:( S1 U& z4 U5 Q9 [1 a2 F6 ^5 x; o
6 ?- x' o) O# u* @% m(1)总线上其他节点发送的确认(ACK)的接收器(如果至少有一个接收器成功收到消息). H" ]" H/ G! P8 n
" H$ R! B) ^$ p/ N2 d b- U(2)帧尾(EOF),在IFS期间不传输任何消息:目标是将当前帧与下一帧分开。
, k! b* `+ n' P) C1 a Q& o- ]" I! M- F/ @* t' [" B
注意:对于29bit标识符帧,当添加18bit标识到第1个仲裁阶段的IDE bit之后与标准CAN FD是类似的。
0 i( y N& M& f8 O6 m# K8 L
( U' T: V, h# a1 d; [91.2.4 CAN FD相比CAN2.0的提升
+ b& B8 A' u# @& ]# eCAN-FD的开发可以满足需要更高带宽的通信网络需求。每帧最多具有64个字节的CAN-FD以及将比特率提高到最大的可能性,使数据阶段要快8倍,在第二个仲裁阶段要恢复到正常的比特率。通过以下方式确保数据传输的完整性:, |2 s+ C! a3 q
! t( y* V# D" x(1)17级多项式对最大16字节的有效载荷进行CRC。$ Y# ]$ ?; p% D7 M6 W
- ^2 y" U& }" x& l" h- S b5 @(2)21级多项式对16到64字节之间的有效载荷进行校验。
) p: M, F9 w; W5 I9 x( \5 [& F" ?0 ]5 w
标准帧和CAN FD的区别:: F% y. s* w- e& t O2 ^
- u; p& ~6 O8 m q! P
3 I# w& H: z+ e7 V+ j. |# T- ?) ^0 F/ y
$ l3 e. f# O( S+ e& a. R/ e( g4 a3 m) \# m8 b) v8 Y$ h! y! p% \
标识符后,CAN 2.0和CAN-FD具有不同的作用:
* T% M- A; K7 X2 a3 `. R3 o( i7 d7 @" S' g# J" W
(1)CAN 2.0发送RTR位以精确确定帧类型:数据帧(RTR为主要)或远程帧(RTR)是隐性的)。0 [; p8 m0 o- z S; {2 o/ D7 a* L
4 r# ?1 O3 V; d# M(2)由于CAN-FD仅支持数据帧,因此始终发送占优势的RRS(保留)。8 @! K' L2 a5 l2 t
, f" P& s1 ^% p5 Y+ P$ \5 t
IDE位保持在相同位置,并以相同的动作来区分基本格式(11位标识符)。请注意,在扩展格式的情况下,IDE位以显性或隐性方式传输(29位标识符)。, |8 a4 R' P4 E% t7 A/ {4 P
" M. S5 T, b9 e; z与CAN 2.0相比,在CAN-FD帧中,在控制字段中添加了三个新位:2 |9 p; o& x) m) s8 F
8 A/ p* [& A1 {0 h3 p5 X6 P5 w(1)扩展数据长度(EDL)位:隐性表示帧为CAN-FD,否则该位为显性(称为R0)在CAN 2.0帧中。; ] Z( _! v/ W
/ _- g q k! t0 ?(2)比特率切换(BRS):指示是否启用两个比特率(例如,当数据阶段位以不同的比特率传输到仲裁阶段)。
( g- ?; Q8 {( K2 V* E1 b5 A- s6 z* |, G% \6 W# I
(3)错误状态指示器(ESI):指示节点处于错误活动模式还是错误被动模式。
1 o r- D7 R9 l: Y. h2 M
3 w5 Z- |- P% R控制字段的最后一部分是数据长度代码(DLC),它具有相同的位置和相同的长度(4位),用于CAN 2.0和CAN-FD。 DLC功能在CAN-FD和CAN 2.0中相同,但CAN-FD有很小变化(下表中的详细信息)。 CAN-FD扩展帧允许单个消息中发送64个数据字节,而CAN 2.0有效负载数据最多可以发送8个字节。6 u% J3 R+ [: ^' a- Y. _3 C
, F7 X7 Q+ h/ c4 x. R, |0 ? L/ i
1 O: _( j6 z! r3 Q+ I% p( [4 V6 I! t* I/ n* ?
) K6 w; C! c* d5 R w! x
4 g$ j. ]1 m) B1 D" o通过增加有效载荷数据的数据字段来改善网络带宽,因为需要更少的包处理。 同时,通过为CRC添加更多位来增强消息完整性:/ r! o S) q0 r
2 B3 g; v( d3 m; {(1)如果有效载荷数据最多为16个字节,则CRC以17位编码。
; L2 V; S5 ^7 E! D/ l! h$ n% @: v
( H' L4 j6 F* H9 C$ j; F' L) l* _(2)如果有效载荷数据大于20(16)个字节,则CRC以21位编码。
2 }$ I5 f- |8 I3 g" p, K9 G' i4 A8 U0 N
另外,为了确保CAN-FD帧的鲁棒性,填充位机制支持CRC字段。下表总结了CAN-FD和CAN 2.0之间的主要区别。 提供的主要功能与CAN 2.0相比,CAN FD的改进之处在于数据有效负载的增加和速度的提高由CAN-FD中可用的BRS,EDL和ESI位来确保。
& A$ c$ ~. O2 J3 |: `3 Q6 d& |5 H/ o
0 `* f8 F8 W4 L( C, e$ [# K' E: @* |, @) X, b3 R9 u
4 e' W( W! p8 E4 Q! s+ g8 l
# [. K4 D6 E* j+ _91.3 FDCAN总线的HAL库用法" _2 y# h: D' y6 n
91.3.1 FDCAN总线结构体FDCAN_GlobalTypeDef
; o$ _+ Q2 e# m1 K' I/ u0 S& xFD CAN总线相关的寄存器是通过HAL库中的结构体FDCAN_GlobalTypeDef定义,在stm32h743xx.h中可以找到这个类型定义: G9 p5 S5 l4 b$ v6 ]( @9 `+ {- P+ m; A
& _, a9 A0 ^5 M0 v
- typedef struct
/ _. P4 S/ w% U/ N# ~ - {
+ i* @+ a# `! ` - __IO uint32_t CREL; # l5 U! y3 I5 r
- __IO uint32_t ENDN;
. Y7 |! g" K3 q2 Z# I9 h& r7 R - __IO uint32_t RESERVED1; 5 E8 U+ u8 |& x9 @$ q# d
- __IO uint32_t DBTP; 6 \2 x# @" i& ?: b" }! n }
- __IO uint32_t TEST;
+ C2 o7 h% ?5 T- @: ^/ f - __IO uint32_t RWD; + Y8 p6 \4 k& e0 s- L9 e
- __IO uint32_t CCCR; + A7 N' A Z# x
- __IO uint32_t NBTP; * E8 v# a# H2 r* w: d0 K
- __IO uint32_t TSCC; 1 p; B" N. L; _( S( M1 K5 I7 t
- __IO uint32_t TSCV; 1 t; H- d% s9 k3 ?0 ]; u
- __IO uint32_t TOCC; ; p7 c& l" _$ N$ R! c0 I
- __IO uint32_t TOCV;
) m( s4 w4 x8 N4 L - __IO uint32_t RESERVED2[4];
- l7 V. o3 }6 G$ C9 e$ W - __IO uint32_t ECR; ; V D* q c/ N( p$ w: ]( E
- __IO uint32_t PSR;
: |" f8 F7 Z2 y' M; l. M& G - __IO uint32_t TDCR; 4 Y& f" z* m: ^3 v* m
- __IO uint32_t RESERVED3; ! o% P- X; I. x
- __IO uint32_t IR; " m( v& ?# n8 E' K2 _0 p' }. g; ]3 m
- __IO uint32_t IE;
8 m6 |2 s# g, f/ M( ` - __IO uint32_t ILS; : y7 P& Y2 K2 @* N$ M# ^# [3 K4 s! ]3 \5 n
- __IO uint32_t ILE;
8 a( o/ Q* D; K5 A - __IO uint32_t RESERVED4[8];
2 e+ r7 m' ?9 ~+ G3 a - __IO uint32_t GFC; 2 c T$ d, j# A+ h4 B! B8 J+ C
- __IO uint32_t SIDFC; 4 e7 b- A7 K( {/ d+ b
- __IO uint32_t XIDFC; & s* P {- T# t4 }' H' k
- __IO uint32_t RESERVED5;
' ]$ `( F3 J9 ?- w! }, k" [ - __IO uint32_t XIDAM;
/ e7 a. c6 l- P5 g0 f$ O' N3 ^. P" a - __IO uint32_t HPMS;
* e. H+ [! f# W% I8 Z2 v1 P - __IO uint32_t NDAT1; ; M# o$ p5 l/ t1 n( g h. U" Y, k; m
- __IO uint32_t NDAT2;
! @; ~1 j" ~7 r8 E" I1 t - __IO uint32_t RXF0C; ) F0 Z$ A p( n6 S3 F
- __IO uint32_t RXF0S;
|4 q: k' \8 C - __IO uint32_t RXF0A; 0 `6 g# |2 p* N' \# A' c
- __IO uint32_t RXBC; 0 N4 R! y7 N# q" `$ @3 {! S# L4 ^
- __IO uint32_t RXF1C;
8 R2 ]1 L) B, D* d2 V - __IO uint32_t RXF1S;
3 Y1 i0 n8 ^) a( e2 k" U# u - __IO uint32_t RXF1A;
l- c. n4 _# T- [ J6 s7 S. q - __IO uint32_t RXESC; / A) p( B, y z% f
- __IO uint32_t TXBC; ! f5 b- D, |, `, N# v* s2 w
- __IO uint32_t TXFQS; ?) C2 D3 W& X
- __IO uint32_t TXESC;
. p2 A- L/ f9 j2 _ - __IO uint32_t TXBRP;
8 H2 Y, g! b5 X% I/ N Q" b- e - __IO uint32_t TXBAR; # v/ Y* X% B) J+ N1 x4 O
- __IO uint32_t TXBCR;
( D1 F+ i% v, \. K' L2 U - __IO uint32_t TXBTO;
! v) D# u9 A1 u - __IO uint32_t TXBCF; 2 L9 c8 y O3 G2 e: g2 }
- __IO uint32_t TXBTIE; $ Q8 [( D( g) c; _0 d& M
- __IO uint32_t TXBCIE;
8 A- n) d- w9 \ ]$ A6 L& ] - __IO uint32_t RESERVED6[2]; ( R: o! u% _% P0 @; r2 p c
- __IO uint32_t TXEFC;
" s3 X2 N; |& S8 }8 i# X - __IO uint32_t TXEFS;
7 v( w4 ?) j0 D+ S - __IO uint32_t TXEFA;
( [, L6 ]7 S4 u! g8 u6 Q$ y% R - __IO uint32_t RESERVED7; f) w* t- v( M3 V" B( {
- } FDCAN_GlobalTypeDef;
复制代码 + k7 p1 X3 }; z# z: J- e& y! S7 v
这个结构体的成员名称和排列次序和CPU的寄存器是一 一对应的。
- u! D1 p3 t, k' o) K' d6 O" f& Q" g
% T" m# n! j9 ]! h0 |. k, E__IO表示volatile, 这是标准C语言中的一个修饰字,表示这个变量是非易失性的,编译器不要将其优化掉。core_m7.h 文件定义了这个宏:
* Q$ v1 B# w1 r5 E z% M
$ k. Z+ }1 v D1 m d! I- #define __O volatile /*!< Defines 'write only' permissions */
7 g( ]; V) ?/ z A( F - #define __IO volatile /*!< Defines 'read / write' permissions */
复制代码 - y4 |/ R3 r* S, x4 e
下面我们看下FDCAN的定义,在stm32h743xx.h文件。
% t y) l) |3 W& M' o( ]0 G' \ H
- #define PERIPH_BASE (0x40000000UL) - `2 U( N4 c4 ?% I4 T
- #define D2_APB1PERIPH_BASE PERIPH_BASE
6 C( P$ E( @/ g, E3 v; A - ' o' G' i8 Y1 |6 e/ F1 Q9 T+ v
- #define FDCAN1_BASE (D2_APB1PERIPH_BASE + 0xA000UL)
4 o3 t) r, G; ?; ~; R - #define FDCAN2_BASE (D2_APB1PERIPH_BASE + 0xA400UL)
. H7 N4 V; v4 V7 [7 d - #define FDCAN_CCU_BASE (D2_APB1PERIPH_BASE + 0xA800UL)
/ B& P: C( E' G: K% z3 k& f
) W, P% p3 K; R' o( O- #define FDCAN1 ((FDCAN_GlobalTypeDef *) FDCAN1_BASE) <----- 展开这个宏,(FDCAN_GlobalTypeDef *)0x4000A000+ o6 [7 z$ [& z6 w7 ^
- #define FDCAN2 ((FDCAN_GlobalTypeDef *) FDCAN2_BASE)- U& E7 l- v% x$ S# I: e
- #define FDCAN_CCU ((FDCAN_ClockCalibrationUnit_TypeDef *) FDCAN_CCU_BASE)
复制代码
4 s) x- u8 s4 Z7 T+ F我们访问FDCAN1的CCCR寄存器可以采用这种形式:FDCAN1->CCCR = 0。
, }/ ?9 M% r# K) Y4 y
) l2 c9 O9 N" W' U6 T1 I1 T9 b4 T91.3.2 FDCAN总线时间触发结构体TTCAN_TypeDef$ z2 Y: V- [" ?8 {
FDCAN总线时间触发相关的寄存器是通过HAL库中的结构体TTCAN_TypeDef定义,在stm32h743xx.h中可以找到这个类型定义:
' k, U. \% O- J" O- A( B9 Y
) ?% D2 X# Z% I, n: [/ K- typedef struct5 u' {1 x0 \# ?! m& `6 c3 f, _
- {+ |: G; N! j* F- Y s
- __IO uint32_t TTTMC; /*!< TT Trigger Memory Configuration register, Address offset: 0x100 *// u: J& j( u& ?% [7 _
- __IO uint32_t TTRMC; /*!< TT Reference Message Configuration register, Address offset: 0x104 */0 R/ r# v) r, r0 _; Z0 V
- __IO uint32_t TTOCF; /*!< TT Operation Configuration register, Address offset: 0x108 */" l( E" [# V8 _3 c
- __IO uint32_t TTMLM; /*!< TT Matrix Limits register, Address offset: 0x10C */! ^ Y4 o/ D) @' |" n. ]
- __IO uint32_t TURCF; /*!< TUR Configuration register, Address offset: 0x110 */5 R; v8 \1 l; d. E
- __IO uint32_t TTOCN; /*!< TT Operation Control register, Address offset: 0x114 */
: ^0 _1 c1 a$ a - __IO uint32_t TTGTP; /*!< TT Global Time Preset register, Address offset: 0x118 */
& n' _0 L3 P' |0 q8 }) w* i - __IO uint32_t TTTMK; /*!< TT Time Mark register, Address offset: 0x11C */
! k) c4 P; ]. j1 I- o3 Z% P; M6 L - __IO uint32_t TTIR; /*!< TT Interrupt register, Address offset: 0x120 */3 `$ f" F2 k- R. [+ R
- __IO uint32_t TTIE; /*!< TT Interrupt Enable register, Address offset: 0x124 */
, R/ b3 K# \& l2 R; C J9 w - __IO uint32_t TTILS; /*!< TT Interrupt Line Select register, Address offset: 0x128 */
* x+ A c+ ~# ]( ]5 L8 `8 N - __IO uint32_t TTOST; /*!< TT Operation Status register, Address offset: 0x12C */
, g1 a6 R' b" v n3 L- q! G - __IO uint32_t TURNA; /*!< TT TUR Numerator Actual register, Address offset: 0x130 */
, k+ E: |$ R+ [; Y - __IO uint32_t TTLGT; /*!< TT Local and Global Time register, Address offset: 0x134 */3 p& L0 m( n4 F' D i
- __IO uint32_t TTCTC; /*!< TT Cycle Time and Count register, Address offset: 0x138 */) A- T$ H {2 c. y% j
- __IO uint32_t TTCPT; /*!< TT Capture Time register, Address offset: 0x13C */
+ y$ X4 X) V0 N8 ?- c, ^ - __IO uint32_t TTCSM; /*!< TT Cycle Sync Mark register, Address offset: 0x140 */# O8 I8 m: a, x$ A W2 j6 [
- __IO uint32_t RESERVED1[111]; /*!< Reserved, 0x144 - 0x2FC */
8 U2 S8 O/ I' v h - __IO uint32_t TTTS; /*!< TT Trigger Select register, Address offset: 0x300 */6 e) F$ ~- }+ \# @8 n, C4 y
- } TTCAN_TypeDef;
复制代码 1 O) z+ _) ], |
91.3.3 FDCAN总线初始化结构体FDCAN_InitTypeDef+ L9 u: z' g0 f) j+ C ~( d& t3 s
下面是FDCAN总线的初始化结构体:9 }6 `* V8 B. y6 ^$ u7 u
) o4 }# ?# P& U) _! b- typedef struct* Q! g6 R' N! c4 V0 @, [2 e9 R# g
- {
( J# k! N; D1 D, d& U- d9 K - uint32_t FrameFormat; /*!< Specifies the FDCAN frame format.% ]) ? a% j+ r' ]
- This parameter can be a value of @ref FDCAN_frame_format */; F: Q: J! l- a0 p* i/ B1 |- K
2 H3 X0 `* O+ w. C8 u- uint32_t Mode; /*!< Specifies the FDCAN mode.( Y1 V4 m9 T. e. G
- This parameter can be a value of @ref FDCAN_operating_mode */ ~, g+ }" ^" G
# i7 |' \8 ]' L7 C5 [- FunctionalState AutoRetransmission; /*!< Enable or disable the automatic retransmission mode.( |; s5 d7 O7 @" k" o) y, F
- This parameter can be set to ENABLE or DISABLE */
4 Z1 S! L' {/ B8 V5 D
9 g/ I0 C" h* K+ w$ d- |, r$ y- FunctionalState TransmitPause; /*!< Enable or disable the Transmit Pause feature.2 v: Y) ?! v( t& t
- This parameter can be set to ENABLE or DISABLE */+ m! |! S h, x) l
9 y9 j O( q! L" p/ q- FunctionalState ProtocolException; /*!< Enable or disable the Protocol Exception Handling.* o% F. v0 P; Z4 R X
- This parameter can be set to ENABLE or DISABLE */0 R% L' D/ A* @
: @% }3 j* X9 p3 f- uint32_t NominalPrescaler; /*!< Specifies the value by which the oscillator frequency is
8 ~( B# a9 }$ U- M - divided for generating the nominal bit time quanta.
' y# G# p' J. b7 d9 U; ~ - This parameter must be a number between 1 and 512 */8 F7 p# q3 H+ W4 B6 a4 Z
& k7 l6 g2 H! ]8 C; g/ a; [- uint32_t NominalSyncJumpWidth; /*!< Specifies the maximum number of time quanta the FDCAN+ F0 Y8 [' u. Z
- hardware is allowed to lengthen or shorten a bit to perform
2 F% C7 o% k, l& c S7 @/ H% Z - resynchronization./ j5 k C" }) [% u& d2 W& k
- This parameter must be a number between 1 and 128 */) a" J# p1 y$ C, A: Y! K$ v8 `% S9 M
) H5 ` I G. J4 n7 f- uint32_t NominalTimeSeg1; /*!< Specifies the number of time quanta in Bit Segment 1.( _ M; C7 G, C6 Z" T
- This parameter must be a number between 2 and 256 */6 \4 T5 ]" Y) q1 A
- 2 D- I7 L) B1 }2 ]7 _; } u* U. q
- uint32_t NominalTimeSeg2; /*!< Specifies the number of time quanta in Bit Segment 2.
, t+ l: D( J' z5 t4 r0 b - This parameter must be a number between 2 and 128 */( n7 O, m2 _0 Q- i, q
5 T0 T8 g4 X+ i! [# @% Z- uint32_t DataPrescaler; /*!< Specifies the value by which the oscillator frequency is+ i f7 N* K1 A, A
- divided for generating the data bit time quanta.1 F* d8 ?( v3 A! x! ]
- This parameter must be a number between 1 and 32 */9 { I. O- ~' R: q4 n& k+ X6 F
( x+ K. s0 ]- D- uint32_t DataSyncJumpWidth; /*!< Specifies the maximum number of time quanta the FDCAN
$ A( R0 d) n% D: a! _ - hardware is allowed to lengthen or shorten a data bit to! }) r0 Q# z: X4 I
- perform resynchronization.1 J. Z4 d7 r5 g+ n0 W0 J" E: k2 B
- This parameter must be a number between 1 and 16 */4 l7 @: Y- n9 g. h2 u# \
+ n$ z, {7 b( I6 R$ H9 P, y- uint32_t DataTimeSeg1; /*!< Specifies the number of time quanta in Data Bit Segment 1.
; T( ]. l0 I/ w `# Y6 n - This parameter must be a number between 1 and 32 */& z y7 \6 _" L5 E
' \7 w4 E9 ^- p4 n) k# M- uint32_t DataTimeSeg2; /*!< Specifies the number of time quanta in Data Bit Segment 2.( }+ Z+ |. r+ V x
- This parameter must be a number between 1 and 16 */( ]$ _: T) n# E f5 z3 T- \1 Y; m
+ b" f9 c6 x N, f- uint32_t MessageRAMOffset; /*!< Specifies the message RAM start address.
" b5 o. J1 I+ @ q - This parameter must be a number between 0 and 2560 */; \4 ~3 m6 M8 C% C
) p3 @: v6 B# m, O- ~. W w1 w* G7 w- uint32_t StdFiltersNbr; /*!< Specifies the number of standard Message ID filters.) w- r" v5 k- F* }
- This parameter must be a number between 0 and 128 */
& Y, c$ \* ?5 r& l - # j( t/ [7 x( V* }
- uint32_t ExtFiltersNbr; /*!< Specifies the number of extended Message ID filters.
& o1 R# s* t/ M; h! ^ - This parameter must be a number between 0 and 64 */
8 |/ v' z1 _4 D2 x, ^1 i
$ a* u" J1 B% [. O" N6 ~* h4 w- uint32_t RxFifo0ElmtsNbr; /*!< Specifies the number of Rx FIFO0 Elements.2 Y4 ^' K4 j" b
- This parameter must be a number between 0 and 64 */' b5 R; V$ u2 w ~( y
- u" ]! L/ A% o
- uint32_t RxFifo0ElmtSize; /*!< Specifies the Data Field Size in an Rx FIFO 0 element.
# |/ H E! x/ ~. ?$ F% } - This parameter can be a value of @ref FDCAN_data_field_size */
3 x0 X' Y1 y# M, @5 z
- d! O- R, _0 c" E- uint32_t RxFifo1ElmtsNbr; /*!< Specifies the number of Rx FIFO 1 Elements.; g* q& z4 q# e0 X, [1 @
- This parameter must be a number between 0 and 64 */1 ?, o: U9 _9 U- w: k/ q$ E" s% S: }
# \ d7 l2 r+ L; Q1 M- u- uint32_t RxFifo1ElmtSize; /*!< Specifies the Data Field Size in an Rx FIFO 1 element.8 b* K x4 M: _" R# g7 ^& h0 e# C
- This parameter can be a value of @ref FDCAN_data_field_size */& I) x# G6 r& \1 }, w/ u# J+ I
0 B) P \; ]6 T' B, G- uint32_t RxBuffersNbr; /*!< Specifies the number of Dedicated Rx Buffer elements.
: L4 z6 f: v, ? B% h: _ - This parameter must be a number between 0 and 64 */
4 ^$ l: m8 Z* C# J" t$ L
- z/ D) R% b% o( z& v" T: ~8 |- uint32_t RxBufferSize; /*!< Specifies the Data Field Size in an Rx Buffer element.
# @$ t: G, o# S! X7 { - This parameter can be a value of @ref FDCAN_data_field_size */; j# Q6 O2 _& u0 L/ x
- ; b3 L6 Q+ W. Y
- uint32_t TxEventsNbr; /*!< Specifies the number of Tx Event FIFO elements.
9 G! d' z0 q$ Z9 p9 T - This parameter must be a number between 0 and 32 */
! O3 q5 Q1 ]8 e3 s7 O2 [; d+ X - / O% r! c+ A( X# G' @! F9 a6 b: a. M
- uint32_t TxBuffersNbr; /*!< Specifies the number of Dedicated Tx Buffers.
- o/ L% |' C3 L( g; ~4 [- \ - This parameter must be a number between 0 and 32 */+ R: P+ V0 e( a2 `% l9 Z
: H( O' G$ \+ J: s2 r2 C- uint32_t TxFifoQueueElmtsNbr; /*!< Specifies the number of Tx Buffers used for Tx FIFO/Queue.
L1 r$ R- [8 }# c2 P4 V - This parameter must be a number between 0 and 32 */" z! u1 m* ]% C9 W8 O! o+ K& e
" [8 X, U. q0 j9 Y( E- uint32_t TxFifoQueueMode; /*!< Tx FIFO/Queue Mode selection.
0 A, i5 ~2 q1 W+ M$ Y4 O8 E) m - This parameter can be a value of @ref FDCAN_txFifoQueue_Mode */
6 a) d/ @1 I0 r( |$ f9 P - F1 ^6 H7 |' Y. }3 c/ F" W8 v
- uint32_t TxElmtSize; /*!< Specifies the Data Field Size in a Tx Element.
( f* W$ G, [8 M" a& d - This parameter can be a value of @ref FDCAN_data_field_size */
# C, s$ O; G3 O" x. i
: }3 n& V5 M, e! ?+ `& y- } FDCAN_InitTypeDef;
复制代码 $ ~; Q- u8 R6 k& w7 ]
下面将结构体成员逐一做个说明:
7 w; Z) l: n! |0 d
. {, k2 Q! n4 F, }: \, e- U5 r" W9 ]/ n FrameFormat
. h2 z5 _- k* @; C9 j1 s用于设置CAN帧格式。0 t* O5 X( |' u- L5 |) N
$ D$ h; i" X. A" `+ ^
- #define FDCAN_FRAME_CLASSIC ((uint32_t)0x00000000U) /* 经典CAN模式 */
2 M6 {4 k2 y- ~- W0 H# i - #define FDCAN_FRAME_FD_NO_BRS ((uint32_t)FDCAN_CCCR_FDOE) /* FD CAN不带可变波特率 */0 e' |9 Y. l6 k. ^$ q
- #define FDCAN_FRAME_FD_BRS ((uint32_t)(FDCAN_CCCR_FDOE | FDCAN_CCCR_BRSE)) /* FD CAN带可变波特率 */
复制代码
7 h( w, b0 h( d! k Mode
+ ^! q' K8 [7 c% D* [/ N用于设置CAN操作模式。1 C0 E1 M* j1 q
" i; G1 _$ E+ O; h; R5 F- #define FDCAN_MODE_NORMAL ((uint32_t)0x00000000U) /*!< 正常模式 */
) Q# u# [# V1 Y: q - #define FDCAN_MODE_RESTRICTED_OPERATION ((uint32_t)0x00000001U) /*!< 有限制的操作模式 */$ T4 c! y( j* z, k; B3 f' {3 ~* P
- #define FDCAN_MODE_BUS_MONITORING ((uint32_t)0x00000002U) /*!< 总线监测模式 */
5 j3 f2 z+ ~" a9 _( ? - #define FDCAN_MODE_INTERNAL_LOOPBACK ((uint32_t)0x00000003U) /*!< 内部环回模式 */
4 q& J8 ^ s2 X+ `, ~$ d7 @/ w - #define FDCAN_MODE_EXTERNAL_LOOPBACK ((uint32_t)0x00000004U) /*!< 外部环回模式 */
复制代码
- S+ P, P% k/ c9 q7 I: f) z0 R AutoRetransmission9 ]$ y: d* E0 i9 h' _; S) p9 w- Q7 X C C
使能自动重传模式。
* \9 I: ~4 g* A4 ]' E3 \7 \1 z. f. D2 c! T7 F
使能ENABLE或者禁止DISABLE。; E3 A/ a& T7 Z% A) h
: ?; ?8 `, [9 C/ u- d TransmitPause
$ k3 G# `6 O# L1 A b3 i$ e' Q使能或者禁止传输暂停特性。ENABLE使能或者DISABLE禁止。3 F( l# D M9 `+ l. }& R4 T0 q0 z
* v5 Z! w4 u5 u# D0 n ProtocolException
) E; I1 ^: f9 G使能或者禁止协议异常管理。ENABLE表示使能,DISABLE表示禁止。
& g1 y+ B4 _4 w. p3 i" y- I& E
8 D! A1 n" d8 J3 S" ?+ e NominalPrescaler$ n2 ~$ v8 d( f- F2 z% Y
用于CAN FD仲裁阶段分频设置,产生标称位时间量,参数范围1-512。: i* r+ ?5 @$ G: f5 T! E, W
- }0 S2 K* c ? D NominalSyncJumpWidth/ \2 |4 R+ l4 g5 l6 F! \4 ^. O
设置FD CAN仲裁阶段最大支持的时间量来加长或者缩短一个bit来实现再同步,参数范围1-128。
' Z8 V5 x p8 n9 B8 f6 | `1 U- |9 U
NominalTimeSeg1
& Q, a* o: g9 b! W6 N设置仲裁阶段Bit Segment 1的时间量,范围2 – 256。
3 i- C; l0 a0 Y3 C
) a! r) y' g; k- J9 ^: Q3 p* y# B NominalTimeSeg2
( n( m" o2 N1 A+ x3 t设置仲裁阶段Bit Segment 2的时间量,范围2 – 128。% ?& S* w0 j; f
5 O4 m+ ^/ T5 h+ t
DataPrescaler: X+ F% |5 m8 A4 W+ n: o6 z0 B
用于CAN FD数据阶段分频设置,范围1-32。; y* B7 r+ O+ X% g
- \4 {$ y4 ?3 d% m. C+ A
DataSyncJumpWidth
# U6 |( s# n# A- \+ e& b. l" u设置FD CAN数据阶段最大支持的时间量来加长或者缩短一个bit来实现数据再同步,参数范围1-16。
: ?4 d- C# G/ y P( W0 r+ ]& A* H, Z- P
DataTimeSeg1; N) O! \9 W# R0 g
设置数据阶段Data Bit Segment 1的时间量,范围1 – 32。( ?" ~" ^5 f7 t" i% l! V- R% o# B
: X% l4 ~ m$ G& M( ^
DataTimeSeg2
F4 f6 X# t+ s# g8 w4 L; z% p) }设置数据阶段Data Bit Segment 2的时间量,范围1 – 16。
: i% y+ B2 `( b! z0 }8 C7 r) B! x
1 e- `' x& z6 f# e' a9 F MessageRAMOffset
- m3 Z" H8 ?7 J6 B) a& q- v设置消息RAM起始地址,范围0到2560。
7 ~; @, \% n" \
. P/ f8 J0 u. K) @/ @; ? StdFiltersNbr" w: i5 N+ E; l+ ^. L1 u1 A1 o9 V
标准ID过滤个数,范围0到128。
: ^4 N# L: u$ |8 l0 }
9 z' B3 U) l$ V- ?# R0 i ExtFiltersNbr
# d0 k p, l/ E1 K6 f扩展ID过滤个数,范围0到64。
' Q3 o ~; Z2 N8 y$ j
/ l' l* { z% h RxFifo0ElmtsNbr
+ L {0 ^" m& W6 D0 B0 WRX FIFO0元素个数,范围0到64。
% P- i0 j4 ~. a" {/ }8 w4 I* g
2 y* T1 n, B" o" `: P- H RxFifo0ElmtSize
6 ^- }1 ^' A- NRX FIFO0每个元素中数据大小,支持参数如下:1 y4 |4 r* Y% g1 R
2 F- J$ m/ U: U9 Q
- #define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */
8 l" E/ O6 \9 t r9 j - #define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */" A, H8 J" Q! N! D9 I/ D, @
- #define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */3 @$ @9 b5 k' L% N1 z
- #define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */! I7 K- C6 b6 _1 r% f% F) j8 C. n
- #define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */- H" }6 M* _- a* g
- #define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */
" a/ ]* M0 W9 | C9 R8 @. x - #define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
3 D- `" f; t8 P }% k" M9 G G - #define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */
复制代码
5 U6 o% m8 a- F& b RxFifo1ElmtsNbr" e a" p7 k, M) U
RX FIFO1个数,范围0到64。( {' V6 C% l/ v+ T9 K5 Z
8 c3 `9 Z1 o* R* s2 M4 e
RxFifo1ElmtSize# R7 w: A) T X0 L2 y5 c
RX FIFO1每个元素中数据大小,支持参数如下:
1 q. o4 ]9 f# O* J% O7 k$ ^2 W" J5 ^9 T; G9 B+ ]
- #define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */
" p$ |0 ]' r" t$ X4 z+ J - #define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */
& G0 x# H$ E8 X; J: {5 B - #define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */
3 w. q# P* f, R - #define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */. T5 B" y1 X) W j( Y; ?- t
- #define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field *// @* ?' p" p5 M% { I* P- Z2 E
- #define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */9 N% U0 N; `/ m: Z% n1 j
- #define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */$ L! n, V) z: x1 K
- #define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */
复制代码 2 Q2 D5 U) @$ o2 J/ d+ W7 L* t
RxBuffersNbr
( ^& b6 q& l7 I! V! `( H n: Y设置Rx Buffer元素个数,范围0 - 64:
3 }2 L$ D$ n& O) A8 D% S( J: Q; q* \: Y1 z" a6 N
RxBuffersSize4 p; h" c( P7 ~4 W% I
设置Rx Buffer元素中每个数据大小,范围0 - 64:% ^- Z8 C: p! C" Z
; w- A/ Z' J, ^: v* n7 t6 Z+ ]
- #define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */# C- d2 ]4 y1 B3 ?2 f: X/ M
- #define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */
1 j+ ~/ p9 w* D, O7 g - #define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */# O6 I4 t: k" W/ a! a4 n; \9 S
- #define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */
. j/ }7 h. I1 a1 H - #define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */
6 ^' S7 x. S& b7 \) g - #define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */1 R8 i$ ~0 A. S9 T0 o
- #define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
2 A C9 m, u8 s' X - #define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */
复制代码 4 g8 V* E3 p7 P
TxEventsNbr
: J2 t2 }1 t! _& I. D- K& [, ETx Event FIFO元素个数,范围0到32。6 P, J# ]2 R* P
# E2 G+ o2 o# s5 i/ q TxBuffersNbr
) L0 u/ y6 o* r2 h+ x, G# G1 H' P5 t设置专用的Tx Buffer元素个数,范围0到32。
+ T) e, m' } e; E. a( f! A. B) Y
TxFifoQueueElmtsNbr2 L0 F8 q( d2 |! b, n. L( ?0 o# Z
设置用于Tx FIFO/Queue的Tx Buffers个数。范围0到32。, ^1 S! j X2 c; Z; ^; p* V" r
+ g) i- x' k& Y7 P
TxFifoQueueMode" {# ~6 c3 Z" {0 _
设置FIFO模式或者QUEUE队列模式。
( `: |. Y+ t+ N
9 [" y9 C; q! k5 S) B- #define FDCAN_TX_FIFO_OPERATION ((uint32_t)0x00000000U) /*!< FIFO mode */
* Q3 a( b' D2 l5 ]0 A% P6 l. s - #define FDCAN_TX_QUEUE_OPERATION ((uint32_t)FDCAN_TXBC_TFQM) /*!< Queue mode */
复制代码
9 l9 F E# L" D TxElmtSize$ {: D& j7 i, [# U
设置Tx Element中的数据域大小。支持参数如下:
* z0 Z8 [: H- h5 e" R3 U4 Q8 I/ J% w5 U; E% v5 K; V5 {
- #define FDCAN_DATA_BYTES_8 ((uint32_t)0x00000004U) /*!< 8 bytes data field */. Y% e7 e9 D n# L6 Y$ g5 u
- #define FDCAN_DATA_BYTES_12 ((uint32_t)0x00000005U) /*!< 12 bytes data field */
4 v. j3 l3 T' W$ |9 M5 u - #define FDCAN_DATA_BYTES_16 ((uint32_t)0x00000006U) /*!< 16 bytes data field */
. D) j: U9 e1 t - #define FDCAN_DATA_BYTES_20 ((uint32_t)0x00000007U) /*!< 20 bytes data field */
T9 a6 _& S$ H5 Y& w$ z6 u/ ^ - #define FDCAN_DATA_BYTES_24 ((uint32_t)0x00000008U) /*!< 24 bytes data field */
* O4 t% Y% ]6 {5 i' t( ] - #define FDCAN_DATA_BYTES_32 ((uint32_t)0x0000000AU) /*!< 32 bytes data field */
2 h/ |* G+ G7 n6 Y; t" c& q. }4 c8 V - #define FDCAN_DATA_BYTES_48 ((uint32_t)0x0000000EU) /*!< 48 bytes data field */
% m) N2 x9 R- L) d - #define FDCAN_DATA_BYTES_64 ((uint32_t)0x00000012U) /*!< 64 bytes data field */
复制代码
9 H* C2 c4 Z) C6 S0 L2 n8 R91.3.4 FDCAN总线消息RAM地址FDCAN_MsgRamAddressTypeDef. {- B' W- h/ I0 r. u7 c9 u
下面是消息RAM结构体:2 v4 |, O6 W7 [4 O7 J9 ]2 C! C
' d7 B# O5 O7 W5 W! J8 Y- typedef struct
* Q) k% h2 |( q: ?6 o/ b$ w% f - {
7 j% o$ N9 b+ L y g - uint32_t StandardFilterSA; /*!< Specifies the Standard Filter List Start Address.
2 r6 ~2 l: b5 ]2 A7 A% U6 B - This parameter must be a 32-bit word address */& Z0 ]& m# D" w& V0 V* \% P& [
- , F' r4 m! q4 \7 V& p) x7 x+ K1 ~
- uint32_t ExtendedFilterSA; /*!< Specifies the Extended Filter List Start Address.$ y! p3 E. g0 k3 W7 i' v, A
- This parameter must be a 32-bit word address */
9 O* R* P' `2 {. L
7 z4 G. o& t, E4 C8 P* N& Z- uint32_t RxFIFO0SA; /*!< Specifies the Rx FIFO 0 Start Address.
2 h5 s& q8 j! R1 z2 O. y7 u - This parameter must be a 32-bit word address */
; d2 v+ Y* O: G6 l" y& z2 y+ ` - / w. }' a$ m6 @0 o y
- uint32_t RxFIFO1SA; /*!< Specifies the Rx FIFO 1 Start Address.% @- k* d$ ]/ u' j8 w
- This parameter must be a 32-bit word address */5 \" Z- x; A9 _% e
4 I" t! v5 q7 k- uint32_t RxBufferSA; /*!< Specifies the Rx Buffer Start Address.$ c L& X8 q' ?- l: @# q
- This parameter must be a 32-bit word address */. \" H1 G0 y- V/ o
; v3 D$ U" N3 |& ] W- uint32_t TxEventFIFOSA; /*!< Specifies the Tx Event FIFO Start Address.
, ]7 q8 K8 N; u6 S% p - This parameter must be a 32-bit word address */( @8 ~) B9 G, `; k; h1 y
- ! ~4 B T2 V% E6 P% a) f1 R8 X7 [
- uint32_t TxBufferSA; /*!< Specifies the Tx Buffers Start Address.
6 u) `6 `" Z# [, o' U - This parameter must be a 32-bit word address */
5 {) ]1 z8 ]( {( Z8 U& R7 M% S - 1 l8 j+ k2 v2 [" U4 ?' M% K
- uint32_t TxFIFOQSA; /*!< Specifies the Tx FIFO/Queue Start Address.) p/ }& ~6 P! Y3 b" @ e
- This parameter must be a 32-bit word address */% \' \9 f0 v6 U @9 S
) k; P% h8 q4 Z- uint32_t TTMemorySA; /*!< Specifies the Trigger Memory Start Address.
[0 P( T3 _ r6 a% d+ W3 u8 ? - This parameter must be a 32-bit word address */7 s5 l$ z6 o- r& z- R: w% ?
- : v/ ?4 H# r7 d7 t$ X* s7 }+ z% d
- uint32_t EndAddress; /*!< Specifies the End Address of the allocated RAM.# O% h7 L+ P( q+ n/ u0 c9 F
- This parameter must be a 32-bit word address */
! \& R. _. x& r0 i: ]( F5 l
3 A6 |' J. O* {8 C4 Q% K- } FDCAN_MsgRamAddressTypeDef;
复制代码
- @. l- ^; z# s. P" R: j2 x下面将结构体成员逐一做个说明:5 A5 C' v2 h1 X0 i3 W( h4 n
|; p* j' i [+ C
StandardFilterSA
0 f! N$ x2 e- _4 o D$ B设置标准过滤器起始地址,必须是32bit地址。6 w( {0 v2 e8 J" O k: d
. M0 G% ] r8 i5 }1 _* Q7 v: I
ExtendedFilterSA$ ?, M' `+ I5 N% w; f3 |8 A5 H2 C% n
设置扩展过滤器起始地址,必须是32bit地址。" c, d* `. _7 n! D9 T, g0 k
5 e$ Q$ f6 L& D- Q5 @( n RxFIFO0SA/ }8 ?% e( b7 e4 d
设置RX FIFO 0起始地址,必须是32bit地址。4 N- U* C" _: a' _ R9 B9 ?/ f
i( \4 t$ Q) z
RxFIFO1SA! a7 |' a U# r B+ \3 y
设置RX FIFO 1起始地址,必须是32bit地址。0 S' h+ M, C! t1 o' O
' E; i9 O5 y0 A6 r
RxBufferSA
+ p1 e( B$ R5 k- o) [2 U; {设置RX Buffer起始地址,必须是32bit地址。$ ^( @& Z' {$ ~/ Z3 [5 ^7 S
; J& _( K6 e7 I4 P8 u
TxEventFIFOSA
& q6 V- W0 M ` a# j+ N设置Tx Event FIFO起始地址,必须是32bit地址。: K; Y, Z4 A- }7 \% a; c0 R* G# z
* `/ h6 l4 |- f2 H# H( n8 k
TTMemorySA
}5 q; S' I: R* {/ o+ F设置触发内存起始地址,必须是32bit地址。
; m( k, I3 U8 C
' I8 _! V. P$ e& u3 ]4 t& { EndAddress, J( {, O: B, Z3 ^( q6 b
设置申请RAM空间的结束地址,必须是32bit地址。. O1 K% j+ P# c8 B
6 n+ |9 [9 U( t
91.3.5 FDCAN总线过滤结构体FDCAN_FilterTypeDef
- g4 c5 H! K$ N# o9 H( D下面是过滤结构体:" B4 c* U, [+ F' @; G" m; S: J9 `, K
5 J* b/ N5 X7 J- typedef struct: k" M& R& M2 {2 [
- {
2 j5 m# A) Q& m9 x5 o - uint32_t IdType; /*!< Specifies the identifier type." i$ y4 s) B* u* G+ K' y! U
- This parameter can be a value of @ref FDCAN_id_type */! U* C- ^2 C N/ n( [. f9 ~1 E) p U
5 D: V" b* _4 ?- uint32_t FilterIndex; /*!< Specifies the filter which will be initialized.. z7 R: R% N- B% z# ^
- This parameter must be a number between:% i# @1 P; `. E
- - 0 and 127, if IdType is FDCAN_STANDARD_ID7 X1 Q2 h# N. w2 h8 t
- - 0 and 63, if IdType is FDCAN_EXTENDED_ID */
- h2 M4 d" K( J$ w1 Z) i6 }
/ k ^9 G- x) D6 V$ l- uint32_t FilterType; /*!< Specifies the filter type.. @9 W% I" P5 W" Z; x4 a$ t
- This parameter can be a value of @ref FDCAN_filter_type.4 V* F" N7 @: i( R/ v* e1 a2 @
- The value FDCAN_EXT_FILTER_RANGE_NO_EIDM is permitted
3 I' c7 q7 V4 l' b+ `# P - only when IdType is FDCAN_EXTENDED_ID.) I# t" t5 v. ^1 }3 e0 I2 u7 Y; A5 Q
- This parameter is ignored if FilterConfig is set to
* Y2 T" e+ E- }0 {) C P% }+ Q - FDCAN_FILTER_TO_RXBUFFER */3 ]0 a( [. C' s; ]. K0 J
; D2 F0 Q! a @* l+ r0 x- uint32_t FilterConfig; /*!< Specifies the filter configuration.
1 b9 d3 X3 ?% V- j, ~ - This parameter can be a value of @ref FDCAN_filter_config */9 R; Y6 X5 K+ V1 O [
- ' Y: T1 @1 q. G0 y
- uint32_t FilterID1; /*!< Specifies the filter identification 1.
. P+ k8 d" h, I# ]- Z. D - This parameter must be a number between:8 O+ h# y, E- G) J) P
- - 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID0 k4 f3 F3 z& d9 j+ k- o
- - 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */2 v P+ K# ]5 Q
- 7 ^( l5 a5 y3 S5 h ]
- uint32_t FilterID2; /*!< Specifies the filter identification 2.
, m/ N" m: M; v/ D3 g4 V2 p% P - This parameter is ignored if FilterConfig is set to
4 D4 p0 K8 b. P3 { - FDCAN_FILTER_TO_RXBUFFER.
/ J4 n L I, X3 N8 X' J - This parameter must be a number between:
; a3 q |. S$ r: v) [* {0 t - - 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID
! y& J* L1 w& ^. W1 ^ - - 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */2 C+ N) T4 o$ W# K, _$ ]$ h0 [) N
- % w# R+ ^/ I. C; D ]! `
- uint32_t RxBufferIndex; /*!< Contains the index of the Rx buffer in which the+ V$ ]& ~, x4 m) O% K a9 |0 B
- matching message will be stored.
- L6 H. _* w2 [/ h% z: P - This parameter must be a number between 0 and 63.4 J+ S* x3 X0 j6 [
- This parameter is ignored if FilterConfig is different6 U8 m3 W+ a( C" G& p) ?* f* g
- from FDCAN_FILTER_TO_RXBUFFER */- }6 l. @* L2 A: a4 d1 J
- 0 W( `, _( |* ]1 D
- uint32_t IsCalibrationMsg; /*!< Specifies whether the filter is configured for
& H+ u+ [+ d5 } - calibration messages.- f+ A7 J/ Z3 V# F; B) f5 U+ y3 ^
- This parameter is ignored if FilterConfig is different6 B6 w( I/ E Y1 m2 f
- from FDCAN_FILTER_TO_RXBUFFER.
" M3 z; f; ?3 z3 P. n - This parameter can be:, N* ~( d; l+ O( Z6 v8 u. g0 F/ q
- - 0 : ordinary message0 q! k% q, l* E$ z' U
- - 1 : calibration message */
% ]) g5 }/ C. a - , e* A" c0 C/ q: C! [. b; F
- } FDCAN_FilterTypeDef;
复制代码
% }' p8 _' x% N% I4 Y9 E IdType" v/ ]& x* A& D O5 e% r$ E" C d
用于设置标准ID和扩展ID。
& ~5 p0 v/ O3 p- w: F( I
' N$ n$ S( s. w2 F- #define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */
* h2 S4 W) v8 R7 ]' m7 C# H - #define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */
复制代码 : t9 _$ `3 e- u; c# p* ~& j
FilterIndex2 ]& \, {5 ?2 K0 [3 R: Z, t
用于过滤索引,如果是标准ID,范围0到127。如果是扩展ID,范围0到64。
! I$ G8 G3 x3 E- C6 S# I# x% L3 }5 Q3 b w
FilterType
/ r( N3 E+ [4 |/ I: B6 O. D0 K' }用于设置过滤类型。如果成员FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER,本参数将不起作用。
0 I' r7 [) D. F: A" E/ ^ s) k
! `) q, z5 J+ R/ x- U8 h- #define FDCAN_FILTER_RANGE ((uint32_t)0x00000000U) /*!< 范围过滤从FilterID1 到 FilterID2 */
9 Y7 ^9 X* N6 m% p1 ?- ^ - #define FDCAN_FILTER_DUAL ((uint32_t)0x00000001U) /*!< 专用ID过滤,FilterID1 或者FilterID2 */6 D2 i; f3 z! F! A! j
3 {! T1 y6 n3 y) r- /*!< 精度屏蔽过滤,FilterID1 = filter, FilterID2 = mask */
! a# H( v2 t9 G! S - #define FDCAN_FILTER_MASK ((uint32_t)0x00000002U) 1 E- W: U& L/ j9 z5 U
- ) M* p$ q& @1 }4 |6 D2 A
- /*!< 仅ID扩展模式支持此参数,范围从FilterID1 到 FilterID2, EIDM mask not applied */* f. m( N2 \( E& |: C
- #define FDCAN_FILTER_RANGE_NO_EIDM ((uint32_t)0x00000003U)
复制代码 % v X( o% O; H% X; ~, F
FilterConfig, |$ R; F6 p0 D4 q2 i, y
用于设置过滤类型。8 d6 }& @3 p" }
/ W* ?/ y$ r O* s, `. M- #define FDCAN_FILTER_DISABLE ((uint32_t)0x00000000U) 禁止过滤
- s7 H7 f8 H$ j7 \9 X - #define FDCAN_FILTER_TO_RXFIFO0 ((uint32_t)0x00000001U) 如果过滤匹配,将数据保存到Rx FIFO 0
! ?& I: n# h/ V$ f$ Z - #define FDCAN_FILTER_TO_RXFIFO1 ((uint32_t)0x00000002U) 如果过滤匹配,将数据保存到Rx FIFO 1" s S+ B/ j9 u1 W5 D+ v
- #define FDCAN_FILTER_REJECT ((uint32_t)0x00000003U) 如果过滤匹配,拒绝此ID) L# k7 m- R: M* R( i( [
- #define FDCAN_FILTER_HP ((uint32_t)0x00000004U) 如果过滤匹配,设置高优先级3 h+ I8 I9 n! Y& X
- #define FDCAN_FILTER_TO_RXFIFO0_HP ((uint32_t)0x00000005U) 如果过滤匹配,设置高优先级并保存到FIFO 0* \+ |" f5 {/ b) F- C5 r! h L6 |
- #define FDCAN_FILTER_TO_RXFIFO1_HP ((uint32_t)0x00000006U) 如果过滤匹配,设置高优先级并保存到FIFO 1& \4 H3 |5 j( X1 Y& \$ ~* h* h4 c
- #define FDCAN_FILTER_TO_RXBUFFER ((uint32_t)0x00000007U) 如果过滤匹配,保存到Rx Buffer,并忽略FilterType
复制代码 8 ^! z3 `* B; `+ _" R$ z
配置" V! N3 g' [# s! P/ e
FilterID1
9 k6 G# ]3 e' H7 N用于设置过滤ID1。如果ID类型是FDCAN_STANDARD_ID,范围0到0x7FF。如果ID类型是FDCAN_EXTENDED_ID,范围是0 到0x1FFFFFFF。
% K7 g) |, m3 _0 h/ n5 F. N; n! K6 y. b z' g
FilterID2
0 |$ c+ X X: ^; D+ d! x! C用于设置过滤ID2。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER,此参数不起作用。如果ID类型是FDCAN_STANDARD_ID,范围0到0x7FF。如果ID类型是FDCAN_EXTENDED_ID,范围是0 到0x1FFFFFFF。
/ U& i; A) M' _9 n
+ J, B9 ^/ y, X) u7 x/ s1 V) U RxBufferIndex: h* U( `/ `4 z+ I
匹配消息存储到Rx buffer中的索引。参数范围0到63。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER,此参数不起作用。
+ j, P' ?; u7 @7 Z5 y' W1 q* B M3 Y; @7 X i V# B
IsCalibrationMsg' K8 ^$ m$ [9 h5 l K
用于设置是否配置校准消息。如果FilterConfig设置为FDCAN_FILTER_TO_RXBUFFER,此参数不起作用。
+ `( W0 ]8 z# ]7 G1 ] v# l
% Z$ N3 m0 r# Q6 x! j+ a0 : 表示正常消息。
' F# X8 a2 I5 h2 q6 i/ @: U x# o0 E. l) v! \! G ?, B8 ^$ b2 _ c
1 : 标志校准消息。
; M( b, A4 O3 s; D O
* w+ `4 W5 f1 Z+ _91.3.6 FDCAN总线消息发送结构体FDCAN_TxHeaderTypeDef
! S0 L$ W% A7 r$ u6 A- P; R" |下面是CAN FD发送消息结构体:
; I. J* B" l# ]1 g U& L8 Z! @) V! ]6 J( k7 S, k7 O
- typedef struct$ l0 d3 p3 y' K$ s9 X
- {
; \- |8 I' a2 u/ }3 [( o* [" Z - uint32_t Identifier; /*!< Specifies the identifier.% E+ N; Q3 H( P3 `+ m9 [& u& c& B
- This parameter must be a number between:
8 ^# \) A1 u8 K0 ?- H# r - - 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID" `' u& d' ?; m1 B3 p4 V8 u I
- - 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */
" U3 x( s+ [; a; \ - + p* K( e: F3 G8 M; I5 E4 N+ Z1 O
- uint32_t IdType; /*!< Specifies the identifier type for the message that will be. j# K8 p- w9 l3 B2 W% _; ?3 f
- transmitted.
7 o; w. b+ b4 r7 n/ J2 Z* J - This parameter can be a value of @ref FDCAN_id_type */- O( N( ~2 X$ j1 `3 e) t( E2 B
3 \! _& P3 f! z9 [( M- uint32_t TxFrameType; /*!< Specifies the frame type of the message that will be transmitted.
' |% p0 L8 E) }$ ]; @5 ] H - This parameter can be a value of @ref FDCAN_frame_type *// n: R1 r" h1 {# [ x
* D$ P: P1 X7 z7 \) Q- uint32_t DataLength; /*!< Specifies the length of the frame that will be transmitted.' @/ [$ {! }6 @& T( G7 q
- This parameter can be a value of @ref FDCAN_data_length_code */* F4 |: c( R# e" I; f; s
- 6 X% P5 Q. |+ {
- uint32_t ErrorStateIndicator; /*!< Specifies the error state indicator.
5 g v% _- g5 `, n& U - This parameter can be a value of @ref FDCAN_error_state_indicator */
! t! D5 r4 ~- f" r/ o4 R, P/ {0 w4 u - / U. t& B4 Q+ l4 b1 J
- uint32_t BitRateSwitch; /*!< Specifies whether the Tx frame will be transmitted with or without; H n& R: i* i* k( [
- bit rate switching.1 ^+ F7 e1 n# ^9 s1 C, U% W8 R
- This parameter can be a value of @ref FDCAN_bit_rate_switching */, W5 {+ Q: L5 ~
, E X7 V1 x A1 D1 T- uint32_t FDFormat; /*!< Specifies whether the Tx frame will be transmitted in classic or
7 t6 p% h: Z7 f7 a4 g4 C8 F' h - FD format.
4 m- c; |- [2 [5 I - This parameter can be a value of @ref FDCAN_format */5 S1 P. O! p( U5 K9 C: b, u6 `
I8 E$ I2 a; n. G- uint32_t TxEventFifoControl; /*!< Specifies the event FIFO control.
) O4 I$ U5 I2 v' f6 `4 E - This parameter can be a value of @ref FDCAN_EFC */
2 ]& {/ W% Q" x" p* n
1 ?$ n, n8 ^1 Z6 ]' `3 S- uint32_t MessageMarker; /*!< Specifies the message marker to be copied into Tx Event FIFO
) V9 i+ t, v2 L; r6 I' ~ - element for identification of Tx message status.
1 ~* T- ^; m' y9 T - This parameter must be a number between 0 and 0xFF */
+ U+ l+ n6 |( U7 X! i0 w - * E: c/ u8 B% N0 ~4 W9 V. l$ b2 P
- } FDCAN_TxHeaderTypeDef;
复制代码 3 J; q; D6 U; S) ]/ `; U: G. Q
Identifier3 R" b6 V9 P8 y8 u
用于设置ID,如果IdType是标准FDCAN_STANDARD_ID,范围0到0x7FF,如果IdType是FDCAN_EXTENDED_ID扩展ID,范围0到0x1FFFFFFF。$ [# A& A" h& s) j/ d
5 _( g/ e- J6 M! V* l IdType
- T7 z7 S6 X3 G l& @# K) A% a% t' X用于设置标准ID或者扩展ID。
' O7 X& z; F* W4 l2 R, ^% W/ X! n5 l) i# d4 g% T/ p8 c# i" {6 F
- #define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */
9 W' l/ L# U! a6 o* [% v" f - #define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */
复制代码
) Z* ~; b' l% f+ R# G" A9 I5 } TxFrameType1 s7 g3 W4 v9 N0 j! x, |! B# _( w
用于设置帧类型,数据帧或遥控帧。0 V. M" E9 L2 m( L
3 D) Y0 g3 u3 _6 @. w: } j
- #define FDCAN_DATA_FRAME ((uint32_t)0x00000000U) /*!< 数据帧 */" E: @) j0 L! m! K* i. e
- #define FDCAN_REMOTE_FRAME ((uint32_t)0x20000000U) /*!< 遥控帧 */
复制代码 4 q; y8 D8 V' d( L- @
DataLength7 p v3 Q$ w* d+ y1 e6 k2 o3 v t, ^
用于设置数据长度。
?* H1 G3 G6 ]; f8 m) w! W" l' Q& }0 |& P! V! C% z# q
- #define FDCAN_DLC_BYTES_0 ((uint32_t)0x00000000U) /*!< 0 bytes data field */
1 H) f9 z, b% m - #define FDCAN_DLC_BYTES_1 ((uint32_t)0x00010000U) /*!< 1 bytes data field */
! t+ c' I4 l- C# O8 A3 b- K3 B - #define FDCAN_DLC_BYTES_2 ((uint32_t)0x00020000U) /*!< 2 bytes data field */. s) s7 j+ h2 ?, _1 b0 m
- #define FDCAN_DLC_BYTES_3 ((uint32_t)0x00030000U) /*!< 3 bytes data field */. W5 O/ M3 {8 ?: j
- #define FDCAN_DLC_BYTES_4 ((uint32_t)0x00040000U) /*!< 4 bytes data field */: f% g e: E& l" Z" ^4 N$ p, z
- #define FDCAN_DLC_BYTES_5 ((uint32_t)0x00050000U) /*!< 5 bytes data field */
% x8 L, \$ W) t z$ A# X6 V - #define FDCAN_DLC_BYTES_6 ((uint32_t)0x00060000U) /*!< 6 bytes data field */
7 Z+ ?- f% W, U- ?% {+ X ~ - #define FDCAN_DLC_BYTES_7 ((uint32_t)0x00070000U) /*!< 7 bytes data field */
5 B+ y1 r+ J1 H, D - #define FDCAN_DLC_BYTES_8 ((uint32_t)0x00080000U) /*!< 8 bytes data field */
3 {/ L3 j" J2 G. Z- Y - #define FDCAN_DLC_BYTES_12 ((uint32_t)0x00090000U) /*!< 12 bytes data field */
( u9 X8 S8 O. A - #define FDCAN_DLC_BYTES_16 ((uint32_t)0x000A0000U) /*!< 16 bytes data field */! ^( w& R3 \. f
- #define FDCAN_DLC_BYTES_20 ((uint32_t)0x000B0000U) /*!< 20 bytes data field */8 N& H$ r8 f* g- a) i+ z
- #define FDCAN_DLC_BYTES_24 ((uint32_t)0x000C0000U) /*!< 24 bytes data field */0 Z k7 ]& v! l$ @7 o
- #define FDCAN_DLC_BYTES_32 ((uint32_t)0x000D0000U) /*!< 32 bytes data field */
" u8 c6 y, b1 k5 T3 @/ Y; c. [7 Y - #define FDCAN_DLC_BYTES_48 ((uint32_t)0x000E0000U) /*!< 48 bytes data field */
2 N% p1 E1 J7 }0 j/ t& J* Z - #define FDCAN_DLC_BYTES_64 ((uint32_t)0x000F0000U) /*!< 64 bytes data field */
复制代码 3 U1 x. g$ C1 V3 u
ErrorStateIndicator7 V8 A' v( l/ E! D0 G4 h( R
用于设置错误状态指示:; ]* u' t, j a5 j1 `9 K2 _
7 Q$ u1 \- H/ x$ k# Z8 \6 t- #define FDCAN_ESI_ACTIVE ((uint32_t)0x00000000U) /*!< 传输节点 error active */
* p: n l5 D& A( I8 u2 \1 U% o - #define FDCAN_ESI_PASSIVE ((uint32_t)0x80000000U) /*!< 传输节点error passive */
复制代码
! D; d# U' ?, C `6 |5 d BitRateSwitch% ~" G) K& s/ D4 x6 ^& m
用于设置发送是否波特率可变。4 R* z3 S* e9 A t# i
# H7 r" a& b2 k- #define FDCAN_BRS_OFF ((uint32_t)0x00000000U) /*!< FDCAN帧发送/接收不带波特率可变 */
( M* Y- k# k: e2 @. e: X: m, U - #define FDCAN_BRS_ON ((uint32_t)0x00100000U) /*!< FDCAN帧发送/接收带波特率可变 */
复制代码 - t5 }( `6 S9 N1 x3 y/ Y9 n
FDFormat4 @# u* J) ^/ N. ^+ P
用于设置发送帧是经典格式还是CANFD格式。
3 a' F' n5 N4 q, C" ^" }# o w- , u* E6 b r% a9 D) l, G
- #define FDCAN_CLASSIC_CAN ((uint32_t)0x00000000U) /*!< 帧发送/接收使用经典CAN */
7 a+ z4 ^/ A) y: j2 o6 U - #define FDCAN_FD_CAN ((uint32_t)0x00200000U) /*!< 帧发送/接收使用FDCAN格式 */
复制代码 ! P+ k( H- p9 k" ^4 b
TxEventFifoControl
* H, _1 n' k, Z1 I& a' X用于设置发送事件FIFO控制。
; C& C2 C# ]3 A; R" W' r3 C! k+ f! q" D8 O! V
- #define FDCAN_NO_TX_EVENTS ((uint32_t)0x00000000U) /*!< 不存储 Tx events */
: Z+ g* T8 V, M - #define FDCAN_STORE_TX_EVENTS ((uint32_t)0x00800000U) /*!< 存储Tx events */
复制代码 ' O% Z7 S/ [7 ]; T2 z3 X1 p
MessageMarker
0 U7 @( S# ]7 W- @% Y9 b用于设置复制到TX EVENT FIFO的消息Maker,来识别消息状态,范围0到0xFF。
/ I( K8 S+ x2 t, Q$ e6 |+ v( h) E7 k( g8 X% m& E" Q) [. T
91.3.7 FDCAN总线消息接收结构体FDCAN_RxHeaderTypeDef
4 p0 e; {+ T" ^4 \1 g6 ?$ ^4 l- X- ?) o下面是CAN FD接收消息结构体:
& ~3 P$ I3 i0 K
4 R) J9 L9 ]. {2 k [- typedef struct! H+ I( Y1 _" X3 x
- {; v* O0 [( D# D# F
- uint32_t Identifier; /*!< Specifies the identifier.
! s9 i; F/ p- u8 O5 R5 d - This parameter must be a number between:
; q# q" O! e) S# ]* L. x- g" L - - 0 and 0x7FF, if IdType is FDCAN_STANDARD_ID$ n/ ^+ K" S& q: \: S
- - 0 and 0x1FFFFFFF, if IdType is FDCAN_EXTENDED_ID */3 `! c% S) f$ s, B
, P# a& J% s( A- uint32_t IdType; /*!< Specifies the identifier type of the received message.
6 x+ _/ O" U9 Z7 g# O8 E# [ - This parameter can be a value of @ref FDCAN_id_type */
' \( i% Q' f/ t1 f3 e; I; \9 l( A; @ - : F" A6 ?' R1 O9 @) m' _
- uint32_t RxFrameType; /*!< Specifies the the received message frame type.
& m j& L* l- V* f" v% `9 v. P - This parameter can be a value of @ref FDCAN_frame_type */
8 |6 H* {' L. }) i: x4 n6 |* y
: j- i. @- x- F1 O* |# N ^- uint32_t DataLength; /*!< Specifies the received frame length.
4 t8 Q! Q* ~3 Y' R$ ] - This parameter can be a value of @ref FDCAN_data_length_code */' n7 Z5 V8 [# j7 X/ s. b( `7 {
( [6 D. k6 G7 s3 _6 M0 \/ K- uint32_t ErrorStateIndicator; /*!< Specifies the error state indicator.
M6 Y# p# w X3 O* t. o - This parameter can be a value of @ref FDCAN_error_state_indicator */
4 S2 ?4 n0 c8 \9 x - ) e$ _+ J- ^5 q" {% r/ p
- uint32_t BitRateSwitch; /*!< Specifies whether the Rx frame is received with or without bit. L) I2 e9 t8 d9 B
- rate switching.
' m. g, n' {' A- O$ v6 o' Q - This parameter can be a value of @ref FDCAN_bit_rate_switching */
: `! t( O' H2 s, K - $ z$ {8 I0 }; {0 a, M% p0 H5 q
- uint32_t FDFormat; /*!< Specifies whether the Rx frame is received in classic or FD
7 D Q5 b4 y9 @0 f. q3 e; O0 i - format." k, `4 G7 T+ w( ^1 U4 x* ?3 X
- This parameter can be a value of @ref FDCAN_format */3 O. A$ d4 b1 u9 }, \1 O. a
/ X H% L- w* T' m# ?) N- uint32_t RxTimestamp; /*!< Specifies the timestamp counter value captured on start of frame6 o l% n' @, c* r
- reception.
. {+ ^# P( W# z - This parameter must be a number between 0 and 0xFFFF */
8 K! l# I# l! p; Y* g8 u/ k7 h7 v - 7 U, p0 g, r: B8 x$ [- S! m
- uint32_t FilterIndex; /*!< Specifies the index of matching Rx acceptance filter element.
, Z6 l. m- N! i: M8 i - This parameter must be a number between:7 Y% y3 W+ w& P, U" f
- - 0 and 127, if IdType is FDCAN_STANDARD_ID- ^6 R9 d; h& w8 }% n: N
- - 0 and 63, if IdType is FDCAN_EXTENDED_ID */
1 j: N9 z. ]- T. i& Z
3 @9 l" n- F( N ?% t- uint32_t IsFilterMatchingFrame; /*!< Specifies whether the accepted frame did not match any Rx filter.
! F4 w b) k/ i$ T' ~$ P - Acceptance of non-matching frames may be enabled via0 L; m& C9 Z" B& ~ w! ?
- HAL_FDCAN_ConfigGlobalFilter().2 `. o5 a, `! X
- This parameter can be 0 or 1 */
; S9 u/ e2 h6 a X- q - " E3 C, [2 i0 A
- } FDCAN_RxHeaderTypeDef;
复制代码 7 s6 N! o5 @& L6 A% h+ N
Identifier$ [5 V! ]. b1 ?1 v
用于设置ID,如果IdType是标准FDCAN_STANDARD_ID,范围0到0x7FF,如果IdType是FDCAN_EXTENDED_ID扩展ID,范围0到0x1FFFFFFF。7 @& I2 h' a$ z" Q9 H) [/ D1 L4 G
, _4 n/ S1 V% `7 y5 \ IdType4 Q. ^$ ]" D6 N8 ]
用于设置标志ID或者扩展ID。
/ r8 ]2 V. u2 t
. ?5 c: K) r/ g/ k9 t# U7 P1 T- #define FDCAN_STANDARD_ID ((uint32_t)0x00000000U) /*!< 标准ID */
2 o+ d6 S% Z# D' L( T6 b/ E& a - #define FDCAN_EXTENDED_ID ((uint32_t)0x40000000U) /*!< 扩展ID */
复制代码 # D6 G1 e3 ?% a4 B; D2 ^" V
RxFrameType
3 y- O) x4 k+ o3 D1 c用于设置接收帧类型,数据帧或遥控帧
$ u* A5 m7 \/ I" X2 F g+ J; p. F( h0 J, b2 T: s
- #define FDCAN_DATA_FRAME ((uint32_t)0x00000000U) /*!< 数据帧 */
9 n j8 \5 V y, D; d. \! R! R - #define FDCAN_REMOTE_FRAME ((uint32_t)0x20000000U) /*!< 遥控帧 */
复制代码 1 q" X# Y0 E7 p
DataLength% Z! i# I6 z8 v/ N
用于设置数据长度。
, e: ]4 j( G4 l6 h: Y" }/ X* u1 D4 n& ^ f
- #define FDCAN_DLC_BYTES_0 ((uint32_t)0x00000000U) /*!< 0 bytes data field */
' h" T6 ]- T, ]' w - #define FDCAN_DLC_BYTES_1 ((uint32_t)0x00010000U) /*!< 1 bytes data field */! F( P+ k2 k5 s! u2 x* r
- #define FDCAN_DLC_BYTES_2 ((uint32_t)0x00020000U) /*!< 2 bytes data field */! D4 t* I3 {+ P3 E! ^7 X
- #define FDCAN_DLC_BYTES_3 ((uint32_t)0x00030000U) /*!< 3 bytes data field */9 v: l' F6 a& ?0 K9 m
- #define FDCAN_DLC_BYTES_4 ((uint32_t)0x00040000U) /*!< 4 bytes data field */% j. I( k" Q7 ]" @ {
- #define FDCAN_DLC_BYTES_5 ((uint32_t)0x00050000U) /*!< 5 bytes data field */! Z! R, r! y# I0 C) Y) j3 C; ^
- #define FDCAN_DLC_BYTES_6 ((uint32_t)0x00060000U) /*!< 6 bytes data field */% |9 ?3 P z" e" s
- #define FDCAN_DLC_BYTES_7 ((uint32_t)0x00070000U) /*!< 7 bytes data field */( v( Y1 C4 X9 t4 T# R" j
- #define FDCAN_DLC_BYTES_8 ((uint32_t)0x00080000U) /*!< 8 bytes data field */, P9 n" L. H9 y' a7 N
- #define FDCAN_DLC_BYTES_12 ((uint32_t)0x00090000U) /*!< 12 bytes data field */! b- Q: h" B( U a
- #define FDCAN_DLC_BYTES_16 ((uint32_t)0x000A0000U) /*!< 16 bytes data field */
5 f2 D5 a, m; z k9 ?* n( |- A - #define FDCAN_DLC_BYTES_20 ((uint32_t)0x000B0000U) /*!< 20 bytes data field */) E8 |% _9 g9 l' j- q; W+ c
- #define FDCAN_DLC_BYTES_24 ((uint32_t)0x000C0000U) /*!< 24 bytes data field */) G: F- d' s. r, P1 ~7 m- E1 _
- #define FDCAN_DLC_BYTES_32 ((uint32_t)0x000D0000U) /*!< 32 bytes data field */
; _2 j4 Z/ E4 b% N3 K; w( v - #define FDCAN_DLC_BYTES_48 ((uint32_t)0x000E0000U) /*!< 48 bytes data field */& k' l9 h% ~5 a" @& u7 }. g# x
- #define FDCAN_DLC_BYTES_64 ((uint32_t)0x000F0000U) /*!< 64 bytes data field */
$ s7 c) d6 R2 t - ErrorStateIndicator
复制代码 $ h8 u, ^. h* N6 j
用于设置错误状态指示:
. B" \" D2 J& \$ \4 e5 n8 e9 f- Q$ ^5 y R1 ?# x$ q
- #define FDCAN_ESI_ACTIVE ((uint32_t)0x00000000U) /*!< 传输节点error active */
3 }0 g2 ^, j" F; H, |3 d5 t4 J - #define FDCAN_ESI_PASSIVE ((uint32_t)0x80000000U) /*!< 传输节点error passive */
复制代码
: a+ s! x/ K6 T6 j% D1 o7 w- ], Y BitRateSwitch/ x3 D( M2 D( o* {# h; O- u
用于设置接收是否带波特率切换+ X% H% M/ q5 o4 {6 u
- p1 b3 K r! [1 \/ g1 |& g
- #define FDCAN_BRS_OFF ((uint32_t)0x00000000U) /*!< FDCAN 帧发送/接收不支持波特率可变*/
9 ?/ R. @6 Y- s& ?3 ` - #define FDCAN_BRS_ON ((uint32_t)0x00100000U) /*!< FDCAN 帧发送/接收支持波特率可变 */
复制代码 5 s: U: V8 _; ?* y( [8 S3 h5 u
FDFormat2 e7 x9 Z6 O3 U" E8 p$ s5 D e! N8 ^+ f
用于设置接收帧是经典格式还是CANFD格式' m8 ], H3 N N2 g' `3 I) }5 ?/ E% U
! U* z7 }9 G3 d! C& E' ]2 v- w! E
- #define FDCAN_CLASSIC_CAN ((uint32_t)0x00000000U) /*!< 经典帧 */7 H* R; f% z3 [: S8 Q% @
- #define FDCAN_FD_CAN ((uint32_t)0x00200000U) /*!< FDCAN帧 */
复制代码
5 ]4 l! X0 m6 {9 L4 J! M$ W7 ` RxTimestamp9 ?5 I3 J: ?9 ] j. B: v) i+ C0 S
用于设置帧接收时间戳,范围0到0xFFFF。
2 R! A3 P# P7 K! R/ }1 p* O6 F6 i7 m D7 J( C% j
FilterIndex
+ i5 S* I' @! g/ A! R$ x用于设置接收过滤索引。如果是标准ID,范围0到127,如果是扩展ID,范围0到63。
) h# V& `) W: Q- K& ]8 l6 S; a) V
$ `' X. b! }$ r; \ IsFilterMatchingFrame
/ E% ]+ M9 U' ~! @5 M用于设置是否接收非匹配帧,通过函数HAL_FDCAN_ConfigGlobalFilter()可以使能。" {$ @5 x1 z6 d" V1 m
# H# \8 T9 L! Q' n0:表示不接受。
# E* {* e6 c5 m: L0 Q! Z5 D- y, i9 e- g+ M2 m+ q. Q
1:表示接收。2 a" Y3 f& m( ]2 L/ e
A' d# w, y, J/ v91.3.8 FDCAN总线句柄结构体FDCAN_HandleTypeDef; `3 J- H9 [! \- |+ M, U$ b
下面是CANFD句柄结构体: d# y& h5 t7 }1 o' R8 b' \
: `4 k7 l9 D% n* O2 n* t' P- #if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
% G; o" [" y; y3 s* a5 h- r/ } - typedef struct __FDCAN_HandleTypeDef
! w2 D& N$ y: } - #else
2 A: _; _, f( ^8 T- z - typedef struct! `; n. Q5 B2 J* ?9 k
- #endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
& M/ e/ @4 B; @+ J. f - {' K5 B. D7 l% j/ t: D7 G( f2 @
- FDCAN_GlobalTypeDef *Instance; /*!< Register base address */
9 ~" K! u: w1 o5 R6 ~7 c6 [ - ; a! E* d! j, v E- d( ^' @3 J
- TTCAN_TypeDef *ttcan; /*!< TT register base address */
- M$ O7 F( u7 j9 {: S
, ?. J7 s+ H5 q+ Z- FDCAN_InitTypeDef Init; /*!< FDCAN required parameters */
& G: ]5 M; Z; r _1 k8 h2 f
5 y# b- ^# N, @$ B0 y, H! U1 D- FDCAN_MsgRamAddressTypeDef msgRam; /*!< FDCAN Message RAM blocks */8 a- i% @' @( i" f! j
- 6 v" W( E+ D* z5 o3 n
- uint32_t LatestTxFifoQRequest; /*!< FDCAN Tx buffer index
5 @% M! f6 o& J - of latest Tx FIFO/Queue request */- }4 F1 N5 `4 z3 }
- ; ^3 T1 r* _( `5 Y. X
- __IO HAL_FDCAN_StateTypeDef State; /*!< FDCAN communication state *// l4 e/ u% Q- o$ Q
- $ [, t9 C" V# `: A$ c' u
- HAL_LockTypeDef Lock; /*!< FDCAN locking object */
& k5 i1 }5 N$ S$ z8 c! H9 V x* b" y) F - ' ]0 F' |2 i0 c/ Y# ]4 H N
- __IO uint32_t ErrorCode; /*!< FDCAN Error code */2 v; M, V# B( _2 B
- $ X ? i: E/ b( p& e: R% h$ O. A' M
- #if USE_HAL_FDCAN_REGISTER_CALLBACKS == 15 H- o6 n6 y; | S( V: x
- void (* ClockCalibrationCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t ClkCalibrationITs); /*!< FDCAN Clock Calibration callback */
( J& F; {! [3 O, y - void (* TxEventFifoCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TxEventFifoITs); /*!< FDCAN Tx Event Fifo callback */
; D r5 I/ k2 H+ M% {5 _ - void (* RxFifo0Callback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs); /*!< FDCAN Rx Fifo 0 callback */
4 \) @' c; x( H0 j0 W - void (* RxFifo1Callback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs); /*!< FDCAN Rx Fifo 1 callback */# r @, J; a+ c: e& R$ y8 s
- void (* TxFifoEmptyCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Tx Fifo Empty callback */
* c1 ^% o4 V4 c- F4 c - void (* TxBufferCompleteCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t BufferIndexes); /*!< FDCAN Tx Buffer complete callback */: n6 j0 e& k: K
- void (* TxBufferAbortCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t BufferIndexes); /*!< FDCAN Tx Buffer abort callback */
$ Z* j2 \# X# Z/ Z% y% A- U4 X" C/ A - void (* RxBufferNewMessageCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Rx Buffer New Message callback */9 N7 }$ P) E$ d! ^2 J
- void (* HighPriorityMessageCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN High priority message callback */
# u1 @3 b2 o4 u - void (* TimestampWraparoundCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Timestamp wraparound callback */, `* Y4 S {. B; w2 o1 C4 X: C
- void (* TimeoutOccurredCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Timeout occurred callback */
4 p( P) d; c" W5 M - void (* ErrorCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Error callback */( n( j6 }( ~( p" L" k
- void (* ErrorStatusCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t ErrorStatusITs); /*!< FDCAN Error status callback */3 j0 X. k0 ?- a4 x5 w e; ]
- void (* TT_ScheduleSyncCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTSchedSyncITs); /*!< FDCAN T Schedule Synchronization callback */
* R- S8 s7 }8 J5 l. N: J! o - void (* TT_TimeMarkCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTTimeMarkITs); /*!< FDCAN TT Time Mark callback */! j. r0 G1 B" q, [! o6 D7 [0 k5 n
- void (* TT_StopWatchCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t SWTime, uint32_t SWCycleCount); /*!< FDCAN TT Stop Watch callback */+ _. g+ e2 u! w3 r3 L' p
- void (* TT_GlobalTimeCallback)(struct __FDCAN_HandleTypeDef *hfdcan, uint32_t TTGlobTimeITs); /*!< FDCAN TT Global Time callback */
6 ?9 i9 l1 s- K- U
" B1 R6 I2 D9 [3 t- y: ?- void (* MspInitCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Msp Init callback */
# P) f% u4 j. A3 l/ \ - void (* MspDeInitCallback)(struct __FDCAN_HandleTypeDef *hfdcan); /*!< FDCAN Msp DeInit callback */
: K, d4 n1 [3 s - #endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
, ^; @( \: K9 G$ b( l2 [ - " F" ]& b( T i. k
- } FDCAN_HandleTypeDef;
复制代码
+ L. x b. G5 ?9 h1 k) t( i9 [注意事项:
5 o: q* p L( \, a" w# D0 v6 c2 g5 b9 ~, w9 S& T$ _5 r J
条件编译USE_HAL_FDCAN_REGISTER_CALLBACKS用来设置使用自定义回调还是使用默认回调,此定义一般放在stm32h7xx_hal_conf.h文件里面设置:$ V- U7 {+ E& N3 v
- #define USE_HAL_FDCAN_REGISTER_CALLBACKS 1
复制代码
; u. w% z* A1 H4 [& ^8 k( A; ? ^9 F& y( s, ~5 W: i
函数HAL_FDCAN_RegisterCallback注册回调,取消注册使用函数HAL_FDCAN_UnRegisterCallback。! {4 d0 Q9 k* X, X# |
6 w& t& \2 ] s, a/ L: \
这里重点介绍下面几个参数,其它参数主要是HAL库内部使用和自定义回调函数。
x( b& g7 g) _3 x/ p5 u4 v4 ~! \6 o1 x
FDCAN_GlobalTypeDef *Instance( c% Y4 T. l3 y+ R* ^ t/ L
这个参数是寄存器的例化,方便操作寄存器。
9 Z; R* w: q3 c& M3 }, g" Z8 ~: A6 P( L
TTCAN_TypeDef *ttcan
. F% O" F: ]$ \0 O( `% }TT CAN时间触发寄存器基地址。
6 n2 a! {3 b8 q, c! d6 b. b& B8 y. T, Q. \1 V1 `) t- [
FDCAN_InitTypeDef Init1 t+ Z o% e- u' Y: u
FDCAN相关的初始化参数。
. k# N* _2 Q! r# K( y4 U" W
/ G0 O8 n1 Z2 z4 u/ V FDCAN_MsgRamAddressTypeDef msgRam
+ @ \2 W4 X: {* G- P2 Q2 h0 z消息RAM地址。; h: e6 @2 }& w" E& }+ [
^& Q8 W+ a Y& I& v
uint32_t LatestTxFifoQRequest* B, [( c5 x! P# I3 P) [
Tx buffer索引最后一个Tx FIFO/Queue参数。
/ V m( y( e8 d: G$ c3 ]
5 Y6 p8 `, P+ O( e+ a __IO HAL_FDCAN_StateTypeDef State
u! u! d. \5 C; d- @HAL_LockTypeDef Lock
( I& I# U3 j$ R. ^+ d: w% u, I Z
m. |! ~1 C( ?" K__IO uint32_t ErrorCode) T0 q/ H$ \+ b2 ^3 i
# Z$ o2 @0 Z" Y
程序内部使用的状态参数。" a9 B7 P& q' J, K, C8 S* Q. a
8 }, c$ `: ?: h/ \; y/ j; q
剩下的都是回调函数
0 H% k" }6 b5 `% j91.4 FD CAN总线源文件stm32h7xx_hal_fdcan.c
: s. L* L8 [( w( ?9 q) B9 R/ R1 A( F% T此文件涉及到的函数较多,这里把几个常用的函数做个说明:3 r: j# l3 `; ~$ \+ q
, q( p7 v' h: I& r% R91.4.1 函数HAL_FDCAN_Init
9 d; C! x. D4 G9 ~0 L- j3 O, R" t函数原型:0 [+ E5 K. i/ @4 G, T. E# T' l
. ~- d4 t' S1 V" G% f
- HAL_StatusTypeDef HAL_FDCAN_Init(FDCAN_HandleTypeDef *hfdcan)
# W3 O* K4 T2 x! X! n }- i - { P/ k# Z2 g7 q, e5 a) o7 Y% ]
- uint32_t tickstart;' i) [2 d: y# A& n
- HAL_StatusTypeDef status;5 o' Y" e- v% w+ w2 t4 C. @
- const uint32_t CvtEltSize[] = {0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 5, 0, 0, 0, 6, 0, 0, 0, 7};1 N* M3 Q. n: H( k
/ R+ t2 c; V- }1 z/ e P$ Z: ~- /* 检测FDCAN句柄是否有效 */5 O0 d5 f' e. U3 U; U/ M
- if (hfdcan == NULL)8 R' R9 j% ?8 ~) T0 F
- {
5 Z! A5 m- f1 [- P$ @/ c& e - return HAL_ERROR;8 G* Q, M. v- L) q3 P
- }
% t% y; \0 o0 _
5 X- A# P- D- N- `- /* 检查FDCAN例化 */
$ M' r5 s( A4 I( ]! [* a+ ^ - if (hfdcan->Instance == FDCAN1); J. |# }" J( ]& Z O" {6 {
- {
/ }! |* T# J; x& x; H4 `! v9 K) q - hfdcan->ttcan = (TTCAN_TypeDef *)((uint32_t)hfdcan->Instance + 0x100U);
+ ]* y& w+ D9 l5 P# I4 ~ - }
1 |8 j5 O$ Y7 x7 R( r g
9 v% b, k0 G1 W4 g9 }' n* |- e5 V* C- /* 检查函数参数 */ Q/ s- _3 {6 b' i6 s
- assert_param(IS_FDCAN_ALL_INSTANCE(hfdcan->Instance));8 O: L% B, @9 h8 U: i
- assert_param(IS_FDCAN_FRAME_FORMAT(hfdcan->Init.FrameFormat));
/ o7 D# x% v3 t - assert_param(IS_FDCAN_MODE(hfdcan->Init.Mode));
0 i8 J0 v) b, ]! h - assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.AutoRetransmission));
9 h a2 C7 |$ t' a - assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.TransmitPause));! n/ v; ^* ~1 ?" d
- assert_param(IS_FUNCTIONAL_STATE(hfdcan->Init.ProtocolException));5 h, @9 I$ A7 H1 ^8 a
- assert_param(IS_FDCAN_NOMINAL_PRESCALER(hfdcan->Init.NominalPrescaler));
" V9 K* Z+ O& }/ c5 `+ ^ - assert_param(IS_FDCAN_NOMINAL_SJW(hfdcan->Init.NominalSyncJumpWidth));* s7 X4 P. f8 V3 l
- assert_param(IS_FDCAN_NOMINAL_TSEG1(hfdcan->Init.NominalTimeSeg1));/ Q2 i! z. J1 \( u5 `
- assert_param(IS_FDCAN_NOMINAL_TSEG2(hfdcan->Init.NominalTimeSeg2));' q4 u8 Q% R( C
- if (hfdcan->Init.FrameFormat == FDCAN_FRAME_FD_BRS)! |' [$ r) e: z" U
- {
2 x, T- r5 t+ R8 b' p. e, D- Y - assert_param(IS_FDCAN_DATA_PRESCALER(hfdcan->Init.DataPrescaler));0 u1 O3 ]2 `5 H9 O" a1 g1 h8 m' D7 `
- assert_param(IS_FDCAN_DATA_SJW(hfdcan->Init.DataSyncJumpWidth));
1 ^$ i9 q$ m/ t! ]9 Q; P8 d - assert_param(IS_FDCAN_DATA_TSEG1(hfdcan->Init.DataTimeSeg1));# e- u3 A6 D- m
- assert_param(IS_FDCAN_DATA_TSEG2(hfdcan->Init.DataTimeSeg2));$ ]) m3 X w' m
- }1 T1 T, ^/ A [3 X& w
- assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.StdFiltersNbr, 128U));
. `5 n/ e9 o, ^9 Q; ~ - assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.ExtFiltersNbr, 64U));
) S' }1 _, u1 w3 t( M4 S - assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxFifo0ElmtsNbr, 64U));
' J1 r; u# @) n+ w! q% V, P - if (hfdcan->Init.RxFifo0ElmtsNbr > 0U)
( m5 L- _, o( H - {2 Z! e5 q9 d& _" D2 K
- assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxFifo0ElmtSize));! t. X) {7 s1 _
- }
. X8 H, K M8 K1 P# x! ]: i, N - assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxFifo1ElmtsNbr, 64U));
7 G" ~) r' s3 I* N1 A! [ - if (hfdcan->Init.RxFifo1ElmtsNbr > 0U)& N7 h6 C) X5 m- O
- {2 y# f& z7 c0 u7 ^0 {, f$ |6 p
- assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxFifo1ElmtSize));
3 h; M4 ]( V4 G - }
3 h `. G* O" \2 s - assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.RxBuffersNbr, 64U));
E! Y' _# q8 g - if (hfdcan->Init.RxBuffersNbr > 0U)
; a( T' g( R1 c' {/ A: n$ [) o - {
. A# L+ G& t) i/ @ C! O - assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.RxBufferSize));4 s6 ^% X$ c, W$ K' D
- }
4 H6 H4 D' I3 @- V. C5 C5 K9 ~ - assert_param(IS_FDCAN_MAX_VALUE(hfdcan->Init.TxEventsNbr, 32U));6 N8 X2 u: n6 j) @5 M$ @
- assert_param(IS_FDCAN_MAX_VALUE((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr), 32U));
" W- U+ l" `6 R' N+ T& Q* @ - if (hfdcan->Init.TxFifoQueueElmtsNbr > 0U): u# g& m+ v/ V9 I3 s
- {! s3 [) w6 O: a% X" p$ {$ f
- assert_param(IS_FDCAN_TX_FIFO_QUEUE_MODE(hfdcan->Init.TxFifoQueueMode));2 |6 G' W! J$ z/ W& s4 S3 k( ^- \8 S
- }
% L$ d' K$ Z+ z8 N - if ((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr) > 0U)* Y6 ^4 G7 {/ S# I, o! N
- {
& }4 o1 L) I: D6 N+ Q; t; z/ P$ z9 p - assert_param(IS_FDCAN_DATA_SIZE(hfdcan->Init.TxElmtSize));
, n `! F0 b4 B" z2 @' M - }" h7 W* M0 C$ V. t, g5 m9 T' X9 b
- $ v9 y+ i7 U j3 ]
- #if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
+ p2 b4 P6 O* A* S9 s: l - if (hfdcan->State == HAL_FDCAN_STATE_RESET)5 U8 \. Q0 ^7 `0 o2 \# O7 n' C- o! L
- {+ N9 ]3 q5 B6 @8 [
- /* 解锁*/
' t$ e. _6 b# P8 E5 r - hfdcan->Lock = HAL_UNLOCKED;
~! I& o7 e( N9 M - ! L# @) D1 E% B$ A5 n" s" A
- /* 复位设置默认回调 */8 ?% S& N! F( y# c
- hfdcan->ClockCalibrationCallback = HAL_FDCAN_ClockCalibrationCallback; /* Legacy weak ClockCalibrationCallback */
p* U* j' _( e+ j# y, S9 x - hfdcan->TxEventFifoCallback = HAL_FDCAN_TxEventFifoCallback; /* Legacy weak TxEventFifoCallback */
: n! C6 v B% l - hfdcan->RxFifo0Callback = HAL_FDCAN_RxFifo0Callback; /* Legacy weak RxFifo0Callback */4 S0 ]# a5 J3 G7 p
- hfdcan->RxFifo1Callback = HAL_FDCAN_RxFifo1Callback; /* Legacy weak RxFifo1Callback */6 n7 O* x+ A+ K I
- hfdcan->TxFifoEmptyCallback = HAL_FDCAN_TxFifoEmptyCallback; /* Legacy weak TxFifoEmptyCallback */
2 h* J- _. I. N5 {4 q5 v - hfdcan->TxBufferCompleteCallback = HAL_FDCAN_TxBufferCompleteCallback; /* Legacy weak TxBufferCompleteCallback */
# }/ h. z7 n c; t! Q - hfdcan->TxBufferAbortCallback = HAL_FDCAN_TxBufferAbortCallback; /* Legacy weak TxBufferAbortCallback */
0 a; f& I1 [' S - hfdcan->RxBufferNewMessageCallback = HAL_FDCAN_RxBufferNewMessageCallback; /* Legacy weak RxBufferNewMessageCallback */$ f6 p) C5 |6 D* ~4 N; {$ B8 ]/ b
- hfdcan->HighPriorityMessageCallback = HAL_FDCAN_HighPriorityMessageCallback; /* Legacy weak HighPriorityMessageCallback */
2 U" e/ Z' i! i5 g# I/ e; i - hfdcan->TimestampWraparoundCallback = HAL_FDCAN_TimestampWraparoundCallback; /* Legacy weak TimestampWraparoundCallback */
L! P6 [2 F) _- h# i" b - hfdcan->TimeoutOccurredCallback = HAL_FDCAN_TimeoutOccurredCallback; /* Legacy weak TimeoutOccurredCallback */2 h5 q4 y# y7 t
- hfdcan->ErrorCallback = HAL_FDCAN_ErrorCallback; /* Legacy weak ErrorCallback */
% V: _+ N/ ]. G1 ^0 P: f9 n/ K - hfdcan->ErrorStatusCallback = HAL_FDCAN_ErrorStatusCallback; /* Legacy weak ErrorStatusCallback */
/ m0 ^2 Z" L t9 ^# ` j6 X - hfdcan->TT_ScheduleSyncCallback = HAL_FDCAN_TT_ScheduleSyncCallback; /* Legacy weak TT_ScheduleSyncCallback */# t; j* N" } g" r
- hfdcan->TT_TimeMarkCallback = HAL_FDCAN_TT_TimeMarkCallback; /* Legacy weak TT_TimeMarkCallback */4 P' g& }. A& _. s5 j
- hfdcan->TT_StopWatchCallback = HAL_FDCAN_TT_StopWatchCallback; /* Legacy weak TT_StopWatchCallback */3 v6 y0 l3 t, |& V6 T
- hfdcan->TT_GlobalTimeCallback = HAL_FDCAN_TT_GlobalTimeCallback; /* Legacy weak TT_GlobalTimeCallback */: e7 d }3 O' m, B$ H: i& J
- 8 c8 j) A4 `- ]! d/ t" P
- if (hfdcan->MspInitCallback == NULL)3 \5 ]' u8 K- j$ P+ z
- {
9 L# m! r5 v* c. F! T) _ - hfdcan->MspInitCallback = HAL_FDCAN_MspInit; /* Legacy weak MspInit */, w7 |: e3 O" f$ u3 u
- }; }0 {: b- M4 i7 D7 D
- 6 N+ D/ ^4 p1 e" M
- /* 初始化CLOCK和NVIC */
+ m1 k- ]: K+ U4 e1 |( p- K& v - hfdcan->MspInitCallback(hfdcan);+ ?- |: }- D Y2 j5 H
- }; O5 L) M: ^- E0 k& T5 ]0 A6 Y$ c
- #else
; A1 H0 U5 T% N6 E - if (hfdcan->State == HAL_FDCAN_STATE_RESET)7 d( J! N) s, J i5 M) _
- {
. X7 A* X7 D% K - /* 解锁 *// T, F" T* f( {+ c% f0 u
- hfdcan->Lock = HAL_UNLOCKED;
( w; Z1 f& |9 H4 e/ c* a
: A& U6 l1 u8 I& `- /* 初始化底层硬件 */
8 P8 s' d: {! [) ^ z - HAL_FDCAN_MspInit(hfdcan);
/ q4 |+ P; R X' s. ?# p - }
: b. D) {+ w& A1 n* Q/ t - #endif /* USE_HAL_FDCAN_REGISTER_CALLBACKS */
& r1 t4 r: L! x7 Z! p% `& K/ W - 1 k+ i: s+ I. ?' a1 [! `# D) F
- /* 退出Sleep */
8 O5 z8 Z+ l- S - CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_CSR);, F/ q5 |( N g, ]5 F4 [
- 6 f2 P! E4 D7 E: p
- /* 获取时钟 */
- V4 D8 `9 _$ W, n5 N - tickstart = HAL_GetTick();
! c8 }$ w; B- s+ F! d0 D - ) z- l6 N2 r( ~, C! L& H/ h
- /* 等待Sleep模式确认 */3 u1 ?- N( v+ `
- while ((hfdcan->Instance->CCCR & FDCAN_CCCR_CSA) == FDCAN_CCCR_CSA)
1 z' T- @4 _1 C0 ?: X3 ` - {
0 N$ `6 G% ^2 N* p - if ((HAL_GetTick() - tickstart) > FDCAN_TIMEOUT_VALUE)
; a) g- {+ I! e( k - {4 V( U+ o, U1 L. u9 m
- /* 更新错误码 */5 o; m2 K" }' F0 k2 ~: j! \
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_TIMEOUT;
, u1 R. v4 n0 P# C0 X2 E - 2 d( o& E! y+ Y8 [
- /* 改变FDCAN状态 */" g4 H8 ~6 @( v. _0 F. i2 s5 Y: {
- hfdcan->State = HAL_FDCAN_STATE_ERROR;0 U9 l, @) a$ `7 H* T
. Y Y: U2 |( J; n, k, c* O- return HAL_ERROR;
1 h! q: |# t# V8 N( Q, Q - }, B+ @8 o( o( y7 t, f+ s
- }
5 W3 l' b% I9 K; D
' E0 h0 {2 e% p# z( d- /* 请求初始化 */
# e' a7 V6 x: u% B$ B9 k4 C8 U - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_INIT);- V4 F5 Z4 ~. Q/ c
- ; w0 \( h7 k7 ^/ C6 d6 P; y
- /* 获取时钟 */9 s9 v6 P5 M8 ]7 ?+ ~
- tickstart = HAL_GetTick();
3 Q8 X0 O- ?5 N3 a! C - 9 H. `8 w% @$ `1 D% a
- /* 等待CCCR寄存器的INIT位 */$ d7 |8 T/ B p- k' u H2 b1 M
- while ((hfdcan->Instance->CCCR & FDCAN_CCCR_INIT) == 0U)5 p! a# X1 w5 H! B( V, D
- {
8 P- ]1 J& D& b+ } - /* 检查溢出时间 */
7 b+ n" B- V# _/ Q" l+ ?* O - if ((HAL_GetTick() - tickstart) > FDCAN_TIMEOUT_VALUE)
2 p' }+ W" \' k" G+ U - {
6 x2 Y' A ^6 Y& s" d - /* 更新错误码 */
- Z9 R( k- A# j+ h' Q9 s& h - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_TIMEOUT;
' ^: f( [% J+ S" ^- m( w( y - 9 h# Y+ n, U3 S1 i; R4 D8 Y8 Y
- /* 设置FDCAN状态 */% F {* c; T# ?9 U# J) L
- hfdcan->State = HAL_FDCAN_STATE_ERROR;
" M2 ^: J8 D# q- f3 b+ u - 7 C# g, Y: x/ L% Q
- return HAL_ERROR;, C! a- O; J& \# ^. A0 f, g
- }
& {/ b' ^/ j8 Y+ U3 L - }( B' L8 }% H8 }" b
- - f- A9 U! \3 [! J- m% e6 ^2 [
- /* 使能配置修改 */
" K* J% B4 X: s c! \% [ - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_CCE);9 E! b6 E0 ~) m
9 l3 e! |% b! g6 ^- /* 设置是否自动重传 */
) c& C! ?! P& s+ j& T7 K9 R& _. M - if (hfdcan->Init.AutoRetransmission == ENABLE)+ e) ]' q" V. W/ l, U
- {
( W. D4 I" d& X - CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_DAR);
9 Y O' r# @/ R7 `0 I - }
9 Z4 D T0 U* w# A' k" r - else9 ?# W2 v: F+ G7 d6 Q+ X
- {
+ @0 S4 J: C- d* f+ ^0 M* ]. T; _ - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_DAR);
# R0 T# b* s% l( {: ^4 ] - }
5 a, U( q7 T7 E& _7 I
8 t& J) S$ W0 N N- /* 设置传输暂停特性 */% d+ Q8 \5 E* y
- if (hfdcan->Init.TransmitPause == ENABLE)
6 }+ u" y# I1 ]' W' v/ O - {
* c! o+ n7 w) N* I9 Q" z - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TXP);
# ~+ u) Y: B y/ c1 o" C9 O - }% H( I2 J+ u8 w3 R& W: x
- else% J1 [ q8 Y9 L. r" H
- {# t+ t) C5 Y# e0 y
- CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TXP);
+ ]8 g) d: i) y) ]" a! e( [ - }
0 ?# e- {* E1 O) q: Z
# Q1 ?; B; O: q3 s5 Y- /* 设置协议异常处理 */8 \& o1 R- T( H/ ] }. \- g
- if (hfdcan->Init.ProtocolException == ENABLE)
$ ?' K2 A" L8 ?, B; Y - {
9 o. @! B9 ]. C2 u; U6 w% p - CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_PXHD);$ r- F( u$ _( F- Z* j+ y9 X
- }, z7 g& H9 {8 D8 }4 i. ^
- else1 W: p- D: p. e+ f' V$ ^/ C
- {$ J0 J+ A. R5 E2 N
- SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_PXHD);
2 X& v3 ]0 e- H8 e- N - }! ]9 `* {, P4 C+ N0 K
4 o' Q6 H7 F: Z: e0 O3 D4 \- /* 设置FDCAN帧格式 */
6 S" L) n" M" x# \ - MODIFY_REG(hfdcan->Instance->CCCR, FDCAN_FRAME_FD_BRS, hfdcan->Init.FrameFormat);4 S3 K1 m" t: s5 V) W- q+ ~
+ E; D. \# F I; h- /* 复位FDCAN操作模式 */
7 D3 ? u# ]# E5 O5 X% H1 I - CLEAR_BIT(hfdcan->Instance->CCCR, (FDCAN_CCCR_TEST | FDCAN_CCCR_MON | FDCAN_CCCR_ASM));& e# ], K9 P/ K' I; X7 O' g9 o: J
- CLEAR_BIT(hfdcan->Instance->TEST, FDCAN_TEST_LBCK);
. u% N( L+ S5 e d( F' O
$ O- H6 o* F6 Z4 @. s7 P- /* 设置FDCAN操作模式:& q& }' n! {! h1 Z1 U- i
- | Normal | Restricted | Bus | Internal | External
) Q& D6 E5 I* V0 V/ w - | | Operation | Monitoring | LoopBack | LoopBack) R* ?2 `- Y$ E" q7 {# d9 Z3 |5 O
- CCCR.TEST | 0 | 0 | 0 | 1 | 1
: |& w5 Q, [1 d3 {& w( `0 g - CCCR.MON | 0 | 0 | 1 | 1 | 0
! h2 e* t& j) w; P7 v; G4 b- P - TEST.LBCK | 0 | 0 | 0 | 1 | 1
% L0 a1 h0 {! Z# ]. I - CCCR.ASM | 0 | 1 | 0 | 0 | 0: q! Y, `5 k5 l% D' ]
- *// o! Z. |7 W" o. ?5 R
- if (hfdcan->Init.Mode == FDCAN_MODE_RESTRICTED_OPERATION)
$ _ C K6 C: m. I6 w9 t! X. Y - {: S# W9 u3 _' c- s3 V0 ^% v
- /* 使能限制操作模式 */- Y$ g& S3 g& w! F3 ^
- SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_ASM);* S* u. Z2 M R9 F
- }
2 A6 B0 {. ~4 H H7 S. ~' g; } - else if (hfdcan->Init.Mode != FDCAN_MODE_NORMAL)
' B9 ^' E; b7 I% s3 h2 h; t# U - {
" l% d! M! ~7 |# }7 d - if (hfdcan->Init.Mode != FDCAN_MODE_BUS_MONITORING)/ h. ^* @5 U0 |$ |: o" L
- {" k" d( N3 k' g- T% ^: g
- /* TEST寄存器写访问使能 */
/ J- k& `& v; w) s7 ] - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_TEST);# X2 X# H( A5 ~- K2 A- V+ k! r* \( [
' v$ H3 D7 j2 P/ c- /* 使能回环模式 */! C: y2 {3 L! d: e" C
- SET_BIT(hfdcan->Instance->TEST, FDCAN_TEST_LBCK);$ s* z4 L; w, }
0 e' f' q: T* |: Z( f- if (hfdcan->Init.Mode == FDCAN_MODE_INTERNAL_LOOPBACK)
2 s, r" j, k0 }: E* \9 _8 {/ b - {
O% \, m8 B9 I0 p: o - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_MON);
0 V) W2 e0 G3 A6 @, x' z - }8 q4 U3 A0 m1 ]+ |8 X- W
- }
) L; w$ U/ V" C1 D; X0 O - else# k+ T% z8 E% J8 V: P$ k% o
- {- y! e1 D" X0 g6 o3 L+ S) N8 P) f
- /* 使能检测模式 */
8 O6 M9 J3 g# r1 T- Q( g3 G - SET_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_MON);! j& P7 G! M6 y2 n7 Q6 [) W$ Y
- }
2 I! N2 e0 K6 O% r& Z - }
4 I" S( q- S6 A0 } - else
- C$ N9 B, f; } - {& b7 A" a0 J2 U
- /* Nothing to do: normal mode */2 r- T5 J5 ^ y% c* {
- }
3 o: l5 d3 n& T9 ? - * S9 L( S4 }" c) Q
- /* 设置nominal bit timing 寄存器 */' {+ y# r4 J4 e Y
- hfdcan->Instance->NBTP = ((((uint32_t)hfdcan->Init.NominalSyncJumpWidth - 1U) << FDCAN_NBTP_NSJW_Pos) | \3 F' k% L! j3 G& w; O- f
- (((uint32_t)hfdcan->Init.NominalTimeSeg1 - 1U) << FDCAN_NBTP_NTSEG1_Pos) | \8 O& C. b' Q. a
- (((uint32_t)hfdcan->Init.NominalTimeSeg2 - 1U) << FDCAN_NBTP_NTSEG2_Pos) | \
3 k& P o4 @- p1 [( z5 N! ` - (((uint32_t)hfdcan->Init.NominalPrescaler - 1U) << FDCAN_NBTP_NBRP_Pos));# S( Z4 B% ~: Y1 x! c
- 0 `; D7 y/ h g1 h
- /* 如果使能BRS(BitRate Switching可变波特率),设置data bit timing 寄存器*/
2 ~( E0 H& S0 |! |& S - if (hfdcan->Init.FrameFormat == FDCAN_FRAME_FD_BRS)/ L/ ^$ _4 k( q( ?4 k h) I2 m
- {
$ ^, d R! V8 r1 y3 T8 [. b, q7 q - hfdcan->Instance->DBTP = ((((uint32_t)hfdcan->Init.DataSyncJumpWidth - 1U) << FDCAN_DBTP_DSJW_Pos) | \
0 A! y- `" @( V' V l( O& E5 F - (((uint32_t)hfdcan->Init.DataTimeSeg1 - 1U) << FDCAN_DBTP_DTSEG1_Pos) | \
8 @6 @- `" J( F8 {) c - (((uint32_t)hfdcan->Init.DataTimeSeg2 - 1U) << FDCAN_DBTP_DTSEG2_Pos) | \
8 N( G0 M4 U7 X9 b - (((uint32_t)hfdcan->Init.DataPrescaler - 1U) << FDCAN_DBTP_DBRP_Pos));$ M3 p2 Y; @7 K3 O% z$ w7 Q
- }+ X) _( t# {: p4 O% q) s9 j
- [& f/ f9 x/ U9 t9 Q
- if (hfdcan->Init.TxFifoQueueElmtsNbr > 0U)# z; H- X4 t! j
- {1 t" S5 W2 }( `- P: Q3 Q
- /* 设置Tx FIFO 或 Tx Queue 操作模式 */
2 P; v3 v2 }9 v4 t: f2 i. \6 ]) m# X - SET_BIT(hfdcan->Instance->TXBC, hfdcan->Init.TxFifoQueueMode);% L3 F, B8 V, B1 h& X6 j0 t$ L
- }
& E/ E; M4 ?# `$ g$ L5 F
+ B; e' b6 k% l5 _$ \+ P- /* 配置Tx element 大小 */6 J8 [" G" d# C4 X u; n
- if ((hfdcan->Init.TxBuffersNbr + hfdcan->Init.TxFifoQueueElmtsNbr) > 0U). O5 D: F) @3 F
- {
[' S7 Q! p; N4 ^; ] - MODIFY_REG(hfdcan->Instance->TXESC, FDCAN_TXESC_TBDS, CvtEltSize[hfdcan->Init.TxElmtSize]);
4 _* _. d" `4 K5 R* Y$ ] - }9 u) m# _+ z/ `6 |- E7 t' A w
6 X& R, \9 R, d$ w0 L$ X7 N- /* 配置Rx FIFO 0 大小 *// p- D- z, e \: O* _7 n
- if (hfdcan->Init.RxFifo0ElmtsNbr > 0U)
' w4 _) [9 v. T& O% \ - {
7 r7 H2 H- Y- H7 k+ P - MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_F0DS, (CvtEltSize[hfdcan->Init.RxFifo0ElmtSize] << FDCAN_RXESC_F0DS_Pos));
f- j% y/ W9 O) O - } d1 Y, ]+ \+ \2 k' T
- 0 q0 D2 f7 O9 Y; e j4 P* ^
- /* 配置Rx FIFO 1大小 */
4 H9 t+ x( c& V - if (hfdcan->Init.RxFifo1ElmtsNbr > 0U)
4 _/ L6 U6 l& M# a2 |2 U( r - {
( D, x& L9 C' O2 D - MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_F1DS, (CvtEltSize[hfdcan->Init.RxFifo1ElmtSize] << FDCAN_RXESC_F1DS_Pos));7 C$ X9 b. X5 |/ S
- }) o3 } e4 r3 @5 H: }! U# ]
0 a$ a1 F) k8 H, j: d) M% ?- /* 配置 Rx buffer element 大小 */+ o% i' E* R$ Z Q z
- if (hfdcan->Init.RxBuffersNbr > 0U)
' ]; j3 `" G( J! h - {" z3 p: n) `6 H( |
- MODIFY_REG(hfdcan->Instance->RXESC, FDCAN_RXESC_RBDS, (CvtEltSize[hfdcan->Init.RxBufferSize] << FDCAN_RXESC_RBDS_Pos));# C9 I# ~ x. L0 Y
- }
% |2 w$ @7 u, ~# T7 M! M4 V0 @
8 f7 d" C1 Y3 f3 m- /* 默认是的事件触发模式,如果使用时间触发模式,用户需要在HAL_FDCAN_Init $ a0 b9 F/ j; D% F t
- 后调用HAL_FDCAN_TT_ConfigOperation */+ R5 _! s) i- m
- if (hfdcan->Instance == FDCAN1)# L7 r# {8 D' ~ y: n
- {
; I9 c8 i) j2 ~: L+ B. M - CLEAR_BIT(hfdcan->ttcan->TTOCF, FDCAN_TTOCF_OM);8 o: w. W8 M8 ?6 H" r3 G, p
- }% w5 G$ v; M) T2 V
- ( P% r: _( _8 }7 C6 y! @
- /* 初始化Tx FIFO/Queue */2 Q) t2 k; R: {! x' q) V9 J- J
- hfdcan->LatestTxFifoQRequest = 0U;8 h) Y! S+ J/ @3 L; u
- 6 ~! H$ e% d/ A, B
- /* 初始化错误码 */
2 Y( R: g* |+ P0 _ - hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;* m! B, W0 X: k) i7 h; y( z5 S# Z9 }3 D
/ w+ N( B% D. w4 z' |1 w& z+ X- /* 初始化FDCAN状态 */
3 e0 c/ L" ?9 ~6 D0 R - hfdcan->State = HAL_FDCAN_STATE_READY;
; q, L* {" A( g# e2 B' B, d
' {8 {( Q! J# Q' t0 f7 _0 \- /* 计算每个RAM块地址 */1 D+ j5 [% C. b
- status = FDCAN_CalcultateRamBlockAddresses(hfdcan);
* q. B# G( m7 F
$ M8 p- o1 o/ P: O; u; w- /* 返回函数状态 */
7 q. n( x$ L7 \' r4 y$ D4 u$ b - return status;
( o( @0 ~/ R+ p - }
复制代码
+ s0 n" A4 V! p3 ~/ F2 J" Q, q函数描述:' k' W; q# f; [
& P. H/ K. B l" g6 k
此函数用于初始化FDCAN。# k4 u f% J( k7 U
8 D: I: D$ ^# ?! k! v% J( `6 M9 l: }6 }函数参数:
3 m& P/ s. S2 ^4 @+ k; U
& _ V+ @$ t1 T" ~4 a 第1个参数是FDCAN_HandleTypeDef类型结构体指针变量,用于配置要初始化的参数。, A6 t' W' S( I$ p
返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。! E& U( F7 `3 a: [
注意事项:6 r# S- `* j0 p( }* I8 k
& Z$ @; k# P/ g4 m
函数HAL_FDCAN_MspInit用于初始化FDCAN的底层时钟、引脚等功能。需要用户自己在此函数里面实现具体的功能。由于这个函数是弱定义的,允许用户在工程其它源文件里面重新实现此函数。当然,不限制一定要在此函数里面实现,也可以像早期的标准库那样,用户自己初始化即可,更灵活些。
8 r$ w$ J4 [) t& p! t. U如果形参hfdcan的结构体成员State没有做初始状态,这个地方就是个坑。特别是用户搞了一个局部变量FDCAN_HandleTypeDef FdCANHandle。% z1 |1 ^; O- f9 v" Q
对于局部变量来说,这个参数就是一个随机值,如果是全局变量还好,一般MDK和IAR都会将全部变量初始化为0,而恰好这个 HAL_FDCAN_STATE_RESET = 0x00U。
6 Y# l. E/ |" u5 q H/ B: L# M( S4 W* o: w
解决办法有三1 f+ C, w( ~* y9 t0 q: r
# A1 c3 s- b1 G& v- ~0 j
方法1:用户自己初始化FDCAN和涉及到的GPIO等。/ r7 R: x, s, m! G0 o
& Y) b$ ], a: q# v _! N) U$ j4 p方法2:定义FDCAN_HandleTypeDef FdCANHandle为全局变量。
2 I) u$ {/ g7 v+ I L
8 P% p# R8 J, D; G2 Z2 u1 j方法3:下面的方法& M) t; E; |2 _0 ^; ?, H6 j1 F
7 I2 f" ?% B0 G1 u& T
- if(HAL_FDCAN_DeInit(&FdCANHandle) != HAL_OK)
! ^# N4 u: |' S4 F5 u1 R; [& r - {
, [( _1 U* C% W, c- |- c - Error_Handler();
1 T( ?0 w( }! T7 b - } R. |+ p$ k1 u" s: D1 O$ k; @3 @/ R
- if(HAL_FDCAN_Init(&FdCANHandle) != HAL_OK)0 ?, q% w0 w7 Y G
- {
1 Q' d# M/ {$ }; A" t. r - Error_Handler();
W9 g( W5 e* b - }
复制代码 6 p, A! E! ^9 o% c2 a
使用举例:
* I v: R+ r1 E: e) l5 h% H4 @. z. ^$ e
- FDCAN_HandleTypeDef hfdcan1;
8 ^6 p. {3 i: d! j% o( S - , s% i7 Y9 n% o4 {. m& Y
- /*
4 a# J, H' t. |( A/ l3 @ - *********************************************************************************************************
8 s ~% H2 Y! K6 h - * 函 数 名: bsp_InitCan1: V+ ^& C6 p. X- B8 p+ x
- * 功能说明: 初始CAN1, G# s6 Z6 \ u1 C: x
- * 形 参: 无! n! k1 m& c* f1 {' K6 d
- * 返 回 值: 无
, t& i- C% G1 Z7 |! V0 z - ********************************************************************************************************** @% V3 q( M- K5 N
- */; G) L$ `4 I% i% t, g
- void bsp_InitCan1(void)9 N1 u Y6 Y5 m3 D) I" w
- { : Z. @( g; ~" B1 F: w$ P- r
- /* 位时间特性配置) @6 p4 g& Q1 |
- Bit time parameter | Nominal | Data" F, \: }0 C4 [3 N; x a& I4 n, Y
- ---------------------------|--------------|----------------6 I* K& k$ e( i) @5 {
- fdcan_ker_ck | 20 MHz | 20 MHz* e4 y7 I+ @* V( p& a$ Y
- Time_quantum (tq) | 50 ns | 50 ns
( w2 u* Q9 j5 T' `% w; ~3 z0 m - Synchronization_segment | 1 tq | 1 tq) |6 W B ~. Q
- Propagation_segment | 23 tq | 1 tq1 L2 N/ x4 i7 X! W
- Phase_segment_1 | 8 tq | 4 tq
# I# j! Z9 D7 G- \& s, | - Phase_segment_2 | 8 tq | 4 tq# u5 M% [0 ?: F3 h8 m! o# Y
- Synchronization_Jump_width | 8 tq | 4 tq
. f" N0 T+ k1 e0 W$ X D - Bit_length | 40 tq = 2us | 10 tq = 0.5us
7 c% b- M$ l* T' o - Bit_rate | 0.5 MBit/s | 2 MBit/s& M' k$ ], e7 d/ \$ |
- */
; r$ C6 I! h0 p, b+ I0 y# `- z - hfdcan1.Instance = FDCAN1; /* 配置FDCAN1 */
) w! t2 {) u0 b. u p. ?# p% n - hfdcan1.Init.FrameFormat = FDCAN_FRAME_FD_BRS; /* 配置使用FDCAN可变波特率 */
0 B! N) X: W3 P/ G - hfdcan1.Init.Mode = FDCAN_MODE_NORMAL; /* 配置使用正常模式 */
5 v- U9 z; B4 q8 n9 m- h! ~" H5 o - hfdcan1.Init.AutoRetransmission = ENABLE; /*使能自动重发 */ 8 k+ P: x/ F# m- s( C
- hfdcan1.Init.TransmitPause = DISABLE; /* 配置禁止传输暂停特性 */: }( A0 k3 M% L% o
- hfdcan1.Init.ProtocolException = ENABLE; /* 协议异常处理使能 */& D& j' b: Q2 w6 _% Y& y" }; a2 d
-
9 M& F3 Y* Y* J' g$ b* |" ~3 D0 }$ T- d - /*
8 Z. `0 K/ f. F! t1 k( L - 配置仲裁阶段波特率
/ h$ D8 Q- v, f" a* i - CAN时钟20MHz时,仲裁阶段的波特率就是
) ~6 a& B' L+ E) h - CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / (1+0x1F + 8) = 0.5Mbps
, G% k! \7 W5 n0 x: M z$ N. E1 P -
5 J6 K* y% Z5 p' e# U. C6 z) X. P - 其中Sync_Seg是固定值 = 1 , Pro_Seg + Phase_Seg1 = NominalTimeSeg1, Phase_Seg2 = NominalTimeSeg2) d6 x/ u0 ~# @' A
- */" Z4 W, M3 p. ]* z; H7 h* C
- /* CAN时钟分配设置,一般设置为1即可,全部由PLL配置好,tq = NominalPrescaler x (1/ fdcan_ker_ck) */
: Y, L5 Y; ^2 w( ^' |0 p - hfdcan1.Init.NominalPrescaler = 0x01; # w; P5 i6 v$ @- n7 b
- * A* m+ q* D0 {! y) j# k3 n' w2 V
- /* 用于动态调节 Phase_Seg1和 Phase_Seg1,所以不可以比Phase_Seg1和 Phase_Seg1大 */3 s6 ]" J' N+ T6 c0 i6 N7 I
- hfdcan1.Init.NominalSyncJumpWidth = 0x08; 7 D# I* R2 Z* ?
6 g) ]( ~, t2 i& M0 y0 q$ n( @- /* 特别注意这里的Seg1,这里是两个参数之和,对应位时间特性图的 Pro_Seg + Phase_Seg1 */4 p( q1 R l& C1 }
- hfdcan1.Init.NominalTimeSeg1 = 0x1F; * g$ r& x7 v" L2 G3 b
- ! d; ?2 F4 T! J8 y
- /* 对应位时间特性图的 Phase_Seg2 */ ^+ W9 r3 w. x X U
- hfdcan1.Init.NominalTimeSeg2 = 0x08;
0 W) b' w/ U' t) Q& q: Y& f - K q# M3 u) P- W/ J" o, }
- : @7 Q9 I. F; o
- /*
8 q. v3 V: e" Q& |& d B - 配置数据阶段波特率
6 M3 O' |8 E- K7 j& G - CAN时钟20MHz时,数据阶段的波特率就是& B$ F4 a; h& U* [7 a2 Q
- CAN FD Freq / (Sync_Seg + Pro_Seg + Phase_Seg1 + Phase_Seg2) = 20MHz / (1+5+ 4) = 2Mbps% j; P0 _8 J. O# _. T0 L
-
6 B3 V5 ^9 o& _ - 其中Sync_Seg是固定值 = 1 , Pro_Seg + Phase_Seg1 = DataTimeSeg1, Phase_Seg2 = DataTimeSeg2; U& a! [; a0 g: [
- */
. |3 q: W$ V7 ?0 \8 p - /* CAN时钟分配设置,一般设置为1即可,全部由PLL配置好,tq = NominalPrescaler x (1/ fdcan_ker_ck),
) L9 z" L2 w8 Q - 范围1-32 */2 ]+ G' y, V9 j! I/ W7 N" C
- hfdcan1.Init.DataPrescaler = 0x01; - [, t8 Q2 U: R
; ~# n1 ]& }3 F, M. C" X4 H- /* 用于动态调节 Phase_Seg1和 Phase_Seg1,所以不可以比Phase_Seg1和 Phase_Seg1大,范围1-16 */
/ Y D3 d' q) _8 j' O- s6 D - hfdcan1.Init.DataSyncJumpWidth = 0x04; 8 u& t" A) u' B9 q3 ~- _/ D+ C1 D, s
- ( ~6 a, ^- y6 n
- /* 特别注意这里的Seg1,这里是两个参数之和,对应位时间特性图的 Pro_Seg + Phase_Seg1,范围 */
- A \) X; `$ V1 J3 G$ b - hfdcan1.Init.DataTimeSeg1 = 0x05;
* W! Z) }" Y |5 O- N. z - 7 M3 `, u6 A" j6 E
- /* 对应位时间特性图的 Phase_Seg2 */
, g7 r' F) ]4 K% l7 ~0 y - hfdcan1.Init.DataTimeSeg2 = 0x04;
v, T6 ]9 }, w& C8 g! T -
4 H; g1 f0 s& R1 T -
; [8 T+ N& k' W: r5 D* i1 J/ F - hfdcan1.Init.MessageRAMOffset = 0; /* CAN1和CAN2共享2560个字, 这里CAN1分配前1280字 */
" f- K8 a2 B' a$ E -
4 `/ g+ W. q- |- ~1 ]3 O -
6 k" r/ z0 C9 V9 V1 `# H5 R6 H - hfdcan1.Init.StdFiltersNbr = 1; /* 设置标准ID过滤器个数,范围0-128 */
& Z: q0 y) S% Z - hfdcan1.Init.ExtFiltersNbr = 0; /* 设置扩展ID过滤器个数,范围0-64 */ ; b+ w" r0 Y. N7 r. ^
- hfdcan1.Init.RxFifo0ElmtsNbr = 2; /* 设置Rx FIFO0的元素个数,范围0-64 */ / s9 i W. v. K* a
- /* 设置Rx FIFO0中每个元素大小,支持8,12,16,20,24,32,48或者64字节 */
- n; ?- V* c' T; f$ _" D: N8 x - hfdcan1.Init.RxFifo0ElmtSize = FDCAN_DATA_BYTES_8; " @6 V8 d. |9 ]
- hfdcan1.Init.RxFifo1ElmtsNbr = 0; /* 设置Rx FIFO1的元素个数,范围0-64 */; n* G* ^$ @& K3 X- [$ i
- }; L ?2 S" W" y
- /* 设置Rx FIFO1中每个元素大小,支持8,12,16,20,24,32,48或者64字节 */
) L+ a% ?9 k2 ]( g$ } - hfdcan1.Init.RxFifo1ElmtSize = FDCAN_DATA_BYTES_8;
( v" A: ~& s, u0 i# N - hfdcan1.Init.RxBuffersNbr = 0; /* 设置Rx Buffer个数,范围0-64 */
# O+ x/ @" P2 p' t% T8 C -
1 H( r+ s1 o2 o+ r% ] - /* 设置Rx Buffer中每个元素大小,支持8,12,16,20,24,32,48或者64字节 */
Y; d2 N9 A6 a. s - hfdcan1.Init.RxBufferSize = 0;
b! c) z' ~. a/ r$ e" B - - V0 ?' l/ D9 d# H
- ; t5 S; m% S3 L4 D
- hfdcan1.Init.TxEventsNbr = 0; /* 设置Tx Event FIFO中元素个数,范围0-32 */
8 G/ X9 M& Q+ V ^( ~/ l - hfdcan1.Init.TxBuffersNbr = 0; /* 设置Tx Buffer中元素个数,范围0-32 */- M8 A1 c( m0 h4 n8 K, ^
- hfdcan1.Init.TxFifoQueueElmtsNbr = 2; /* 设置用于Tx FIFO/Queue的Tx Buffers个数。范围0到32 */- j% u8 u4 Y4 f" P6 K0 K
- hfdcan1.Init.TxFifoQueueMode = FDCAN_TX_FIFO_OPERATION; /* 设置FIFO模式或者QUEUE队列模式 */9 X% `9 F$ r" r' P! f. z
- : ?! Q! _" h$ j" |/ F
- /* 设置Tx Element中的数据域大小,支持8,12,16,20,24,32,48或者64字节 *// ~' L8 X" c! m* R
- hfdcan1.Init.TxElmtSize = FDCAN_DATA_BYTES_8;
( k* m, x" O1 K. R/ t/ @ - HAL_FDCAN_Init(&hfdcan1);
& y0 C/ s" d \* M5 a/ l+ W1 e$ V
! j. T2 ~; \( N( }# g3 V- 2 L. A( a6 k6 M7 Y. r
- //省略未写
! G6 M- `' |* O, b6 j
) _1 R- M/ K, h% b; F. ]- }
复制代码
7 b* H% L0 U& e- v: _8 t! a91.4.2 函数HAL_FDCAN_DeInit
% E) s$ ^/ ?, E: G函数原型:
: m7 ]2 o- X8 A* I/ F4 ~% n
2 u I, R$ h. M0 j( G' U- HAL_StatusTypeDef HAL_FDCAN_DeInit(FDCAN_HandleTypeDef *hfdcan), \: s( p4 B# ^
- {' h8 d* X. }2 ~7 P
- /* 检测句柄 */
0 J4 I5 w" i0 x% u; B( {" m) @ - if (hfdcan == NULL)
& b% X; _9 z8 h: G' b% A - {
* r) K# ?0 Y% @! } - return HAL_ERROR;
8 O" J$ W* |0 \: K3 C. Z8 G) U - }
, k9 X1 ^9 Q( M7 S& ?9 B" E - / m, m; ]* M% C) C' H: q
- /* 检查函数形参 */6 j3 _& [$ n$ F0 d5 A8 ?* A
- assert_param(IS_FDCAN_ALL_INSTANCE(hfdcan->Instance)); z5 `, S5 x# ?. _
- 5 {7 k' k. }6 M5 Z9 d1 @
- /* 停止FDCAN */
6 e/ g) f# s+ I4 D - (void)HAL_FDCAN_Stop(hfdcan);
* M, I) b% H# T; E/ |0 v$ u
- ?& U# J# I& Y1 R. h! x- /* 禁止中断 */
7 B0 K! g- g7 c - CLEAR_BIT(hfdcan->Instance->ILE, (FDCAN_INTERRUPT_LINE0 | FDCAN_INTERRUPT_LINE1));
6 A$ ~ q. [& s3 y, t - 9 W. a! ^7 A; Q' m
- #if USE_HAL_FDCAN_REGISTER_CALLBACKS == 1
* ]7 Y+ ? h! W c9 ~! b! |# w3 D! u - if (hfdcan->MspDeInitCallback == NULL)
% R* d C" v& M+ r4 c9 w - {5 w% v7 Q3 j4 {8 B
- hfdcan->MspDeInitCallback = HAL_FDCAN_MspDeInit; /* Legacy weak MspDeInit */8 V& I' B: c) i7 K, \- U7 P8 q
- }" P/ a4 N# N* w! b
o+ i0 U3 F/ r& K- }- /* 复位底层硬件,如时钟,NVIC等 */! p; e \8 ], E: I5 l; Z1 {
- hfdcan->MspDeInitCallback(hfdcan); l( ~4 g% s$ W. a5 j1 V! F. n
- #else) g9 ], T) N3 v& L0 @1 Y
- /* 复位底层硬件,如时钟,NVIC等 */& f" o" J s1 }7 K. {! H
- HAL_FDCAN_MspDeInit(hfdcan);4 x. g1 H, Y4 y$ j9 \
- #endif
/ o; t- ?: {& z6 K6 r, a- U5 Z) Z
5 l, R2 q) p) W) G7 H/ X; `- /* 复位错误码 */% q! |4 P! Y3 H' @, ?2 A8 H2 }5 m
- hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;( X( d8 d/ c# P: R' r
% t: k6 ]. Y" _% F- /* 设置FDCAN状态 */- c0 r4 O$ A) r& i1 \! }4 n- J
- hfdcan->State = HAL_FDCAN_STATE_RESET;3 {- g; ~# h! X5 X
; r4 _8 y* n. e+ j) Q; V* ?- /* 返回HAL_OK */3 l- K& y2 L: N$ d
- return HAL_OK;
6 D0 n: {6 u5 O. S# U - }
复制代码
. R# ^% Q. V( Z- b函数描述:
* T! ?4 d" ?+ ~- J( Q; z: L% x( `
2 g. O, \4 f6 x# k# {7 x( u; S* B用于复位FDCAN。
Q# b) }, U3 z& l0 l
9 I& ?2 b( Y" {+ r. y" n+ F( Y) b6 Q函数参数:0 q( w8 W" c3 t( t. A
& x# a2 d. [* G
第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
* H( N& W$ P' J$ N" q3 G' P V 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。
# m+ I. t* U4 W' j91.4.3 函数HAL_FDCAN_ConfigFilter% a+ b4 ^# O j: v# W
函数原型:1 c( L! e; ~+ t6 B1 ^$ V2 A, i
( e+ H9 J& N* E/ }- W
- HAL_StatusTypeDef HAL_FDCAN_ConfigFilter(FDCAN_HandleTypeDef *hfdcan, FDCAN_FilterTypeDef *sFilterConfig)8 z5 d' ?0 x, c/ u" o% ?
- {5 K0 G( x5 e( ]
- uint32_t FilterElementW1;
8 w7 P0 D* k* S( p - uint32_t FilterElementW2;) g1 J4 z% \+ R
- uint32_t *FilterAddress;
' B" P/ }' {; K6 k6 k+ _6 G H; J - HAL_FDCAN_StateTypeDef state = hfdcan->State;
# F, J ^, g7 G1 t
8 X; u! M T+ l, S7 i; K- if ((state == HAL_FDCAN_STATE_READY) || (state == HAL_FDCAN_STATE_BUSY))* S* [3 E3 p3 ]
- {$ f8 N- \( u5 t8 T( V2 e7 k( {2 w
- /* 检测函数参数 */
2 [. D/ l% ]6 g# g7 D - assert_param(IS_FDCAN_ID_TYPE(sFilterConfig->IdType));, q o8 Z4 Q: y# {5 X' g
- assert_param(IS_FDCAN_FILTER_CFG(sFilterConfig->FilterConfig));; Y3 z0 z9 C3 m5 I" M! W
- if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)
& }9 \3 l. B5 w& @) F( z3 Z3 u& D- N& w - {
4 o N9 _1 }3 Q4 ~) v) t( w - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->RxBufferIndex, 63U));
: s3 s! D T3 d a7 R) W - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->IsCalibrationMsg, 1U));
% h4 b% @; i1 l( h/ { - }. K% d) Y4 v# ~: c% y0 @& s7 ?4 W
7 P& J' P% R2 r7 F- w/ Q" R- /* 标准ID */" @, Q. Z$ K" A, l) I0 e4 O) `3 i2 v
- if (sFilterConfig->IdType == FDCAN_STANDARD_ID)
. J; e, j: `% n" X - {2 E) n( e! P# B' S- Z
- /* 检测函数形参 */
! o4 Y1 N; ?4 A& g: I5 A: a - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterIndex, (hfdcan->Init.StdFiltersNbr - 1U)));; O$ ~5 V. z Y
- assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID1, 0x7FFU));# Y; p. r6 b; q, H3 D, l
- if (sFilterConfig->FilterConfig != FDCAN_FILTER_TO_RXBUFFER)
5 [, {$ ], C- M1 M - {
+ U; P( j5 v, R8 Q+ `# ? - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID2, 0x7FFU));
7 U7 e2 N i! g; f# R - assert_param(IS_FDCAN_STD_FILTER_TYPE(sFilterConfig->FilterType));( ]1 z2 c7 _0 _) g
- }
) |0 D! M* Y: Q) J$ m* i5 l
! O: m0 [2 B8 s0 v' S) c" F- /* 构建过滤元素 */3 W1 i$ T9 k- \& S8 O' c0 @
- if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)
% S% }7 Q8 R5 Q0 ]& U - {$ K- b. r+ {1 w
- FilterElementW1 = ((FDCAN_FILTER_TO_RXBUFFER << 27U) |
; K* \( v9 W2 T5 | - (sFilterConfig->FilterID1 << 16U) |
" @9 I; ^4 q/ K' P% u2 L) j - (sFilterConfig->IsCalibrationMsg << 8U) |6 x/ g6 c; F3 r! _! k" W: F
- sFilterConfig->RxBufferIndex);
& @ X7 A- O: Z; v q# S' a( l+ h - }
: f& o4 e+ ?, y Y8 c - else
! Y& L+ O) J4 a# T9 ?7 p3 ] - {
. @4 q+ g4 i6 y% J- M* y. I - FilterElementW1 = ((sFilterConfig->FilterType << 30U) |, d3 r8 n" \+ _. R$ y
- (sFilterConfig->FilterConfig << 27U) |1 G% E x1 C) W4 }/ b! X0 X. t8 I
- (sFilterConfig->FilterID1 << 16U) |
8 ^5 j, {. J1 m) _4 u8 k - sFilterConfig->FilterID2);
9 m; k7 x4 t# ^5 v0 e3 e - }
, @/ s! E0 X0 W! D# j
& @2 C, E# m( k; _, ^- /* 计算过滤地址 */
! w# `# z. F! p: b( j - FilterAddress = (uint32_t *)(hfdcan->msgRam.StandardFilterSA + (sFilterConfig->FilterIndex * 4U));
4 i0 \, }) X( G2 y( P) _ - # F) _# l* o9 Y0 C( O
- /* 将过滤元素写到消息RAM中 */* `5 k/ B: h4 {3 `
- *FilterAddress = FilterElementW1;% I7 a8 w3 A# R* Q, I5 C
- }
: b: z* _- O* ^9 A' p - /* 扩展ID */6 A N2 y7 j7 b" b' l
- else
) G9 `( z+ d5 Q - {
' C5 W' T4 X* p O( V% p - /* 检测函数参数 */$ M( [! F7 V, ^6 \+ s
- assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterIndex, (hfdcan->Init.ExtFiltersNbr - 1U)));
, S7 B' s- y; e/ J$ A7 e% n - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID1, 0x1FFFFFFFU));( U) x! [. s5 c6 h- b: j( q
- if (sFilterConfig->FilterConfig != FDCAN_FILTER_TO_RXBUFFER)9 ~) C8 |7 F D
- {
4 j3 x# A0 D5 N8 g. ^) H - assert_param(IS_FDCAN_MAX_VALUE(sFilterConfig->FilterID2, 0x1FFFFFFFU));
0 ?$ u& S2 v/ T. X - assert_param(IS_FDCAN_EXT_FILTER_TYPE(sFilterConfig->FilterType));
a4 o; _ f$ G2 } - }
0 k9 ]" O1 j& j - 9 {, g. D. h# R0 X2 l- c2 D, z
- /* 构建第1个word的过滤元素 */
2 T: N% E3 X6 W1 r7 f/ x - FilterElementW1 = ((sFilterConfig->FilterConfig << 29U) | sFilterConfig->FilterID1);7 ?1 I. A% q! }! u* s* r
! L6 z3 B/ `5 @2 s- /* 构建第2个word的过滤元素 */
G8 U$ N& { h& Q( D - if (sFilterConfig->FilterConfig == FDCAN_FILTER_TO_RXBUFFER)* r2 H1 E5 U: D! c
- {
4 V/ ` o6 k8 ~ - FilterElementW2 = sFilterConfig->RxBufferIndex;; y; X+ i" v* ~
- }3 w2 ` v) A- f* h6 m7 J
- else$ l, q! u! a" W) M0 [
- {
% c; S: ]7 B* x1 i6 q - FilterElementW2 = ((sFilterConfig->FilterType << 30U) | sFilterConfig->FilterID2);: B' E, N) ]3 W" y2 y
- }
2 H+ ?; a) J- H: x* s2 B
" y' ], S+ u9 E- /* 计算过滤地址 */+ K- b$ f0 m; k
- FilterAddress = (uint32_t *)(hfdcan->msgRam.ExtendedFilterSA + (sFilterConfig->FilterIndex * 4U * 2U));
" h; ~) v, l. | - ) L- n |' ?1 Q! e9 r
- /* 写过滤元素到消息RAM */3 B1 K8 M! N7 d7 \" c
- *FilterAddress = FilterElementW1;
+ |5 ~* c. Y: h! ]; S - FilterAddress++;
& Z! f& _1 _0 u' P1 V% h8 W - *FilterAddress = FilterElementW2;
4 J X( C% {3 X, V - }
3 s$ v2 I' Y4 ]0 W5 o6 `' y - 1 i5 j/ d V7 x: L K( L
- return HAL_OK;1 P$ e; e/ ~3 q, m3 M$ M7 d* J- M
- }
* q8 D: s: g0 ^ - else
, K$ }( n1 X/ V6 ^ - {8 P& z2 V" Z( M8 d
- /* 更新错误码e */
& \ q) V& _) i i) [. ] - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_INITIALIZED;- S) q3 F% S% g0 E
- , L4 x; ?! ^+ z2 B& ^+ B. x
- return HAL_ERROR;
1 u. Y7 ]; J( L ]7 m - }0 c' O% C8 b" f3 C2 o7 Y- t
- }
复制代码
. c9 }+ G4 T( |函数描述:4 ? j7 Z, M S1 C. F8 m) r) J
P$ o; n; }4 Z4 A- f7 J/ S
此函数主要用于设置FDCAN过滤。
9 K3 h$ g6 X' |# U- B2 Z
3 {1 f' {- \ a2 G5 F8 q$ b函数参数:- r- ^0 R" o* d2 j, o
( \* E" f7 }7 y# c 第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
6 E& w+ O1 i* g6 k6 P 第2个参数是FDCAN_FilterTypeDef类型结构体变量,主要用于过滤参数配置。9 e0 x6 ]8 Y( |
返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。! O$ }. E7 b" l6 N9 C* m! S. N
使用举例:1 g$ b& X1 q- e. d' W- N9 n! _, _
$ D) I9 U2 K. w F- FDCAN_HandleTypeDef hfdcan1;+ H" v% Y, p# g0 r; z3 n
+ K, E7 C2 ^! F- /*
, }& [; f; C+ a4 x4 j - *********************************************************************************************************
6 t* }* f- W- s6 X3 u! I: Y) e - * 函 数 名: bsp_InitCan1; f% x( ?! C* P6 U9 e: {" l8 K
- * 功能说明: 初始CAN1; |& s6 t8 Z4 O/ w. b
- * 形 参: 无2 _8 _& t. @8 |8 x
- * 返 回 值: 无
9 P d5 H% G# E& _ M1 ~; Z% j6 G6 i/ j - *********************************************************************************************************& V9 b$ u6 [3 ?; _$ J
- */
& G: Q* M% f. [$ R - void bsp_InitCan1(void)
! G% M# e0 c* T- n/ P - { ; T2 N _+ T( p" K; Y
- 0 U1 ?( j8 a a
- /*
' [% G' u' A! N! J: l - 配置过滤器, 过滤器主要用于接收,这里采样屏蔽位模式。
& P* V$ W5 L! Q5 z. q7 q - FilterID1 = filter
+ a5 E. F+ B& I1 W( W - FilterID2 = mask7 }; e. k. e1 S0 T4 t
-
! f* _4 t2 @* ^. o1 C - FilterID2的mask每个bit含义* p' q. I" d' e# O8 T3 C/ O! X
- 0: 不关心,该位不用于比较;
" i3 S" x M% C8 B7 k - 1: 必须匹配,接收到的ID必须与滤波器对应的ID位相一致。
0 ^! Z" d% H/ x - 1 _6 Y2 e) f/ s9 b9 B; f
- 举例说明:& x5 N5 H+ y5 B& |6 D5 j' q1 O, |- n1 @
- FilterID1 = 0x111
) W0 c4 b$ t/ ` - FilterID2 = 0x7FF ( ~( |& T' X) U7 [+ {+ C
- 表示仅接收ID为0x111的FDCAN帧。
6 T' R- }. c: }4 N" m# p! f: W- ^ -
1 }4 g9 q, P; r- _% m6 U - */
" m* \ B' b Q7 m1 A5 E3 g - sFilterConfig1.IdType = FDCAN_STANDARD_ID; /* 设置标准ID或者扩展ID */1 z$ T) ]! w% a3 R5 g1 Q5 c
- /* 用于过滤索引,如果是标准ID,范围0到127。如果是扩展ID,范围0到64 */1 q* Y* K, s8 ]! p% G/ {
- sFilterConfig1.FilterIndex = 0; , u# D# e/ b7 P8 Z m R
- sFilterConfig1.FilterType = FDCAN_FILTER_MASK; /* 过滤器采样屏蔽位模式 */
% h0 U! s; I% c p: h - sFilterConfig1.FilterConfig = FDCAN_FILTER_TO_RXFIFO0; /* 如果过滤匹配,将数据保存到Rx FIFO 0 */
! j) ^! w2 C6 x2 H - sFilterConfig1.FilterID1 = 0x111; /* 屏蔽位模式下,FilterID1是消息ID */
9 ?( i- R. | f4 f: z0 ? - sFilterConfig1.FilterID2 = 0x7FF; /* 屏蔽位模式下,FilterID2是消息屏蔽位 */# \) V1 r" o# f; s- F
- HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig1); /* 配置过滤器 */; _* Z1 O# ` a' v7 E8 `. h
0 Z- q! f M9 d& k2 }- }
复制代码
5 X" N1 w i! u: l2 R9 p91.4.4 函数HAL_FDCAN_ConfigFifoWatermark
! t8 A1 P5 m E. _函数原型:
" v) c4 E* F2 L8 r2 Z& Y( H, F6 _$ l- z% P$ Q
- HAL_StatusTypeDef HAL_FDCAN_ConfigFifoWatermark(FDCAN_HandleTypeDef *hfdcan, uint32_t FIFO, uint32_t Watermark)0 z' d1 Z1 M) A7 e7 A
- {
+ m( l9 i7 d+ b+ M" i. _+ ]4 k - /* 检测参数 */
$ P; b S/ ]+ D6 n/ R* A - assert_param(IS_FDCAN_FIFO_WATERMARK(FIFO));
6 B$ Q6 c2 o' M - if (FIFO == FDCAN_CFG_TX_EVENT_FIFO)0 K3 \% a6 M$ g' m( V. @
- {
% B& d I% K+ M( i. c% p, [ - assert_param(IS_FDCAN_MAX_VALUE(Watermark, 32U));
2 s( P+ {5 K A9 h+ H/ n - }
2 U" u$ a( t% t! ~$ G: e - else /* (FIFO == FDCAN_CFG_RX_FIFO0) || (FIFO == FDCAN_CFG_RX_FIFO1) */
4 ~5 x. k; |; \* ]/ H - {
0 q& I9 G$ E9 o& c/ y( M - assert_param(IS_FDCAN_MAX_VALUE(Watermark, 64U));7 q+ _8 F: r( D3 s1 M5 x( o
- }
& U; O R# H C' M8 G - 3 z# o+ K6 k# [; O) w- [6 M
- if (hfdcan->State == HAL_FDCAN_STATE_READY)# L; l0 R* X* N) G1 s2 u9 h/ m/ ~
- {
1 W' q/ o0 x, k; N" v+ y A- \) L% x - /* 设置发送事件FIFO */
7 v* _2 q8 R% Y6 e+ l0 h7 Y - if (FIFO == FDCAN_CFG_TX_EVENT_FIFO)' s9 ^. v9 F7 R; w/ x, Q" s1 g
- {9 e; v3 I$ \8 I% E$ X+ k4 Z9 D
- MODIFY_REG(hfdcan->Instance->TXEFC, FDCAN_TXEFC_EFWM, (Watermark << FDCAN_TXEFC_EFWM_Pos));8 N8 V. A' D! A$ K$ s- t @
- }
; e" U6 Y6 A# R - /* 设置接收FIFO0 */9 W0 c4 \0 |8 Z2 ]" p# l
- else if (FIFO == FDCAN_CFG_RX_FIFO0)
: A6 u# ^" l- l( }" | - {7 ]% N$ y) p6 g- a5 v# Q. l
- MODIFY_REG(hfdcan->Instance->RXF0C, FDCAN_RXF0C_F0WM, (Watermark << FDCAN_RXF0C_F0WM_Pos));
5 G* o" `# r3 O }+ j - }
/ K8 `* E+ J" c6 J7 T+ j - /* 设置接收FIFO1 */
5 s0 Y) I) F E" A" ]7 s* T! ? w - else
x2 Y& {- @1 H8 S9 { - {$ A& [2 k6 Q; ?" k! \
- MODIFY_REG(hfdcan->Instance->RXF1C, FDCAN_RXF1C_F1WM, (Watermark << FDCAN_RXF1C_F1WM_Pos));
2 s7 c6 P3 |6 \6 ?# V - }
' N" o4 `) q! X4 i1 V - / G6 E, \, m5 W
- /* 返回状态 */
8 ?3 U( L0 A' r1 B# O j" H - return HAL_OK;
$ q% _+ ~2 H9 u d) M8 T) N; Z - }
- l1 F9 J9 `4 v9 | - else" E4 q& w! Z& h1 m/ l7 F/ |; R
- {$ W) i( {& E3 [+ A% E& C
- /* 更新错误码 */
~3 p1 }- [. v. k9 M) \7 I: u - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_READY;1 f0 l9 Y9 k. Y* @
- + l2 J* y/ S! `& Z5 d* S# j
- return HAL_ERROR;, G {4 }* d: u0 ]3 _% a
- }9 L3 V/ Z2 L+ P- i/ H" |
- }
复制代码
! s9 ?( W& {8 T6 Q1 c函数描述:
" D: N( S# l& W! m9 M
( g8 Y2 V- c9 X. A. k) |+ s此函数主要用于配置FIFO Watermark. m0 e D. N% j/ y. Q$ S
5 l1 p- {' o6 J* _( B
函数参数:
2 p8 [2 ^$ G3 g, ]4 }, A& H8 v* ?4 b! r, D# g- D, ~
第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
' Y* K2 G: x5 y' h 第2个参数是FDCAN FIFO Watermark) @4 ?6 F/ g: O) Q8 V
- #define FDCAN_CFG_TX_EVENT_FIFO ((uint32_t)0x00000000U) /*!< Tx event FIFO */2 `" z a. N( Q2 v2 ~% W! ^
- #define FDCAN_CFG_RX_FIFO0 ((uint32_t)0x00000001U) /*!< Rx FIFO0 */6 q' {+ P( V1 R, R
- #define FDCAN_CFG_RX_FIFO1 ((uint32_t)0x00000002U) /*!< Rx FIFO1 */
复制代码 # D0 W9 I7 v: \9 [
第3个参数FIFO Watermark 中断位置,如果是FDCAN_CFG_TX_EVENT_FIFO,范围0到32,如果是FDCAN_CFG_RX_FIFO0 或FDCAN_CFG_RX_FIFO1,范围0到64。
( y# u! k+ K C& t* H9 S- | 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。
/ P& ]$ i5 o) |2 S2 l5 o v使用举例:- {% c: r. }% d
- H+ U! R P7 R0 O- FDCAN_HandleTypeDef hfdcan1;
3 n2 ?& ^+ F' t6 T3 i2 }; o0 T - 7 D6 v6 c5 }* `' w
- /* 设置Rx FIFO0的wartermark为1 */
+ c' [" ]) b9 Z6 g; ?: F- C - HAL_FDCAN_ConfigFifoWatermark(&hfdcan1, FDCAN_CFG_RX_FIFO0, 1);
复制代码 7 I5 ~7 J8 s( p8 u7 t% x& j v: D
91.4.5 函数HAL_FDCAN_ActivateNotification3 J0 A4 ^- a9 b0 @/ b
函数原型:
+ a7 ]* J: e( @. @/ G' x, @
2 p: v- V; i. q" N: O5 \7 O) P- HAL_StatusTypeDef HAL_FDCAN_ActivateNotification(FDCAN_HandleTypeDef *hfdcan, uint32_t ActiveITs, uint32_t BufferIndexes)9 a( x8 d& W+ y! L& i
- {
: M1 U: k) {/ j! R! S - HAL_FDCAN_StateTypeDef state = hfdcan->State;6 [" q/ I7 s& i9 Q
" E- p6 j+ O# A4 Y9 P8 U3 A9 c- /* 检测函数形参 */
/ L9 k+ B9 k6 T - assert_param(IS_FDCAN_IT(ActiveITs));; B4 ]( B1 ?: m8 }. Y) ]' g$ V5 z O0 ?
- ' u3 M+ b' d) m7 Y- b# W. t; }
- if ((state == HAL_FDCAN_STATE_READY) || (state == HAL_FDCAN_STATE_BUSY))
) N' F; o8 T: ^ - {( w+ A. j7 u; j' G; N
- /* 使能中断行 */
3 y% R8 z( H) [5 I9 c - if ((ActiveITs & hfdcan->Instance->ILS) == 0U)
3 S9 p/ O& V! h* ~2 _ - {
* K, i) G0 c, ^! G% O% R# z - /* 使能中断行0 */
* J0 w6 f1 A& W - SET_BIT(hfdcan->Instance->ILE, FDCAN_INTERRUPT_LINE0);' \# p `: K2 O4 C
- }
4 c8 \( b7 O! `$ F6 |% Z# U - else if ((ActiveITs & hfdcan->Instance->ILS) == ActiveITs)
) t0 @) ^! h; d6 q! X2 W2 ^) ` - {
* B# N- M' k3 | - /* 使能中断行1 */
" J( i! W& n, Z/ E3 k( e2 S" z4 f - SET_BIT(hfdcan->Instance->ILE, FDCAN_INTERRUPT_LINE1);
T) \( V6 h8 b# O - }# S' p9 Q% z9 [, g/ Y# ~
- else
! g3 Y) f; U( d, H - {
0 s. c( t4 u' N5 l* i" p- A - /* 使能中断行0和中断行1 */
* T, Z9 Q/ w2 i5 {6 p1 p - hfdcan->Instance->ILE = (FDCAN_INTERRUPT_LINE0 | FDCAN_INTERRUPT_LINE1);
. o( D, Q3 R" |, o: [0 I - }3 C6 ^% o* K5 E, A& t
- R D8 U6 `/ v# w; W, c8 z- if ((ActiveITs & FDCAN_IT_TX_COMPLETE) != 0U)
6 B; U/ r. l7 f. c - {
' s. {; C! Q4 e* V+ g - /* 使能Tx Buffer Transmission 中断 */
$ ]" Z9 u/ i* n0 V - SET_BIT(hfdcan->Instance->TXBTIE, BufferIndexes);: A- f" }( S* ^# H
- }8 M! F/ I# l, O' B I
- / } I9 z! |1 a- Q
- if ((ActiveITs & FDCAN_IT_TX_ABORT_COMPLETE) != 0U); C5 |) R, _2 U, }# z6 g- y
- {
& j Z4 U1 k3 P - /* 使能 Tx Buffer Cancellation Finished 中断 */6 j J3 [3 X8 [! ^. C0 X" ~
- SET_BIT(hfdcan->Instance->TXBCIE, BufferIndexes);" w2 B- |4 e0 ]! {! O4 p
- }4 ^# _* Z+ d }9 a, O5 P
1 N7 j0 f+ i' s* [ M+ N2 [0 r- /* 使能选择的中断 */
# n6 Q' O2 U" ^ X3 K/ x - __HAL_FDCAN_ENABLE_IT(hfdcan, ActiveITs);
; l2 `9 _/ t, e+ K - " q' t5 n% s4 R. _* T
- /* 返回函数状态 */+ `; b s( `& v% k- O
- return HAL_OK;
/ y% Q" ?8 C8 c4 I# ^ - }
0 `0 R8 m, d9 ` - else
) o, V9 H- R2 C5 S Z- u- d - {5 |- J' U. \5 y6 E/ ^" w
- /* 更新错误码 */
8 K/ W% A9 J4 o - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_INITIALIZED;
7 O* l: ~: O9 Z" q/ r- r8 k! ?
$ q& F2 l. p6 q }- return HAL_ERROR;* S: P& v& `" p; ]
- }# R- }3 q9 y% V/ k
- }
复制代码 ; _: w) ]4 K. n' T' M
函数描述:
r- ~- w8 W) D
S; H! }" k- r* s- x) [此函数主要用于使能中断。
# ]0 n4 ?9 y3 ^, r% N9 @' k Y0 ~' k! ]2 W
函数参数:) n+ g. ^3 K8 s# Q: f3 e. b+ a& s
( z/ m5 |- n( z1 Z0 Z5 M9 S
第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。/ j/ W+ J/ W3 @
第2个参数用于设置要使能的中断,支持的参数如下:
5 j2 |9 f3 e6 W A+ p* f' ^& p- #define FDCAN_IT_TX_COMPLETE FDCAN_IE_TCE /*!< Transmission Completed
5 o7 v$ F I8 j6 h- P - #define FDCAN_IT_TX_ABORT_COMPLETE FDCAN_IE_TCFE /*!< Transmission Cancellation Finished */6 K/ C) b! p' W8 o+ L) T3 D; r
- #define FDCAN_IT_TX_FIFO_EMPTY FDCAN_IE_TFEE /*!< Tx FIFO Empty
! o3 o; H3 y* d - #define FDCAN_IT_RX_HIGH_PRIORITY_MSG FDCAN_IE_HPME /*!< High priority message received */
, M h0 \% z4 H/ x4 U+ i* V - #define FDCAN_IT_RX_BUFFER_NEW_MESSAGE FDCAN_IE_DRXE /*!< At least one received message stored into a Rx Buffer 4 V1 l2 d0 y- @3 l6 ?- `
- #define FDCAN_IT_TIMESTAMP_WRAPAROUND FDCAN_IE_TSWE /*!< Timestamp counter wrapped around */
( o6 V7 x! g6 \, D( M( T8 M+ e; E - #define FDCAN_IT_TIMEOUT_OCCURRED FDCAN_IE_TOOE /*!< Timeout reached */
% n O) l/ d7 s- I$ M/ ~ - + f6 i7 U+ z) A7 d- j" u6 j T M9 @
- #define FDCAN_IT_CALIB_STATE_CHANGED (FDCANCCU_IE_CSCE << 30) /*!< Clock calibration state changed */) L' R1 V7 E, e6 f+ a/ c1 D
- #define FDCAN_IT_CALIB_WATCHDOG_EVENT (FDCANCCU_IE_CWEE << 30) /*!< Clock calibration watchdog event occurred
2 L* n, L0 w9 u - #define FDCAN_IT_TX_EVT_FIFO_ELT_LOST FDCAN_IE_TEFLE /*!< Tx Event FIFO element lost */
+ U# Z4 m9 l3 v0 U* t7 m9 O - #define FDCAN_IT_TX_EVT_FIFO_FULL FDCAN_IE_TEFFE /*!< Tx Event FIFO full */
- u: g' r2 I9 E+ h - #define FDCAN_IT_TX_EVT_FIFO_WATERMARK FDCAN_IE_TEFWE /*!< Tx Event FIFO fill level reached watermark */+ p" F/ w9 \- `, b+ S8 f- k- G
- #define FDCAN_IT_TX_EVT_FIFO_NEW_DATA FDCAN_IE_TEFNE /*!< Tx Handler wrote Tx Event FIFO element */1 J$ j9 ]; }5 I6 I
- : ~' K5 p! b! t" ?) @" R' W
- #define FDCAN_IT_RX_FIFO0_MESSAGE_LOST FDCAN_IE_RF0LE /*!< Rx FIFO 0 message lost */
3 H J3 _0 o$ i% N6 P - #define FDCAN_IT_RX_FIFO0_FULL FDCAN_IE_RF0FE /*!< Rx FIFO 0 full */; t2 ~+ Y2 |' x) h' c6 V
- #define FDCAN_IT_RX_FIFO0_WATERMARK FDCAN_IE_RF0WE /*!< Rx FIFO 0 fill level reached watermark */# ^( d# k" I. _! I. i) M. _2 M
- #define FDCAN_IT_RX_FIFO0_NEW_MESSAGE FDCAN_IE_RF0NE /*!< New message written to Rx FIFO 0 */9 o+ }9 k: {$ _ [: `
- . C( k3 ]. |+ {3 Q% c
- #define FDCAN_IT_RX_FIFO1_MESSAGE_LOST FDCAN_IE_RF1LE /*!< Rx FIFO 1 message lost */
2 ^* a3 m( W& E/ ^" ?0 N8 u - #define FDCAN_IT_RX_FIFO1_FULL FDCAN_IE_RF1FE /*!< Rx FIFO 1 full */
' u1 \# S6 `% G- J, H5 ^ - #define FDCAN_IT_RX_FIFO1_WATERMARK FDCAN_IE_RF1WE /*!< Rx FIFO 1 fill level reached watermark */: \/ L* K& Y; r7 {5 m
- #define FDCAN_IT_RX_FIFO1_NEW_MESSAGE FDCAN_IE_RF1NE /*!< New message written to Rx FIFO 1 */0 B6 r+ y8 I% M1 { `1 b/ E J; i1 ~+ H
3 ?* O: N' e3 s! ~1 h- #define FDCAN_IT_RAM_ACCESS_FAILURE FDCAN_IE_MRAFE /*!< Message RAM access failure occurred
. ^" a0 x2 ?" N! b4 w" O - #define FDCAN_IT_ERROR_LOGGING_OVERFLOW FDCAN_IE_ELOE /*!< Overflow of FDCAN Error Logging Counter occurred + h0 q, A( H4 Q6 p# b' x5 S
- #define FDCAN_IT_RAM_WATCHDOG FDCAN_IE_WDIE /*!< Message RAM Watchdog event due to missing READY % g" |* K4 y! ?2 v$ f0 f
- #define FDCAN_IT_ARB_PROTOCOL_ERROR FDCAN_IE_PEAE /*!< Protocol error in arbitration phase detected
, q6 a' |7 X) z! U - #define FDCAN_IT_DATA_PROTOCOL_ERROR FDCAN_IE_PEDE /*!< Protocol error in data phase detected
' s: m) U. n" F - #define FDCAN_IT_RESERVED_ADDRESS_ACCESS FDCAN_IE_ARAE /*!< Access to reserved address occurred
: C% |' |& d; H% \1 P' R - #define FDCAN_IT_ERROR_PASSIVE FDCAN_IE_EPE /*!< Error_Passive status changed */, A1 j' t I4 @
- #define FDCAN_IT_ERROR_WARNING FDCAN_IE_EWE /*!< Error_Warning status changed */+ Y; L8 }7 R5 r# o1 H6 x
- #define FDCAN_IT_BUS_OFF FDCAN_IE_BOE /*!< Bus_Off status changed */
复制代码
* ^. h+ B% o- t6 M 第3个参数是Tx Buffer Indexes,可以如下参数的任意组合:; G% Y, U4 J& E- a- z; H ~
- #define FDCAN_TX_BUFFER0 ((uint32_t)0x00000001U) /*!< Add message to Tx Buffer 0 */
E6 s0 u, e: M( h$ V& g8 O - #define FDCAN_TX_BUFFER1 ((uint32_t)0x00000002U) /*!< Add message to Tx Buffer 1 */
" X/ c8 D1 U$ @/ C) Z5 D - #define FDCAN_TX_BUFFER2 ((uint32_t)0x00000004U) /*!< Add message to Tx Buffer 2 */2 E3 V# _1 [5 Q8 D3 Z3 ~
- #define FDCAN_TX_BUFFER3 ((uint32_t)0x00000008U) /*!< Add message to Tx Buffer 3 */
% c: e2 Z- n! m - #define FDCAN_TX_BUFFER4 ((uint32_t)0x00000010U) /*!< Add message to Tx Buffer 4 */
# e( S5 A! U3 E, T - #define FDCAN_TX_BUFFER5 ((uint32_t)0x00000020U) /*!< Add message to Tx Buffer 5 */
% L6 \) n$ ?/ O) R8 a - #define FDCAN_TX_BUFFER6 ((uint32_t)0x00000040U) /*!< Add message to Tx Buffer 6 */* V o" }* b) L* y
- #define FDCAN_TX_BUFFER7 ((uint32_t)0x00000080U) /*!< Add message to Tx Buffer 7 */, t- P$ }' L( t. E* L5 ]1 |
- #define FDCAN_TX_BUFFER8 ((uint32_t)0x00000100U) /*!< Add message to Tx Buffer 8 */
: n. J6 j( V5 ~& y/ G$ y2 G) L - #define FDCAN_TX_BUFFER9 ((uint32_t)0x00000200U) /*!< Add message to Tx Buffer 9 */
M* V6 w/ b! u' u& v0 [+ T - #define FDCAN_TX_BUFFER10 ((uint32_t)0x00000400U) /*!< Add message to Tx Buffer 10 */
6 I: J0 E" k' Z0 c2 j - #define FDCAN_TX_BUFFER11 ((uint32_t)0x00000800U) /*!< Add message to Tx Buffer 11 */% t4 v4 c! C$ D+ I% B* z, o
- #define FDCAN_TX_BUFFER12 ((uint32_t)0x00001000U) /*!< Add message to Tx Buffer 12 */$ G$ C! G$ ]" Q' p* `
- #define FDCAN_TX_BUFFER13 ((uint32_t)0x00002000U) /*!< Add message to Tx Buffer 13 */
* ~' Y$ c; n$ x( e; y5 F - #define FDCAN_TX_BUFFER14 ((uint32_t)0x00004000U) /*!< Add message to Tx Buffer 14 */! R* n- `0 \2 P% Z+ I
- #define FDCAN_TX_BUFFER15 ((uint32_t)0x00008000U) /*!< Add message to Tx Buffer 15 */
. G' r$ n1 B" Z& m6 G - #define FDCAN_TX_BUFFER16 ((uint32_t)0x00010000U) /*!< Add message to Tx Buffer 16 */
! b( x; d% v' |1 B& @: z - #define FDCAN_TX_BUFFER17 ((uint32_t)0x00020000U) /*!< Add message to Tx Buffer 17 */
* N3 w* G0 g/ _5 F% W - #define FDCAN_TX_BUFFER18 ((uint32_t)0x00040000U) /*!< Add message to Tx Buffer 18 */
6 H- v+ r8 ?; J - #define FDCAN_TX_BUFFER19 ((uint32_t)0x00080000U) /*!< Add message to Tx Buffer 19 */8 v/ y7 m, C) w
- #define FDCAN_TX_BUFFER20 ((uint32_t)0x00100000U) /*!< Add message to Tx Buffer 20 */
7 y7 T+ f% _& d$ E9 L4 Y7 y" U - #define FDCAN_TX_BUFFER21 ((uint32_t)0x00200000U) /*!< Add message to Tx Buffer 21 *// q* A, o$ q9 I( F+ I, o" @
- #define FDCAN_TX_BUFFER22 ((uint32_t)0x00400000U) /*!< Add message to Tx Buffer 22 */- l0 d* C- K" K9 } O% }$ C4 h& ^
- #define FDCAN_TX_BUFFER23 ((uint32_t)0x00800000U) /*!< Add message to Tx Buffer 23 */& j" ?8 N* N( Y, `4 O0 d
- #define FDCAN_TX_BUFFER24 ((uint32_t)0x01000000U) /*!< Add message to Tx Buffer 24 */$ B- d, Y( M+ A6 j) |
- #define FDCAN_TX_BUFFER25 ((uint32_t)0x02000000U) /*!< Add message to Tx Buffer 25 */
& P( L( o/ X& _4 J3 l - #define FDCAN_TX_BUFFER26 ((uint32_t)0x04000000U) /*!< Add message to Tx Buffer 26 */
+ ~5 }0 N- m4 |4 ~; E5 s; W - #define FDCAN_TX_BUFFER27 ((uint32_t)0x08000000U) /*!< Add message to Tx Buffer 27 */
7 A- q1 I) ]8 }' u - #define FDCAN_TX_BUFFER28 ((uint32_t)0x10000000U) /*!< Add message to Tx Buffer 28 */. H# u! ~, z( Z/ D2 q# A; M
- #define FDCAN_TX_BUFFER29 ((uint32_t)0x20000000U) /*!< Add message to Tx Buffer 29 */
4 O: T8 h1 N% g5 r7 m# L - #define FDCAN_TX_BUFFER30 ((uint32_t)0x40000000U) /*!< Add message to Tx Buffer 30 */4 O( `/ R0 r* ]$ u# _3 c" y5 S% P
- #define FDCAN_TX_BUFFER31 ((uint32_t)0x80000000U) /*!< Add message to Tx Buffer 31 */
复制代码
6 g$ }' I2 ]% P9 [3 N* }如果第2个参数不包括FDCAN_IT_TX_COMPLETE或FDCAN_IT_TX_ABORT_COMPLETE,此参数将被忽略。1 z! U; I; g# E: p( S
5 t7 Y* Q# h! p4 u$ W- h 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。' N9 l4 S: u2 s" Y, B$ H
使用举例:
* {6 Y6 g; ]+ K) R
0 T' L7 S6 l0 ^9 D9 xFDCAN_HandleTypeDef hfdcan1;) F. S( m* h# y9 V6 Y! F, e# {
3 j G# o7 j% c. w. p( J/* 激活RX FIFO0的watermark通知中断,位开启Tx Buffer中断*/; z. T7 ?3 C ?0 ?- F( P: Y0 Q
HAL_FDCAN_ActivateNotification(&hfdcan1, FDCAN_IT_RX_FIFO0_WATERMARK, 0);
3 S) c/ `0 k; f9 ]$ a$ P6 e8 [91.4.6 函数HAL_FDCAN_Start
- i6 V4 c$ y3 J( V7 z- ?" a9 |函数原型:
( k3 K- t. h# S5 q
! n, F7 a2 `- I; r- HAL_StatusTypeDef HAL_FDCAN_Start(FDCAN_HandleTypeDef *hfdcan)
+ g! T h! v2 @ - {9 s' e o2 r4 Y3 O' a. X
- if (hfdcan->State == HAL_FDCAN_STATE_READY)
. k* Q0 A- W. `5 P - {
' s! f- X; Z& l3 K1 B3 O6 p - /* 设置FDCAN外设状态 */: L! v8 j4 o5 N
- hfdcan->State = HAL_FDCAN_STATE_BUSY;: K; M3 s' O W2 M0 B
- / e5 d/ W) }+ T
- /* 请求离开初始化状态 */% S8 {% u8 m5 q3 K E
- CLEAR_BIT(hfdcan->Instance->CCCR, FDCAN_CCCR_INIT);
( @2 m q$ a* ]/ U- _
0 B1 N, U* O$ @0 l4 G9 P/ d- ~5 h- /* 设置错误码 */2 J( ~0 Z; ~2 `+ }8 T9 N& V( p
- hfdcan->ErrorCode = HAL_FDCAN_ERROR_NONE;: K$ R) s) ]* _* J8 P9 i, K
' q) ^$ m: \$ E6 Z" B+ W" [; M- return HAL_OK;
8 {7 h. c! P% c3 X - }: X" {; A) f& H( e+ x# a3 S
- else
+ ]' X: n/ R9 ? - {' T9 c$ ?6 C; t1 b% p! w9 u
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_READY;
6 Z4 q+ H% Y' _; I$ m
9 w* A3 [- |' S6 x, Y* V- g- return HAL_ERROR;
( E4 _9 s9 N8 X+ m) x1 k - }
& u( ]( `# S( \9 Q- O9 b - }
复制代码 ! B3 l7 F7 I: R9 b0 D6 }& @
函数描述:/ J" W$ r$ G2 n! H
6 t+ V$ x2 e% I# `. v" Q
此函数主要用于启动FDCAN。
& @, x; Q% d' {6 V0 h8 U) V
, e* [& p, v+ c+ M# F8 E3 v) p3 P函数参数:6 Q" ?1 O: Y: Q5 K$ E
% h$ ~6 i h4 T5 n( O- ~5 ^9 |( G
第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
( L/ e( }2 e- Z9 ?& C 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。( Q1 V. Z6 Q5 j- `! V j6 p( S
使用举例:
% d$ G" X( z# x* q2 {
4 ?0 v/ s: C( ]! p- /*** K" `$ @4 ]8 @6 K- C
- * @brief Writes block(s) to a specified address in an SD card, in DMA mode.% H# H* r: o; Z# y# G7 _) u) K
- * @param pData: Pointer to the buffer that will contain the data to transmit
) m% C4 O) ~: [6 C) B0 ~ - * @param WriteAddr: Address from where data is to be written
( B8 I+ P9 b! W& Q - * @param NumOfBlocks: Number of SD blocks to write
* V. O! f, Y" D; C# E - * @retval SD status" q7 V2 O" O$ E6 ^( h
- */
0 v- e3 s& G+ B8 j9 h" S - uint8_t BSP_SD_WriteBlocks_DMA(uint32_t *pData, uint32_t WriteAddr, uint32_t NumOfBlocks)$ ~, _- j5 p. i6 s+ E9 d
- {
/ ]3 b4 Q v3 M: G' u5 h; t V - 3 H( ?5 l/ G* }
- if( HAL_SD_WriteBlocks_DMA(&uSdHandle, (uint8_t *)pData, WriteAddr, NumOfBlocks) == HAL_OK)
. ~+ F o: l8 x& I& u - {7 q' |: O$ C. z4 R' `% \8 p( i
- return MSD_OK;
: O; r$ ~- h7 J9 X, B - }- G" B% }* i- N5 U7 M' w$ l
- else
! c6 T% c( K J, A - {; ~8 m% y" U+ N- S2 T
- return MSD_ERROR;
/ Q! O _" G0 a& V9 u( F; _1 s1 X4 h) g - }2 P- Y/ N2 C* ~ U: ?+ W; Q
- }
复制代码 : z. `) ^5 a4 P2 @
91.4.7 函数HAL_FDCAN_AddMessageToTxFifoQ1 L+ y9 \6 P1 B9 i1 d
函数原型:
% T# c y2 g |8 B% V2 p# J6 E* [; M' @4 A" ?
- HAL_StatusTypeDef HAL_FDCAN_AddMessageToTxFifoQ(FDCAN_HandleTypeDef *hfdcan, FDCAN_TxHeaderTypeDef *pTxHeader, uint8_t *pTxData)
3 P7 @" M- C$ k6 G( b) u+ h - {6 |# A4 @' O& w7 I5 r$ c' d
- uint32_t PutIndex;
. B I+ @8 b- j$ ?6 {" @* I
* M j& I7 w4 Z0 x( D! R- /* 检查函数形参 */9 D3 u$ M/ }# l: p" w
- assert_param(IS_FDCAN_ID_TYPE(pTxHeader->IdType));
# Z+ l% r6 ?, B/ M0 S6 Q - if (pTxHeader->IdType == FDCAN_STANDARD_ID)5 e2 l! c* L" F5 K
- {
7 Q2 Y6 v* C3 A - assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->Identifier, 0x7FFU));
: Q8 ~' @, J# @) o - }
# X( Z/ n9 l4 s8 t: Q5 Y - else /* pTxHeader->IdType == FDCAN_EXTENDED_ID */6 U `, g W& ^) V6 M6 m% c
- {
1 ]" |7 U: t) j3 M7 N6 x - assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->Identifier, 0x1FFFFFFFU));
6 F4 p; c/ F9 E9 ?5 T - }
; u9 R( r, _. @7 F0 |$ l9 e - assert_param(IS_FDCAN_FRAME_TYPE(pTxHeader->TxFrameType));: P" j6 ^% v! B3 ?
- assert_param(IS_FDCAN_DLC(pTxHeader->DataLength));
- w1 p9 \/ f+ E' N - assert_param(IS_FDCAN_ESI(pTxHeader->ErrorStateIndicator));
: S$ Y, J# M" ]% `- k - assert_param(IS_FDCAN_BRS(pTxHeader->BitRateSwitch));% Z6 I" ~5 t. v/ q
- assert_param(IS_FDCAN_FDF(pTxHeader->FDFormat));
. j8 S; K$ F: D5 w5 r/ ?3 T - assert_param(IS_FDCAN_EFC(pTxHeader->TxEventFifoControl));
* {* `1 R( b- w( i8 t/ X( V - assert_param(IS_FDCAN_MAX_VALUE(pTxHeader->MessageMarker, 0xFFU));, y- {0 u4 Y# w. G
- 6 ~* A6 f. o' q( d+ j
- if (hfdcan->State == HAL_FDCAN_STATE_BUSY)( [: y+ c" ~* h: f9 f
- {
" N! k0 l) |. K- s d0 @4 A5 w4 F. ^: { - /* 检测Tx FIFO/Queue 是否在RAM中分配到空间 */
1 H1 D0 M. t: X$ j% Z - if ((hfdcan->Instance->TXBC & FDCAN_TXBC_TFQS) == 0U), |& S D& V) _' G' [7 d0 l
- {' J0 H" a1 J6 l9 E6 |/ y
- /* 更新错误码 */! K- Q8 Z# r O9 Q
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
& [4 r8 `- g+ N
* Q' x9 d& p9 D! _$ f- return HAL_ERROR;
. `6 M" L) M+ Y c0 z4 D - }7 A) I0 G; Z( T9 t) V& p* {4 |. U
+ s! S* g, j; i$ G- /* 检查Tx FIFO/Queue 是否满 */
0 T! C* H7 o3 ?/ R4 d( N/ s' n - if ((hfdcan->Instance->TXFQS & FDCAN_TXFQS_TFQF) != 0U)$ {0 ?3 c2 o& N2 t7 M1 m/ T2 m( y
- {: T- N/ H$ \) q0 j
- /* 更新错误码 */2 j3 A) t. [$ f7 H1 H1 \! k
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_FULL;, V% D: A1 t$ z+ o: ^" x5 V% O
- # {/ X8 ? R2 }* r+ Z
- return HAL_ERROR;
' T" G' I( j8 K1 @/ R - }
" a! F2 _+ ?) B - else* M* O7 T3 i C. q4 |; x; O$ ?
- {& ^* {7 S0 |4 \1 N) V( d
- /* 获取Tx FIFO PutIndex */
8 X+ k! L( {( E8 y6 T$ C - PutIndex = ((hfdcan->Instance->TXFQS & FDCAN_TXFQS_TFQPI) >> FDCAN_TXFQS_TFQPI_Pos);
, A$ B& R. v, ]3 k, n: c" x - : i1 r8 c. C3 X S' h/ }" r6 b8 M1 ^
- /* 添加消息到Tx FIFO/Queue */
; V1 L" a) h j/ p - FDCAN_CopyMessageToRAM(hfdcan, pTxHeader, pTxData, PutIndex);
: S0 j% O! }1 i3 P% p7 }; q, |; E* H
2 _: ?, B. G$ L- /* 激活相应的传输请求 */( C+ `$ m$ g* I
- hfdcan->Instance->TXBAR = ((uint32_t)1 << PutIndex);
( M; ~, y) d! o ?* s( `
% }7 F0 n% F+ W- Q& M- /* 存储最近的Tx FIFO/Queue Request Buffer Index */+ a8 r8 N% i$ b4 V# v' r' ]
- hfdcan->LatestTxFifoQRequest = ((uint32_t)1 << PutIndex);) @* P# [. e& N# k8 X# F
- }
* t- y: y; Z4 f: J r9 A) Q" a: l - ) c" g. q0 o' O( s
- /* 返回错误状态 */ f- z* o# P {6 p. s7 H
- return HAL_OK;
" p0 [$ B" D' }5 R" N - }
' o, x- ~/ Z: B" H% o9 F: U- o - else
" ~8 Q1 O' c/ e& f* e6 E - {
7 y: |. P8 q* \3 K - /* 更新错误码 */# _: S$ g6 y1 M# X3 h2 F
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_STARTED;
( s# f1 z+ P% t- k+ g ?7 h6 U - % L" Y% k0 A# S% F: `, J- L" L
- return HAL_ERROR;
5 v% Q: P& J7 e5 d6 }5 X - }
' ?& t! ], x$ q5 o3 A7 e0 m8 |) I - }
复制代码
) R0 ?2 Y2 C. V函数描述:( A) q, a4 n4 L
1 B& C+ I4 x w0 K2 Q7 Y1 i
此函数用于添加消息到Tx FIFO/Queue并激活相应的传输请求。
' b9 ^; s% W: Q* Q
5 N2 P, I1 F" L; Q7 C函数参数:
$ B3 ` K& j/ |# u! {9 L% i
) f, a: B( w4 o: ]: ` 第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。- Q* s' ?+ d- ]* n1 j9 p1 V
第2个参数是FDCAN_TxHeaderTypeDef类型结构体变量,用于消息发送。
4 u: g& Y; P: Y; `6 b3 h7 E3 \ 第3个参数是要发送的数据地址。程序里面会将数据复制到发送缓冲区。
+ x# ^6 n: O! Y7 O+ a; t' H 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。# o! }7 ~% l. d, p; B) `- A7 n6 |
使用举例:
" T' V4 d2 R) x' r" f5 G$ _
& w! l$ k/ U4 a- ~8 ~% A6 r. m" u- /*
- ]* |1 @. B1 H" S2 O8 d - *********************************************************************************************************4 _ Z9 h* U; l" _ [8 ?& N0 a
- * 函 数 名: can1_SendPacket B2 a( d3 w2 [$ |" Q6 w: X. t; U6 W
- * 功能说明: 发送一包数据) Z9 C1 f8 T [0 _# T
- * 形 参:_DataBuf 数据缓冲区
+ E, [. A3 j) C+ S& y9 i: Q* N - * _Len 数据长度, 支持8,12,16,20,24,32,48或者64字节
* D) o4 w- b' s h4 J% ` - * 返 回 值: 无1 p* ]4 r* \2 c6 F& S' a
- *********************************************************************************************************
% r/ q& q+ F" |! k- T - */
. r* `3 [% T( B- m: ^% \ - void can1_SendPacket(uint8_t *_DataBuf, uint8_t _Len)
0 g+ i: v; J3 [! S, A - {
& J4 l8 \0 f- G) v/ D' F - FDCAN_TxHeaderTypeDef TxHeader = {0};
x* a% w) G9 _ -
. `# S( j1 U, V - /* 配置发送参数 */' V' E$ m) \& F
- TxHeader.Identifier = 0x222; /* 设置接收帧消息的ID */
' f0 Y. d" t& L$ k5 Y - TxHeader.IdType = FDCAN_STANDARD_ID; /* 标准ID */- ?+ y9 Q9 R% V* n/ E# s
- TxHeader.TxFrameType = FDCAN_DATA_FRAME; /* 数据帧 */! N9 V# z4 _7 B; ~; C4 M
- TxHeader.DataLength = (uint32_t)_Len << 16; /* 发送数据长度 */
% ?) A7 h. W/ D$ Q - TxHeader.ErrorStateIndicator = FDCAN_ESI_ACTIVE; /* 设置错误状态指示 */
2 n2 N* S4 b W+ l7 [" S$ i$ S - TxHeader.BitRateSwitch = FDCAN_BRS_ON; /* 开启可变波特率 */
! _- k) i) B7 t, W% @0 Z5 I% [ - TxHeader.FDFormat = FDCAN_FD_CAN; /* FDCAN格式 */. u7 D7 I& A+ t! U! ~8 A: z' Z
- TxHeader.TxEventFifoControl = FDCAN_NO_TX_EVENTS;/* 用于发送事件FIFO控制, 不存储 */! x. x0 x& |8 b
- TxHeader.MessageMarker = 0; /* 用于复制到TX EVENT FIFO的消息Maker来识别消息状态,范围0到0xFF */, A) |7 o" Y0 R Q/ J
- 6 |1 s1 V P8 ~$ J2 {
- /* 添加数据到TX FIFO */7 @$ O( S; q7 u- q: n* A
- HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1, &TxHeader, _DataBuf);
/ {1 k* D& P, S( Y - }
复制代码
. [9 |- c- @! v- N( d. M9 w6 F91.4.8 函数HAL_FDCAN_GetRxMessage
; ?: t. h) I g& x, n函数原型:
# X6 h+ _ q* Q& i" P- L, b( H2 l/ j5 g6 V+ z# `- B/ l
- HAL_StatusTypeDef HAL_FDCAN_GetRxMessage(FDCAN_HandleTypeDef *hfdcan, uint32_t RxLocation, FDCAN_RxHeaderTypeDef *pRxHeader, uint8_t *pRxData)
- t1 U7 x8 s- E( L! K1 I+ k - {: G' `, z- K* N4 B$ |' ]4 J
- uint32_t *RxAddress;
( O4 M( r V& @# G - uint8_t *pData;" B# {2 [9 n$ a( V9 ?; b
- uint32_t ByteCounter;
4 q% W0 l) v% H7 Q5 Q - uint32_t GetIndex = 0;
3 v2 j* [- N% X9 N - HAL_FDCAN_StateTypeDef state = hfdcan->State;
. m( L! e' Y% H5 j0 T: [4 Z' R/ h/ W - ) o4 g) @, ?: w% U( U8 _
- if (state == HAL_FDCAN_STATE_BUSY)- z% n b- ?) T
- {) w9 K0 V+ }/ V
- if (RxLocation == FDCAN_RX_FIFO0) /* Rx element分配到 Rx FIFO 0 */
/ L0 } u% H( i* b+ F - {
# V: Z0 b1 s. g( F$ _4 j8 K' W% _ - /* 检查Rx FIFO 0 分配了RAM空间 */8 t2 [4 L! w' ~6 w- `
- if ((hfdcan->Instance->RXF0C & FDCAN_RXF0C_F0S) == 0U)
$ [/ n v- o$ W- ?3 L- G - {' S( L5 S5 l* o! T; n$ J
- /* 更新错误码*/% ^& v6 \! D* X$ U C( P: Z
- hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
7 R" T" w. c. |9 y ?# i o - " M% w' `. x3 W, N4 D
- return HAL_ERROR;: e9 V' S% G/ O& e: x
- }8 Q3 i. t# @( B& i1 o
, m& i* l$ G5 U9 h1 q# F- /* 检查Rx FIFO 0 非空 */) Q) b+ [$ O) e; g
- if ((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0FL) == 0U)
5 h0 \* ~9 [/ u7 k0 O& b - {, l/ h: |8 d5 Q; k& k0 y; @
- /* 更新错误码*/
8 h" v& h5 w2 j, E: }# i3 h - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_EMPTY;
( ?2 W, i5 ?7 A: @/ L* E
3 G8 s1 Q" w N! _1 i% B- return HAL_ERROR;) u U7 {2 _/ ^# i$ M! X
- }
: B' W: ^: z, ~: B0 O) g - else
" u$ B! [, e: Y- m/ c, V% c# ] - {- ^: p' d0 k4 }% y8 f
- /* 检查Rx FIFO 0 满且开了覆盖模式 */; M3 Q8 U$ E3 N3 v0 C I
- if(((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0F) >> FDCAN_RXF0S_F0F_Pos) == 1U)
: [ ^! I U) h0 @: t - { E. }7 P }1 {3 k* I
- if(((hfdcan->Instance->RXF0C & FDCAN_RXF0C_F0OM) >> FDCAN_RXF0C_F0OM_Pos) == FDCAN_RX_FIFO_OVERWRITE)
4 Z1 v2 f) v6 `2 p0 A& X - {2 f; b. ^3 B$ `3 x! `- e* a
- /* 开启了覆盖模式,丢弃第1个数据 */
' } \7 _ k; D* T6 r( c - GetIndex = 1U;
8 P m3 M( @% L. | - }3 ]$ T1 E" s8 r7 g( q. _5 d: t
- }
2 J* ]8 \0 z! t3 d7 G4 O - 3 a( h; {# u3 x* t$ I$ G
- /* 计算Rx FIFO 0 element 索引 */
7 c% n) S- I8 P& I - GetIndex += ((hfdcan->Instance->RXF0S & FDCAN_RXF0S_F0GI) >> FDCAN_RXF0S_F0GI_Pos);
- Y# b6 {& }, [/ T% g( T) h
$ i4 \4 P, U0 A+ Y- /* 计算 Rx FIFO 0 element 地址 */
0 ~2 Z/ H7 |! V( E - RxAddress = (uint32_t *)(hfdcan->msgRam.RxFIFO0SA + (GetIndex * hfdcan->Init.RxFifo0ElmtSize * 4U));
9 v/ {: W2 h) k- G$ m - }+ t, e3 b7 Q- p8 y$ j9 x
- }
Y# |, Q# u6 c+ f - else if (RxLocation == FDCAN_RX_FIFO1) /* Rx element is assigned to the Rx FIFO 1 */- |- T. x8 X t; t6 ]4 Q! y9 x5 ]
- {4 A" \: Z$ d# g. n: K/ U) A5 h) Z& U
- /* 检查Rx FIFO 1 分配了RAM空间 */+ b7 j4 K0 L' P8 D6 Y
- if ((hfdcan->Instance->RXF1C & FDCAN_RXF1C_F1S) == 0U): P- G3 M6 S3 g, ?1 Z! ~
- {# u, v0 K1 O m6 Z" @
- /* 更新错误码 */
& a5 X% H- ~8 Y/ l$ X% Y7 \ - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
. k- U& ?- r% p. b3 a9 M, n
5 P3 e" h6 ~- c- return HAL_ERROR;$ ?' v- E; W& k( ^6 b7 k, v8 W
- }
0 {# E4 O% _$ c! I% k' k1 v - % H, ?$ L+ r4 q; |
- /* 检查 Rx FIFO 0 非空 */2 H- v: ?4 g* b J! k
- if ((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1FL) == 0U)
( F% [0 I% m$ J3 N* H - {0 B O5 |4 T* U \' m/ d4 G v( y
- /* 更新错误码 */
3 J' {/ @) A8 X* l# a! t - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_FIFO_EMPTY;
/ C6 J7 H3 D" p. Y3 M y! z: S- C& B - " R2 N% ]2 B4 H0 o' Z& k
- return HAL_ERROR;4 q3 C4 Q1 ], V. w
- }
3 |4 }; [5 W, ~8 Q - else, O2 U* N9 j" |1 |6 `) R! P
- {. I7 u* F/ K8 L0 I4 B6 B7 _
- /* 检查Rx FIFO 1 满且开了覆盖模式 */9 _7 t' V( f; u9 Y5 f
- if(((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1F) >> FDCAN_RXF1S_F1F_Pos) == 1U)
$ j) M1 L% }9 J6 p0 [: p' X( f - {7 f5 ^% N; B3 |9 \! d% h
- if(((hfdcan->Instance->RXF1C & FDCAN_RXF1C_F1OM) >> FDCAN_RXF1C_F1OM_Pos) == FDCAN_RX_FIFO_OVERWRITE)
+ v1 S% c$ p( n+ j: [8 i6 l - {+ Z- l J8 x) A, \6 o
- /* 开启了覆盖模式,丢弃第1个数据 */
; k/ M' D# F- m! z+ h5 S% [! i - GetIndex = 1U;
' E9 Y+ f, b* p r4 k - }- b1 M3 e1 O7 I# f1 O* P! a
- }0 |% _' `% P2 g. v
- / o' {2 W1 d! T2 [/ ]
- /* 计算 Rx FIFO 1 element 索引 */
6 q/ x9 u$ o- }' \# ]0 ?! u9 O - GetIndex += ((hfdcan->Instance->RXF1S & FDCAN_RXF1S_F1GI) >> FDCAN_RXF1S_F1GI_Pos);% j' P5 \& Y: x X4 a* ]) @* D
0 h- W( X m2 O7 W/ [- /* 计算 Rx FIFO 1 element 地址 */, t4 Q# i6 R4 ^. l8 g- {
- RxAddress = (uint32_t *)(hfdcan->msgRam.RxFIFO1SA + (GetIndex * hfdcan->Init.RxFifo1ElmtSize * 4U));
8 \) L( H6 Y# p$ L - }( u* L. ~& x3 s
- }2 x" h* s5 u1 l& K5 G
- else /* Rx element 分配了专用 Rx buffer */3 A! u0 R" w6 d! n6 j1 I
- {
0 t6 z, j! u& L; h' X& @- i( z$ P - /* 检查选择的buffer分配了RAM空间 */
! p* C5 u# @- r+ w$ O: R! t - if (RxLocation >= hfdcan->Init.RxBuffersNbr): r/ d) h. E6 M
- {# v$ I* D, X/ ]$ C* a( S& V4 s
- /* 更新错误码 */
/ g |6 m# W' ~7 \$ L - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_PARAM;
1 B: b) e* Z" @, b7 J# m
0 c' V* R' A: ]* [- return HAL_ERROR;. E% l% g( p1 c/ D% X0 x
- }0 P5 ]: m& Z, Z- y) C: m
- else* z3 u) m3 F5 V- D2 |/ i
- {' _1 r3 e; U0 u7 l1 _/ Z
- /* 计算Rx buffer 地址 */* S# c9 ]# m4 V. Q8 q
- RxAddress = (uint32_t *)(hfdcan->msgRam.RxBufferSA + (RxLocation * hfdcan->Init.RxBufferSize * 4U));
$ s4 P4 p: F: ^8 M. p( R: u* u# D | - }" J* C# r5 A" k3 O2 @0 z! ]! h6 v
- }2 V* X- p3 { F6 U( k
- [9 j2 l# T9 U3 y& H* b- /* 接收IdType */+ u# C( l1 U) D( ]* N- u) B
- pRxHeader->IdType = *RxAddress & FDCAN_ELEMENT_MASK_XTD;
# g- E7 Q' s3 N5 p( f! h& p - ! g- Q$ |0 o. ^5 B1 {% v) \
- /* 接收Identifier */7 C* X- t/ n/ J0 M% e! g
- if (pRxHeader->IdType == FDCAN_STANDARD_ID) /* Standard ID element */- R5 p9 i: J; O8 w' C$ H& f
- {
0 {1 R/ e( T! v# `, W: m4 H - pRxHeader->Identifier = ((*RxAddress & FDCAN_ELEMENT_MASK_STDID) >> 18);
- M* ?' H5 H/ H# o" P( x# u! u+ V - }& y' k N4 [ L, G5 k
- else /* Extended ID element */; P6 F L. E! |" n- D: f
- {$ i k+ {$ B2 `
- pRxHeader->Identifier = (*RxAddress & FDCAN_ELEMENT_MASK_EXTID);9 |* K. X1 ?1 v; y! ~7 g9 \- ~
- }8 q# g R( S) X( }: Y
- m0 c) C1 P/ s, w# Z7 `* f
- /* 接收RxFrameType */9 u2 W4 o! O8 _ ~
- pRxHeader->RxFrameType = (*RxAddress & FDCAN_ELEMENT_MASK_RTR);
/ _: _+ {8 S* Q8 P
; i6 B0 ^" B; u2 y4 Q! g2 [; G- /* 接收ErrorStateIndicator */7 G& O: p% a' n7 o8 @2 G& i( y" l
- pRxHeader->ErrorStateIndicator = (*RxAddress & FDCAN_ELEMENT_MASK_ESI);
5 O5 N+ W& o6 N1 o3 n6 X! `5 U+ } - ! T% v1 n4 ]+ G2 W
- /* Increment RxAddress pointer to second word of Rx FIFO element */) f; g% e) V! T
- RxAddress++;" k: E" m! b5 m; L# _9 M! I
- ( n8 E) {6 D" i
- /* 接收RxTimestamp */0 e+ z$ B) X3 j* b; \/ K
- pRxHeader->RxTimestamp = (*RxAddress & FDCAN_ELEMENT_MASK_TS);3 A9 n B+ U% d% f
- - o; }! |3 A6 P/ |- P& E% I
- /* 接收DataLength */
. |$ Q: E* i" | - pRxHeader->DataLength = (*RxAddress & FDCAN_ELEMENT_MASK_DLC);1 s: C; i9 |, I+ R
' f+ u4 f. i. _. W7 ^: ~/ |- /* 接收BitRateSwitch */3 d5 ]* m! e0 I1 P3 V2 l X6 z
- pRxHeader->BitRateSwitch = (*RxAddress & FDCAN_ELEMENT_MASK_BRS);
0 S4 a2 ?# m) \5 p
. P& ]; R" W# O6 F* u6 G: j9 Q, E3 F- /* 接收FDFormat */5 X, w3 k' y B% g+ ^
- pRxHeader->FDFormat = (*RxAddress & FDCAN_ELEMENT_MASK_FDF);9 g( k( E. W' a1 i
2 f2 W. G% P+ i1 s2 G+ d* y- /* 接收FilterIndex */
0 V0 F% s. i* b1 A( ~5 ]4 k - pRxHeader->FilterIndex = ((*RxAddress & FDCAN_ELEMENT_MASK_FIDX) >> 24);
' u, e$ P/ N* N0 u+ [ c - 6 {0 L0 ^* f# A6 E- Z
- /* 接收NonMatchingFrame */7 Z$ t% w. |9 _# z8 ~- G& ]
- pRxHeader->IsFilterMatchingFrame = ((*RxAddress & FDCAN_ELEMENT_MASK_ANMF) >> 31);7 H' p; ~" B- j3 C
+ B+ L3 w8 x9 L9 U5 v- /* 增加地址,指向Rx FIFO element的payload */
& v0 B W* M* w+ @3 b/ P! @ - RxAddress++;
3 F; Y8 |" h" A1 A - ! Z! A' z* ^4 u! @7 |* O
- /* 接收 Rx payload */
( ]: m* z% Y6 m, e. I- t0 ~8 a& x - pData = (uint8_t *)RxAddress;& t4 y6 [, I6 o
- for (ByteCounter = 0; ByteCounter < DLCtoBytes[pRxHeader->DataLength >> 16]; ByteCounter++)1 _$ w& \9 W: G: V" W1 K
- {5 W; e: F7 R, e2 z& L/ W, K
- pRxData[ByteCounter] = pData[ByteCounter];8 p; L$ I! d% T
- }
- I ^. M G- p1 j3 D; f
" ?3 ^2 J; `' m( A2 m- if (RxLocation == FDCAN_RX_FIFO0) /* Rx element is assigned to the Rx FIFO 0 */0 R3 Z( B. \8 b' O9 a5 w% j$ V
- {( Y: D) U" l- b4 q6 n
- /* 确认Rx FIFO 0先进的数据已经读出 */
|; S' x5 P/ g6 D- Z d ^$ Z - hfdcan->Instance->RXF0A = GetIndex;! T1 ?( ?7 n3 i0 J4 I+ B( F B
- }
$ F, u( P9 d# l - else if (RxLocation == FDCAN_RX_FIFO1) /* Rx element is assigned to the Rx FIFO 1 */4 z3 Q1 A& s8 h) I
- {6 G7 x* Z7 x& L/ t) x6 R* `. t
- /* 确认Rx FIFO 1先进的数据已经读出 */
% j- y6 ?' o C& }; _0 q; f - hfdcan->Instance->RXF1A = GetIndex;
9 ]/ r H+ v8 |' Q8 j, P! j - }
, L* I& h7 R" l' g - else /* Rx element is assigned to a dedicated Rx buffer */) u; B* [. e5 C
- {
& }+ W5 n9 c2 d% T! F - /* 清除当前Rx buffer的新数据标志 */
4 B4 H# s8 }5 ~2 y. T0 \ - if (RxLocation < FDCAN_RX_BUFFER32)7 Q+ l( ]0 s1 r* l B. x
- {
5 y2 K8 Y) M- h& O9 ?6 H; u. A9 Y - hfdcan->Instance->NDAT1 = ((uint32_t)1 << RxLocation);
E6 D$ w/ H4 a& T* D1 b9 H( w6 w - }
# g9 v3 s3 \2 L% o) R$ N - else /* FDCAN_RX_BUFFER32 <= RxLocation <= FDCAN_RX_BUFFER63 */# u0 F3 T5 \. u, o
- {$ C B$ b* a! i
- hfdcan->Instance->NDAT2 = ((uint32_t)1 << (RxLocation & 0x1FU));" {* s8 F' [% o" `( h
- }
4 v( S7 E. n% \+ v$ e. L3 p. q - }
; `2 p6 N2 v! T7 h ~5 P - ' U. {3 Q9 E3 p# u8 c6 u
- /* 返回状态 */% W8 Y6 i) n2 ]6 x
- return HAL_OK;
& h- A& @3 B0 J8 I- i, u, U - }
% b7 L- O, b+ Y: Q: k/ g' }' k - else! w4 r# ~& i* I: h1 x# u5 O6 ?: i9 r
- {
# E. [ E9 o' A4 O6 q3 ]- }: o - /* 更新错误码 */
6 V: X' K" T2 K- s2 s - hfdcan->ErrorCode |= HAL_FDCAN_ERROR_NOT_STARTED;8 z0 k. C! C5 `, }7 ] T
- & A) a' A5 e. }" l
- return HAL_ERROR;
, b3 O" o9 A0 h( }7 \8 P - }' ^& E: N, X2 k% p; A, ~7 @6 T' P
- }
复制代码
7 ]. d/ p. ]2 }: k3 M函数描述:
* W6 W9 U2 M0 V3 P6 r6 I3 ?, E9 ]0 q, t" X- i$ z' ~
此函数主要用于获取接收到的数据。
- `) C" t1 @4 d V1 A/ l) j f+ s4 b5 y' _4 m$ h
函数参数:4 R; O; d* U9 i
9 _0 y2 P2 a' o; ?$ j, x
第1个参数是FDCAN_HandleTypeDef类型结构体指针变量。
; t/ y+ ]. x7 K- ]! |8 b0 V' Z" ` 第2个参数是读取位置,支持如下几种参数:* p9 j/ e/ j& ?- y
- #define FDCAN_RX_FIFO0 ((uint32_t)0x00000040U) /*!< Get received message from Rx FIFO 0 */( t: } x# G* z
- #define FDCAN_RX_FIFO1 ((uint32_t)0x00000041U) /*!< Get received message from Rx FIFO 1 */
, l9 L( K/ N1 }0 e( A1 S - #define FDCAN_RX_BUFFER0 ((uint32_t)0x00000000U) /*!< Get received message from Rx Buffer 0 */
& ~. o) e, }- t& W3 ? - #define FDCAN_RX_BUFFER1 ((uint32_t)0x00000001U) /*!< Get received message from Rx Buffer 1 */
% g; A! ]' y# {- k. N - #define FDCAN_RX_BUFFER2 ((uint32_t)0x00000002U) /*!< Get received message from Rx Buffer 2 */) c" u$ A+ e F2 d" H
- #define FDCAN_RX_BUFFER3 ((uint32_t)0x00000003U) /*!< Get received message from Rx Buffer 3 */( f5 j8 P8 F* i' t/ l1 a8 z- U
- #define FDCAN_RX_BUFFER4 ((uint32_t)0x00000004U) /*!< Get received message from Rx Buffer 4 */4 s/ i2 [9 K- u. r! G
- #define FDCAN_RX_BUFFER5 ((uint32_t)0x00000005U) /*!< Get received message from Rx Buffer 5 */. k3 V/ d% u! D9 }/ Q0 v8 c
- #define FDCAN_RX_BUFFER6 ((uint32_t)0x00000006U) /*!< Get received message from Rx Buffer 6 */
: I) I5 U X/ Q, W; o. L' ? - #define FDCAN_RX_BUFFER7 ((uint32_t)0x00000007U) /*!< Get received message from Rx Buffer 7 */( D9 e3 f9 i, L& z) c f
- #define FDCAN_RX_BUFFER8 ((uint32_t)0x00000008U) /*!< Get received message from Rx Buffer 8 */) H8 a' H+ M+ l2 d
- #define FDCAN_RX_BUFFER9 ((uint32_t)0x00000009U) /*!< Get received message from Rx Buffer 9 */" j0 Z8 x0 Y/ y% H- S
- #define FDCAN_RX_BUFFER10 ((uint32_t)0x0000000AU) /*!< Get received message from Rx Buffer 10 */; T ]" i7 Y2 S( s
- #define FDCAN_RX_BUFFER11 ((uint32_t)0x0000000BU) /*!< Get received message from Rx Buffer 11 */4 t' G5 j) F) e8 n. \( }# G6 v
- #define FDCAN_RX_BUFFER12 ((uint32_t)0x0000000CU) /*!< Get received message from Rx Buffer 12 */, e3 K; e8 R) \" H
- #define FDCAN_RX_BUFFER13 ((uint32_t)0x0000000DU) /*!< Get received message from Rx Buffer 13 */' T' J, t0 Q; j+ a1 p O% t% c, _' v
- #define FDCAN_RX_BUFFER14 ((uint32_t)0x0000000EU) /*!< Get received message from Rx Buffer 14 */
) g6 f3 p3 W) i: k: p9 ]: F - #define FDCAN_RX_BUFFER15 ((uint32_t)0x0000000FU) /*!< Get received message from Rx Buffer 15 */
) o+ Y6 o, W6 k& O - #define FDCAN_RX_BUFFER16 ((uint32_t)0x00000010U) /*!< Get received message from Rx Buffer 16 */
1 X- Y" g; F. l - #define FDCAN_RX_BUFFER17 ((uint32_t)0x00000011U) /*!< Get received message from Rx Buffer 17 */
! K6 g5 G# l' A3 {3 A4 _. r - #define FDCAN_RX_BUFFER18 ((uint32_t)0x00000012U) /*!< Get received message from Rx Buffer 18 */7 M* c) L/ N# e2 L* K
- #define FDCAN_RX_BUFFER19 ((uint32_t)0x00000013U) /*!< Get received message from Rx Buffer 19 */
9 [, l! N3 [ f+ K- Z - #define FDCAN_RX_BUFFER20 ((uint32_t)0x00000014U) /*!< Get received message from Rx Buffer 20 */6 R* m9 q7 W. G: G
- #define FDCAN_RX_BUFFER21 ((uint32_t)0x00000015U) /*!< Get received message from Rx Buffer 21 */
; Z/ I- l6 `) M8 W2 I! m - #define FDCAN_RX_BUFFER22 ((uint32_t)0x00000016U) /*!< Get received message from Rx Buffer 22 */! M& f- }0 @5 C0 L2 d
- #define FDCAN_RX_BUFFER23 ((uint32_t)0x00000017U) /*!< Get received message from Rx Buffer 23 */% |- i" M& D- r) t# c# t' W0 V& B% ^- U
- #define FDCAN_RX_BUFFER24 ((uint32_t)0x00000018U) /*!< Get received message from Rx Buffer 24 */
$ l$ \5 X5 ~7 V( p - #define FDCAN_RX_BUFFER25 ((uint32_t)0x00000019U) /*!< Get received message from Rx Buffer 25 */# H( Q: M% y" P6 J, D3 g7 k! q
- #define FDCAN_RX_BUFFER26 ((uint32_t)0x0000001AU) /*!< Get received message from Rx Buffer 26 */" s! M" i3 u$ t. s b: t
- #define FDCAN_RX_BUFFER27 ((uint32_t)0x0000001BU) /*!< Get received message from Rx Buffer 27 */+ ~! f& _) P: c# S# z
- #define FDCAN_RX_BUFFER28 ((uint32_t)0x0000001CU) /*!< Get received message from Rx Buffer 28 */ u" J0 R" n7 f# L0 L
- #define FDCAN_RX_BUFFER29 ((uint32_t)0x0000001DU) /*!< Get received message from Rx Buffer 29 */
' ?# r! d) @: M6 o: q _& Z0 { - #define FDCAN_RX_BUFFER30 ((uint32_t)0x0000001EU) /*!< Get received message from Rx Buffer 30 */
( _" Z5 a' {/ {- O: V - #define FDCAN_RX_BUFFER31 ((uint32_t)0x0000001FU) /*!< Get received message from Rx Buffer 31 */
! w- C: r8 ]5 G/ Q8 { - #define FDCAN_RX_BUFFER32 ((uint32_t)0x00000020U) /*!< Get received message from Rx Buffer 32 */0 u. G$ S# V1 S% Y/ |; N. I: K
- #define FDCAN_RX_BUFFER33 ((uint32_t)0x00000021U) /*!< Get received message from Rx Buffer 33 */0 O& v# H* x2 g! [* `) A
- #define FDCAN_RX_BUFFER34 ((uint32_t)0x00000022U) /*!< Get received message from Rx Buffer 34 */% w; I5 O$ t$ M; P- i, B% c1 G4 r
- #define FDCAN_RX_BUFFER35 ((uint32_t)0x00000023U) /*!< Get received message from Rx Buffer 35 */: x2 c2 @( N( V) x, t8 c! _
- #define FDCAN_RX_BUFFER36 ((uint32_t)0x00000024U) /*!< Get received message from Rx Buffer 36 */
% F0 z1 i8 @# J) E( o - #define FDCAN_RX_BUFFER37 ((uint32_t)0x00000025U) /*!< Get received message from Rx Buffer 37 */3 L, [- T4 T. i* `; p
- #define FDCAN_RX_BUFFER38 ((uint32_t)0x00000026U) /*!< Get received message from Rx Buffer 38 */2 W4 h( |' C0 l
- #define FDCAN_RX_BUFFER39 ((uint32_t)0x00000027U) /*!< Get received message from Rx Buffer 39 */
/ [' \% _; q( S0 L. m - #define FDCAN_RX_BUFFER40 ((uint32_t)0x00000028U) /*!< Get received message from Rx Buffer 40 */
: j4 u: B" X- a& n! `3 x" E% n - #define FDCAN_RX_BUFFER41 ((uint32_t)0x00000029U) /*!< Get received message from Rx Buffer 41 */; R% s' r) U+ G+ X; L
- #define FDCAN_RX_BUFFER42 ((uint32_t)0x0000002AU) /*!< Get received message from Rx Buffer 42 */$ i7 k* |9 O! D0 _% ^) w- q6 @+ N
- #define FDCAN_RX_BUFFER43 ((uint32_t)0x0000002BU) /*!< Get received message from Rx Buffer 43 */
& B- u# A# i7 q% ~" P, T - #define FDCAN_RX_BUFFER44 ((uint32_t)0x0000002CU) /*!< Get received message from Rx Buffer 44 */; A0 H4 O. v% I r1 ^ E* s" e# ?) Z4 \7 j
- #define FDCAN_RX_BUFFER45 ((uint32_t)0x0000002DU) /*!< Get received message from Rx Buffer 45 */' L, V8 R D" U) L0 S8 e) a
- #define FDCAN_RX_BUFFER46 ((uint32_t)0x0000002EU) /*!< Get received message from Rx Buffer 46 */$ W- C3 n. S2 D/ d
- #define FDCAN_RX_BUFFER47 ((uint32_t)0x0000002FU) /*!< Get received message from Rx Buffer 47 */, G. F7 {, r7 G" L, F
- #define FDCAN_RX_BUFFER48 ((uint32_t)0x00000030U) /*!< Get received message from Rx Buffer 48 */
( m% s9 v$ v* _9 u - #define FDCAN_RX_BUFFER49 ((uint32_t)0x00000031U) /*!< Get received message from Rx Buffer 49 */& B1 g: G5 X" N7 R9 Y( {
- #define FDCAN_RX_BUFFER50 ((uint32_t)0x00000032U) /*!< Get received message from Rx Buffer 50 */
8 X" |! O1 j W, Z% R _ - #define FDCAN_RX_BUFFER51 ((uint32_t)0x00000033U) /*!< Get received message from Rx Buffer 51 */
5 a: u5 Y! R! x/ g* K4 F - #define FDCAN_RX_BUFFER52 ((uint32_t)0x00000034U) /*!< Get received message from Rx Buffer 52 */
; \1 k- B9 s# L - #define FDCAN_RX_BUFFER53 ((uint32_t)0x00000035U) /*!< Get received message from Rx Buffer 53 */
2 f! {$ I; k: `# A. ~ - #define FDCAN_RX_BUFFER54 ((uint32_t)0x00000036U) /*!< Get received message from Rx Buffer 54 */& O) S Y/ S1 b5 h0 J0 `
- #define FDCAN_RX_BUFFER55 ((uint32_t)0x00000037U) /*!< Get received message from Rx Buffer 55 */3 T5 Q9 S; O5 D3 R7 Y
- #define FDCAN_RX_BUFFER56 ((uint32_t)0x00000038U) /*!< Get received message from Rx Buffer 56 */
! e& l6 o9 n' x: k! Z - #define FDCAN_RX_BUFFER57 ((uint32_t)0x00000039U) /*!< Get received message from Rx Buffer 57 */) e* K# ^. }0 W
- #define FDCAN_RX_BUFFER58 ((uint32_t)0x0000003AU) /*!< Get received message from Rx Buffer 58 */
: g7 m- `# O# k) U7 V - #define FDCAN_RX_BUFFER59 ((uint32_t)0x0000003BU) /*!< Get received message from Rx Buffer 59 */. {2 }) E) @& g; w! U* _7 b# T. o0 D
- #define FDCAN_RX_BUFFER60 ((uint32_t)0x0000003CU) /*!< Get received message from Rx Buffer 60 */
) |/ Z" P8 q+ S7 J1 q - #define FDCAN_RX_BUFFER61 ((uint32_t)0x0000003DU) /*!< Get received message from Rx Buffer 61 */
. T2 m) C" Y7 W j, w" \ - #define FDCAN_RX_BUFFER62 ((uint32_t)0x0000003EU) /*!< Get received message from Rx Buffer 62 */' s f. a. N6 m6 `+ v) I _4 K, i% X
- #define FDCAN_RX_BUFFER63 ((uint32_t)0x0000003FU) /*!< Get received message from Rx Buffer 63 */
复制代码
, G. F0 M s. W; u4 } 第3个参数是FDCAN_RxHeaderTypeDef类型结构体变量,主要用于消息接收。) u7 @% g D4 {: }( W7 E
第4个参数是数据接收缓冲地址。
3 z& x+ P, K; d' V" l: m. ~ 返回值,返回HAL_TIMEOUT表示超时,HAL_ERROR表示参数错误,HAL_OK表示发送成功,HAL_BUSY表示忙,正在使用中。
* z( ~1 p, t6 b6 p使用举例:8 f+ {! B; E+ x" `$ T5 b
( U5 {$ @' B& ~8 ]; i# o! Z- /*
2 w5 d, D. r5 D' c+ E! P - *********************************************************************************************************/ k2 B: q- M! X0 q& a
- * 函 数 名: HAL_FDCAN_RxFifo0Callback
+ Z# Y0 F% B! E - * 功能说明: CAN中断服务程序-回调函数/ ]- d- x+ @' \3 E0 f8 X) s
- * 形 参: hfdcan% v/ H# p) J" T" p! T* Z$ L
- * 返 回 值: 无' _: \4 x7 V; _" N- I3 p
- *********************************************************************************************************
8 X& s w. ~% H- m [% l4 o2 g- q - */& g$ f5 F7 f! ]* b
- void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs)
+ x& h5 o9 `2 w6 W - {
2 I0 P. S, ?3 g1 ~5 { - if (hfdcan == &hfdcan1)) B7 l& k4 i- f2 |" z9 g+ S
- {( x: Z o9 u3 h' [/ s( \
- if ((RxFifo0ITs & FDCAN_IT_RX_FIFO0_WATERMARK) != RESET); ? x! i7 L6 w8 z/ Q; U
- {6 S% J8 I/ S6 A$ ]9 G8 F- o5 N4 \
- /* 从RX FIFO0读取数据 */
( E& {' b* D {: a; c/ B/ V - HAL_FDCAN_GetRxMessage(hfdcan, FDCAN_RX_FIFO0, &g_Can1RxHeader, g_Can1RxData);
5 O" \, C; u+ h1 b& T7 Z - & ?, r3 Q4 \, J# u- n4 U
- /* 激活Rx FIFO0 watermark notification */
+ `# v# Z, r/ b- v6 \ - HAL_FDCAN_ActivateNotification(hfdcan, FDCAN_IT_RX_FIFO0_WATERMARK, 0);/ P& T8 J1 i+ p
- 0 T9 J7 Z) ?& x ]3 u! i! [! i' P3 n
- if (g_Can1RxHeader.Identifier == 0x111 && g_Can1RxHeader.IdType == FDCAN_STANDARD_ID)
1 t8 h1 V! @/ U5 M5 W - {
$ z) ]5 y+ H# `- D O% { - bsp_PutMsg(MSG_CAN1_RX, 0); /* 发消息收到数据包,结果在g_Can1RxHeader, g_Can1RxData */
; R* j. }/ P0 w: i - }
$ k4 X$ K0 C. u+ y4 |9 E - }
^+ Z: ^) D& O* i4 P - }
: X3 [4 H% r+ r) w0 F! ? - }
复制代码 ! s$ x0 k6 g- T2 A% T7 A- C
91.5 总结( o* A( O- {7 r0 s
本章节就为大家讲解这么多,更多FDCAN知识可以看本教程的第90章。2 o9 ]6 p% t* F# \; Q& e4 W9 Z
* ?& e$ p) K4 S1 U' p5 `* C
7 u/ c' E. `$ I3 g |