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

7 X8 e7 i# h  P8 n& c3 scan.h
' x! o  k8 l! ~! g6 _9 [1 @: P

1. #can.h
   
2. 
   
3. #include"stm32f2xx.h"
   
4. 
   4 w& t2 F9 |: C  u" B4 Q( o
5. #ifndef __CAN_H_
   
6. #define __CAN_H_
   5 k  O; @: m1 t2 Q/ Q
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   
9. 
   4 Z' r8 K4 b. ]( U- U+ J
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    
12. u8 CAN_Receive_Msg(u8 *buf);
    
13. 
    7 U1 G% ^. d0 y9 V
14. #endif

复制代码

can.c

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   
3. #include"can.h"
   ( e, `6 w! W1 L) C) G' Y
4. 
   8 q9 ]- R! R- o; G
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   5 I+ f0 V4 F( H- B5 q9 r3 y& r# `
6. {
   4 e/ s$ F! T; a" Q
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   
8.         CAN_InitTypeDef CAN_InitStructure;
   , ]& H9 u5 f4 `! D- [* _
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   9 g7 T* A3 S1 z0 C6 q/ b$ I* b) ?
10.         NVIC_InitTypeDef NVIC_InitStructure;
    4 t% S) C1 Y: w" ^: S$ m
11. 
    ! a5 O' ^0 E  O* G* f+ M- w5 H! Y
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    2 d1 G& I- X( m: ~' B8 x
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    
14. 
    0 V' o" Y6 H- l) D& n( a) o
15.         //GPIO初始化
    5 R9 ?9 `6 T8 m. [5 G+ P9 S
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;
    
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    * S; ~* s0 ?2 a
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    
22. 
    & |% ^* ^6 {8 e. M0 ]* `
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    
25.         
    
26. 
    ! p  ?# v, p- @+ Z. V
27.         //CAN初始化
    ) d* Z; F2 y, ]& z% e
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    7 {: N8 Z# r8 j. x7 P0 f
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    
31.         CAN_InitStructure.CAN_BS2 = CAN_BS2_ytq;    //时间段2的时间单元，取值在CAN_BS2_1tq~CAN_BS2_8tq
    ! _( ~& d* w/ Z8 V: e" {' @
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    
34.         CAN_InitStructure.CAN_Prescaler = Prescaler;         //分频系数(Fdiv)为brp+1        
    3 y  u) {8 {+ s1 a
35.         CAN_InitStructure.CAN_RFLM = DISABLE;      //报文不锁定,新的覆盖旧的  
    4 V( E- X4 E' k1 S/ z) L3 r
36.         CAN_InitStructure.CAN_SJW = CAN_SJW_1tq;    //重新同步跳跃时间单元，CAN_SJW_1tq~CAN_SJW_4tq
    / x; [9 ~' P4 b. W5 ]3 r
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    
39.         CAN_Init(CAN1, &CAN_InitStructure);
    & ]0 m: z& R& ?% W
40. 
    7 e# G! l+ X6 U
41.         //筛选初始化
    # E" a$ o, y! ~6 X' C
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;
    
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    
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;    //
    
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    3 O7 E, t: t/ {: m0 R
52. 
    & ?! f% F# P4 D
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    . s$ H( F( x( x1 R4 Q
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    7 e3 ~& K7 r2 C: ~
58.         NVIC_Init(&NVIC_InitStructure);
    
59. }
    
60. 
    9 ~9 J  P- q0 E2 f! [& j
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    4 N, h7 M0 h* W% H, s
63. {
    
64.         u8 mbox;   //邮箱
    * ^, I5 m. x7 `% R6 H: U- i; k
65.         u16 i = 0;
    
66.         
    ( ~& S/ e9 p! g6 r; j5 S
67.         CanTxMsg TXmessage;    //can发送结构体
      D9 v* H+ R  m8 F, B* ?
68.                
    
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    - G. G. S, q" I( t+ d& C9 R
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    6 V9 l+ J4 w4 \( q7 T
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++)
    $ e0 k/ }& K% N& r% t: ]
77.         {
    2 Z# p: `! C6 z- p5 Y7 K7 T. W
78.                 TXmessage.Data<i> = msg;
    / r8 k9 {: x9 W; {: K# q
79.         </i>}
    
80.         
    * ]6 ]! G" O' k) n: i
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    
82. 
    5 q! S7 p; ]' n; ?- g
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    0 m$ |8 w1 G* m2 I. C3 t3 R
86.         }
    
87.         if(i >= 0xFFF)
    ' w, u$ ?) o( k8 E6 v
88.         {
    
89.                 return 1;  
    2 ]( z, y* d, }9 }7 E/ o
90.         }        
    $ i2 y7 C0 e: h1 k6 `
91.         return 0;
    - z2 H* o  X: e& q" G
92. }
    5 r) C: u4 E3 F( `
93. 
    
94. 
    
95. 
    ) [7 z# u7 r: w& V
96. u8 CAN_Receive_Msg(u8 *buf)
    0 L+ B' Q2 j  \% i) m( B4 y
97. {
    
98.         CanRxMsg RXmessage;         //can接收结构体
    1 y' _; {1 b9 k9 I" J: ?
99.         u16 i = 0;
    & S  i# C5 D  E
100. 
     , V. k% e6 A* P
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     1 H" m% n& b6 h* k8 \! T' C
102.         {
     ( L* D: {9 k& ]# Y( n9 v1 S( k
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     ' `9 P1 s, ~9 n, a
104.         }
     
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     
106.         
     # J. O% X6 \6 e0 E. I1 p9 I
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
       u. A8 j: H: X( Q
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     
110.         }
     - B1 }- m- {% C& A
111. 
     ( M& \9 n$ O2 v- `
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

3 B3 o* C( e9 O$ Q- D$ wled.h
' l, t6 ?* X# e& i, C$ B! W" ]

1. #include"stm32f2xx.h"
   & Z" ^9 C. V7 p4 ~
2. 
   & o# Q9 }' ^6 r; W' r0 p2 K* C5 T
3. #ifndef __LED_H
   ) b5 V6 c6 z* Y! I
4. 
   
5. #define __LED_H
   1 v! f$ b5 ?  g, k0 N* u; e
6. 
   
7. 
   
8. void LED_Init(void);
   2 H; F. v2 U$ `+ O
9. 
   * s" u2 G: W8 g) G
10. void Delay(vu32 nCount);
    
11. 
    
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    1 r) W) ?; n! X3 z5 [: U
13. 
    : F) k+ X1 n! h) B
14.         
    + M9 Y/ A$ x5 i8 J8 r
15. #endif

复制代码

led.c

1. #include"led.h"
   " b0 M, A9 Z" i$ v5 D8 p
2. #include"stm32f2xx.h"
   
3. 
   ( D! Z% {, V# w, Y5 N
4. void LED_Init(void)
   / p2 w* [# k. S" @+ ~: A- x3 N
5. {
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   0 k6 t. {- a5 v. _% _/ q
7.         
   
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   ) o/ p+ r3 ]  h" a: h* ?; D
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   , ^7 E: l" r1 B! J! O
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    4 b* x% b$ f4 a) Z% z9 Q
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;
    8 D0 D  D, n: ?4 u6 W
14. 
    " ]7 p& Z( H. p  r
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
      T' {2 S$ m* Y& W
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    # v$ `( m" p, i8 z* i, K4 Q
17. }
    
18. 
    4 C' n- [6 g) t
19. 
    - c3 H% D% ~9 z' i5 V' t
20. void Delay(vu32 nCount)
    
21. {
    
22.   for(; nCount != 0; nCount--);
    : Y) t  k5 p, n/ \% y" @5 s" _
23. }
    
24. 
    
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    8 q( q0 y! P( }
27. {
    
28.   switch(LED_NUM)
    
29.         {
    9 a" C  G0 ~6 J! m1 i
30.             case 0:
    
31.                         if(OFF_ON == 1)
    / b4 T1 I9 u' A- w# p
32.                         {
    
33. 
    0 U- ^: x; v1 r
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    
35.                         }
    , K! z0 e' `, M+ n# N! F% C: S
36.                         else
    7 `- B7 P; w/ n  e3 J5 {6 \* k
37.                         {
    + \4 ]. I& @+ I; e3 ?: X. J4 T
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    
39.                         }
    
40.                     break;
    
41.                     
    5 F7 ?; {. u* J
42.                 case 1:
    $ G- s% ~+ u) V, ^5 k
43.                         if(OFF_ON == 1)
    
44.                         {
    
45. 
    
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    
47.                         }
    
48.                         else
    ' F& Z7 F* K0 d- V9 C+ ^# L: ~, C! L
49.                         {
    
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    
52.                     break;
    
53.                 default:
    # I" Z$ F+ B0 x) C8 ~7 d: _7 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);
    . U# ^  e9 S9 {6 Z; c7 r8 B8 i
56.                     break;
    : p# }/ C2 m7 {' W6 E7 s
57.         }
    + D: t* |" i, m" U6 W
58. }
    
59. #endif

复制代码

' w8 M* l8 f: t8 _) C0 Q4 ^% imain.c
1 F. n1 `9 H1 r( E0 b; M5 I
0 b3 P  x' H- c# ^* ]

1. #include"stm32f2xx.h"
   - V/ G  i; F. C1 u$ u1 c: C4 A
2. #include"can.h"
   
3. #include"led.h"
   
4. 
   
5. 
   
6. int main(void)
   6 h& R. z$ ], {1 W9 F1 I1 g* g# }' r
7. {
   ; p! k6 P" f7 D
8.         u8 res;
   
9.         u8 key;
   ) E  l6 \6 z9 L4 ]- q% M1 s
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
    : s. l$ N" G+ b. R
13. 
    " x' ^# s( S' i+ A/ u' ?
14.         LED_Init();
    . d4 m" ^, _3 v
15.         Delay(168);
    0 q9 w. H3 _& a* Y0 k$ m
16. 
    
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    
18. 
    
19.         while(1)
    
20.          {        
    7 N$ m5 n9 G* K' k3 K/ C& D/ X) y
21.             //1.接收数据
    
22.             key = CAN_Receive_Msg(canbuf);
    : i" B; N, A" Q
23. 
    # O  O2 `5 b' l8 h: r( H
24.                 //2.解析数据
      z' i, K# H3 w$ Z+ h1 H  d
25.                 if(key == 0)
    
26.                 {
    
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    0 M2 a( l% i. b) d3 r
28.                 }
    4 T; A, y; K; f' M# b
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    8 g7 }7 Q2 s' h
30.                 {
    
31.                     //3.发送数据给PC
    , \6 r! p. V$ [! h7 c
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    
34.                         if(res == 0)
    ) W* U9 O( x" s+ }: m* v
35.                         {
    
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    # x% I+ n% Y4 k1 F" G
38.                         else
    6 |- C( {0 Q& x& [9 `7 L( X
39.                         {
    ' X6 i" l. ~8 t, V5 f0 q* l2 n, F+ a
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    6 `& y6 k3 z$ {! Q
41.                                  
    
42.                         }
    
43.                 }        
    
44.         }
    
45. 
    
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    
47. //若数据发送失败，熄灭led灯1
    ! w5 k% y  V) B
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    - u! p8 c) e9 f0 {, Z( a/ I5 ?6 F7 d
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    + G5 w  e: B4 `' B' ]
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    
51. /*
    
52.         while(1)
    
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    ' u% Z3 _# B3 N: O
55.                 if(res == 0)
    5 s( ?  O" i7 l! q
56.                 {
    1 \6 A& u" k/ u( y
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    
58.                         key = CAN_Receive_Msg(canbuf);
    $ T8 A  i2 v& G/ G' [) C
59.                         if(key == 0)
    $ ^& O- a- M4 |9 `9 z" J9 f
60.                         {
    ; V) N# u. S/ J% h2 Q! Q. h
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    ) I7 I; R" c4 a; f2 }( M/ Q3 G6 W6 p( x
62.                         }
    
63.                         else if(key > 0)
      D0 P& z2 Q' P% T* g1 y2 A
64.                         {
    
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    / k6 ?4 o: H2 V/ z- Z& K
67.                         }
    , q+ v) P% I. i& h" X2 o; _
68.                 }
    
69.                 else
    
70.                 {
    
71.                         Delay(5000);
    
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    
73.                 }
    
74.         }
    
75. */        
    
76. }
    
77. 
    % ]7 J+ l( Z2 u3 X# q" ?

复制代码