CAN控制器通过两根线上的电位差来判断总线电平
9 E& M( N: w2 L( i# b0 @% ]
can.h

1. #can.h
   ) ~2 r( A# N: M/ w9 w8 i
2. 
   
3. #include"stm32f2xx.h"
   
4. 
   , D: l: m! W8 v  r3 U
5. #ifndef __CAN_H_
   
6. #define __CAN_H_
   
7. 
     c8 V, m. l: u+ [
8. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler);
   6 P; ~, P! g/ j/ y$ q% `
9. 
   
10. u8 CAN_Send_Msg(u8 *msg, u8 len);
    
11. 
    6 i: u, `: D0 X+ T3 J# H
12. u8 CAN_Receive_Msg(u8 *buf);
    
13. 
    3 K; n" ?$ P; p; V
14. #endif

复制代码

7 r- H% G! a3 s! z- L6 ~: }can.c
9 V; c. J9 A* ?# J

1. #include"stm32f2xx.h"
   
2. #include"stm32f2xx_can.h"
   : C, ~' a& ^- s$ c8 @8 n
3. #include"can.h"
   1 K, m, X& Y7 W- {( X; l7 t+ F5 ~
4. 
   ) d  B1 `1 T. o" \
5. void CAN_Mode_Config(u8 CAN_BS1_xtq, u8 CAN_BS2_ytq, u16 Prescaler)
   * ?1 [, w6 k3 x& N+ _+ d
6. {
   & ]  C, m# Q. k/ {4 O
7.         GPIO_InitTypeDef  GPIO_InitStructure;
   1 k' j" Q7 S5 R/ R2 p2 Z1 e: @9 B
8.         CAN_InitTypeDef CAN_InitStructure;
   8 ?( `. A, i% Z, Z5 q. f1 `
9.         CAN_FilterInitTypeDef CAN_FilterInitStructure;
   
10.         NVIC_InitTypeDef NVIC_InitStructure;
    / h- p7 q% Z" N5 Q: k  a/ g1 i
11. 
    
12.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);  //使能AHB1外设时钟
    * H' z4 N& t, x( ]/ o7 n
13.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);  //使能CAN1时钟
    
14. 
    
15.         //GPIO初始化
    
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;
    6 o' o5 p3 z8 B) x; n
19.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
    . x* f# E$ l3 d8 |2 m: h# v3 w+ ~
20.     GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    
21.     GPIO_Init(GPIOD, &GPIO_InitStructure);
    
22. 
    % J* F4 ?1 z/ `7 q2 p9 C/ i
23.     GPIO_PinAFConfig(GPIOD, GPIO_PinSource0, GPIO_AF_CAN1);
    ! ~$ O( H$ s2 j! l, q/ ?
24.         GPIO_PinAFConfig(GPIOD, GPIO_PinSource1, GPIO_AF_CAN1);
    5 o3 O" R$ L) R- _, h) V2 x
25.         
    
26. 
    / b7 x0 T( f" x2 g
27.         //CAN初始化
    
28.         CAN_InitStructure.CAN_ABOM = DISABLE;           //软件自动离线管理        
    
29.         CAN_InitStructure.CAN_AWUM = DISABLE;   //睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    6 |: c0 K4 e# }
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
    
32.         CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;    //模式设置，普通模式
    
33.         CAN_InitStructure.CAN_NART = ENABLE;      //禁止报文自动传送
    
34.         CAN_InitStructure.CAN_Prescaler = Prescaler;         //分频系数(Fdiv)为brp+1        
    
35.         CAN_InitStructure.CAN_RFLM = DISABLE;      //报文不锁定,新的覆盖旧的  
    " L1 C% m% M$ S" a' I7 G( u1 X
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;     //优先级由报文标识符决定
    
39.         CAN_Init(CAN1, &CAN_InitStructure);
    & m& ?& F6 r3 O  C) E0 J/ F! C
40. 
    - L& l0 i# ]: @; w* h
41.         //筛选初始化
    
42.         CAN_FilterInitStructure.CAN_FilterActivation = ENABLE;    激活过滤器0
    
43.         CAN_FilterInitStructure.CAN_FilterFIFOAssignment = CAN_FilterFIFO0;    //过滤器0关联到FIFO0
    0 V, x- G8 Q  N/ }
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;    //
      C6 N8 c$ Q- V, A; c9 }
51.         CAN_FilterInit(&CAN_FilterInitStructure);        
    . W  X- l3 T& f3 {
52. 
    + X) F, ?  h+ E/ M
53.         CAN_ITConfig(CAN1, CAN_IT_FMP0, ENABLE);   //fifo0的中断
    1 w% Q9 x: X) H* N6 ?
54.         NVIC_InitStructure.NVIC_IRQChannel = CAN1_TX_IRQn;  //stm..xx.h，发送中断
    8 [8 ~3 [# M# S( W5 v
55.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
    2 U- j* R; X9 h( ]( q' ^
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
    
58.         NVIC_Init(&NVIC_InitStructure);
    / J; X# O. Y7 O$ c8 ?+ E/ g) S0 ?+ a% c
59. }
    
60. 
    
61. //开始发送
    
62. u8 CAN_Send_Msg(u8 *msg, u8 len)     //msg为数据，len为长度
    2 |# S2 x; w0 h' D
63. {
    
64.         u8 mbox;   //邮箱
    
65.         u16 i = 0;
    
66.         
    7 b& ~+ M: U7 N$ {% x% B; F+ p
67.         CanTxMsg TXmessage;    //can发送结构体
    
68.                
    " s& W( g7 L" O) b% _( B, r* n8 \
69.         TXmessage.DLC = len;  //数据个数，不能超过8个
    ! A; I* c! `7 t: X5 J% |- i6 `
70.         TXmessage.ExtId = 0x12;    //扩展标示符
    
71.         TXmessage.IDE = CAN_ID_STD;     //帧类型是标准帧，与这里的标准标示符和扩展标示符无关
    % D, k+ |2 l1 H* X
72.         //TXmessage.IDE = CAN_ID_EXT;   //这里的帧类型也可以设置为扩展帧，在USB_CAN那里设置标准帧，传输记录中会有
    
73.         TXmessage.RTR = CAN_RTR_DATA;   //...can.h，传送的是数据帧
    $ P7 |/ C9 I! z+ F% z  M1 [9 x" A
74.         TXmessage.StdId = 0x12;  //标准标示符
    
75.                
    ; I; a( v( Y, q2 F; R4 B5 r, Y
76.         for(i = 0; i < len; i++)
    
77.         {
    3 ~+ g5 Y1 X1 V- E& \* u6 [$ M
78.                 TXmessage.Data<i> = msg;
    & T: k; r" P4 t7 T
79.         </i>}
    
80.         
    
81.         mbox = CAN_Transmit(CAN1, &TXmessage);  //返回当前邮箱
    9 {" _& u" B+ X5 V, H5 N
82. 
    
83.         while((CAN_TransmitStatus(CAN1, mbox) == CAN_TxStatus_Failed)&&(i < 0xFFF))
    
84.         {
    
85.                 i++;      //等待发送结束完成
    : c) W% V' C# a2 Z; N: X  [
86.         }
    
87.         if(i >= 0xFFF)
    $ K+ g/ u; U) q( A$ E$ E
88.         {
    ) H' h2 X# u) v" K+ E. ~( M7 y
89.                 return 1;  
    
90.         }        
    9 y  c! h% |. M
91.         return 0;
    
92. }
    5 H3 M. b2 Y3 f( y
93. 
    
94. 
    & k/ W) u; C4 V0 {7 ^; ~
95. 
      s1 q2 F" L8 p% k8 U
96. u8 CAN_Receive_Msg(u8 *buf)
    
97. {
    
98.         CanRxMsg RXmessage;         //can接收结构体
    
99.         u16 i = 0;
    4 |5 ~( A- ]  e+ m. w, l2 E  U
100. 
     4 W/ \  S5 a6 U" @1 D
101.         while(CAN_MessagePending(CAN1, CAN_FIFO0) == 0)     //查询接收状态位，看是否由信息(报文)到达
     # H' z  Q! K. S6 l# |. e% J
102.         {
     ! k$ \) J# `0 a/ v8 }
103.                 return 0;           //没有接收到数据，直接退出，看CAN_FIFO0中是否有数据
     
104.         }
     
105.         CAN_Receive(CAN1, CAN_FIFO0, &RXmessage);   //接收信息(报文)，将CAN_FIFO0中的数据通过can1拷贝到RXmessage结构体中
     3 q6 \; A/ T$ K  j/ Z3 E
106.         
     - k- e+ |' r' f; Y6 [; L. m
107.         for(i = 0; i < RXmessage.DLC; i++)
     / d4 T7 |. H, ]; S
108.         {
     
109.                 buf<span style="font-style: italic;"><span style="font-style: normal;"> = RXmessage.Data</span><span style="font-style: normal;">;
     ! c7 i3 }& {& [  z
110.         }
     
111. 
     
112.         return RXmessage.DLC;
     
113. }</span></span>

复制代码

led.h

1. #include"stm32f2xx.h"
   4 k# F/ y4 Q# g" y3 o
2. 
   
3. #ifndef __LED_H
   
4. 
   " d# n- }& Y% k% P( j- t
5. #define __LED_H
   
6. 
   : f. `& [- P+ C+ D3 ~6 ]' p8 r. D* D
7. 
   
8. void LED_Init(void);
   
9. 
   % {/ F9 z6 W( }& F: T9 s$ B& I
10. void Delay(vu32 nCount);
    
11. 
    
12. void CTL_LED(u8 LED_NUM, u8 OFF_ON);
    # a/ R: ?+ y  v8 _+ l4 N0 Y
13. 
    
14.         
    
15. #endif

复制代码

led.c
$ E* }2 G) Y' ?8 v

1. #include"led.h"
   
2. #include"stm32f2xx.h"
   ( c3 e* [/ k9 J& [
3. 
   2 i% H  ]- g; s
4. void LED_Init(void)
   % h# n9 x% M) y, P6 l# G  ]
5. {
   
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         
   
8.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
   
9.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_11;
   
10.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   //led灯做输出，不用复用
    & X( `& e  v0 S/ U
11.         GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; //GPIO_OType_PP表示推挽方式输出，GPIO_OType_OD表示开漏
    5 R1 ~- R6 Z) N4 @. D- {: b
12.         GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
    # ?1 n, m& v, _$ [3 l6 m/ E
13.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    4 c! p7 s( D; F: q) F
14. 
    
15.         GPIO_Init(GPIOD, &GPIO_InitStructure);
    ; F8 c8 c6 L0 j6 ?9 f8 I& L& E; J1 P
16.         GPIO_SetBits(GPIOD, GPIO_Pin_12|GPIO_Pin_11);
    9 h( @0 _/ o: I& _* [
17. }
    
18. 
    7 F! k9 O  F8 D3 o1 k
19. 
    
20. void Delay(vu32 nCount)
    
21. {
    
22.   for(; nCount != 0; nCount--);
    
23. }
    . U& B) ]5 b3 c8 K6 C; M
24. 
    / s( b7 P" x* @: `9 p% I0 a  U9 O
25. #if 1
    
26. void CTL_LED(u8 LED_NUM, u8 OFF_ON)
    
27. {
    
28.   switch(LED_NUM)
    1 g  a3 o. j8 E
29.         {
    
30.             case 0:
    9 B5 e9 r% {& B+ l* a& r. B
31.                         if(OFF_ON == 1)
    
32.                         {
    # F. M& y# _/ ~$ A6 s
33. 
    8 q9 f( k  x9 c  N. N% I8 H
34.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_11);
    9 u) n! z$ D6 `& Z- \0 n1 j
35.                         }
    2 S  [+ P2 n% _% p; s
36.                         else
    % H- L; n; O2 z, v
37.                         {
    
38.                                 GPIO_SetBits(GPIOD, GPIO_Pin_11);
    8 b0 F7 x+ I2 F' A: g
39.                         }
    
40.                     break;
    
41.                     
    3 ]. N+ f' n$ @
42.                 case 1:
    ' d- R! ]9 G4 b  a
43.                         if(OFF_ON == 1)
    
44.                         {
    ' T$ d+ t% }. \* t# J/ \
45. 
    ! v' f4 P5 ]) m
46.                                 GPIO_ResetBits(GPIOD, GPIO_Pin_12);
    
47.                         }
    
48.                         else
    + _" m) L  d  v5 z- m, {
49.                         {
    
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;
    
57.         }
    
58. }
    
59. #endif

复制代码

5 H) ]& @8 V- f9 xmain.c

" C/ B. y! `7 Q. g% g2 U- A

1. #include"stm32f2xx.h"
   : }  _! V! E( y/ }0 \. x! @
2. #include"can.h"
   0 O7 x: i+ W' s0 O) F
3. #include"led.h"
   
4. 
   * {9 D$ W- c. [3 R2 u3 X
5. 
   
6. int main(void)
   
7. {
   
8.         u8 res;
   
9.         u8 key;
   
10.         
    # B% H1 z2 V$ \4 W1 e/ O
11.         u8 canbuf[8] = {0};    //这里因为不知道从USB_CAN发的是什么，只需初始化为0即可
    
12.         u8 a[8] = {02, 02, 02, 02, 02, 02, 02, 02};   //这里的02和2一样，12是0c
    
13. 
    
14.         LED_Init();
    
15.         Delay(168);
    ! k% `! ?& H. ?* j; t: ?" F
16. 
    8 w4 j: `& R5 ~0 I( p" T# {; j
17.         CAN_Mode_Config(CAN_BS1_8tq, CAN_BS2_6tq, 8);   //此时CAN波特率为：30000/(1+8+6)*8 = 250kbps
    
18. 
    
19.         while(1)
    0 d% ?7 F2 I7 S# G& \% g
20.          {        
    
21.             //1.接收数据
    3 V! j: @/ _4 ^$ t9 f
22.             key = CAN_Receive_Msg(canbuf);
    
23. 
    ( ^) m$ v+ G- o' z* z
24.                 //2.解析数据
    + ?! R! o+ z" s; E( v' [
25.                 if(key == 0)
    
26.                 {
    
27.                         CTL_LED(1, 0);   //开始的时候，没有接收到数据，故左边灯亮
    , L: A& z; d2 o  n
28.                 }
    
29.                 else if(key > 0)     //当接收到数据时，开始执行这一步
    
30.                 {
    $ ~$ ~& A% Y) ^4 s
31.                     //3.发送数据给PC
    # N9 }& N' D2 ]- B( o1 n
32.                     CTL_LED(1, 1);   
    , `5 d# m+ m2 t8 L! y! B$ m& {
33.                         res = CAN_Send_Msg(a, 8);   
    ( H4 _6 c/ d" v  g
34.                         if(res == 0)
    8 u8 s! i2 R1 S$ F7 b8 D" ?( R
35.                         {
    8 W+ g, |6 Y  W, ^  R4 x
36.                                 CTL_LED(0, 1);   //若数据发送成功，点亮led灯0
    
37.                         }
    
38.                         else
    
39.                         {
    , D, J" a. d+ d& x6 W, m2 m
40.                                 CTL_LED(1, 0);     //若数据发送失败，熄灭led灯1
    
41.                                  
    ! D2 W7 d" p3 Y3 T5 N9 y
42.                         }
    
43.                 }        
    6 |8 f# w3 c5 a9 m5 _& w
44.         }
    
45. 
    % K7 h0 T2 n+ D
46. //开始的时候，没有接收到数据，故左边灯亮，当接收到数据时，开始执行发送数据函数，若发送成功，右边灯亮，
    
47. //若数据发送失败，熄灭led灯1
    
48. //问题:数据发送成功和失败的判断:是否合理?左边的灯会一直亮
    
49. //结合上面程序，将没有接收到数据时灯灭，数据发送时灯亮，可知数据发送成功，
    . m1 o  x! X' n; O/ p
50. //问题:can程序实验代码不显示接收?而且和发送数据框的数据无关?
    ; u+ G5 j/ F! ]! i! d4 r
51. /*
    , b. }# z$ t7 G" y& @4 F
52.         while(1)
    
53.         {
    : T1 m; I' d7 m) k0 z% P& O- i
54.                 res = CAN_Send_Msg(a, 8);
    
55.                 if(res == 0)
    9 L: `4 d8 Q$ {( G0 Y
56.                 {
    3 ]% `! v' G& W$ z  V$ [
57.                         CTL_LED(0, 1);   //若数据发送成功，点亮led灯0，即右边灯
    
58.                         key = CAN_Receive_Msg(canbuf);
    $ k/ t5 Z: N/ J+ A& F" Y4 ?: j/ Z
59.                         if(key == 0)
    8 |! d! u: W! l1 n
60.                         {
    
61.                                 CTL_LED(1, 1);   //实验结果是，执行这一步
    2 l1 a# ?+ `' I4 A2 O7 `
62.                         }
    
63.                         else if(key > 0)
    
64.                         {
    
65.                                 Delay(5000);
    
66.                                 //CTL_LED(1, 1);   //灯1为左边的灯
    
67.                         }
    
68.                 }
    
69.                 else
    
70.                 {
    & }" l& Z& G9 H$ L2 |; U
71.                         Delay(5000);
      N- x- u. t; X9 {2 T, ?, A4 N& {
72.                         //CTL_LED(1, 0);     //若数据发送失败，点亮led灯1
    6 M/ S; G2 \; {* ]
73.                 }
    $ z; ?  S* p9 |
74.         }
    
75. */        
    " E. \! M1 t+ [  N5 C+ o" L
76. }
    + E' M4 Z; H0 L" K# d; n
77. 
    * y3 Q4 l- _" ]- V. Q. `

复制代码