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

6 h# |  m4 Q0 P! X' ~* Xcan.h

1. #can.h
   
2. 
   
3. #include"stm32f2xx.h"
   
4. 
   - H9 ]- O9 o& h
5. #ifndef __CAN_H_
   
6. #define __CAN_H_
   ' f7 z) Z  h$ K+ D
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   
9. 
   ! t0 Z0 Q* h! v2 F
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    9 u4 A7 }2 Z: N0 d- O/ Q$ G
12. u8 CAN_Receive_Msg(u8 *buf);
    
13. 
    $ [4 A5 h5 f" Z, H
14. #endif

复制代码

& ]* T$ n) N, `- a  A; l/ Wcan.c
+ [  S' p* Y4 y: l# o- V

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   3 s+ U% R' W0 q5 v. h' [9 l
3. #include"can.h"
   
4. 
   
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   - _0 l5 ?+ K- x- G. J/ p- Y
6. {
   ; F3 i- g" T. k2 D2 @5 K" K
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   
8.         CAN_InitTypeDef CAN_InitStructure;
   4 H& _' o9 S! \1 Z0 i1 n, s* ?
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   " D; P: Y9 A) ?& y( [
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11. 
    
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    $ U3 k9 R: b& B7 ?
14. 
    5 d( \2 o# {; n: F1 w) B! j
15.         //GPIO初始化
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    * S! M3 h1 F. j# ?5 x+ m' b2 s
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    $ w+ y& L2 I  j, F) D  c& E/ ~
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    ; D& d' T  b; f' l( b* K) |
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    6 k; d& T, t1 A4 N9 L
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    ' G- ^: }# u5 W
22. 
    
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    & U3 b) w! N! F* Y0 v& M& h) Y+ W9 e
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    , ?) m- c# T3 X6 F' T/ I
25.         
    + r6 e0 A# _8 s8 t' {
26. 
    9 l8 A( }0 a" ^; H0 H
27.         //CAN初始化
    
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    0 R) ?: ?# t" }1 C7 I6 L
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    ! C' B2 ~  H& Q  s9 n, N5 i$ ?" N
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    ; j! C5 p/ b5 }1 Q' Y4 y
31.         CAN_InitStructure.CAN_BS2 = CAN_BS2_ytq;    //时间段2的时间单元，取值在CAN_BS2_1tq~CAN_BS2_8tq
    / D1 f2 G7 _& h  x
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    ' o2 M0 D1 L0 ^! A1 v4 @& _! y+ a
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    - G/ @( z6 M; K7 g8 L# S/ Z
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
    . M! d# w# T- N/ M
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    2 Z. V, u) X6 P8 Z9 i
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    
39.         CAN_Init(CAN1, &CAN_InitStructure);
    ; G) {1 f! [6 H: }6 {2 y2 k4 s
40. 
    
41.         //筛选初始化
    
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    
44.         CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;    //32位ID
    
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    : g, d; A5 O7 Z  _. I0 {
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    8 z5 x! i' C% E4 @5 Y
47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    
48.         CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;    //屏蔽模式
    
49.         CAN_FilterInitStructure.CAN_FilterNumber = 0;    //过滤器0
    
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    0 s1 B# f' P: T0 h. E' F
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    
52. 
    
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    , ?: C, U7 F5 w( c: e2 |5 L! z
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    ' Y1 _. C& r( C, P7 i2 F) }- ?
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    . g+ t! P- `4 [
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    
58.         NVIC_Init(&NVIC_InitStructure);
    
59. }
    
60. 
    
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    
63. {
    
64.         u8 mbox;   //邮箱
    % i. i4 _$ R7 D8 t
65.         u16 i = 0;
    
66.         
    * H1 V7 H: o1 B2 ^* G, c
67.         CanTxMsg TXmessage;    //can发送结构体
    . U1 q/ V& O( c0 W# }! s& W4 W: _
68.                
    
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    - X6 q% I2 d- v& n) g6 h
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    
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++)
    
77.         {
    2 Y  V8 r* S) _# K3 W8 w' n
78.                 TXmessage.Data<i> = msg;
    
79.         </i>}
    , O! M9 f* r8 L) J, o4 J
80.         
    
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    
82. 
    # W9 Q: G* Y$ c" }, u) d
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    % G% ]$ R$ R2 f  h/ T
86.         }
    + r2 O/ y  L2 C) p4 L. j
87.         if(i >= 0xFFF)
    * u) \4 D8 n7 T$ g' K! V& y+ o9 H2 D- M
88.         {
    
89.                 return 1;  
    
90.         }        
    
91.         return 0;
    
92. }
    
93. 
    2 F5 a' I3 J6 {
94. 
    
95. 
    0 u  w+ w: Z7 E5 O' K! I& P
96. u8 CAN_Receive_Msg(u8 *buf)
    # k; \0 V0 B: o6 j# W( w% o  h, u
97. {
    
98.         CanRxMsg RXmessage;         //can接收结构体
    
99.         u16 i = 0;
    
100. 
     
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     
102.         {
     9 `; g7 `: Q0 b2 n2 ?
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     * p( S7 ^& o: S& e2 e% s; G2 k
104.         }
     
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     3 V: K! [7 m$ ^- \8 C9 P: C/ k
106.         
     2 r6 F- G' ?7 A! i1 H- y/ d
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
     - V' ~) q5 y$ C: r+ r8 M, a: q- M
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     % `) q9 \- f8 X( X, V
110.         }
     - m! S5 }+ S% m. m7 L
111. 
     
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

led.h
/ P& `- J/ X: ~& {4 Y

1. #include"stm32f2xx.h"
   
2. 
   - E- ~0 @9 O- m3 r! X8 F/ m, C1 Z
3. #ifndef __LED_H
   
4. 
   * r( @' B# C) ?" `. b
5. #define __LED_H
   
6. 
   8 \+ [3 w4 y8 l1 k8 V, D( b
7. 
   
8. void LED_Init(void);
   ! V& l# Z5 w5 D8 Y
9. 
   
10. void Delay(vu32 nCount);
    ) G( Y, A# u$ ~7 y: [9 B9 z( ?0 V
11. 
    
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    - z3 A! D" E! r7 k$ J1 p+ m
13. 
    5 B2 T3 T0 Q+ N7 n# b
14.         
    2 ?  ~. Y, c8 o, W5 }" o1 j
15. #endif

复制代码

led.c

1. #include"led.h"
   
2. #include"stm32f2xx.h"
   
3. 
   
4. void LED_Init(void)
   # E$ T" D% c0 O
5. {
   " F/ n% X: H' X
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         
   ( n( S6 f  _6 [7 \3 w
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   # k+ a) P0 d2 a+ X5 V6 ?! q
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    , Q" P+ A8 x, L2 y) A$ s
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    ! c% l/ n" j/ j" C: ]" l% r
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    9 w* H8 ^( [( n' t2 m4 J# ?
14. 
    . n3 A) x2 F* W2 c" d* t
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    
17. }
    : o) E% X% o0 b( K6 P9 W+ ]
18. 
    8 k  T  H7 `9 M3 b( Y
19. 
    + Z4 e- V4 e; U' a
20. void Delay(vu32 nCount)
    7 b" x6 D7 |" T6 ?
21. {
    ' i6 c  Z6 z, y0 J% Y
22.   for(; nCount != 0; nCount--);
    ; J) N% @) s1 g' b9 h+ }: J+ D" r
23. }
    
24. 
    . ^% q; Y* d7 d- K: [/ F: y
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    6 b! H* ]6 E8 m7 Y# n$ I
27. {
    ) a5 r2 P4 }1 {% I) I3 a" g* w
28.   switch(LED_NUM)
    
29.         {
    
30.             case 0:
    " q: P4 h  v# q# e* a3 X- g5 L; B
31.                         if(OFF_ON == 1)
    
32.                         {
    
33. 
    
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    ; ?8 G! F7 ^) G
35.                         }
    6 L) C5 v4 c5 `2 x  E1 G
36.                         else
    
37.                         {
    
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    2 M- |  u, [5 \8 [6 ]# O; P
39.                         }
    
40.                     break;
    & n* \: \2 {; s
41.                     
    / X7 ]; U& u7 b4 p! M
42.                 case 1:
    
43.                         if(OFF_ON == 1)
    ; U; i$ h' c. ^+ C) y
44.                         {
    5 a$ |/ `) @5 f/ {3 L' P
45. 
    
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    " b1 I+ a) j) Y# q& q$ m8 r- R  q
47.                         }
    
48.                         else
    7 s6 }+ x' ~0 |5 T' k) C
49.                         {
    % d6 a/ u9 Q- S
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    ' K4 l: c. ~) }" }  V
52.                     break;
    
53.                 default:
    ; w) y1 B; M; z$ X2 n; h) P
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);
      l& W# E6 H$ {, A9 P, o/ c
56.                     break;
    
57.         }
    3 M$ x" B9 c( ^; [$ R3 E* {; l  W( c
58. }
    
59. #endif

复制代码

0 h8 e4 Z5 }4 Wmain.c

1. #include"stm32f2xx.h"
   
2. #include"can.h"
   
3. #include"led.h"
   
4. 
   7 x6 l: }5 q3 p0 C3 Z1 U
5. 
   
6. int main(void)
   
7. {
   
8.         u8 res;
   ! `, f; r& j3 C/ H7 V
9.         u8 key;
   
10.         
    
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    6 L% d/ D0 b8 \' g, a
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    
13. 
    
14.         LED_Init();
    ) `8 g: N7 }8 y! u% x
15.         Delay(168);
    * K0 p7 p9 _: n0 I7 I0 N% m2 a
16. 
    
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    7 c/ R8 K) N0 p" w1 W
18. 
    + w$ E1 f# l) `$ t& a* T" L- i# G
19.         while(1)
    0 p$ F/ }, f8 O; U
20.          {        
    
21.             //1.接收数据
    
22.             key = CAN_Receive_Msg(canbuf);
    
23. 
    
24.                 //2.解析数据
    
25.                 if(key == 0)
    
26.                 {
    
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    
28.                 }
    
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    
30.                 {
    " U9 ^+ y9 `, H8 u3 w7 x' O. @: D
31.                     //3.发送数据给PC
    ( W2 r; _; f6 U& p
32.                     CTL_LED(1, 1);   
    . d+ ]& X1 w9 U9 j  Q
33.                         res = CAN_Send_Msg(a, 8);   
    / _- c; g; t8 w5 B- ~# R
34.                         if(res == 0)
    ) q2 h6 _# I: B& ?3 s6 @/ g" f; L
35.                         {
    
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    
38.                         else
    8 g8 _5 f% t+ A  |: }" R: [
39.                         {
    ' Y1 }& J) h1 P  L
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    
41.                                  
    + g9 h- k5 U  \/ w, A
42.                         }
    * D9 I+ B& [8 P4 r4 G
43.                 }        
    
44.         }
    
45. 
    
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    
47. //若数据发送失败，熄灭led灯1
    
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    : `& L( A3 \* H% Y  ~
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    
51. /*
    7 ^/ Q5 m4 ~0 _8 x  d; _0 w
52.         while(1)
    
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    / `& y0 d" C" p/ Z! f) Z
56.                 {
    
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    7 z. D3 j9 e- b9 E
58.                         key = CAN_Receive_Msg(canbuf);
    
59.                         if(key == 0)
    $ d; \5 ?2 y; L' f. s, G6 U: E7 C0 I
60.                         {
    3 v+ J# g; d; o. u0 Y8 T+ v
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    
62.                         }
    + T3 A7 t1 I7 J4 L% O
63.                         else if(key > 0)
    ! @% l, B$ y1 w0 y& A* C3 e
64.                         {
    , `$ i7 }" G7 N1 w2 V( L% G
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    
68.                 }
    ! ^- _. i/ s2 r0 U
69.                 else
    3 m5 _$ \6 q+ N
70.                 {
    ( Y# L" B1 O9 Z1 t' }
71.                         Delay(5000);
    2 j7 L- }9 V8 S
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    . t5 _$ d) o8 A9 X4 E
73.                 }
    ) q5 ~- ~: p8 `( F) O
74.         }
    ' f+ x* F3 j0 U* X) [; a
75. */        
    2 c' \, T* w$ ?5 E6 O5 h; O8 h
76. }
    6 C5 I" V$ R9 o( e* D$ I
77. 
    1 n) `: q- v# Q! C; e, H

复制代码