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

8 ~6 L1 x" H  O; W+ C& rcan.h

1. #can.h
   
2. 
   
3. #include"stm32f2xx.h"
   ' G+ X( Q1 c6 J* i* a
4. 
   # V. b1 z5 `/ k* K) F  W% }( `+ b8 t
5. #ifndef __CAN_H_
   0 V$ K$ v1 U; B, O4 s
6. #define __CAN_H_
   1 V$ |. p. S2 v1 a1 G
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   
9. 
   
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    ; h! d7 V& j0 [# i% T2 R
12. u8 CAN_Receive_Msg(u8 *buf);
    & h% E% r, |! I. x" e' _6 k6 R3 `. y
13. 
    
14. #endif

复制代码

can.c

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   & n, ?; j* C( B3 j
3. #include"can.h"
   
4. 
   ) j' b$ y8 p. T- @
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   ! k" ~9 T: x6 i
6. {
   . k8 [& L& J5 d) B! }* J
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   # m0 O: e( I! K" w  L9 L" x) ^
8.         CAN_InitTypeDef CAN_InitStructure;
   ' }" e. `) R9 t; O8 W
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    + m: H: ~+ h, q. a& m# c) Y9 t% C- C
11. 
    4 }' _: a5 ]) \0 b; \. C- S
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    
14. 
    ! q0 s# F! k7 A9 Z3 _! ?; O* K3 O
15.         //GPIO初始化
    
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    5 w7 L9 |; E& `  N" R* V
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    " i* ]" T2 s( w1 n2 U  |; N4 M
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    ) L+ f. {5 u7 c% c8 ]3 f. S
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    , s! b) A$ v; ~9 p
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    
22. 
    / ^. f8 Q8 e& D1 q
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    7 v; z$ ^( W  n
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    ; a! F- X9 U; j7 P. `
25.         
    
26. 
    
27.         //CAN初始化
    
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    - P( X* |- i& H+ k$ h# I, P$ Z9 n
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
      V# y+ R6 m7 C5 N8 }! I& {# v
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
    $ I* N, y$ m+ z* @( ]
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    : I! u" @3 y# r3 _6 N
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    ! p+ ~% e2 }' ~" E5 I
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
    
37.         CAN_InitStructure.CAN_TTCM = DISABLE;    //非时间触发通信模式
    
38.         CAN_InitStructure.CAN_TXFP = DISABLE;     //优先级由报文标识符决定
    ; D. n$ L( d+ y5 v
39.         CAN_Init(CAN1, &CAN_InitStructure);
    
40. 
    
41.         //筛选初始化
    ( a# w/ b  w5 ?+ \4 t
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    / t. h0 g7 G  ^% X& k4 D
44.         CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;    //32位ID
    
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    
46.         CAN_FilterInitStructure.CAN_FilterMaskIdHigh = 0x0000;   //32位MASK
    ! @4 w' \, L9 Q; [6 K) C
47.         CAN_FilterInitStructure.CAN_FilterMaskIdLow = 0x0000;
    9 W' G: Y" F1 V0 K% @& o
48.         CAN_FilterInitStructure.CAN_FilterMode = CAN_FilterMode_IdMask;    //屏蔽模式
    
49.         CAN_FilterInitStructure.CAN_FilterNumber = 0;    //过滤器0
    4 X) C- G& ^! C4 k
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    % [+ b( d$ t, {( d4 |
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    - P% }; b$ S% y7 q
52. 
    
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;
    * {# k) R; U4 ]5 ~; a
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    
58.         NVIC_Init(&NVIC_InitStructure);
    
59. }
    
60. 
    ( l- L9 [8 E$ Y
61. //开始发送
    # @% P' l* E  R% U5 h( u$ l
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    
63. {
    * S. q4 \1 n$ [5 V* l
64.         u8 mbox;   //邮箱
    + V+ A8 T7 A. H; z% V+ Q
65.         u16 i = 0;
    
66.         
    + ^1 [' H0 O. a- C
67.         CanTxMsg TXmessage;    //can发送结构体
    
68.                
    + [4 ~8 q, }; ^' i; Q; n$ y
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    & ]; L) [4 S1 l  V' V
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    ; k6 h; G) ~2 Z5 e
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.         {
    
78.                 TXmessage.Data<i> = msg;
    
79.         </i>}
    
80.         
    " w) k& i- E+ W% v$ T- J7 }2 ?. b
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    ( e/ P5 f# v5 e- g$ E
82. 
    
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    
86.         }
    
87.         if(i >= 0xFFF)
    
88.         {
    
89.                 return 1;  
    8 D" @# g2 U0 _5 o+ O0 R. L3 S8 }, \
90.         }        
    
91.         return 0;
    5 F, E6 B! M2 i- X
92. }
    
93. 
    ( j- [! _- d! u) q
94. 
    
95. 
    . ]3 a7 q, h1 `2 T  |+ D3 Q
96. u8 CAN_Receive_Msg(u8 *buf)
    
97. {
    
98.         CanRxMsg RXmessage;         //can接收结构体
    
99.         u16 i = 0;
    
100. 
     ; j) q& z+ j5 q6 q
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     
102.         {
     . G& ^/ o7 S# O5 h1 i
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     7 s2 v9 }; H+ T  P/ M3 p
104.         }
     : e2 B4 h( p' \! w3 B' ^3 c
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     
106.         
     ! z" _7 ]! c) G6 ]  a* ?1 D5 b
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
     : R  u( X/ E1 J* l" Z7 w) k# }: M
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     
110.         }
     % j! d" U" L9 {0 j2 F% J
111. 
     6 }! z" A, m, M: p; K
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

" i  c5 V% q, s4 q% p* Q2 Kled.h
; w& Q1 `) h/ ~+ e) m- k! N* E' a

1. #include"stm32f2xx.h"
   
2. 
   
3. #ifndef __LED_H
   . v6 N2 M. d  d3 l* G( S, p
4. 
   5 G: L" _$ A! m6 V) t$ S2 T+ Y
5. #define __LED_H
   
6. 
   
7. 
   * g  i# R% x) u) a2 k* Q
8. void LED_Init(void);
   9 H# C& l$ z. K1 Q  T7 H' d( ?: q. v
9. 
   
10. void Delay(vu32 nCount);
    3 Y8 h" R# [, g8 R0 Y& U
11. 
    
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    : H" D* q' ?; ?% @5 x+ P
13. 
    
14.         
    
15. #endif

复制代码

led.c
" m4 W1 R  K' }' p  d

1. #include"led.h"
   
2. #include"stm32f2xx.h"
   - B0 U* `$ V& }$ S3 J
3. 
   * u: h% A8 E% C8 _+ X2 f% `
4. void LED_Init(void)
   4 c" H1 p) T5 d+ [8 [. J
5. {
   3 z) `& ~5 G0 J# X7 U" |0 n
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         
   
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   ! A7 d$ \2 E8 _+ J4 T
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    ; y4 S" p- _/ q6 J' G: T/ E0 {7 Y( e
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    , b7 c8 N/ k7 O  V+ q3 g+ I
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    # W" Q- C. M5 H
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
14. 
    9 [( P' G& A( a8 I5 l/ u
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    
17. }
    3 C. w7 r7 Z/ |1 _& p7 d+ W5 _
18. 
    * r" _. B. K5 x! e
19. 
    4 N; }" G3 F# g9 t0 n
20. void Delay(vu32 nCount)
    & c+ {7 f+ O/ e& H# A! U
21. {
    & X+ ?5 n6 {8 p+ ~/ q
22.   for(; nCount != 0; nCount--);
    
23. }
    - Z1 R( h1 f5 E' {
24. 
    % r5 G! P: y0 c) l; ?  B$ a
25. #if 1
    " B2 H& B; B) ^1 F. w* w
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    
27. {
    $ O! A/ s" _- ]2 b+ F7 m6 d3 s- F
28.   switch(LED_NUM)
    
29.         {
    
30.             case 0:
    
31.                         if(OFF_ON == 1)
    , Y7 V7 j0 q* Y9 p0 \. u7 f
32.                         {
    7 ^+ j- W5 `; C% G1 s  V3 l- e) o
33. 
    
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    * x4 c- F4 \3 V2 B* M
35.                         }
    
36.                         else
    ; g; d) q) S8 L9 l. V; I: F$ J  v
37.                         {
    
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    
39.                         }
    
40.                     break;
    
41.                     
    
42.                 case 1:
    4 z+ b. w6 |7 A& ^1 I  {5 G, N
43.                         if(OFF_ON == 1)
    : }5 X" N1 b  F
44.                         {
    
45. 
    
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    , v9 w/ x% C4 y& ]
47.                         }
    
48.                         else
    
49.                         {
    5 U7 j1 @4 @; z( C: ]2 o, @
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    
52.                     break;
    
53.                 default:
    0 k2 }$ l% r3 I8 y* ?- v
54.                         //GPIO_ResetBits(GPIOF,GPIO_Pin_7|GPIO_Pin_8|GPIO_Pin_9|GPIO_Pin_10);
    9 o( A/ c( K1 j3 _# ]$ Q
55.                         GPIO_SetBits(GPIOD,GPIO_Pin_11|GPIO_Pin_12);
    / y( P" l' i; T) q$ v
56.                     break;
    3 {( \0 U+ O( D- j- o* V( J5 K
57.         }
    
58. }
    . c) Y9 k- @% G/ t  x8 i4 e
59. #endif

复制代码

main.c

1. #include"stm32f2xx.h"
   
2. #include"can.h"
   6 J( Z+ |9 s' P) f' ?) V6 d) L
3. #include"led.h"
   
4. 
   9 h' @, ?, h: P9 S
5. 
   2 x" s: \9 b3 f6 a& y4 q: e9 B: H
6. int main(void)
   
7. {
   
8.         u8 res;
   4 b; i$ a5 x7 p* g
9.         u8 key;
     a3 Y; f- @+ D& O
10.         
    5 Y$ o6 D$ a! [. d# G( P- ^* H
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    5 l( }# x, t% V0 y' _; x
13. 
    
14.         LED_Init();
    
15.         Delay(168);
    - z- _5 F8 f2 C* P& u
16. 
    , c2 V: E, D9 o2 J7 V
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    
18. 
    
19.         while(1)
    
20.          {        
    - Z0 e" N9 B( r! k' R
21.             //1.接收数据
    
22.             key = CAN_Receive_Msg(canbuf);
    
23. 
    $ S$ y7 B; @; W: F
24.                 //2.解析数据
    2 L3 k# [& ?* Q& q
25.                 if(key == 0)
    
26.                 {
    
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    
28.                 }
    
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    
30.                 {
    
31.                     //3.发送数据给PC
    , y* l$ H8 N* a  b$ v/ `
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    
34.                         if(res == 0)
    3 b5 p  i6 c$ _+ m$ d2 N1 z. n7 i
35.                         {
    
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    
38.                         else
    - J+ y( q8 w: A; i% K8 c: a0 f$ ~+ u
39.                         {
    
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    
41.                                  
    7 N  m! m" L# c3 }( S
42.                         }
    ' E$ U% m& l7 L  r+ v
43.                 }        
    
44.         }
    " [: r1 B$ K) ], `
45. 
    ( `+ K2 q2 R8 b- F
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    5 e8 n) ?4 B6 r: ~  Y
47. //若数据发送失败，熄灭led灯1
      ]5 D. A3 l: v, ]. V& [
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    6 y9 E; x) X9 O( {/ }- p: C
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    8 @  n/ K8 w+ x
51. /*
    3 l" d" {5 R1 N' ~3 L
52.         while(1)
    
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    ; g* a, a/ S, e7 ^# `
55.                 if(res == 0)
    " U5 O& z, V) c' m* T; v
56.                 {
    
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    ) B  m* E, T( d+ G5 {$ J0 _9 Z
58.                         key = CAN_Receive_Msg(canbuf);
    3 N" a( g, v* D0 E* O
59.                         if(key == 0)
    
60.                         {
    
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    
62.                         }
    . ~( q- E) y6 h
63.                         else if(key > 0)
    
64.                         {
    
65.                                 Delay(5000);
    1 L! l' I" c% U4 l% z
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    4 B; e9 ^" F) P
67.                         }
    3 |) V" L; r" Q+ R
68.                 }
    
69.                 else
    
70.                 {
    
71.                         Delay(5000);
    . u( {" P5 C. w* I- K' |- K
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    
73.                 }
    
74.         }
    5 e8 K' l2 T- W# h. j
75. */        
    - ^) ^' P: K; n  M% U
76. }
    
77. 
    

复制代码