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

# Y* E! d) W' ~' p$ \can.h
, F! `: j: g" u

1. #can.h
   
2. 
   " k* V& E6 f& E/ J( {- c; a. p
3. #include"stm32f2xx.h"
   
4. 
   
5. #ifndef __CAN_H_
   : B5 H4 s, c8 [. @+ W
6. #define __CAN_H_
   ; ]2 M7 ~/ _6 u4 F* j" v
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   3 R4 q5 j9 O% r* g9 B  w
9. 
   - [  _: S/ v$ j
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    
12. u8 CAN_Receive_Msg(u8 *buf);
    ! C; ^# q9 N) f1 V
13. 
    
14. #endif

复制代码

6 h5 \! T$ U" d+ u$ B1 G8 G& jcan.c

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   ; U* V2 R- W: q8 _9 w- V& z
3. #include"can.h"
   $ B, K" b# T& B0 Z0 b
4. 
   9 a3 O; n; O9 d8 p5 q' R
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   2 j6 x9 }; I. H9 I
6. {
   
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   " g% Q1 K. Y8 \* Z1 z! Q
8.         CAN_InitTypeDef CAN_InitStructure;
   
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   5 H3 Z. s* x+ X; t
10.         NVIC_InitTypeDef NVIC_InitStructure;
    ; y# E- v' t  O
11. 
    
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    7 ?; N: O: Y8 W: a# g# o/ d
14. 
    
15.         //GPIO初始化
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    1 l3 r; H/ L% \/ J& n
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
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);
    
25.         
    
26. 
    1 A. ?) n9 Q* i" C0 |9 v0 W
27.         //CAN初始化
    1 l# e# p& l$ B! f9 W
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    2 q( e3 ?$ y  V+ S: {
31.         CAN_InitStructure.CAN_BS2 = CAN_BS2_ytq;    //时间段2的时间单元，取值在CAN_BS2_1tq~CAN_BS2_8tq
    
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    ! T3 y& s7 o8 O  f9 Q
34.         CAN_InitStructure.CAN_Prescaler = Prescaler;         //分频系数(Fdiv)为brp+1        
    $ y8 N7 S4 X, r8 |* O
35.         CAN_InitStructure.CAN_RFLM = DISABLE;      //报文不锁定,新的覆盖旧的  
    
36.         CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;    //重新同步跳跃时间单元，CAN_SJW_1tq~CAN_SJW_4tq
    
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    2 o7 g% k* |  I8 L, q
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    
39.         CAN_Init(CAN1, &CAN_InitStructure);
    
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
      g& [- Y% y4 W  i
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    
47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    6 Y4 ~8 a( k/ q4 O
48.         CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;    //屏蔽模式
    
49.         CAN_FilterInitStructure.CAN_FilterNumber = 0;    //过滤器0
    
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    / x" h1 o! ~( N7 S
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    8 Q: v1 \: w, K$ z# y
52. 
    
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    : O" v7 l8 {" ^) x
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    * ^1 {' T8 `3 \
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    
58.         NVIC_Init(&NVIC_InitStructure);
    
59. }
    
60. 
    ( m6 k# }) x( X0 \+ n
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    2 @* x  J! p) ]' b2 N6 l- q
63. {
    
64.         u8 mbox;   //邮箱
    
65.         u16 i = 0;
    + F6 {! m  Y( l6 H
66.         
    6 _9 D4 B* R0 w; o& l! F( T
67.         CanTxMsg TXmessage;    //can发送结构体
    
68.                
    
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    ! u4 s5 g4 O3 O8 k- P5 L, H; L
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    2 f5 [- v5 W  E) [8 L
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
      Z2 P. C1 e$ e/ @) [# R
72.         //TXmessage.IDE = CAN_ID_EXT;   //这里的帧类型也可以设置为扩展帧，在USB_CAN那里设置标准帧，传输记录中会有
    
73.         TXmessage.RTR = CAN_RTR_DATA;   //...can.h，传送的是数据帧
    $ O) \& n6 w$ Y8 H1 F# ^8 D
74.         TXmessage.StdId = 0x12;  //标准标示符
    
75.                
    
76.         for(i = 0; i < len; i++)
    & r+ r8 j* U" C" X) T) \. d
77.         {
    & E+ p) z6 @/ I
78.                 TXmessage.Data<i> = msg;
    
79.         </i>}
    
80.         
    ! E: p9 c$ ^( }; o! K8 \& r  ^
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    . H5 g+ N8 ]2 D; X' q# s9 e; M, ?
82. 
    
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    6 h  u+ q" E+ c# G
84.         {
    
85.                 i++;      //等待发送结束完成
    : U* n# u2 p: P  L( v0 e
86.         }
    % N) ]9 a. L+ ^; v! Y
87.         if(i >= 0xFFF)
    
88.         {
    
89.                 return 1;  
    ! V2 g& J7 x; l5 K- g% X/ M# h! q
90.         }        
    
91.         return 0;
    
92. }
    
93. 
    $ X/ f0 d1 V1 E) y, K. k4 ]  I4 t
94. 
    
95. 
    " d* s. |7 x" [' \( O( E; A
96. u8 CAN_Receive_Msg(u8 *buf)
    / g( N! J5 Q2 j4 ]9 P& O* P+ O
97. {
    
98.         CanRxMsg RXmessage;         //can接收结构体
    
99.         u16 i = 0;
    4 D" D% S/ [) X* U
100. 
     : `+ O$ h% ~6 a: l7 Q9 F+ z% q
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     6 D. @6 B6 V5 w$ m! l$ ?
102.         {
     ) S4 x. |. ?4 _$ p+ E- _
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     2 {$ r& o4 L5 S& q
104.         }
     
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     8 l3 p% ~4 j0 [# x
106.         
     
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
     
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     
110.         }
     & S# ]  h6 m, l" r) R
111. 
     
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

; Q8 ~7 R& w5 }8 E" Sled.h
, h, A! `  V, N) H0 S

1. #include"stm32f2xx.h"
   
2. 
   : x$ @5 u; `1 |) K0 e9 M9 W
3. #ifndef __LED_H
   
4. 
   
5. #define __LED_H
   
6. 
   
7. 
   9 ^( J* Y( _1 T; M  y
8. void LED_Init(void);
   7 M4 x' s# t6 a/ }7 f
9. 
   
10. void Delay(vu32 nCount);
    
11. 
    
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    
13. 
    
14.         
    
15. #endif

复制代码

, V( D- `+ L4 ?( f4 G  T. G7 |led.c

1. #include"led.h"
     a0 Q: X$ }2 x9 ~
2. #include"stm32f2xx.h"
   + c$ i* T5 G( K( h2 v8 H$ Q
3. 
   
4. void LED_Init(void)
   
5. {
     E! Y7 M1 a! c9 N: `. Z
6.         GPIO_InitTypeDef GPIO_InitStructure;
   8 U- A' e  s. ~
7.         
   $ T5 t& e4 \2 }" W" t
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   # E  g  y5 b, a7 S
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    , q8 _4 u9 ?" B  Q) o# Z+ H1 Q
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
14. 
    ) D3 s! c( a9 n8 m  R
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    
17. }
    
18. 
    
19. 
    
20. void Delay(vu32 nCount)
    4 X* d4 J/ C, i- i1 N7 _# {6 i3 f
21. {
    
22.   for(; nCount != 0; nCount--);
    3 s' g. H$ S! ^/ N& K
23. }
    5 K2 U1 [, _/ [; A
24. 
    
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    / }: B/ Y. h: |# Z7 D7 S
27. {
    
28.   switch(LED_NUM)
    
29.         {
    
30.             case 0:
    4 c% Z( J1 _* A: t1 H( {& O9 Z
31.                         if(OFF_ON == 1)
    + E* e# g3 {0 c5 R" U& f) B
32.                         {
    ) v- P0 P3 O' C) n2 R$ Z  V1 ]' O3 B
33. 
    
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    3 v: N# |* k' P6 c
35.                         }
    
36.                         else
    
37.                         {
    2 [& R0 y  U, D. R) z( C( o( m
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    8 O% Y% {) m2 ~; C
39.                         }
    # m2 x7 X3 F  r/ M& J- b
40.                     break;
    
41.                     
    
42.                 case 1:
    * O  Q; X) e: d# R9 y3 p6 E
43.                         if(OFF_ON == 1)
    ! u) R( M0 `; \; R
44.                         {
    & f6 I" d) h) F" F2 J: X% L/ v1 W
45. 
    4 w0 ^0 e3 T6 O3 L
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    4 Y1 X/ I# Z2 k
47.                         }
    
48.                         else
    * `* M8 D2 I% {$ l
49.                         {
    
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    ) [0 E, p* A; z# g
51.                         }
    ( H  P8 F4 c. z- A& g
52.                     break;
    9 x) y. x6 p! a
53.                 default:
    ' w" M2 H5 j4 o: G* Z
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 B3 m+ {  G8 {6 G: o
56.                     break;
    
57.         }
    
58. }
    : i4 K9 T6 U, n; j5 {: M0 g1 |
59. #endif

复制代码

main.c

' U: k( b, T. q# _4 W- l; `6 P1 B

1. #include"stm32f2xx.h"
   0 m: ?4 F% E; k1 m
2. #include"can.h"
   
3. #include"led.h"
   
4. 
   , \- s  B- W6 k/ s
5. 
   
6. int main(void)
   
7. {
   5 u9 n6 w! Y& P; x) m
8.         u8 res;
   
9.         u8 key;
   $ ?% W. c. e! X$ Q  F1 q2 H) V
10.         
    " i! u* |2 |% v
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    4 M: \7 P* d" z3 k% Z
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    
13. 
    
14.         LED_Init();
    
15.         Delay(168);
    
16. 
    
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    ( P7 i% H& e( B5 E
18. 
    
19.         while(1)
    0 C% Z5 s1 z  i& Y* n
20.          {        
    
21.             //1.接收数据
    
22.             key = CAN_Receive_Msg(canbuf);
    + Y: e/ t# V7 l  h
23. 
    9 m5 C# H2 c6 N' T/ w2 T
24.                 //2.解析数据
    
25.                 if(key == 0)
    
26.                 {
    " F5 L7 `) ~: [7 \3 c4 z9 o0 Y
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    , L" n9 V' p( o+ \
28.                 }
    6 w" l. {9 l' k
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    
30.                 {
    9 D% o+ {3 F1 [6 A5 ~
31.                     //3.发送数据给PC
    5 r1 ]- k% _7 [# Q
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    - I$ o1 |0 q- O4 j" I
34.                         if(res == 0)
    
35.                         {
    
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    ) c% Z* _* U0 q1 }4 v. U3 x. H2 o# ?
37.                         }
    
38.                         else
    1 i7 e/ G' }4 O; I( f" W4 @' D
39.                         {
    3 |; N3 j% \+ r1 J+ @
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    
41.                                  
    
42.                         }
    
43.                 }        
    
44.         }
    2 M9 F4 ^- I) o. X. |+ l
45. 
    ' V& h' v7 T3 \  ?* e
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    
47. //若数据发送失败，熄灭led灯1
    6 A" `' Y2 ]! y' C. f7 I, h
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    6 k# y1 ^2 [5 B5 ^9 z# I+ Q, a* g
51. /*
    
52.         while(1)
    * e4 W1 A. `4 v; h2 W- L
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    4 g+ Q5 \! |: A6 }5 P: z  t) a1 w6 g
56.                 {
    ' v! m6 O- {& a  ?) y7 z$ O
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    6 m( u: t' [, i
58.                         key = CAN_Receive_Msg(canbuf);
    
59.                         if(key == 0)
    ( T' {3 z5 C  P# U
60.                         {
    
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    3 k1 V) c4 b& f0 W5 F
62.                         }
    
63.                         else if(key > 0)
    0 u9 U0 o  h8 W
64.                         {
    2 L+ ^! b, h2 Y
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    " V" U# C1 s3 y& y2 s  a
68.                 }
    
69.                 else
    8 F- `& D, M3 S* M" U# `& C: J6 T
70.                 {
    
71.                         Delay(5000);
    
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    
73.                 }
    
74.         }
    
75. */        
    
76. }
    
77. 
    

复制代码

1 M. e+ {5 I( R  h3 t