CAN通信
7 ]+ }3 i" L0 t8 } CAN 是Controller Area Network 的缩写(以下称为CAN),该通信使用的是ISO11898标准,该标准的物理层特征如下图所示。+ P5 I8 C& _& t7 e* S/ N4 y
9 n& J" A* i$ Z. e# A8 H
: N+ M- ? m7 @! q f; G
0 z9 ~: I8 T, {# w+ _4 D CAN协议是通过以下5种类型的帧进行的:2 B; r% ^' r+ V" q4 ?8 A. C8 Y
数据帧
: P# W7 ~' y' r摇控帧3 B+ u2 I7 f D5 |4 ^" C' c
错误帧$ _7 @% r2 X4 l6 R( p
过载帧& _1 V! B' |) }# ^7 f$ c
帧间隔
! s2 i6 I3 c$ `! r# X+ F! n, q3 \& V
. [0 o7 F( Z- z# V 另外,数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符(ID),扩展格式有29 个位的ID。' I4 ?# q2 e# x" P1 t7 W
, u; e/ j0 W' K- G5 X; a" }+ L
大部分系统使用的都是数据帧 ,我这里使用的也是数据帧。
' D9 K! r4 b" l, d 数据帧一般由7个段构成,即:
F1 {* m6 U: c. J(1) 帧起始。表示数据帧开始的段。
7 s, |8 D8 M3 O4 ^(2) 仲裁段。表示该帧优先级的段。* a3 v. l0 |4 n
(3) 控制段。表示数据的字节数及保留位的段。' j7 X) ~# H9 f0 W. Q0 C
(4) 数据段。数据的内容,一帧可发送0~8个字节的数据。- N" K2 U. e4 L& C: K3 {+ X0 t
(5) CRC段。检查帧的传输错误的段。* q0 ^3 h8 R$ d/ f* M
(6) ACK段。表示确认正常接收的段。! H* O, t; G: v
(7) 帧结束。表示数据帧结束的段。* m7 f0 i4 v/ v: T. j: m
5 d, q7 W; P' Y1 R: w4 D
明确了数据帧概念,还需要理解一下过滤器的作用。
( z9 m# d9 o: G" V
' v- r2 c, T" `( E( g8 S STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个(互联型),但是STM32F103ZET6只有14个(增强型),每个滤波器组x由2个32为寄存器,CAN_FxR1和CAN_FxR2组成。9 {( I" X. ]1 X& F4 w: L
/ H7 ~+ D9 f/ Y/ p* ^. J7 k1 T
STM32每个过滤器组的位宽都可以独立配置,以满足应用程序的不同需求。根据位宽的不同,每个过滤器组可提供:
' | |9 Y+ l+ ~# d7 W1个32位过滤器,包括:STDID[10:0]、EXTID[17:0]、IDE和RTR位) n9 \; j3 F; _
2个16位过滤器,包括:STDID[10:0]、IDE、RTR和EXTID[17:15]位4 u* t8 J1 B' i; a6 Y& S: q1 f8 Q6 |; R
5 ~$ Q7 r! {% W4 Q: D8 B8 `* Q 此外过滤器可配置为,屏蔽位模式和标识符列表模式。. f3 u+ b# n" D' u
2 p: _( |/ c4 r9 ?
在屏蔽位模式下,标识符寄存器和屏蔽寄存器一起,指定报文标识符的任何一位,应该按照“必须匹配”或“不用关心”处理。
7 J% z' F/ y+ A" H2 p9 M+ ]0 Q
0 [ T8 M- h3 r6 O3 _; m8 _: _: m 而在标识符列表模式下,屏蔽寄存器也被当作标识符寄存器用。因此,不是采用一个标识符加一个屏蔽位的方式,而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章:CAN总线详解。# Y0 w, |4 k- K' e9 e) O t
; Q+ k9 Y6 r+ N" V
一般也都是使用标识符列表模式,这里使用的也是标识符列表模式。滤波过程举例如下:' ]+ U1 ?- }( v: V. Q4 z
5 d9 x" A# ?! O4 J2 y8 Y
/ M$ c9 H9 P1 m \- x# D
+ R$ s' W& t8 D2 J 在程序中就是:! u6 O+ Y& V* e- L5 }
- //要过滤的ID高位# x1 Y9 C9 Q2 k
- CAN_FilterInitStructure.CAN_FilterIdHigh=0X00; + z! I0 v$ b6 z, j. ?3 S m+ T9 r
- //要过滤的ID低位 # i& L+ L: l( v( R" T* b( g
- CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF;
. G. ~" Q( i" z# G5 R& E; v, x - //过滤器屏蔽标识符的高16位值
7 n- [5 Y' ]* v, i, ?6 S - CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF;
! e( o6 F7 o0 w+ r* Q& N - //过滤器屏蔽标识符的低16位值
& ~/ j+ n1 f' M7 I - CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;
复制代码 7 x: Y9 [8 @6 L d [& ~
这里的CAN_FilterId和CAN_FilterMaskId是配合使用的,意思是CAN_FilterId指出需要屏蔽ID的什么内容,什么格式;CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤,若CAN_FilterMaskId在某位上是1的话,ID对应位上的数值就必须和CAN_FilterId该位上的一样,保持一致,反之则是“不关心”。
) I+ G: j" ?/ [$ o9 ]5 }( B9 G) C, o- J+ |! q" x( w' F: I! N: l* Z. l4 G
上述程序的设置的含义就是:只接收来自0x1314的数据,屏蔽其他ID的数据。
) j6 i0 [9 y. C' {
' w& r$ `, s: b程序思路$ z: B# \9 r5 ^% E0 Y
这里准备做一个主机与从机的通信,主要用扩展标识符ExtId来区分,分配的标识符是:
0 F' j5 z/ W+ l6 q) k7 m主机:0x13142 ]2 U- U( w, Q* ]* c2 _
从机:0x1311& {$ O- [1 R7 G( W0 Q+ _4 V
" m/ ^9 J; h R' X
主机负责接收所有从机的数据,不需要过滤,用扩展标识符ExtId来区分不同从机的数据;主机还可以向不同从机发送信息。而从机则只接收来自主机的数据,同样用扩展标识符ExtId来区分是否是发向自己的数据;同时,也能够向主机发送信息。! i9 F+ }8 Y+ s6 P
! s$ c* w7 B5 U) W
4 X, m. _ B, K$ O* y! x2 U相关代码
e- M. Z, i9 n) s8 u4 z* V 代码也是非常简单的,这里贴出了主机和从机的can.c和can.h两个文件。' B0 n. g8 _ t
, ^! k0 _" ^1 h# C4 A* q& D
从机相关代码3 s d0 M _) C1 _+ z; m {
can.c文件:' Z& G& |* L4 G w ~4 @
- #include "can.h"
) d4 `7 q2 v$ Z, @6 f - x2 Y/ b( n6 }' m! }; N
: ?5 x" L: R% ~0 a* J# c; ^" \. z
. q: H+ k' l6 ]7 A# C
4 q8 L5 N7 N5 V! s0 d4 Z- /* 在中断处理函数中返回 */
& z; Z; @9 [5 v0 V) d* r* } - //__IO uint32_t ret = 0;
% ]5 x" c# B$ |5 H: @ - A5 ~ u7 ]- M' a* m
- 9 H. w! T! W5 o0 G4 o+ n& m; ]% s. m
/ a% w) W6 {; i" d( O
; C' C. p. l: a2 u0 w- //接收数据缓冲器# N$ w% {5 y% h2 j0 K/ o- X w
- u8 RxBuf[5];
4 @ I8 W) h5 o) g8 p, r6 P0 u - u8 Rx_flag=0;
' X2 g, P3 F: Y$ E& e
* c7 i0 N! G' t+ `/ T; ~) E
6 n" m. E/ F- ?& k3 ]2 s
& l; j7 L% V9 @( M. r$ k; `
0 B+ v) X0 o# W! ?5 q9 k& a- void CAN1_Init(void)
% B7 Y7 \, M! m6 Z/ R* i+ K3 B - {1 @( \3 `: l% v- m! V6 ^: T; P
- GPIO_InitTypeDef GPIO_InitStructure;
" i2 @. \/ s9 @ - NVIC_InitTypeDef NVIC_InitStructure; |* p% @' d; z: Y$ J7 }% y/ ]
- CAN_InitTypeDef CAN_InitStructure;* a8 D: t2 I1 K0 A+ o
- CAN_FilterInitTypeDef CAN_FilterInitStructure;/ h1 }4 t1 q; J" b
- 9 A e7 _$ F5 X4 {6 L, l
- # o4 h: P" N- B: U3 a" P' b8 _) C) ^
- - E; r! M2 w$ M! Q+ T
- 1 d6 b, {5 W. Z7 |
- /* 复用功能和GPIOB端口时钟使能*/
" j& ?* d. l9 w) H" j: f - RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE); # ]1 A4 |* C% ^# Y$ R
- 6 l8 L! G4 ]( D3 L4 J# ]; p/ E# n0 b
- h: L6 @0 p% Q9 _2 m
$ q, [& X3 I0 `. o, C: I+ V- + B! s( y& @/ r+ X$ n' ^
- /* CAN1 模块时钟使能 */
7 |. \$ E2 ` m: j- }- ]' u - RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);6 P3 O$ h9 F& o1 c
- ) R+ n+ j3 _* ]) k8 @
& O; r/ S2 W# [! l+ H- A2 H2 D- , j9 `- M, ^1 j z$ {) P A; z
- 1 I0 t3 r( C. B: Q! t' X
- /* Configure CAN pin: RX */ // PB8( G0 K1 @) D# ]1 p1 j8 u
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;9 y. w: H; {. \8 b5 i3 U) {
- GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入" k3 S/ k% e3 G" q
- GPIO_Init(GPIOB, &GPIO_InitStructure);
1 d6 }* I9 `8 R - 6 u9 u, r6 n2 s0 d! r
- ; X# |! S! t( ^. `
- 5 u4 ~8 h. h1 |) O0 r
- # b9 e, X2 ?$ [6 `. {
- /* Configure CAN pin: TX */ // PB9
9 O/ P$ y5 C2 z8 J$ T% I - GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;% B5 g% l0 y5 ~* W
- GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
3 M+ q1 L# z8 l2 J4 D - GPIO_Init(GPIOB, &GPIO_InitStructure);
9 w+ Z t: Y; a& J1 O! g: } - 7 L, W; }! _$ q* z1 v; N
8 l, }- U2 ^9 P% n7 ?0 B% l- V2 p% I- j2 t' }0 t
- + i6 Q' _' ^; g" {
- //#define GPIO_Remap_CAN GPIO_Remap1_CAN1 本实验没有用到重映射I/O. S! |! M! J" h: y' d8 l3 K X+ n) n
- GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
5 _/ n9 p8 K! ]' J U1 k
/ {8 W, ~3 Q/ N& v: T
* E4 ~' o6 e$ ^" o" M. c' q
% B3 \( L+ |1 L! [$ A
9 o) K$ _* t0 K2 g0 a* k# ^6 E- //CAN_NVIC_Configuration(); //CAN中断初始化
& U4 n8 ^* a6 S; H1 y. W# N4 y - /* Configure the NVIC Preemption Priority Bits */
7 @8 v5 J, y6 i8 {' V k - NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);" a2 }4 q) N2 d8 g" E
; v" U6 i* l6 B
/ D. v3 w3 m5 R! y: N7 |" Y2 Z( ~- 1 h7 A' F5 n! h. G
' Z8 a. ?5 E H7 b( m M) ~- #ifdef VECT_TAB_RAM
! n% M5 c: V0 V0 l: R - /* Set the Vector Table base location at 0x20000000 */
8 N9 b: j! _; V8 q: | R% O - NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0);
$ A3 `$ k3 E, s) V, {$ I: N - #else /* VECT_TAB_FLASH */
I7 @9 l- a% ~ P$ {9 I" H - /* Set the Vector Table base location at 0x08000000 */
* y# t6 s& r* N3 U - NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0); 1 z& N- D7 ^0 h; _
- #endif
3 v0 U% A+ W$ |# |! [
5 q. N. N0 w; d& S
; [) C# |" d, A# @& y1 {8 y
0 Z; c# V' Z5 p& k- # w; X2 h4 N, V$ B
- /* enabling interrupt */( U* x+ ^2 {0 P w8 U
- NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;: _+ b9 E4 T: f' M" j! o e
- NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
& } X; Z) z' A8 R9 s ~% S - NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;: }1 Z! l+ C" _' s& c% E8 A
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;9 K* P3 F3 X' w& n
- NVIC_Init(&NVIC_InitStructure);0 ^& U+ F) P# L m M8 i
- 1 Y& a0 o) T/ w1 f( y
% J, l2 v! J/ f4 e9 I/ `- / n5 k2 M. S6 A2 H) w: a' X0 |
+ H7 z, \2 b8 |- //CAN_INIT();//CA初始化N模块( N* b9 t6 S5 f2 s
- /* CAN register init */- U, N F7 R- B% m
- CAN_DeInit(CAN1); //将外设CAN的全部寄存器重设为缺省值
5 o# K4 A4 I, |7 Z/ @ - CAN_StructInit(&CAN_InitStructure); //把CAN_InitStruct中的每一个参数按缺省值填入+ C- [- M# I2 V. v2 J; F; O
8 y. {" v! g* a; w1 f4 U8 o% `$ H0 E- ) J0 ?/ B$ r; U2 |" o2 G
. I5 `1 c/ e; _: M: E# r6 a R9 \
# q/ K3 s% \1 h# O: S5 m+ S" W- /* CAN cell init */
$ E: `% T; r2 Q/ G) o - CAN_InitStructure.CAN_TTCM=DISABLE; //没有使能时间触发模式
# T" T. o$ j/ G( H - CAN_InitStructure.CAN_ABOM=DISABLE; //没有使能自动离线管理
8 H' B k% S6 x0 ^( J5 }6 } - CAN_InitStructure.CAN_AWUM=DISABLE; //没有使能自动唤醒模式
- [. h" N; x4 a, U t$ p% ^ - CAN_InitStructure.CAN_NART=DISABLE; //没有使能非自动重传模式" n0 a& ~0 U7 [+ j0 u/ h
- CAN_InitStructure.CAN_RFLM=DISABLE; //没有使能接收FIFO锁定模式9 a7 F; k @8 ~+ Y ` v
- CAN_InitStructure.CAN_TXFP=DISABLE; //没有使能发送FIFO优先级6 \; b, T5 Q( u: x3 t
- CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式
! \3 z0 R* X9 W A - CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度1个时间单位
2 w, }; g5 u6 X& j1 z9 N4 L - CAN_InitStructure.CAN_BS1=CAN_BS1_3tq; //时间段1为3个时间单位
" u" ]7 s& T% g2 H# i- r7 Z5 x5 l - CAN_InitStructure.CAN_BS2=CAN_BS2_2tq; //时间段2为2个时间单位
I" f$ E! o4 m H7 m - CAN_InitStructure.CAN_Prescaler=60; //时间单位长度为60
: d* P" [2 n9 G$ r - CAN_Init(CAN1,&CAN_InitStructure); //波特率为:72M/2/60(1+3+2)=0.1 即波特率为100KBPs4 e/ ~( n- ~+ m' L- g
5 T k( t" F6 M6 I- $ O( F5 W- U; e- e! A" ^+ ?8 J
- 2 G/ k; S1 A \( j5 t& |4 [9 P" C
% m( q! P# t* j' P2 Y' ~/ n4 N- // CAN filter init 过滤器,注意,只接收主机发过来的数据,屏蔽其他数据2 V+ R% m1 A6 s1 M% U' o* w& P% ^% C4 j- G
- CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1
0 e/ m7 n8 L4 p5 q - CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式8 A: p. x" F5 Q% g
- CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位* H1 |5 E, S+ ?& d
- 4 _$ q7 r5 q2 H, Z2 a$ d. y* `
- , F' g$ q) G& L7 O( n* J: Y4 k/ k
- " O/ k1 Z4 X% @
v# j1 b+ w/ N% C- //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16;
* r! E( G1 ^9 F1 t - CAN_FilterInitStructure.CAN_FilterIdHigh=0X00; //要过滤的ID高位1 s! h* u+ y5 d! j$ n
- CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位$ e I. f' T1 n$ {, M
% y0 l/ L0 X& s6 f8 K- / a- `$ o5 Y( q
- 2 J3 q* Y x5 g
- - A2 [5 n4 N: _) o) u+ T6 y
- CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF; //过滤器屏蔽标识符的高16位值1 [8 ?/ ?& y" o" G/ y2 g2 q
- CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF; //过滤器屏蔽标识符的低16位值
. ~) e) c8 B+ \$ \5 M/ y - CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0
5 @6 \. R3 I4 _0 m- m/ W - CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //使能过滤器
# k# k, O' @; p* c# l$ _ - CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器6 g9 B% h* u9 n1 I3 P
* I* \: F+ U2 o1 i0 [
" i n0 [. `, X8 o3 c8 y9 G
" ^, l7 k& _+ @6 t+ z
8 a) n1 Y" F/ F$ r- /* CAN FIFO0 message pending interrupt enable */. p# s8 J7 b4 D& j2 O
- CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断) p( q& Y! i/ }- g
- }
3 [" K0 C2 S) Q
5 g0 S1 {6 j5 Z) O
+ O& t7 T6 j2 E' j' Z, x5 Q. l
7 D5 B& ]1 T6 T3 \) C
0 X' e( m5 \' c; ~+ b! S) X- /* 发送两个字节的数据*/5 D U' T7 a1 M, U
- u8 CAN_SetMsg(u8 Data1,u8 Data2)5 O+ R$ w: ~; c* i& _% t
- {
L7 e% m6 k6 d* F1 v/ I' S7 e - u8 mbox;
& N( _- _; W# G2 ? - u16 i=0;
% T+ \6 y! H3 ^" K - CanTxMsg TxMessage;
8 b6 ?1 z- p$ P. i4 V
% R3 g& V9 q0 y, Z& m- , _, v+ O0 \6 c& s Q
- % \$ ]5 ]! d6 S% q$ K! Y
8 I( Y7 G6 i! [2 A- TxMessage.StdId=0x0000; //标准标识符为0x00
- r' c, ?% o0 e) C% d - TxMessage.ExtId=0x1311; //扩展标识符0x1311,可以更改该标识符以示区分不同从机# O& m" F- g/ ]0 f3 f2 q4 e
- TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
7 p& h" b9 _+ p6 w - TxMessage.RTR=CAN_RTR_DATA; //为数据帧. j- K# w0 z) K$ R$ s, M6 y* @' I
- TxMessage.DLC=2; //消息的数据长度为2个字节* y0 c7 d6 `8 ?' W! {
- TxMessage.Data[0]=Data1; //第一个字节数据
$ q* Y( {+ v4 {" p6 Z3 ~ - TxMessage.Data[1]=Data2; //第二个字节数据
5 V6 x+ }) O8 W0 K - - D4 H6 c8 L! S. Z
- $ f3 `% G" V1 o8 x8 T
. v4 C4 C/ `' w$ v
( ]% i: I7 a2 m) b" O0 ~# T* x- //发送数据6 Y( _. z P3 Z/ Z9 A
- mbox= CAN_Transmit(CAN1, &TxMessage); 7 o" l2 Z: W% T1 F+ \: }" N
- while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
6 D( K+ w' Q | - i++; //等待发送结束2 V7 z2 n% f0 H6 S4 i
- if(i>=0XFFF)0 V; _+ e3 S) O& M! X/ I
- return 0;" @/ t7 E6 b. m, |0 I
- return 1;+ ]- @, t3 `9 `. W( }
- } n) c' `" E& a2 }
- u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
8 \" A; {( l; \ - {
& D, j! C: G8 q H1 i* w, E1 h3 i - if(Rx_flag == 1)//发现数据
4 ~- b: d& s4 u# \- A - {+ h" R+ A. X! V" C8 c
- *msg1=RxBuf[0];
: D: _, [1 u5 c, Q4 V4 R/ d4 _ - *msg2=RxBuf[1];
* ~( C2 f: j' Z - Rx_flag=0;//数据已经取走,可以更新数据$ m5 y, Z1 X* d. O; C
- return 1;) y0 D0 t5 R6 f5 g- g, C
- }else: P: ~, _6 d5 C; Q9 M: O
- return 0;1 A5 [' V. c" h, ~
- }% S+ f9 a ]8 I. Q- n: t8 p% a; {
- /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。*/) b, B9 f; z+ k9 P8 H0 W
- void USB_LP_CAN1_RX0_IRQHandler(void)
. A9 K r' Y h8 ` - {1 C& e, s" s4 [0 P5 [# Z* N' n
- % E* _6 i2 H" R
- # n: t8 h$ j! I9 @) O9 v7 Y7 M
- : j# o9 R. s/ N3 o
- & N9 r% W2 u9 I! U" C" D+ h) l
- CanRxMsg RxMessage;" v3 ^* q) d( s+ ^* i# d, i
- 5 [; w% e, O; Q4 U9 ^
: N1 I( j4 j: s
! ^: j3 B. A* `. l) ] Z- ! Z2 m3 h o1 R9 {/ }
- RxMessage.StdId=0x00;
4 N0 Y0 h$ G- F2 A0 P# k1 h E$ } - RxMessage.ExtId=0x00;
4 `. X, B% u+ x5 ?4 M$ s - RxMessage.IDE=0;* j' t( `6 @: i5 w: E2 P/ { {2 _. {
- RxMessage.DLC=0;% |5 l' M* ?; N7 S
- RxMessage.FMI=0;2 k9 o9 A2 M9 Z' u4 Q* h
- RxMessage.Data[0]=0x00;& V8 O" m4 B/ U2 Z# T
- RxMessage.Data[1]=0x00; ; \ p: Z* Q9 y9 _" _/ m+ T7 `4 _
- 9 h. h0 z1 ^2 O* u- S2 ]. L
0 J \( J. k. D0 O t% b- 1 ^/ \1 i% F( W
- ) \8 h3 v1 J, n# n4 Q2 X
- CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据
0 m5 E0 e. X8 B1 t& Z! ^! ~: N
9 L2 A: [ h+ d# b7 E, [/ u$ P- 8 e8 C4 n( i& W5 Z4 M+ N$ o
- 2 U( d5 r D/ G' l6 q8 ?6 @9 l
- $ }2 X7 r9 l; f8 t. D7 v9 R- a1 l
- if(Rx_flag == 0)//数据已取走或者缓冲器为空. q- W- L1 D( A- F
- {
6 i0 Z( f( H$ n; h$ ]7 D - RxBuf[0]=RxMessage.Data[0];" e( Z4 z" R" ? x) P3 c
- RxBuf[1]=RxMessage.Data[1];
" G ?7 b- A$ o+ v+ I7 L - Rx_flag=1;//数据已经备好,等待取走 s+ @( ]2 E$ f0 \" l; m7 g
- }
7 W$ ?; P8 b( I& R4 e) w; N - ( d: K7 f" l9 b; [
- ( o" y% { O4 M% ~: Q$ T% l
- ' ]0 V- D! U. O7 |" D
- 1 s0 _4 g" _+ v/ v, c; O R
- }
复制代码
4 R/ A# e- J1 l' X. ]can.h文件
, ^7 X' d$ V$ G9 s9 y7 ~- h1 X( @+ ]' ]6 r: D- o
4 C) }! k1 d* x1 d z, n
( H h7 ~% E1 B主机相关代码
8 k/ T! M/ \5 K. x. ^ a2 `/ X+ H 这里主机代码大部分是和从机类似的,就只贴出不同的地方了。" r2 B) i. a! a8 d/ j! n3 j+ I
can.c文件:
$ Z( _% v5 @' K' }, l+ i; g- #include "can.h"
* U3 o! w1 o, y - ' x* \( Z; ?6 S1 F: R8 h, C8 L
- 4 ?9 g1 D& d+ n+ m
- /* 在中断处理函数中返回 *// d# A. C: ?" y5 n# Z5 J+ U
- //__IO uint32_t ret = 0;
$ | l, [# m7 N: F% T4 j - 2 a9 Z N( a/ P% g2 P: g& W
- # e6 M7 U/ Q. X9 V! q( R3 Y; ~
- void CAN1_Init(void)
' g, [( o* C& R* C' f - {8 u, Z; H. k7 C/ ^! i
- ......//以上与从机部分相同' Y( E {# G. N8 p% B! T1 c/ w
4 H3 ^( \+ T6 O6 y0 [3 k- - n3 w9 H6 l8 s2 b, c
- //CAN filter init 过滤器,已经设置为任意,可以通过ExtId标识符区分从机代号, |8 ~; g: S& \/ T( F3 N5 }
- CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1
% _' Z' t6 ?1 U3 w - CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式
, r% J1 s. m# [0 g3 L4 r, [% h+ X - CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位7 L; Q" Q8 } n$ E+ m) M% _. L
- CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000; //过滤器标识符的高16位值
8 K' N4 A+ P4 U( B* U. J - CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值$ Z. V- k7 L% t
- CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000; //过滤器屏蔽标识符的高16位值! V; i$ U; H* K! z2 d4 p$ j
- CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000; //过滤器屏蔽标识符的低16位值
u. F9 m4 Q! q$ y: f - CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0; p( O! h$ ^! `+ i6 b9 S) z& N; H
- CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //使能过滤器
& U* c Z- D6 N5 z+ a$ O8 s4 N - CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器& R& m1 H/ X& W4 m1 E% Y% W
- 6 l3 m$ v0 m* E' T5 p2 { _
$ k- J, r0 k0 e- e) S, [- /* CAN FIFO0 message pending interrupt enable */
! g4 R. I L8 o1 \8 L - CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断
! H6 h$ W/ Y- R1 g X - }; s2 [7 q; `8 M3 C! J1 T' b6 u
- 8 i# a! r U+ R& v" O1 l
/ D& g! q. F( t" ~& B- //接收数据缓冲器
* z* ^1 g! U$ ~& r; v# ]8 Q& m - u8 CAN_RX_BUF[CAN_RX_LEN]={0}; //接收缓冲,最大USART_REC_LEN个字节.
0 K3 `1 i) D( R - //接收标志位
9 |6 W, n1 p* u. }$ U, q9 s - u8 Rx_flag=0;
/ @ V. P4 O; K' i1 W o8 U - /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */! x2 g$ C( V6 [2 c: E; g4 W
- void USB_LP_CAN1_RX0_IRQHandler(void)* o/ S5 ^3 a+ P% E O& R% J: s1 B
- {
1 k$ C2 i# g' i - u8 i=0;, s% u. {( \. u" F J& D" G; f W
- CanRxMsg RxMessage;
/ L+ A# \9 W5 i5 f, C
0 ]$ i' q. i1 Q( F( |6 E( x
$ q- |1 N6 K- d- RxMessage.StdId=0x00;& _- i3 n5 a# u3 [! q
- RxMessage.ExtId=0x00;7 i& [. l: ?+ W; ^% L( w9 @5 X+ R
- RxMessage.IDE=0;
* i" |# `1 N! a& J7 U2 f: q( A( r - RxMessage.DLC=0;
% ~5 L3 {# `1 {$ ~ - RxMessage.FMI=0; _ z; U& E) B
) ]0 a% ]7 a1 G0 j! [# ]
8 H+ V* \7 m- T% _4 w& z9 [3 K8 I- CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据 * `) |5 r, s% z. d
- 0 F9 y$ _; l3 w3 O* R) i$ y8 O
- $ ^- M% h1 \1 o2 h& I; o. |5 m
- if(Rx_flag == 0)//数据已取走或者缓冲器为空* O, s0 ^* P* _* h4 s, G
- {4 u0 L: M1 W5 Z( h! `) e! l9 \
- if((RxMessage.DLC) == 2)//是否收到2位字节数据" W2 G0 Y; D; ~3 ]- L" y
- {
. i# L0 t, d) \) @3 z# R - CAN_RX_BUF[0]=RxMessage.Data[0];: L' M$ z. |. \2 {0 _
- CAN_RX_BUF[1]=RxMessage.Data[1];
) x9 d* j+ n+ I/ `! V - }
4 T2 Q) U% @3 @' m: \6 S K - }
# @ @6 a1 Z9 J9 W& E - 5 w3 c/ |( n+ D# C
# L* v- V6 d9 D3 W6 x! g- }
% I; }: ~- r% w7 a3 R
- G$ Z* j5 d8 K3 P9 ?1 o* R
; S- w l3 z" V% N* p! I/ u4 C) a- /* 发送两个字节的数据*/0 b1 [2 s7 k: h5 i, F3 k2 T
- u8 CAN_SendMsg(u8* data1, u8* data2)
( C) U$ V6 p* n: {2 F% j - {; Q _/ Z: x3 Y# W' f2 z8 i0 T
- u8 mbox;( a4 l* A, y8 {1 w9 `4 C
- u16 i=0;9 I/ C& G9 _ A/ v! T- u
- CanTxMsg TxMessage;
' e% U7 @5 e4 j5 D3 i* M; M' a - 3 t+ A# d0 L p
- + {) o4 h5 `6 l# i
- TxMessage.StdId=0x0000; //标准标识符为0x008 y. q+ I# U+ u. C" x
- TxMessage.ExtId=0x1314; //扩展标识符0x00009 q' y3 B8 g4 y8 M
- TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
9 @7 `. s1 n1 l# m - TxMessage.RTR=CAN_RTR_DATA; //为数据帧
# ~4 E( h+ G9 W - TxMessage.DLC=2; //消息的数据长度为2个字节 w& G. P; H$ U: |
- TxMessage.Data[0]=Data1; //第一个字节数据3 F1 q$ E% M$ |& N, ?+ W: x$ O
- TxMessage.Data[1]=Data2; //第二个字节数据0 Z% m: }( `' `" T% I
, Z. {: |( w, E) J
+ z3 [" s, b% O" ?5 N- s- //发送数据/ G7 n s2 L. R6 ?* P9 j# s4 i
- mbox= CAN_Transmit(CAN1, &TxMessage);
0 P/ C1 r2 l- ]$ x% j; F - while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))7 n0 g( o" j8 B; |: ]
- i++; //等待发送结束
' k5 @8 n+ e2 h - if(i>=0XFFF)" v# ^# C5 c2 X- ]) q: V
- return 0;//发送失败
, [) h- v; I y8 V, j9 J - return 1;//发送成功, s3 s6 q9 P4 Y! ^/ @2 ^
- }
1 C0 t9 ~3 }# M2 G1 d& ^# v" @( u - u8 CAN_GetMsg(u8 *msg1,u8 *msg2)8 I( a4 m" A8 A9 c5 |
- {$ f' `' r( h$ R, l; u9 P- l8 R
- if(Rx_flag == 1)//发现数据
; \$ a! t/ U+ D0 l) G - {' l+ O8 h; R' W5 D; B
- *msg1=CAN_RX_BUF[0];/ d K6 F( P0 ?" k% s. ]
- *msg2=CAN_RX_BUF[1];
?) `7 M5 I! \" ? - Rx_flag=0;//数据已经取走,可以更新数据/ {0 g( p, ~, m9 R/ ]
- return 1;
" v. p# q6 Y. t1 Y% u! r+ n& d# w - }else
3 A1 c+ V/ z0 ~. m6 H - return 0;' Z$ t. a& E4 o a/ r
- }- d$ m) k+ \) W
- void Clear_canBuffer(void)
3 t3 _, A" y. x7 k$ h - {
; z8 C0 A$ O5 p% G$ Z& M" h - Rx_flag=0;//清楚接收标志位% Z+ H* D* R4 i! M
- memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区0 Q& ]5 D9 R3 ~
- }$ K3 T6 a, Q2 l7 Z6 C& P1 M
- u8 Check_canRX(void)
$ e5 }$ i' Y* Y* Q' F! n4 s - {# h/ G; \* K) U7 } x9 L+ k2 z
- return (Rx_flag == 6);
0 P8 }" R# M6 e4 T+ V+ ~ - }
复制代码
0 |- G A: U, G2 R) s* n
& y n! A; s' R/ K1 j$ bcan.h文件:' B; g7 `* ]8 I7 N& Q8 \2 u
- #ifndef __CAN_H
" H3 x5 m( Z8 f' o - #define __CAN_H- y1 J* A- T; ~" u( W' N
- + v* ^, t) c' |; m. R
- 7 J5 n7 U( e) p8 f/ o* I
- #include "sys.h"5 u; h# _3 b, n9 J6 ]
- #include "string.h": F6 M6 X1 d, g S. e' j! u
- 9 i' C' Q7 l1 F9 h* ]) }, g
6 y* u+ C# C: ?& g- #define CAN_RX_LEN 30 //定义最大接收字节数6 V0 m& s7 N, c
& H. S$ z& w7 O" Q9 t. V& j- ~
) y6 E3 y# _* R5 c; E/ O- extern u8 CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符* J3 d ?( [8 \5 n; c
5 R1 | Y; ~; I( |( P! B8 n
8 }. R1 Q/ |4 H/ F+ Z' [/ X6 z- void CAN1_Init(void);7 G* [) m. u. _# N) g6 n
- u8 CAN_SendMsg(u8* data1, u8* data2);! L1 l( I$ u! \; Y" A' {5 [( R
- u8 CAN_GetMsg(u8 *msg1,u8 *msg2);* U& Z# { Z/ o2 a8 t
# ~0 e0 C6 g1 c
; e' j' @% l& _- #endif /* __CAN_H */
7 H: d) v. H% f! Q; G' |/ F
复制代码
. g7 Z; o( w% L3 y3 v$ [8 k
0 q N M0 N" P h5 [转载自:单片机与嵌入式
y- e; a% W9 z! n3 t) P% b- g z4 N9 S% z
如有侵权请联系删除
" w* |$ u! ]) l9 N
+ M- E5 u6 I& k; t& V5 I- n
- Y- p; R2 _5 ? n
0 N( |$ U' Y- `- ~; }/ b! q' V1 V7 b# Z
4 i. t( W+ q( a6 U0 x0 P3 W |