|
CAN通信 CAN 是Controller Area Network 的缩写(以下称为CAN),该通信使用的是ISO11898标准,该标准的物理层特征如下图所示。 CAN协议是通过以下5种类型的帧进行的: 另外,数据帧和遥控帧有标准格式和扩展格式两种格式。标准格式有11 个位的标识符(ID),扩展格式有29 个位的ID。 大部分系统使用的都是数据帧 ,我这里使用的也是数据帧。
) ^' s$ k5 F' j* I& j% H 数据帧一般由7个段构成,即:" B: F$ W6 @2 {, C- T
(1) 帧起始。表示数据帧开始的段。
- G& w/ M5 c7 D% }0 R(2) 仲裁段。表示该帧优先级的段。6 D" n# N+ ^9 c3 S6 `% L
(3) 控制段。表示数据的字节数及保留位的段。
) U2 @" h$ d$ X. X(4) 数据段。数据的内容,一帧可发送0~8个字节的数据。
1 ~8 O, `& O$ q) e* U# p(5) CRC段。检查帧的传输错误的段。% j7 B3 F3 o3 K/ T* t+ N
(6) ACK段。表示确认正常接收的段。; R- M5 n, @% z& s
(7) 帧结束。表示数据帧结束的段。 明确了数据帧概念,还需要理解一下过滤器的作用。 STM32的标识符屏蔽滤波目的是减少了CPU处理CAN通信的开销。STM32的过滤器组最多有28个(互联型),但是STM32F103ZET6只有14个(增强型),每个滤波器组x由2个32为寄存器,CAN_FxR1和CAN_FxR2组成。
0 ~; ]2 T. @; k3 [6 |& g d STM32每个过滤器组的位宽都可以独立配置,以满足应用程序的不同需求。根据位宽的不同,每个过滤器组可提供: 此外过滤器可配置为,屏蔽位模式和标识符列表模式。 在屏蔽位模式下,标识符寄存器和屏蔽寄存器一起,指定报文标识符的任何一位,应该按照“必须匹配”或“不用关心”处理。 5 W c5 w/ B: o% F$ t
而在标识符列表模式下,屏蔽寄存器也被当作标识符寄存器用。因此,不是采用一个标识符加一个屏蔽位的方式,而是使用2个标识符寄存器。接收报文标识符的每一位都必须跟过滤器标识符相同。相关文章: CAN总线详解。 一般也都是使用标识符列表模式,这里使用的也是标识符列表模式。滤波过程举例如下: % a4 O7 e5 G0 L. E% |
# [8 e d3 Q: R2 e- v, s2 j, l 在程序中就是: - //要过滤的ID高位 ( \/ S2 G' b. `3 D& K+ n' x
- CAN_FilterInitStructure.CAN_FilterIdHigh=0X00; : H+ e7 k5 N. s* v
- //要过滤的ID低位
* F$ U1 b3 e z5 a. \! ?- W4 L( M - CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; 8 ~7 c% ?0 d3 s+ {5 u; I
- //过滤器屏蔽标识符的高16位值' o3 d# J, X5 _
- CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF; ]+ x3 d/ N7 i4 G4 u: }+ s
- //过滤器屏蔽标识符的低16位值 7 Q4 e* q8 Z1 n; T. x' l. \* h. d+ i J
- CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF;
复制代码 " T0 ]3 s+ e; S7 [9 N
这里的CAN_FilterId和CAN_FilterMaskId是配合使用的,意思是CAN_FilterId指出需要屏蔽ID的什么内容,什么格式;CAN_FilterMaskId是指CAN_FilterId的每一位是否需要过滤,若CAN_FilterMaskId在某位上是1的话,ID对应位上的数值就必须和CAN_FilterId该位上的一样,保持一致,反之则是“不关心”。! Z" z6 s: Y% [0 L. t( ^
上述程序的设置的含义就是:只接收来自0x1314的数据,屏蔽其他ID的数据。 程序思路 这里准备做一个主机与从机的通信,主要用扩展标识符ExtId来区分,分配的标识符是:
- S! ^5 M2 Q1 W1 v. K: h# R1 e: X+ U主机:0x13143 p* ]1 [6 g; L9 P
从机:0x1311 主机负责接收所有从机的数据,不需要过滤,用扩展标识符ExtId来区分不同从机的数据;主机还可以向不同从机发送信息。而从机则只接收来自主机的数据,同样用扩展标识符ExtId来区分是否是发向自己的数据;同时,也能够向主机发送信息。 相关代码 代码也是非常简单的,这里贴出了主机和从机的can.c和can.h两个文件。 从机相关代码can.c文件:
2 H- R8 P/ D( B: g2 v2 J- #include "can.h"
# a! A* ~. f8 C( K% @
; k/ r" Q' }) M. M: R4 t# j
/ ~2 w: D- ]' e- /* 在中断处理函数中返回 */
. P' V! L3 Y J( Z - //__IO uint32_t ret = 0;7 u3 W+ y4 L" a1 L
" b! E" J8 P" }7 Z' M: T/ T
) f X0 `7 s5 ?( G- //接收数据缓冲器$ k! F) f; m* T/ }6 o
- u8 RxBuf[5];8 `9 j4 k* W: Q0 E0 j. v R
- u8 Rx_flag=0;1 ^# A! y. Q, [# j, p# N) O5 h
% L: s v, y9 Y$ q+ d- % } a7 d- \ x; F
- void CAN1_Init(void)
) P/ o, P7 N& p0 S. c - {
" ^. x$ @" f- W- P - GPIO_InitTypeDef GPIO_InitStructure;
8 l# w9 S/ Y9 N - NVIC_InitTypeDef NVIC_InitStructure;8 ]; E8 u2 j5 k. c" B
- CAN_InitTypeDef CAN_InitStructure;
2 j1 B( P: a) C8 R' l - CAN_FilterInitTypeDef CAN_FilterInitStructure;
/ V8 ]+ r0 v3 B8 x2 x! y9 }7 \: r - & O+ ~, D) l }5 p! m& f" f1 F
- 0 m x' e6 |5 T
- /* 复用功能和GPIOB端口时钟使能*/
0 O& } g% w c. _; o5 f: V - RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOB, ENABLE);
3 {0 g* r' q o: |' E! I( I - 0 G1 X2 N" N: g) o+ j
4 p" C. w7 o, I2 j) g t- /* CAN1 模块时钟使能 */2 b+ f. E Y' I" l$ Z1 Z+ f1 Y
- RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
" z! ?0 v) ~- g k; O. [& C - ( l5 n; {3 ?& E9 j
- + j5 m- @6 N- u8 Z/ O
- /* Configure CAN pin: RX */ // PB8
2 S1 f3 ~: r+ @3 Z, A - GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
3 P: |4 X q+ ]# y; r - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //上拉输入
' p) f" _: {3 y% P# N! d - GPIO_Init(GPIOB, &GPIO_InitStructure);3 K5 G7 S1 c; e0 N% v% V% \
: o; m5 |" r2 c# r9 p- & C" C/ H/ N5 T, `+ K2 ?5 i" A% {
- /* Configure CAN pin: TX */ // PB9+ t/ `- y- R; h% E, v
- GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
0 _ o# n2 k' \/ e6 { - GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
; p: L* f7 o* k( _0 r& H5 C1 M' h3 O - GPIO_Init(GPIOB, &GPIO_InitStructure);
1 R! I; b+ n8 _& |* L
/ E, r8 w7 S* }, Y5 `' t; |8 W
, O7 z5 V8 A i$ r* }- //#define GPIO_Remap_CAN GPIO_Remap1_CAN1 本实验没有用到重映射I/O7 v1 V( N. H7 e3 Y! h
- GPIO_PinRemapConfig(GPIO_Remap1_CAN1, ENABLE);
* l0 j0 w$ z7 G0 _+ V( R+ W% ` - " J2 l; \$ D! T6 P8 r& {5 S7 u4 N% [# {
( b3 r7 t+ C* g0 B5 e# ?- //CAN_NVIC_Configuration(); //CAN中断初始化
4 V8 Y* p$ j9 g2 H& V - /* Configure the NVIC Preemption Priority Bits */ 9 G9 X) S) X& l( b. B- g( _5 p
- NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
6 I8 w; g9 f. Q7 h/ \3 @1 J9 y7 @ - 4 z# C4 V. o* o5 [" R* Y2 S3 R) [
- % Z3 @1 u7 \4 g# a
- #ifdef VECT_TAB_RAM / Z- y& X) b: P+ H7 u$ Y/ r; g k
- /* Set the Vector Table base location at 0x20000000 */
- m+ H+ v. S+ Q! k6 L6 L; y - NVIC_SetVectorTable(NVIC_VectTab_RAM, 0x0); & Z: x# Q( B! ~$ k! A1 c
- #else /* VECT_TAB_FLASH */6 q3 ?) `4 j; O* W4 G
- /* Set the Vector Table base location at 0x08000000 */
6 R' c* `# B/ Y$ o$ ` - NVIC_SetVectorTable(NVIC_VectTab_FLASH, 0x0);
7 Q, x( P. j( M2 ^2 L - #endif# H" R/ Y# g5 X9 \, u
& O2 e: i, v$ m: D+ j6 M" w- G2 H9 h3 Y+ z: e( ~# p
- /* enabling interrupt */
: M2 y7 x8 X* i" M- z - NVIC_InitStructure.NVIC_IRQChannel=USB_LP_CAN1_RX0_IRQn;;/ e+ i& K( O5 n. h8 s" N. v
- NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
) z# R- i- W7 v* W- x - NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;" ^3 S2 n/ u8 v. ]8 v4 Y$ Q7 I
- NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
) \3 z6 |. O6 U8 a2 O v - NVIC_Init(&NVIC_InitStructure);9 m, l$ }6 C5 ~' z
- 0 d2 U* o/ ~. l/ [7 @$ N3 g
- * j+ J! |) b+ F' T
- //CAN_INIT();//CA初始化N模块
' C( U _: S3 |1 o3 a( _+ m - /* CAN register init */
5 t) {3 A/ |" h2 X B - CAN_DeInit(CAN1); //将外设CAN的全部寄存器重设为缺省值
( p A; G% v( L3 U( R' a! @7 _9 h - CAN_StructInit(&CAN_InitStructure); //把CAN_InitStruct中的每一个参数按缺省值填入& o/ b+ T( a; [
- 1 L" `- b; P/ L( R. S$ s5 q' s
- 8 b4 o( b/ ]$ R, V8 N
- /* CAN cell init */
F" }8 h8 A+ V - CAN_InitStructure.CAN_TTCM=DISABLE; //没有使能时间触发模式
& `# u: o+ O* A+ n0 X4 w2 G - CAN_InitStructure.CAN_ABOM=DISABLE; //没有使能自动离线管理6 m- U. P8 Z+ p/ A7 R
- CAN_InitStructure.CAN_AWUM=DISABLE; //没有使能自动唤醒模式
U8 l. | I5 c, C5 E, B( | - CAN_InitStructure.CAN_NART=DISABLE; //没有使能非自动重传模式, B; F" F7 K' w5 ~! q3 }
- CAN_InitStructure.CAN_RFLM=DISABLE; //没有使能接收FIFO锁定模式" l/ N+ K8 o6 _8 @
- CAN_InitStructure.CAN_TXFP=DISABLE; //没有使能发送FIFO优先级4 R8 ^' s" T* O1 Y* [* g
- CAN_InitStructure.CAN_Mode=CAN_Mode_Normal; //CAN设置为正常模式0 R$ e( U9 z1 K/ L0 `/ A: _
- CAN_InitStructure.CAN_SJW=CAN_SJW_1tq; //重新同步跳跃宽度1个时间单位
) v" n' _' C/ c9 \ - CAN_InitStructure.CAN_BS1=CAN_BS1_3tq; //时间段1为3个时间单位
. x! D7 I9 f4 L' K9 h - CAN_InitStructure.CAN_BS2=CAN_BS2_2tq; //时间段2为2个时间单位
% V% L j8 Y8 y1 |1 S& @5 q - CAN_InitStructure.CAN_Prescaler=60; //时间单位长度为60 j+ R. k4 v. n7 ?& H
- CAN_Init(CAN1,&CAN_InitStructure); //波特率为:72M/2/60(1+3+2)=0.1 即波特率为100KBPs
$ S" S: Z# m& g! S- q( g+ [ o' r - 2 q3 C+ [. i l$ U+ {; N
, o" o7 ^1 ~0 Y- // CAN filter init 过滤器,注意,只接收主机发过来的数据,屏蔽其他数据
+ G# n3 d( H8 i5 [8 \ - CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1$ `- @1 q# X9 A
- CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式+ z& `, G" A6 v0 b
- CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位% a B/ F0 G' ?" l/ d, }8 J
- - _; @. T& V- n6 q
2 u+ Z4 u1 _# a- //CAN_FilterInitStructure.CAN_FilterIdHigh= (((u32)0x1314<<3)&0xFFFF0000)>>16; 5 y% Q; [$ I2 {$ N! k6 {& D
- CAN_FilterInitStructure.CAN_FilterIdHigh=0X00; //要过滤的ID高位
8 S2 h+ l1 u. w0 ~ - CAN_FilterInitStructure.CAN_FilterIdLow= (((u32)0x1314<<3)|CAN_ID_EXT|CAN_RTR_DATA)&0xFFFF; //要过滤的ID低位
( ]9 p, R5 F7 w - 9 n8 Z3 U* ?5 P( T/ d2 j
- $ w+ k1 K3 E) j
- CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0xFFFF; //过滤器屏蔽标识符的高16位值4 l4 ?2 c8 t; J1 R4 g/ |% g
- CAN_FilterInitStructure.CAN_FilterMaskIdLow=0xFFFF; //过滤器屏蔽标识符的低16位值
/ r/ T7 B) m- J- L7 B7 G - CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0, `) \6 g |' m/ {5 w" c
- CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //使能过滤器; v0 T2 \/ P& O4 J* l
- CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器6 ^( S7 Z4 \, w/ P. H! R
/ D: O3 j: o2 V W+ A) f+ c- 2 p, E0 ^3 o* @( X* ~, s3 b: z
- /* CAN FIFO0 message pending interrupt enable */
9 v: c$ B7 P& C) E K6 C - CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断# Z7 G, t( ~, L( \1 P( ?+ w# _
- }
/ ~$ N; r( z' k# e8 S* Q - : H& a7 |* e1 p: ~: C3 p
- & H) r9 A( I1 W
- /* 发送两个字节的数据*/
) G, p2 F: G) ]( S* {. l - u8 CAN_SetMsg(u8 Data1,u8 Data2)- }% {$ ^& E# q: b
- { N& g. V, w4 t4 x" l
- u8 mbox;& T; _: ~- s0 N# r9 k
- u16 i=0; 2 M" Y+ ^ _/ x$ [+ E2 H
- CanTxMsg TxMessage;
% Q1 q6 _) W- E7 W4 K. ~
) S v0 R% e- b0 P7 i! w+ p9 ?
: K) p0 n( e! o/ C+ f- TxMessage.StdId=0x0000; //标准标识符为0x00' h7 a( Z9 C& K& G: _6 k" w
- TxMessage.ExtId=0x1311; //扩展标识符0x1311,可以更改该标识符以示区分不同从机, K: s# l4 G# Q- {3 {; {
- TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
+ N3 F% l3 i3 N% i - TxMessage.RTR=CAN_RTR_DATA; //为数据帧, Y' y/ b1 a; ]% v
- TxMessage.DLC=2; //消息的数据长度为2个字节
6 K" K% Y( ^& @ - TxMessage.Data[0]=Data1; //第一个字节数据; v4 ]3 u0 e( j
- TxMessage.Data[1]=Data2; //第二个字节数据
; k4 h- } f. Z$ b+ i& Z - 9 j r) |- V* @: M0 p$ \" b6 M$ `
0 U% Z& F( M C' b* B- //发送数据: X$ g. `2 i1 h
- mbox= CAN_Transmit(CAN1, &TxMessage);
- R" n+ T( Y2 g - while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))1 {# \# o' S/ V* z9 B5 J" B
- i++; //等待发送结束3 U9 q. \" i! `* z0 y# [
- if(i>=0XFFF)
# V% n+ e5 X9 E3 W# w - return 0;
8 R: b6 F$ H7 c+ `9 T( C9 n# {; G9 s - return 1;
2 w: R7 b0 U1 @2 V; @6 g - }
8 j3 C4 H+ W8 C - u8 CAN_GetMsg(u8 *msg1,u8 *msg2)- \ [ z2 o8 j& e, f9 B
- {$ y) n0 f/ @2 U9 i5 W- J
- if(Rx_flag == 1)//发现数据9 D& {. @# J. F' N; D
- {
; l& R# j" T* E+ t- I# } } - *msg1=RxBuf[0];9 t1 R) @; W4 [+ y6 G( Z7 a
- *msg2=RxBuf[1];" I, u. p, K7 B; l
- Rx_flag=0;//数据已经取走,可以更新数据6 d' {9 r4 {3 r0 H1 j
- return 1;
0 s) P: I/ b/ M6 Y4 R# L - }else) A$ ^% S9 q4 m# E/ g
- return 0;! K5 n* n- S, t3 R0 d$ R
- }, N$ B8 j* c' `) Q* L8 n/ @
- /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */
( D0 V* r$ F& }8 s* @, V+ i s - void USB_LP_CAN1_RX0_IRQHandler(void)
- ~) e0 Y ?; a/ V0 y5 i( \ - {: T* [" n( J1 B5 S* h+ j
- - x2 _! d1 M# s( m% ?0 ^
- 4 r) ^0 D* Q6 t5 ?
- CanRxMsg RxMessage;5 _0 T4 N D1 I7 @
- 5 x- T( f; ^: {# u2 a- J- A
, w9 ]% S7 G$ }1 p+ P( H8 K" N- RxMessage.StdId=0x00;
. E% E# z" R7 W! p9 p2 a4 n - RxMessage.ExtId=0x00;3 ~6 N! o# N0 P/ d/ X& J
- RxMessage.IDE=0;
4 s& F3 z" q( O0 @( R- P! ] - RxMessage.DLC=0;; Q6 Z1 G, D9 @1 W
- RxMessage.FMI=0;
0 U$ o& T0 M+ v9 ?: ?/ s' j' [6 d - RxMessage.Data[0]=0x00;
7 v9 l J- l4 I9 f" W' g, p# M - RxMessage.Data[1]=0x00; 0 G3 l; c) J2 {. ~
- c' e s/ r, O
- : R9 s: g1 n3 x0 H5 _& @
- CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据 7 c5 N5 \, x0 O$ s
- 2 P0 M: M6 N' K7 C) H- Z
1 r( g e5 M0 h. ?1 X# W7 f: ^/ s- if(Rx_flag == 0)//数据已取走或者缓冲器为空
; V p8 a4 p3 B5 \! K# _ - {
1 k% J5 ]; V3 _) O# z# R* r - RxBuf[0]=RxMessage.Data[0];
$ z* Q+ z/ U5 u4 w - RxBuf[1]=RxMessage.Data[1];- s4 U2 U; Y' n
- Rx_flag=1;//数据已经备好,等待取走7 `3 m$ J- _9 `0 A
- }. ]- ?5 g( C' }, M8 l
3 m- S: [" h9 b) J' k- 2 }& Z" \5 c) v9 ^
- }
复制代码 , I5 N4 P8 g, Y
can.h文件 主机相关代码 这里主机代码大部分是和从机类似的,就只贴出不同的地方了。3 Z( k+ H( K4 o h! B9 l+ h
can.c文件:
% [4 L+ E1 v( w' m1 r" c- #include "can.h"
2 z7 d% q7 t' Y: ~( J2 M7 \ - $ a: }& K2 ?! X; O" `4 C
1 f; y4 D! W* ^# A8 i- /* 在中断处理函数中返回 *// B; j* U; \4 }& ^, b4 D8 {$ y
- //__IO uint32_t ret = 0;
# x( [* g. {: a" V& ?2 }& z - # h. J0 B& B& k! q( y, n- q
/ N2 e" H3 I# I- void CAN1_Init(void)
" Z9 C5 x6 y% t4 u9 C6 ?2 \ - {
/ P, x$ n0 x ~7 ?" P- k - ......//以上与从机部分相同; l2 s" A/ L: i3 ~$ x
6 _0 R7 r' P |% j; p- . A% ~- h! Q3 O1 M# ^ [0 `
- //CAN filter init 过滤器,已经设置为任意,可以通过ExtId标识符区分从机代号5 n/ s0 e% l+ o
- CAN_FilterInitStructure.CAN_FilterNumber=1; //指定过滤器为1
* C/ h6 Z7 y* |+ d( [) z1 ^4 j1 r - CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask; //指定过滤器为标识符屏蔽位模式
0 H( M3 i4 s5 i3 ], D - CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit; //过滤器位宽为32位
' B& B2 g, k9 I {0 E - CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000; //过滤器标识符的高16位值
& k$ e" w, ?8 ?& h1 O5 j8 }+ } - CAN_FilterInitStructure.CAN_FilterIdLow=CAN_ID_EXT|CAN_RTR_DATA;//过滤器标识符的低16位值
) s+ P9 R5 `/ V. o }5 _ - CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000; //过滤器屏蔽标识符的高16位值2 W' R! {/ B9 P1 @! U/ K- U
- CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000; //过滤器屏蔽标识符的低16位值1 h1 K, Q% ?- r" Z, P' _4 W: M2 X( D
- CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_FIFO0; //设定了指向过滤器的FIFO为0
) F. N3 ]; z9 W8 H% ]3 }* |( Y - CAN_FilterInitStructure.CAN_FilterActivation=ENABLE; //使能过滤器! s- G, T; o8 }+ J
- CAN_FilterInit(&CAN_FilterInitStructure); //按上面的参数初始化过滤器
* y! I9 P9 i* Y( W& L
! R7 k1 _! c" ]1 v" d( x* M- 1 @; _: s' y4 G& ?7 }% W' }
- /* CAN FIFO0 message pending interrupt enable */ + V% |* w# t* H' ?
- CAN_ITConfig(CAN1,CAN_IT_FMP0, ENABLE); //使能FIFO0消息挂号中断" x, \8 a' e) m C8 c1 g6 o
- }; b+ A3 ?) V$ c, m
9 t+ ~: [7 u) g' J- ]* w- ) n7 E. @$ w: n1 x4 b+ k: S1 X
- //接收数据缓冲器
/ `8 c7 ^( b' K& `- ?2 b - u8 CAN_RX_BUF[CAN_RX_LEN]={0}; //接收缓冲,最大USART_REC_LEN个字节.
) F* ^. L, ?8 j' r6 k9 w$ ` - //接收标志位+ y. e5 V/ F+ @9 C. p% ~
- u8 Rx_flag=0;
% W1 S- {/ o" ^0 O - /* USB中断和CAN接收中断服务程序,USB跟CAN公用I/O,这里只用到CAN的中断。 */ ^( C; H9 E: _
- void USB_LP_CAN1_RX0_IRQHandler(void)
& Q5 t" h) X9 Y8 W- b) ~ z - {( K: Q }' d. u
- u8 i=0;- t. r9 E1 Q, w
- CanRxMsg RxMessage;
' q. h9 ` D' v/ M0 Q - , a; ^+ t7 U7 ^4 U [& K h
* ~( d" ~: ?/ ~5 C5 C" w- RxMessage.StdId=0x00;
1 v& f- D& ]6 X: t7 r% b! K$ D4 E - RxMessage.ExtId=0x00;
$ g/ A. p9 z# b/ F* r - RxMessage.IDE=0;$ u4 Z" K2 ?' z+ K) l- {( c
- RxMessage.DLC=0;$ y2 v g6 F3 Y7 o
- RxMessage.FMI=0;- `! I! L2 b. }9 D, D4 F
- 2 \% L! t+ T! n! N% W$ O' d
$ _$ C! w. b0 n) B- CAN_Receive(CAN1,CAN_FIFO0, &RxMessage); //接收FIFO0中的数据 . K+ J% H6 K' e* A! _) c+ G+ a
8 L; u" a" u. E7 u( P3 Q5 P7 l% s
& J! @ t+ Z7 _9 t" F- if(Rx_flag == 0)//数据已取走或者缓冲器为空7 T6 P4 r7 u/ }3 j- v
- {6 I( f V$ o; F& B2 e9 T, l( K
- if((RxMessage.DLC) == 2)//是否收到2位字节数据
! ~5 n: c0 I8 `! O - {
+ z$ G; N( X a/ ] - CAN_RX_BUF[0]=RxMessage.Data[0];2 A8 m0 l6 w2 _% ^) [5 {( n. W
- CAN_RX_BUF[1]=RxMessage.Data[1];
, G: N+ e' M5 w/ ?! G+ @ - }. U a' f; k1 D# d) D
- }% L/ u9 s! x/ C3 T2 R
% V! p( x+ m! f! B" V8 \- 0 u+ ]$ h6 B! |0 ]" {
- }
7 }( f# F% _4 u! y" N
& p" k. o9 ]: ^
2 p$ e. ?- |2 ]# A' P2 j0 Y- /* 发送两个字节的数据*/0 }6 s) I) v$ F) T3 a
- u8 CAN_SendMsg(u8* data1, u8* data2)+ R( z1 K# Z ^ o& g
- { 0 t2 V" e# I& K+ D$ R0 O" m
- u8 mbox;
' {* i+ [# l |/ S$ a8 S; E5 A - u16 i=0;
. d! e% h* y) H9 U( b6 N/ l - CanTxMsg TxMessage;
$ i5 G" u% W( C2 b5 B& ~/ B - $ P: |0 W; Q. ?
- 5 _/ L6 a: O- O% g1 z
- TxMessage.StdId=0x0000; //标准标识符为0x00
0 e+ G6 w8 U& @; Z - TxMessage.ExtId=0x1314; //扩展标识符0x0000
( s1 J! i R z8 s - TxMessage.IDE=CAN_ID_EXT; //使用扩展标识符
, ]8 i2 B9 b3 b0 T - TxMessage.RTR=CAN_RTR_DATA; //为数据帧9 A2 f' A8 s3 m5 b" o# H
- TxMessage.DLC=2; //消息的数据长度为2个字节4 C& E: y! c0 K
- TxMessage.Data[0]=Data1; //第一个字节数据* R" s0 j/ E0 D* u, t: w- B2 P
- TxMessage.Data[1]=Data2; //第二个字节数据
) h+ _+ F: R- e - ) Y' z9 b. ^5 Y$ U8 P3 j6 e
- , T8 s% n. q' r% l( m. N
- //发送数据/ D0 o' C% _ x! V# [' Y7 [6 V- a, T
- mbox= CAN_Transmit(CAN1, &TxMessage); 9 |/ r8 h3 Q% m- @
- while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF))
3 R6 w8 i2 ~+ [7 e* ?, d% i; [. E - i++; //等待发送结束
: N! h) P7 F- c* q' E- {2 ^0 h% n: ` - if(i>=0XFFF)
! v' x# S# c2 M - return 0;//发送失败
0 C+ a- W3 z- e+ c: I - return 1;//发送成功 ' U6 \3 c' C1 g8 f9 N
- }
8 x7 f1 K+ B) o) Q5 U" I. @- d - u8 CAN_GetMsg(u8 *msg1,u8 *msg2)
0 l# d* Z4 ?+ D1 Y - {8 |- {! }* m& ~7 K& D& O& h
- if(Rx_flag == 1)//发现数据: z% M' O4 e0 S" Q! I+ ]& o! x
- {
+ W8 _' X7 i* M3 G& C- F0 \ - *msg1=CAN_RX_BUF[0];
5 G: v/ Q7 P ]9 \" m Z5 N( O - *msg2=CAN_RX_BUF[1];
* F. k6 X0 W3 a+ F - Rx_flag=0;//数据已经取走,可以更新数据$ X* j* `0 J2 M9 [4 w5 W% j
- return 1;0 r# T: o6 t+ f8 _/ q
- }else
/ M0 w( k5 K) @% J9 | - return 0;& w4 g0 ^5 g' N- L7 J
- }
2 X3 m4 W, H5 X2 S" I; L5 c - void Clear_canBuffer(void)
; ~& e; d$ L$ v( i4 {, u2 ` - {" M% i: j1 r# m$ z
- Rx_flag=0;//清楚接收标志位6 R* ^5 p0 l/ \- P
- memset(CAN_RX_BUF, 0, sizeof(u8)*CAN_RX_LEN);//清空缓冲区2 F1 R$ f$ E# x" s5 g5 o" l4 ~! m
- }0 W# U: ?! h6 }! L6 c/ _& Z
- u8 Check_canRX(void), W9 ?; G" y9 j/ r
- {% B3 V/ }; t4 _4 E% K' M `
- return (Rx_flag == 6);5 K7 }, x* U# z1 e( y
- }
复制代码 9 R6 V9 s( ~" a5 {" g: }# n
can.h文件: - - Z" h/ n! Y e! _% s* P( M6 D
- #ifndef __CAN_H
0 b2 E/ r# H: [/ y3 C! I% c1 K& p - #define __CAN_H
1 w; ~0 y. z2 m* I# Y, C - # y Q x" l# h9 Q
, H' R4 z( U q; { R- F- #include "sys.h"
* i, Q7 b( W R - #include "string.h"' w7 J8 `+ p5 I: H. B5 c
2 M! q3 E4 h" f+ k& k
) j( X& U& s5 z2 v- #define CAN_RX_LEN 30 //定义最大接收字节数 A a) o5 L9 e* o( U
- % Y; q2 B2 y u5 m+ a/ h
) q ]9 [# @4 k- extern u8 CAN_RX_BUF[CAN_RX_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 ]) N5 ~* f2 o) K7 y* H& _* }7 i
4 Q# h" ~" s0 ~! D: r9 G3 C: i! ^
6 u( n" }; ]' g3 A3 Q- void CAN1_Init(void);
& w0 U7 B" W- F5 y9 T* n - u8 CAN_SendMsg(u8* data1, u8* data2);5 K! u1 i) u) w O( Y
- u8 CAN_GetMsg(u8 *msg1,u8 *msg2);
8 e2 D, l3 l1 V0 }+ Y2 F6 C
: d" o6 |: l' o% N8 F- 8 i" |3 x' v6 r* G
- #endif /* __CAN_H */
复制代码
' g8 c, D3 ]8 m. T: y% @& \ |