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

can.h
- U6 f1 J  o$ T& V# f

1. #can.h
   
2. 
   4 w5 t; [2 B8 e3 I5 H
3. #include"stm32f2xx.h"
   
4. 
   
5. #ifndef __CAN_H_
   
6. #define __CAN_H_
   . N4 F7 n) y! v. }
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   0 `; X9 o- H3 R. s
9. 
   ( Z) s) b$ O- a4 M+ d; V
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    
12. u8 CAN_Receive_Msg(u8 *buf);
    . C% |3 z8 R) Y- l! b6 ?0 L
13. 
    + y* L/ X! A/ ~; Y7 s# E
14. #endif

复制代码

3 G% O" ^$ ^8 k" _2 ?can.c

1. #include"stm32f2xx.h"
   " f5 l& `8 }& E/ q4 i) ]
2. #include"stm32f2xx_can.h"
   0 [0 ^2 i% ?) y5 [7 m
3. #include"can.h"
   
4. 
   
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   
6. {
   
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   
8.         CAN_InitTypeDef CAN_InitStructure;
   
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   4 @+ I% ~" s. `3 m( w2 M
10.         NVIC_InitTypeDef NVIC_InitStructure;
    
11. 
    : M; i8 m) R3 `# V3 j5 {
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    3 n$ {) [+ m1 A9 y8 Z2 ~
14. 
    : X5 {3 ]1 ?. I# h" M  `7 j; D
15.         //GPIO初始化
    + L8 G, Y$ E% G- \- r
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    + u* Y! A& S. O: y  Y+ W- n4 D
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    6 z5 k2 M  i4 n) r, s
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    
22. 
    
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    ; r" U* j: ~: F/ h2 w
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    7 z8 M0 p+ N8 _5 Z
25.         
    
26. 
    
27.         //CAN初始化
    
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    2 A, r- n" k- C0 g
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    ( E2 e8 \( Y+ N# }: m4 r7 i) l4 L3 w
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;      //禁止报文自动传送
    ( b3 d) ^9 S$ R
34.         CAN_InitStructure.CAN_Prescaler = Prescaler;         //分频系数(Fdiv)为brp+1        
    # J7 Y3 J: U, X- f: u
35.         CAN_InitStructure.CAN_RFLM = DISABLE;      //报文不锁定,新的覆盖旧的  
    ! T% \7 Y* ]/ a; E, o, A; R
36.         CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;    //重新同步跳跃时间单元，CAN_SJW_1tq~CAN_SJW_4tq
    
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    6 _1 O  G6 F9 y3 I7 c. {; D  Y
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    . L" {9 T2 ?( R7 ~
39.         CAN_Init(CAN1, &CAN_InitStructure);
    
40. 
    / `" _% j+ S2 d
41.         //筛选初始化
    8 V2 U4 O# i$ ^1 j% K
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    / L5 [- e4 ~% S6 d
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    7 A# C7 e5 \& m" |* ]
44.         CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;    //32位ID
    
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
      D  ~1 o9 \8 r! ^  A
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    
47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    $ n& ^! D7 p8 n: V! E! Z
48.         CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;    //屏蔽模式
    9 k/ V. ^8 m9 Y7 O4 q" }
49.         CAN_FilterInitStructure.CAN_FilterNumber = 0;    //过滤器0
    & R5 U  ?! d4 d7 J, j4 \
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    
52. 
    $ F; N( D" ^6 d2 ]6 _. t
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    ; t: T0 g' i6 x: ~8 p
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    
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为长度
    8 p0 ]# _( }" G" n  Z% `7 Q% T
63. {
    7 W0 r4 z8 q9 _6 W& Q  q+ f& `4 ?* g
64.         u8 mbox;   //邮箱
    
65.         u16 i = 0;
    $ ]; }4 c- w& m. @
66.         
      @. k6 P4 ^  W3 A
67.         CanTxMsg TXmessage;    //can发送结构体
    
68.                
    
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    4 X* D( J& n" b- l, v; E. |* s
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    ) K5 K. P5 c8 ?
72.         //TXmessage.IDE = CAN_ID_EXT;   //这里的帧类型也可以设置为扩展帧，在USB_CAN那里设置标准帧，传输记录中会有
    
73.         TXmessage.RTR = CAN_RTR_DATA;   //...can.h，传送的是数据帧
    . D* P2 p; W7 j  i  @
74.         TXmessage.StdId = 0x12;  //标准标示符
    
75.                
    
76.         for(i = 0; i < len; i++)
    ( C# f; e! {9 D) P
77.         {
    
78.                 TXmessage.Data<i> = msg;
    0 @, v; i4 B1 k
79.         </i>}
    
80.         
    . Q6 D5 A% |, a% ?+ f
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    
82. 
    6 L2 g" e0 N- \- @7 K6 }
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    
86.         }
      F" M# a4 n$ b% H
87.         if(i >= 0xFFF)
    
88.         {
    
89.                 return 1;  
    * g% i1 f! M' M" ^, S
90.         }        
    
91.         return 0;
    6 A1 j9 t4 g4 v- B8 @. G6 E
92. }
      M- X( e/ ^' I$ m7 d' ~0 d" D5 t
93. 
    
94. 
    ' Q2 t7 K8 D! j+ U( h
95. 
    * F/ Q4 u+ n8 G$ v# H* n7 z
96. u8 CAN_Receive_Msg(u8 *buf)
    ; j& y0 G' E& ^/ x8 o
97. {
    ' `0 p0 v& v4 l9 v* u3 V
98.         CanRxMsg RXmessage;         //can接收结构体
    % w# _$ `# k. ?& i& f7 y4 S
99.         u16 i = 0;
    4 @0 O" X: e; `4 {' G% x; B- }2 u
100. 
     $ y$ U: S1 o6 M+ C" I$ m
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     
102.         {
     
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     / I( [6 O5 y! _6 I+ z- Q$ z
104.         }
     2 N; f: _% [- A
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     * K& R4 {. r0 y- H
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;">;
     # W1 z9 e) \( z
110.         }
     + {6 C* d/ H" F  `6 O/ i7 `3 f# Z
111. 
     
112.         return RXmessage.DLC;
     8 e& B* X( |7 W  V
113. }</span></span>

复制代码

led.h
% A6 V  t' Z- b$ B* m

1. #include"stm32f2xx.h"
   
2. 
   . S* F. U+ ]1 Z
3. #ifndef __LED_H
   % o" E; c4 f' @* o$ D% ?
4. 
   
5. #define __LED_H
   
6. 
   
7. 
   2 G" _; [* ^0 B9 W: k3 y3 C* X
8. void LED_Init(void);
   ; j% x3 y2 |4 w8 _' a
9. 
   & H, G; J) Q- O, f7 U5 m+ l
10. void Delay(vu32 nCount);
    - k8 J/ p- h' ~% X$ J6 m/ n
11. 
    5 T! T8 _- B' K. R- X
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    - \7 F; I) }8 o4 Z1 _* L
13. 
    
14.         
    
15. #endif

复制代码

led.c
7 A5 q+ a: I5 P; o

1. #include"led.h"
   - O2 b0 Q' |, Q+ }) L8 O
2. #include"stm32f2xx.h"
   
3. 
   2 ]6 ^: S1 @- d/ o* S( b* @
4. void LED_Init(void)
   
5. {
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   ) H) r- Y6 ?3 {+ ]) C$ O" Q
7.         
   9 r9 L8 k7 Z  V6 h) M' i8 g! W
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   + ?9 S% B* z+ Y" w! y. g% b
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   - ^; G) l& E; y( W9 D+ c
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    4 g! x% C+ c2 |
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    ! ^; a/ U+ F/ L
14. 
    
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    
17. }
    
18. 
    % L# y" ?! W+ D; T1 N; ]7 x
19. 
    3 E: d$ |4 h2 |1 b9 a
20. void Delay(vu32 nCount)
    
21. {
    : [$ j+ K6 y: l, Z
22.   for(; nCount != 0; nCount--);
    
23. }
    
24. 
    6 F; P& X( U4 E% K$ t7 x# F6 [
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    ) `& Q9 N) |2 ?
27. {
    % E" T3 B" n2 l+ s: F5 N# R5 Q
28.   switch(LED_NUM)
    + {2 `1 @9 [1 ?" q+ x
29.         {
    
30.             case 0:
    
31.                         if(OFF_ON == 1)
    
32.                         {
    ) _- t3 a# X5 i. }# F0 k
33. 
    # d' t7 o/ q% i1 g4 {% e
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
      E+ ]! N# n  n% p2 f. s9 ~4 S
35.                         }
    6 B' V" r2 d$ k4 q7 ~4 W/ V$ K
36.                         else
    . c, D  o/ W/ P5 _
37.                         {
    
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    
39.                         }
    
40.                     break;
    ! z* |" ?; E6 Y
41.                     
    $ u- _" T8 \# d5 [" @$ D
42.                 case 1:
    6 E+ ?: }/ h7 |5 ?
43.                         if(OFF_ON == 1)
    
44.                         {
    
45. 
    
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    . `' Q, u# @* G4 L2 F! j
47.                         }
    
48.                         else
    2 c& f. ~5 }% \; M# P  G
49.                         {
    
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    
52.                     break;
    * E3 ?* ]2 w3 i( `( z
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);
    9 D: b1 ?4 E, d
56.                     break;
    3 R- ?% w, X+ U, |  `( s
57.         }
    
58. }
    : L* W, @! d# r! n8 B% ?: q
59. #endif

复制代码

7 {; Z, ?9 p" ~- Q9 y0 }+ K, a& Z5 f7 ymain.c
2 m4 M1 J8 x0 [

1. #include"stm32f2xx.h"
   
2. #include"can.h"
   
3. #include"led.h"
   9 Y7 ^& }* h% a6 B* q. `# V
4. 
   
5. 
   6 p2 i/ k# R; d& U3 V  z
6. int main(void)
   
7. {
     F% s- T3 G0 d6 g
8.         u8 res;
   
9.         u8 key;
   
10.         
    
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    ( |+ i8 g* e+ B
13. 
    - @% b' q, M: X5 m1 s1 r7 J
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
    ) M5 R+ ]" \4 K: K- ^
18. 
    
19.         while(1)
    " X+ h" ?" j7 Z0 M4 O* a3 }, h" _9 \) r% l
20.          {        
    5 ]# r* z# w% {  E% Q8 p
21.             //1.接收数据
    5 P0 c$ L/ |* O; |9 t# T
22.             key = CAN_Receive_Msg(canbuf);
    8 W: S0 f& d: `, ~0 ]2 J# y
23. 
    ! P" ]$ n1 I7 m9 t$ R7 ]4 }
24.                 //2.解析数据
    
25.                 if(key == 0)
    
26.                 {
    % }/ [: e# b8 t' E8 i  r
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    ! ~: \' ^' {5 O3 M+ j* v1 j
28.                 }
    * K* d/ F0 I) p! ^4 a" h
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    
30.                 {
    0 h% o: p$ x. b! E$ ?
31.                     //3.发送数据给PC
    
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    8 Q/ r, t7 U  A; o
34.                         if(res == 0)
    
35.                         {
    ! Z& O% K, p" _6 P9 v0 Y4 u+ G5 G1 ~
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    ; c& s& Q& z, F2 a3 I- Z
38.                         else
    ; a& h( H( ~2 [- p( n
39.                         {
    $ z5 v2 p! a% ~5 Z, @
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    8 [+ ~) G+ I1 h6 h" g# R% x
41.                                  
    7 O8 g2 _7 K+ i! W
42.                         }
    & y2 Z0 s2 t! x6 ]) a9 T5 M
43.                 }        
    
44.         }
    3 U% R* z, v' p3 q+ i
45. 
    
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    
47. //若数据发送失败，熄灭led灯1
    7 r0 _5 l7 r, G+ E" q" m8 L
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    
51. /*
    
52.         while(1)
    7 G4 X0 |' u/ ~4 O4 O
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    7 f' |5 q4 l5 G7 M4 x8 z- U! o; j
56.                 {
    / Y0 o: `5 r# U) a( n! C
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    
58.                         key = CAN_Receive_Msg(canbuf);
    ' f. G- z- m' W  L
59.                         if(key == 0)
    
60.                         {
    # S+ Z% ?' w8 F
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    
62.                         }
    : e/ ^/ e  Z& S) g! s/ d$ V
63.                         else if(key > 0)
    5 u9 h) m3 n. f% h! U" \( e- @
64.                         {
    9 c7 U9 c1 K; \, O$ x
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    
68.                 }
    
69.                 else
    
70.                 {
    
71.                         Delay(5000);
    
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    " D8 k8 ~) t7 ^3 s) y; i. O5 Y
73.                 }
    : K. K# t3 z! z" e7 J
74.         }
    
75. */        
    $ M$ @- @) [3 ^$ f3 q& m  H9 n0 T
76. }
    
77. 
    

复制代码

5 ]8 K* E  K) n3 a( [# M, T