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

% x$ a: s1 [1 m( f3 ocan.h

1. #can.h
   - t( I& N4 w$ K$ E
2. 
   2 }/ J* x& x" O, P4 F
3. #include"stm32f2xx.h"
   ! F' h7 I1 h+ h0 Y0 n6 I; W! G0 H
4. 
   , ~  d: Q$ q7 r0 l' r
5. #ifndef __CAN_H_
   
6. #define __CAN_H_
   3 @& k; e2 }, F
7. 
   
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   $ I- ?2 G9 T9 N: q* ~3 b
9. 
   
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    
12. u8 CAN_Receive_Msg(u8 *buf);
    
13. 
    4 J: J! ?2 e9 d2 x
14. #endif

复制代码

can.c
% y8 F6 {6 W2 A/ p

1. #include"stm32f2xx.h"
   ) z! O6 ^# z# ?1 F0 K5 P/ J& L
2. #include"stm32f2xx_can.h"
   
3. #include"can.h"
   + C& O( c/ t8 j, k* h
4. 
   7 t' `* Q: [9 y& j; f& V
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   7 l# t# J; V/ Y9 c/ N4 |9 w
6. {
   . N* f) `& F+ K: R* z
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   
8.         CAN_InitTypeDef CAN_InitStructure;
   2 \# R2 S( s. q7 ^+ S9 f* G# F
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    0 b1 K& E2 u' k
11. 
    
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    4 N1 O$ T; Z$ P2 ~. a
14. 
    
15.         //GPIO初始化
    1 u& w+ U  X9 X2 n
16.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
    : x  s; l1 k" a+ q
17.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    : `- K$ u7 }8 H+ M" Z
18.     GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    $ ?0 @- j5 [+ J6 b* F
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    * U+ Y# t: V: U# f# }) q: e4 x2 k+ \
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    0 B& s: U4 `' X9 f) }9 O
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. 
    ( ]- g8 a& m5 f
27.         //CAN初始化
    
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    . n9 K& c6 {/ ]# ?! W
30.         CAN_InitStructure.CAN_BS1 = CAN_BS1_xtq;   //时间段1的时间单元，取值在CAN_BS1_1tq~CAN_BS1_16tq
    & y0 \$ L9 u) Z8 a% Q7 y$ s/ A
31.         CAN_InitStructure.CAN_BS2 = CAN_BS2_ytq;    //时间段2的时间单元，取值在CAN_BS2_1tq~CAN_BS2_8tq
    
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    " @, J( y7 f- c; N
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    
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;     //优先级由报文标识符决定
    9 {# h* J; M& B; ?
39.         CAN_Init(CAN1, &CAN_InitStructure);
    8 v4 w. [* t1 D4 j% @
40. 
    9 B. n5 Z* M9 ]9 ]) {; u' c
41.         //筛选初始化
    
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    ( C/ R1 V+ M* v3 C4 f  z
44.         CAN_FilterInitStructure.CAN_FilterIdHigh = 0x0000;    //32位ID
    
45.         CAN_FilterInitStructure.CAN_FilterIdLow = 0x0000;
    - u) n+ L. C( [+ b, j! L
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
    7 m! Z* K: G; z2 Q' |
50.         CAN_FilterInitStructure.CAN_FilterScale = CAN_FilterScale_32bit;    //
    * j* M+ M% d$ }( F; G9 W1 b( }2 O
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
      }; r. f# E: u+ R/ B4 \  F% i) e
52. 
    
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    ( i* r0 e: V" O$ g) y% Y6 q; T* O
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    ; Q8 L5 O2 b" f$ |  n
58.         NVIC_Init(&NVIC_InitStructure);
    3 [+ C) d# l, z/ T
59. }
    
60. 
    8 V9 e; K: `& h6 Z2 ]; Z
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    7 `0 w, h0 S5 j: D3 d
63. {
    
64.         u8 mbox;   //邮箱
    
65.         u16 i = 0;
    4 V2 w9 L9 N3 c
66.         
    
67.         CanTxMsg TXmessage;    //can发送结构体
    : R8 K" U# ]3 j& z- X$ k7 t0 M% R
68.                
    9 i/ p* O8 I8 q$ f! ~
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    * H7 Y) S9 U  ?9 G' x0 G2 X# y% F
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    ( T( J! \: u7 V0 Z
72.         //TXmessage.IDE = CAN_ID_EXT;   //这里的帧类型也可以设置为扩展帧，在USB_CAN那里设置标准帧，传输记录中会有
    
73.         TXmessage.RTR = CAN_RTR_DATA;   //...can.h，传送的是数据帧
    * Y/ v8 e1 p5 ?! a4 n5 o
74.         TXmessage.StdId = 0x12;  //标准标示符
    - h1 y' {9 o+ O' _. T
75.                
    ! _, n* f  \" X) O6 C
76.         for(i = 0; i < len; i++)
    : p& W$ @: l, R, o8 G" C
77.         {
    / L) r  l6 b8 X' \1 \1 P  K2 X
78.                 TXmessage.Data<i> = msg;
    1 v: p! C7 C1 p
79.         </i>}
    
80.         
    
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    
82. 
    / e8 v& p( ?, |* I) l) _1 @1 d: r$ n
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    
86.         }
    ) b' H# ?6 W9 x0 J8 Q! N$ A
87.         if(i >= 0xFFF)
    : v- D" W$ a% I, m5 j* D
88.         {
    
89.                 return 1;  
    4 B8 ^* @: R- x3 G6 r
90.         }        
    
91.         return 0;
    
92. }
    ( K# p7 b; u% w; L" r5 W
93. 
    
94. 
      y# ?& V5 t, {
95. 
    & j; g' T0 h+ A+ j4 {! m4 M
96. u8 CAN_Receive_Msg(u8 *buf)
    
97. {
    ) Y& y+ F9 E; |* v8 s, S
98.         CanRxMsg RXmessage;         //can接收结构体
    
99.         u16 i = 0;
    
100. 
     
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     ( n5 M* D- D  \$ W
102.         {
     
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     & s: p4 }' I& v3 j' Z
104.         }
     & z8 X0 ^: u6 A  k3 D5 n, P
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     5 u2 x% ?+ E( f& `" y" d7 s
106.         
     
107.         for(i = 0; i < RXmessage.DLC; i++)
     
108.         {
     & H) K+ m. e4 c. [
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     7 ?' o5 T* [! N8 E: w* u! B9 S: i
110.         }
     
111. 
     
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

9 b) [9 }' S8 L0 d6 Eled.h
+ ~0 S; H& l9 C' x9 w4 L

1. #include"stm32f2xx.h"
   & E) P/ H& f8 h) N) G) ?
2. 
   8 `" r2 V. B+ Y$ B
3. #ifndef __LED_H
   3 ?, U# s% `" R& ~) t% j' A: N  e
4. 
   
5. #define __LED_H
   6 Q4 q# Z* f2 \- Y7 v, f
6. 
   . u* z6 _6 F3 X2 l; J
7. 
   
8. void LED_Init(void);
   ( |+ x% g. S' N, o
9. 
   
10. void Delay(vu32 nCount);
    
11. 
    4 X; f. ?2 l1 b. _. ^# T3 Y" Y+ n
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    ; l( {  a1 @: q
13. 
    
14.         
    " e/ p! H6 z  m- ~9 T6 q
15. #endif

复制代码

led.c

1. #include"led.h"
   
2. #include"stm32f2xx.h"
   ' Q# l! x4 z3 g2 w+ Q
3. 
   
4. void LED_Init(void)
   
5. {
   # N# a/ |" t. P# g: a& V
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         
   
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   & d7 C& X" j  L# T* |
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    ( x& w. @% K' I! r, N( B! g
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    2 M$ O" n4 B! D8 j& V5 H
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    # V( m8 R4 M. [
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    1 n* h+ K" ^1 }
14. 
    * K8 q4 {) i: N1 w- f4 \
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    ( b' Q' B  o6 ]+ ^: ]8 u
17. }
    ! _5 s" v: J- ^1 B$ ~* u* d5 U9 o
18. 
    . H; q  \6 \+ s! m# Y0 S
19. 
    4 Z5 u0 _2 O+ G; k  s
20. void Delay(vu32 nCount)
    5 t$ i; m2 t. }! f
21. {
    
22.   for(; nCount != 0; nCount--);
    " P. D  V+ y3 C' X) I( u2 M1 B/ ^
23. }
    
24. 
      |& E) {! \. F- q: F
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    7 V6 j. p  T( D
27. {
    1 d" f' }- J! S# [6 v
28.   switch(LED_NUM)
    0 U( A0 @! ]# e5 \" f6 E/ @
29.         {
    : w/ E) ?9 d) }3 h! n) p
30.             case 0:
    
31.                         if(OFF_ON == 1)
    % G6 o. R" C$ R7 ^0 s. z; Z- G
32.                         {
    & h2 ?4 c4 J' V# x. Z
33. 
    
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    
35.                         }
    * S7 P) s) }. X6 R9 a& S1 c
36.                         else
    
37.                         {
    / A% B2 Q) x2 o# o) t4 ?3 s4 {9 C
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    : x# O& H  Q+ U/ B  }: ^
39.                         }
    6 w# d2 V4 ?3 J/ c
40.                     break;
    - Y: n. u  D1 g# Y) Y
41.                     
    + W8 q/ a: V: n/ U* Q6 n1 O
42.                 case 1:
    % F4 \" B  X, }3 V+ V$ |- F
43.                         if(OFF_ON == 1)
    7 I# F% h& ]' Z, i
44.                         {
    / P9 O3 c7 m( G1 _* o6 x
45. 
    0 [9 }/ O" D' T. \6 ^/ s  D4 w
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    
47.                         }
    
48.                         else
    + u0 f  O* Y+ `
49.                         {
    1 n3 s& o8 H; u7 w* m
50.                                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
    
51.                         }
    
52.                     break;
    
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);
    
56.                     break;
    + S0 G# d) k0 p0 n: k
57.         }
    
58. }
    , Z) H# L- u: M9 A) \% ^- i
59. #endif

复制代码

  T2 \) a2 S. K* }2 @9 omain.c

1. #include"stm32f2xx.h"
   
2. #include"can.h"
   8 q! r* h& E) f# Y+ i3 N& ~
3. #include"led.h"
   ; G5 C5 s' X( S& t/ w$ g# ]
4. 
   ( t8 q) D. t- l: n3 R2 J
5. 
   
6. int main(void)
   * T% Q/ a+ {+ ?4 X: B8 L  H
7. {
   
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
    ) N  y8 O0 ^. }
13. 
    - O& a# z; A- X
14.         LED_Init();
    ' x5 j( p% z4 j, n6 l/ I7 j9 J
15.         Delay(168);
    
16. 
    / o" T* L4 i+ S. f
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    " m8 K4 D5 V' i
18. 
    
19.         while(1)
    9 o7 |( Q1 I, l( T4 l" u$ f
20.          {        
    
21.             //1.接收数据
    
22.             key = CAN_Receive_Msg(canbuf);
    / j6 C" N; ~+ }( U' n
23. 
    # `5 S1 O1 ]0 Y8 c2 K1 W! I
24.                 //2.解析数据
    
25.                 if(key == 0)
    
26.                 {
    0 ]  F  g) K! A$ o$ s' F0 v+ O
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    7 d3 \+ z% m5 c
28.                 }
    4 B1 m$ B/ k% d
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    ( p! B6 L+ f! C% v+ ^9 t& p
30.                 {
    
31.                     //3.发送数据给PC
    
32.                     CTL_LED(1, 1);   
    
33.                         res = CAN_Send_Msg(a, 8);   
    
34.                         if(res == 0)
    " A8 b" s, q: l' I6 V/ X3 B
35.                         {
    3 O7 l1 f2 |7 Q
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    : X8 V5 {) D% n3 X
38.                         else
    
39.                         {
    
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    2 W: P6 S. Z2 n8 S: a5 e
41.                                  
    
42.                         }
    + ]1 u2 U3 ?' A1 {, f) w( r
43.                 }        
    
44.         }
    , g6 o  X# c* U
45. 
    
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    - c, u$ S; O1 x& e2 o4 }
47. //若数据发送失败，熄灭led灯1
    5 X( i$ y8 E% `4 f3 K! R8 u
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    ' U+ F. e7 S* v. Y
51. /*
    7 f( J  d1 o+ j# F7 C; M
52.         while(1)
      |# q$ ?1 Y9 }
53.         {
    
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    * ?3 M8 q5 B1 k5 V$ N
56.                 {
    
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    + r9 N; b  X9 P! N* {* M
58.                         key = CAN_Receive_Msg(canbuf);
    
59.                         if(key == 0)
    
60.                         {
    2 G6 n7 n8 @6 C% G  f' B
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    
62.                         }
    
63.                         else if(key > 0)
    
64.                         {
    
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    / C$ s7 [& u  U0 ]# u
68.                 }
    
69.                 else
    
70.                 {
    6 L4 E5 d2 W" ~, t4 B+ x+ x) m) L
71.                         Delay(5000);
    % z; T9 Z* i: E- r( A
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    5 R( l( G! J5 l$ [
73.                 }
    ) E4 _6 q7 S; m
74.         }
    
75. */        
    
76. }
    ' f: r) C/ U4 |7 m+ ?6 S+ V5 F* X
77. 
    7 f6 m$ |2 ^- c- X" S! P6 L' l

复制代码

1 |2 R$ n/ U; f) `6 @! J