CAN控制器通过两根线上的电位差来判断总线电平

' e4 p- V4 T! r' @can.h
" P; F+ c! [5 m: U$ o

1. #can.h
   
2. 
   : R( J# m$ ^! b9 Z$ _
3. #include"stm32f2xx.h"
   & C% [& E+ J* E4 x( w' ^  f4 P, I4 R
4. 
   * y' y7 Z# o2 _1 a
5. #ifndef __CAN_H_
   3 s' x6 K" o5 ]0 Z% x
6. #define __CAN_H_
   
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   9 R4 V( \7 U6 C! A/ g- t
9. 
   
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    3 J: \5 Q" D( x
11. 
    
12. u8 CAN_Receive_Msg(u8 *buf);
    
13. 
    
14. #endif

复制代码

can.c

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   
3. #include"can.h"
   
4. 
   
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   ! Q8 ?. O7 A  `5 |. k1 K
6. {
   
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   1 t* H# k  _7 f' t& K; b" o
8.         CAN_InitTypeDef CAN_InitStructure;
   
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   % u. M* U: y' r: u8 ?
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11. 
    
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    ; ]* e+ L$ n  L! Q5 o; U7 _
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    
14. 
    
15.         //GPIO初始化
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    8 V- ?% W* \* D' o' A& }! G
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    ( y6 r( A' o/ s/ t5 Z0 f
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    
22. 
    
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    7 W  p2 q2 B/ T
25.         
    
26. 
    
27.         //CAN初始化
    ! O8 Y; S$ E" Y" ~$ ^/ k
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    7 V* U2 v" {- s
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    3 g) P- R) f7 Y' E# V
31.         CAN_InitStructure.CAN_BS2 = CAN_BS2_ytq;    //时间段2的时间单元，取值在CAN_BS2_1tq~CAN_BS2_8tq
    
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    6 m  N  c' w# |3 j% \1 d5 }
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    
34.         CAN_InitStructure.CAN_Prescaler = Prescaler;         //分频系数(Fdiv)为brp+1        
    
35.         CAN_InitStructure.CAN_RFLM = DISABLE;      //报文不锁定,新的覆盖旧的  
    
36.         CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;    //重新同步跳跃时间单元，CAN_SJW_1tq~CAN_SJW_4tq
    5 F, _- F0 B9 X7 n$ d
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    / l+ a$ ?. I: R! t/ Q
39.         CAN_Init(CAN1, &CAN_InitStructure);
    
40. 
    1 I. p* _, l8 y! w; o" G/ l: U
41.         //筛选初始化
    $ h9 r# N* C0 ^9 g( y8 R0 T! D; |
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    7 t9 K  h+ u  O8 f; E& Z
44.         CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;    //32位ID
    
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    # x% \* s; q; k  |% e6 A( v% R9 J/ W
47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    
48.         CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;    //屏蔽模式
    
49.         CAN_FilterInitStructure.CAN_FilterNumber = 0;    //过滤器0
    & [" N3 u" J  X  l8 z$ A7 s
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    3 o* D+ ~+ S; m' b+ q. o  |8 Y9 Q
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    ' \1 b8 c$ R3 m( z6 E1 @/ U
52. 
    
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    $ z: _' \! f- w) D
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    9 W. C! H6 B' ?3 h
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    
58.         NVIC_Init(&NVIC_InitStructure);
    6 z$ w: j9 n9 y- @8 Z/ q$ g
59. }
    
60. 
    
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    7 r" X  ?: s+ j* V* M' f0 |
63. {
    8 R. G1 o0 g; j6 t
64.         u8 mbox;   //邮箱
    
65.         u16 i = 0;
    
66.         
    ' A+ a8 W6 j4 I; A7 i& T/ q+ I
67.         CanTxMsg TXmessage;    //can发送结构体
    
68.                
    
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    7 U9 Q6 d* B* L# M- a/ `( m( g
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    + J1 k& ?1 H  c! y7 T3 l3 Z/ m
72.         //TXmessage.IDE = CAN_ID_EXT;   //这里的帧类型也可以设置为扩展帧，在USB_CAN那里设置标准帧，传输记录中会有
    
73.         TXmessage.RTR = CAN_RTR_DATA;   //...can.h，传送的是数据帧
    
74.         TXmessage.StdId = 0x12;  //标准标示符
    
75.                
    
76.         for(i = 0; i < len; i++)
    ( C( j/ x* u7 }2 a. O; m
77.         {
    8 w+ L+ q* M5 b9 @1 v- h5 `: J
78.                 TXmessage.Data<i> = msg;
    : Q" q$ {5 {6 p3 |! Y
79.         </i>}
    
80.         
    
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    
82. 
    
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    
86.         }
    
87.         if(i >= 0xFFF)
    
88.         {
    8 K) C/ Z* O) i: D* y+ ]
89.                 return 1;  
    
90.         }        
    ; U6 A) @3 `" j1 |% `1 f
91.         return 0;
    
92. }
    
93. 
    3 Y3 E! @/ x) b! d: i$ [
94. 
    
95. 
    
96. u8 CAN_Receive_Msg(u8 *buf)
    # |( {9 w' v4 n- X; ^3 a. x/ ^
97. {
    6 k) t6 [. M, D( ?) M9 H
98.         CanRxMsg RXmessage;         //can接收结构体
    ) S2 R3 j/ G& {3 F
99.         u16 i = 0;
    % n: O$ k/ w% ?" C% C  w
100. 
     
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     ' C. s: i2 ^, K
102.         {
     
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     3 R2 R5 R3 a; b8 d1 Y! m" O, Q2 d1 C
104.         }
     0 Q0 M4 O! q' Y: H$ U$ h: K
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     $ C' Q& V2 T. W
106.         
     
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
     & A' d) @* U: ^
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     
110.         }
     + `% Y) ~0 {2 Y; ^( L
111. 
     - p5 }* i3 B1 b/ e4 g4 r$ R% L
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

led.h
$ a7 R: d9 i$ R' m( X) J

1. #include"stm32f2xx.h"
   * `6 ~+ ]' ^5 l7 S: z9 U
2. 
   
3. #ifndef __LED_H
   9 L! }* a7 o# q! `
4. 
   - s. L: D: I6 C4 s
5. #define __LED_H
   
6. 
   
7. 
   
8. void LED_Init(void);
   & P) C  \( R* j0 |" }
9. 
   1 C% M4 l$ C/ |# k* Q: U% g
10. void Delay(vu32 nCount);
    9 B& H3 [' m) Y0 c
11. 
    9 s9 {  E7 D; w7 F
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    
13. 
    & z$ f/ X4 ~3 _) R
14.         
    5 ~6 g: t) w4 n2 ~9 b- \3 D
15. #endif

复制代码

led.c
+ ]$ n$ j7 {. x! a3 e

1. #include"led.h"
   
2. #include"stm32f2xx.h"
   
3. 
   9 i0 }3 R) q% w' {( t& K3 u
4. void LED_Init(void)
   - X5 x" ]) A3 m- I- ?
5. {
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   # s1 @' n  L, v
7.         
   ' b1 q3 f: V, x! Z+ T- b- v
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   # g% x9 }; A3 c$ h, M
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    # u6 p$ A% m* J" y3 r) z! A6 v
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
14. 
    
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    # @2 A7 L: Z: l. q# L
17. }
    
18. 
    
19. 
    
20. void Delay(vu32 nCount)
      O. {! ^5 F) P2 P7 \0 [/ I0 }$ M
21. {
    
22.   for(; nCount != 0; nCount--);
    : G4 b" e/ f7 {& z! e" ~
23. }
    ( h, c7 I7 x, K% y9 C8 P7 U
24. 
    # R  x$ `5 P- T* L+ r
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    3 }: S6 R0 J% U8 T/ Q+ k( Z
27. {
    7 \* i0 V) p( X% x
28.   switch(LED_NUM)
    
29.         {
    
30.             case 0:
    
31.                         if(OFF_ON == 1)
    
32.                         {
    2 N  V% L+ G9 k0 X6 |
33. 
    
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    4 E( r" {" g8 |; w
35.                         }
    
36.                         else
    " {* K2 P* g4 D& Q9 h, ?
37.                         {
    ) L& ]" }# P. m  y- z& `
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    9 b8 k: ]$ E- [. A% {8 s
39.                         }
    
40.                     break;
    ( f. U. s, D: `+ J" ?  _& h
41.                     
    
42.                 case 1:
    + d: c4 ^& _+ N- O  D, j
43.                         if(OFF_ON == 1)
    ) {7 F  b' ~2 K6 x$ t% I
44.                         {
    
45. 
    0 c! ]: A+ x( z- M8 R
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    $ u1 U* a% C# P, ^' r$ L
47.                         }
    
48.                         else
    
49.                         {
    
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    
52.                     break;
    
53.                 default:
    
54.                         //GPIO_ResetBits(GPIOF,GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10);
    
55.                         GPIO_SetBits(GPIOD,GPIO_Pin_11|GPIO_Pin_12);
    1 ?; T2 G& g& l, m% a) D" v
56.                     break;
    * k5 o7 W6 m* D: P$ v; z8 s
57.         }
    
58. }
    6 l# z) |( l# T
59. #endif

复制代码

main.c
* I, u- e+ o2 X7 T

1. #include"stm32f2xx.h"
   2 \8 i- r6 L2 C' p
2. #include"can.h"
   
3. #include"led.h"
   % [/ i3 O4 X) p; P) A3 @
4. 
   7 _" K3 F5 D3 i8 }" b( q
5. 
   
6. int main(void)
   
7. {
   , X8 u$ B# N6 c  H
8.         u8 res;
   ; P, z& r9 ^2 l9 d9 ]% t" t& J
9.         u8 key;
   7 e: p  T6 k% j* `$ B; y
10.         
    7 Y/ w+ O4 a$ H! h6 X% G
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    1 C7 G, [. W% g/ ~
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    * l7 ?4 J2 ^5 f! e
13. 
    
14.         LED_Init();
    / \: \" ?" S! K( y0 G9 E
15.         Delay(168);
    . b* e/ ~% Q$ c) q. ?
16. 
    
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    / j/ O3 R/ C3 w4 o3 v2 M: p5 D
18. 
    
19.         while(1)
    4 F" y* b* S$ C/ F
20.          {        
    ( U6 r/ S; n8 z# v. T
21.             //1.接收数据
    ! m* `0 c( @+ V# d$ D7 c! o* q
22.             key = CAN_Receive_Msg(canbuf);
    
23. 
    
24.                 //2.解析数据
    % G1 ^% U' t- _) O' ?
25.                 if(key == 0)
    ; o# V  V* U. S/ [
26.                 {
    
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    ) ~4 Y" Z. r/ N( q5 z% C& I, E
28.                 }
    & h0 \2 S" Y; R& y# d
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    1 L$ {+ ~+ {8 Q: [& |
30.                 {
    
31.                     //3.发送数据给PC
    & G7 m0 X# K4 r- e6 A
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    , Y4 p+ l# Z1 t2 `; O
34.                         if(res == 0)
    
35.                         {
    # |% P9 r* B# ]" p3 Y- E" B
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    ' H5 v5 Y7 Z( _8 v5 q
37.                         }
    % l  f$ L+ H6 M$ W
38.                         else
    
39.                         {
    
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    
41.                                  
    % l& e9 j4 s5 V1 q- g4 J
42.                         }
    , S" z& B' ~9 a) I/ S
43.                 }        
    
44.         }
    
45. 
    
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    + s+ N  A+ q& b, c2 O
47. //若数据发送失败，熄灭led灯1
    
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    / }: q+ C# L* I4 H2 _6 T
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    ) k% q: s' j6 {6 f4 a" v: Y9 Z; N6 }
51. /*
    6 a6 U; L, ?" J1 S0 N
52.         while(1)
    
53.         {
    3 {% t7 r2 E" m  ^. `# W
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    
56.                 {
    
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    
58.                         key = CAN_Receive_Msg(canbuf);
    
59.                         if(key == 0)
    4 c# U; @- ?6 U
60.                         {
    $ p! r, w% Y" P, }2 P7 a8 r
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    ( U. s  i' \$ q8 A' z$ l3 ^
62.                         }
    
63.                         else if(key > 0)
    ! K2 Q1 i: c/ u1 ?- \! u
64.                         {
    : l: |# H7 u/ h% \% Y% X5 Z
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    
68.                 }
    % t( {, D% E& n/ q- b
69.                 else
    - W: `$ f- d2 l6 V
70.                 {
    
71.                         Delay(5000);
    
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    5 Q% w" i" r, J' z1 @( W
73.                 }
    
74.         }
    
75. */        
    7 Z2 O. A2 b! I$ F0 `
76. }
    9 Z5 q' L) Y$ Q0 j) P/ ]& Z( ^
77. 
    1 R0 C  c- f& q, b

复制代码