一、CAN通信简介
: z- E* A' E$ `# V4 f& s8 t1.1 CAN简介
0 j4 g6 D3 D2 L) s/ ]CAN全称是Controller Area Network，控制器局域网络，是ISO国际标准化的串行通信协议。CAN是国际上应用最广泛的现场总线之一。CAN通信只有两根信号线，分别是CAN_H和CAN_L，CAN 控制器根据这两根线上的电位差来判断总线电平。总线申平分为显性电平和隐性申平，二者必居其一。发送方通过使总线电平发生变化，将消息发送给接收方。
6 o! ~( |" A6 y) L* ~% P: [
3 j7 H. }% U+ h8 w/ T+ N" x  g• 2.0V---------逻辑0------显性电平
; Y5 k4 i( R& a• 0 V-----------逻辑1------隐性电平

7 v8 m& i* ?9 KCAN总线遵从“线与”机制，显性电平可以覆盖隐性电平。这就导致只有所有节点都发送隐形电平时总线才处于隐性状态。
: @$ J+ k% v3 B& ^$ V
3 t! F, L3 @. j' v; W

CAN通信示意图

2 s+ j4 b3 T* B
1.2 CAN协议特点
• 多主控 在总线空闲时所有单元都可以发送消息。当两个以上单元发送消息时，会根据标识符（ID）决定发送的优先级。
5 J/ k6 w1 ?8 ^: Y4 q1 B• 通信速度较快，最高可达1Mbps。通信距离较远。当速度为1Mbps时，传输距离小于40m。当速度小于500Kbps时，传输距离最远可达10Km。
• 具有错误检测，错误通知和错误恢复功能。CAN总线上的任意一个单元都可以检测错误，当任意一个单元检测出错误时，会立刻通知其他单元。正在发送消息的单元一旦检测出错误，会强制结束当前发送。强制结束的单元会不断重新发送消息，直到发送成功。
/ w. @, u4 K: N5 n7 R; ~  Y• 故障封闭功能 CAN可以判断出错误的类型是总线上暂时的数据错误还是持续的数据错误。当总线上持续出现数据错误时，可以将引起故障的单元从总线上隔离出去。
• 连接节点多 理论上连接单元没有数量限制，但是连接单元越多，速度就会越低。

11.3 CAN通信的帧类型
CAN通信有5种帧类型
5 O; S( M, N. n# y7 G' `9 F

& Y5 X) j* U6 _+ h4 f5 d2 o$ {5 Q9 Z- P在上述的几种帧里，数据很和遥控帧有标准帧和扩展帧两种。标准帧有11位ID，扩展帧有29位ID。

1.4 数据帧结构
CAN通信数据帧的构成如下

+ m" k& F( Y& x6 k: B& m: @

CAN通信数据帧结构

' e, y8 b0 f+ C" ]8 H7 |• 帧起始 表示数据帧开始的段，标准帧和扩展帧的帧起始都是由1个位的显性电平组成。
• 仲裁段 表示数据帧优先级的段。
  @+ u0 N+ v$ f4 S; q1 u

  U, A* n' f7 r9 G( D) b! L6 A

) C4 K4 t( E% M$ D" ]$ Z/ P

仲裁段

4 K# ~- O( m) ~" z, X/ \- j
  \, }3 Q4 ^8 P) P5 s4 t4 q
RTR是用来表示是否是远程帧（遥控帧）。RTR为0是数据帧，RTR为1是远程帧。扩展帧中的IDE是标识符的选择位，如果为0，使用标准标识符，如果为1，使用扩展标识符。扩展帧的SRR相当于标准帧中的RTR位。标准帧的ID禁止高七位是隐性电平。
; _6 f& J- c! V: l+ R- E2 p
• 控制段 控制段由6位构成，表示数据段的字节数。
2 D" q! A) d" r" \

3 m6 @5 F8 E3 q8 W% J2 }: E9 V; @$ m

) r5 F8 Z# E( J. G

控制段

6 ^- w! @+ v! e扩展帧的r0和r1是保留位，保留位必须全部以显性电平发送。DLC是数据的长度码，数据的字节数范围是0~8。IDE是标识符的选择位，如果为0，使用标准标识符，如果为1，使用扩展标识符。
• 数据段 数据段可以包含0~8个字节的数据。从MSB（最高位）开始传输。标准帧和扩展帧的数据段相同。
) U+ c, I/ d' ?4 I, ^# J: n• CRC段 CRC段用于校验，检查帧传输是否存在错误。CRC段包含15位CRC序列和1位CRC界定符。标准帧和扩展帧的CRC段相同。
  {; R9 R  h; c
$ A) r4 h  s' I
$ h" j) d) C2 Q3 \2 P

# c" v' \8 w0 Q0 G- r* E% `- E

CRC段

+ Y$ w* F" w' c! D8 t, z7 u- _' P

5 ^7 Z: b1 _% Y- A• ACK段 ACK段用来确认是否正常接收。由ACK槽和ACK界定符2位组成。标准帧和扩展帧的ACK段相同。

/ l; w. J1 O' h' t1 E3 x5 y! n

ACK段

8 K' A2 p6 M9 [# ~6 |9 N: X
( W, V7 P5 |7 J8 \3 c5 i$ m! o
• 帧结束 由7位隐形电平组成，表示帧的结束。标准帧和扩展帧的帧结束相同。


11.5 CAN的位时序
由发送单元在非同步状态下每秒钟发送的位数称为位速率。一个位可以分成4段。
• 同步段 SS
  j# b& f( w* @3 j5 S• 传播时间段 PTS
: ^4 \# K) |& b1 M• 相位缓冲段1 PBS1
• 相位缓冲段2 PBS2

2 }, s. a! b# U% T( g3 i9 I上面的这些段由称为Time Quantum（Tq）的最小时间单位组成。1个位分成4个段，一个段又分成若干个Tq，这成为位时序。
0 F7 S2 H* {, ?; K

. m2 n  s- f+ v, y3 D$ z3 I

位构成

采样点是读取总线电平，并将读到的电平作为位值的点。
  [7 s: b( ^) f! \9 d
1.6 CAN的仲裁功能
3 q) q- \/ n$ v0 j1 h2 s0 H$ Q在总线空闲态，最先开始发送消息的单元获得发送权。当多个单元同时开始发送时，各发送单元从仲裁段的第一位开始进行仲裁。连续输出显性电平最多的单元可继续发送。
6 o+ O% a* {: b, E! f$ O

' }8 m9 i4 v8 N& m3 Q( G7 X) Y

% H; }- I% C: K% X- ~& s' C" n

仲裁过程

二、STM32F1的CAN
2.1 bxCAN简介
STM32F1芯片自带bxCAN 控制器 (Basic Extended CAN)，即基本扩展CAN，可与 CAN 网络进行交互，它支持 2.0A 和 B 版本的CAN 协议。STM32F1的bxCAN有以下特点
• 支持 CAN 协议 2.0A 和 20B 主动模式
7 j! A7 S: ^  l; E, S+ y• 波特率最高达 1Mbps
" l, g$ n& z8 O$ c- u$ m* r/ S, I• 支持时间触发通信
: Q, U  p0 P* R( y& }8 Z• 具有 3 个发送邮箱
• 具有 3 级深度的 2 个接收 FIFO
• 可变的过滤器组（STM32F103ZET6有14个）

bxCAN模块可以完全自动地接收和发送CAN报文，且完全支持标准标识符(11位)和扩展标识符(29位)。
4 A5 _1 [% }/ e
2.2 bxCAN工作模式
0 R! ^4 g: y- [* t6 _% F' l; ]9 {' WbXCAN有3个主要的工作模式：初始化模式、正常模式和睡眠模式。除此之外，还有测试模式，静默模式，环回模式。
+ B# k4 O* V' @. P

2.2.1 初始化模式
首先看一下CAN主控制寄存器 (CAN_MCR)的INRQ位。

寄存器介绍CAN_MCR

! u5 e, {5 x* n2 J9 M

* B8 `- Z0 K6 d

寄存器CAN_MSR介绍

8 s. ]8 q/ F2 r! q! J, B! t) P通过介绍可以直到，想要进入初始化模式，软件先将CAN_MCR的INRQ位置1。然后等待硬件将CAN主状态寄存器（CAN_MSR）的INAK位置1。此时进入初始化模式。

; p2 Q- I. b" v% d# [8 _1 g5 m/ T9 G当bxCAN处于初始化模式时，禁止报文的接收和发送，并且CANTX引脚输出隐性位(高电平)。


2.2.2 正常模式
在初始化完成后，软件应该让硬件进入正常模式，以便正常接收和发送报文。继续看上面对于CAN主控制寄存器INRQ位的介绍。软件将INRQ位清0，可以使CAN从初始化模式进入正常模式。此时等待硬件将CAN主状态寄存器的INAK位清0即可。


0 ^7 X& L4 k/ w2 Z& o: o2.2.3 睡眠模式
bxCAN可工作在低功耗的睡眠模式。在该模式下，bxCAN的时钟停止了，但软件仍然可以访问邮箱寄存器。
$ `) ^5 O1 V; G* ~! V
0 x- @5 D" ?! ?6 n4 F& _

寄存器CAN_MSR介绍

4 g2 W( R1 a3 T$ g" M0 H% u
( b+ h4 e/ S9 x5 p

$ N* i5 {( L. j' l  @( ^  ?2 g

可以看出，软件将CAN主控制寄存器的SLEEP置1，即可请求进入睡眠模式。清零该位，退出睡眠模式。另外，如果CAN_MCR寄存器的AWUM位为’1’，一旦检测到CAN总线的活动，硬件就自动对SLEEP位清’0’来唤醒bxCAN。
5 B/ e. e& }8 P# ~& Y
2.2.4 静默模式
3 A' B2 S# a$ b) k0 K5 Z/ O6 P6 l将CAN_BTR寄存器的SILM位置’1’，来选择静默模式。

8 p  N# n+ T8 x8 r% U% i

寄存器CAN_BTR介绍

* [! [  n0 N) b5 S) N$ O

+ c& X3 Z5 d7 Q% g/ J9 V在静默模式下，bxCAN可以正常地接收数据帧和远程帧，但只能发出隐性位，而不能真正发送报文。如果bxCAN需要发出显性位(确认位、过载标志、主动错误标志)，那么这样的显性位在内部被接回来从而可以被CAN内核检测到，同时CAN总线不会受到影响而仍然维持在隐性位状态。因此，静默模式通常用于分析CAN总线的活动，而不会对总线造成影响－显性位(确认位、错误帧)不会真正发送到总线上。

  C" b8 O. E; H  X. p
  X+ I  g5 L. {+ C) _; y

# t/ k2 w6 ?  J5 E7 y# z5 z

静默模式

: m9 J& S! Y/ Y  @: F2 x& h

2.2.5 环回模式
. S2 a; o6 Y# D) H/ Z; F6 i4 ]将CAN_BTR寄存器的LBKM位置’1’，来选择环回模式。在环回模式下，bxCAN把发送的报文当作接收的报文并保存(如果可以通过接收过滤)在接收邮箱里。

# q2 y3 p! y5 v; J4 L5 X3 \

) e- ]0 K2 ?5 }0 X0 h: ^

寄存器CAN_BTR寄存器介绍

) e2 N& u$ b6 ~1 h6 m1 Z环回模式可用于自测试。为了避免外部的影响，在环回模式下CAN内核忽略确认错误(在数据/远程帧的确认位时刻，不检测是否有显性位)。在环回模式下，bxCAN在内部把Tx输出回馈到Rx输入上，而完全忽略CANRX引脚的实际状态。发送的报文可以在CANTX引脚上检测到。
0 _5 u. l! d" {1 {7 I
  V9 x! v# a) M6 |5 I& _

环回模式

- F0 @- Y) K. x4 i+ C, Y

" _( r3 q2 U+ c/ ~; N2.3 位时序和波特率
STM32将每一位分成三段
• 同步段 SS
- |  U7 D; h: G  W' a: y• 时间段1 BS1
• 时间段2 BS2
+ Z# ^. m0 _& [: h+ |
" P3 X) ^$ b2 X: Q( ~* N& k* J

9 P. Z% v( O5 h. |7 F5 c

位时序

其中tpclk是APB1总线的时钟频率，默认为36MHz。

  R# q  o0 m" q  O
% g# [  t! C1 C8 R" y三、CAN配置步骤
* R2 H5 n$ b' j* g, H2 N• 使能CAN时钟，将对应引脚复用映射为CAN功能。STM32F103ZET6只有一个CAN，对应引脚如下
0 \% c, b: p5 o: p" g0 p+ B! C4 _+ L
( O! s, C) @& i* p

CAN_RX配置为上拉输入模式，CAN_TX配置为复用推挽输出。

• 设置CAN工作模式，波特率等。库函数提供了一个结构体和一个函数来配置。初始化函数为
' [4 q$ l/ v+ }4 g, X

1. uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct)

复制代码

+ i8 t1 W; @$ T. J3 T/ n3 A+ f结构体成员如下

, q9 @# n/ G* Q' N5 @# h- W
波特率 = Fpclk1 / （（CAN_BS1 + CAN_BS2 + 1）* CAN_Prescaler）

  ^0 V$ [2 ?- l. S1 ^• 设置CAN筛选器（过滤器） 库函数也提供了筛选器的配置函数
' _' w9 `8 D* T( F( l1 l0 v9 {& t  q

1. void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct)

复制代码

- {9 X$ e% n/ v6 O/ a! o结构体内容如下
( S3 R+ d0 x8 C) b" {$ R) E5 }3 f1 V, ?3 i
2 Y) Z2 l6 P$ n* \" o  x1 P! ^7 z

$ ~! n, h+ V( F( _• 选择CAN中断类型，开启中断 库函数提供了一个中断的配置函数

1. void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState)

复制代码

" t! ?" C' `& |8 n, O" \0 Y% MCAN的中断类型有很多，这里就不再一一介绍了。
, P& _; m2 y; Y, d1 N

1. #define IS_CAN_IT(IT)        (((IT) == CAN_IT_TME) || ((IT) == CAN_IT_FMP0)  ||\
   
2.                              ((IT) == CAN_IT_FF0)  || ((IT) == CAN_IT_FOV0)  ||\
   
3.                              ((IT) == CAN_IT_FMP1) || ((IT) == CAN_IT_FF1)   ||\
   
4.                              ((IT) == CAN_IT_FOV1) || ((IT) == CAN_IT_EWG)   ||\
   
5.                              ((IT) == CAN_IT_EPV)  || ((IT) == CAN_IT_BOF)   ||\
   
6.                              ((IT) == CAN_IT_LEC)  || ((IT) == CAN_IT_ERR)   ||\
   
7.                              ((IT) == CAN_IT_WKU)  || ((IT) == CAN_IT_SLK))

复制代码

• CAN发送和接收消息 CAN发送消息的函数是
' i* B$ T0 F# }7 F! C

1. uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage)

复制代码

发送之前需要配置好消息的结构体，消息结构体成员如下
% W( E0 }: A. C, d8 l9 x; q


CAN接收函数为

1. void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage)

复制代码

CAN接收结构体与发送结构体基本相同，多了一个

0 @+ Y9 _  G. d* L1 j$ e0 W
" k) q- j% ]! z% S. e# |6 |
• CAN状态获取 库函数提供了很多可以获取CAN状态标志的函数，比如

1. uint8_t CAN_TransmitStatus(CAN_TypeDef* CANx, uint8_t TransmitMailbox)
   
2. 
   
3. FlagStatus CAN_GetFlagStatus(CAN_TypeDef* CANx, uint32_t CAN_FLAG);

复制代码

四、实战项目
, t4 \- G, Y$ S: G5 L( n0 w4.1 CAN初始化

1. /*
   % K# }8 D/ J9 I0 ^
2. *==============================================================================
   ; {" M4 Z4 @7 j, P- t
3. *函数名称：Drv_Can_Init
   
4. *函数功能：初始化CAN
   & H- y, E7 ~$ ?4 C& R  x8 i
5. *输入参数：tsjw：重新同步跳跃宽度(Tsjw)；tbs1：BS1长度；tbs2：BS2长度；
   % k1 q3 d9 T/ T- E$ H
6.                         brp：Tq大小；mode：CAN工作模式
   * u4 u, [% [+ l# g* G2 D
7. *返回值：无
   $ T" j! n- _6 y* \1 {) c- r
8. *备  注：无
     I) f4 j8 I5 q& ]  M
9. *==============================================================================
   " N0 ?) t" k- t9 ]* N' }3 K, V
10. */
    1 n# o4 P) }. {8 Q" m- \. u
11. void Drv_Can_Init (u8 tsjw,u8 tbs1,u8 tbs2,u16 brp,u8 mode)
    
12. {
    $ U, _. ?& u1 Z" ^9 J! A! ?
13.     // 结构体定义
    / Z: `' e. }5 X% n* ^
14.     GPIO_InitTypeDef GPIO_InitStructure;
    
15.     CAN_InitTypeDef CAN_InitStructure;
    9 a, V! m! m/ u& H! ^; f" x
16.     CAN_FilterInitTypeDef CAN_FilterInitStructure;
    
17.    
    
18.     // 开启时钟
    
19.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);   // 打开CAN1时钟
    
20.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);   // PA端口时钟打开
    
21.    
    
22.     // 初始化GPIO
    " m  c- F% i# n9 @! s$ J
23.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;   // PA11 CAN_RX   
    " X6 r$ T. ?0 k# f+ j
24.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;   // 上拉输入模式
    
25.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    * h" b& X6 }$ R' v0 O7 f
26. 
    3 e9 q8 e# ^, r3 {; g, g* e4 _
27.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;   // PA12 CAN_TX   
    
28.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   // 复用推挽输出
    1 X# n: a, M. x4 w. }; [- c
29.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;   // IO口速度为50MHz
    
30.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    
31.    
    , W8 k1 }, n0 u6 O0 v- F/ M
32.     // 初始化CAN
    ! }7 n' e; {: E
33.     CAN_InitStructure.CAN_TTCM=DISABLE;   // 非时间触发通信模式   
    ( R  o, h/ x& u6 T7 f4 L! V
34.     CAN_InitStructure.CAN_ABOM=DISABLE;   // 软件自动离线管理   
    
35.     CAN_InitStructure.CAN_AWUM=DISABLE;   // 睡眠模式通过软件唤醒(清除CAN->MCR的SLEEP位)
    
36.     CAN_InitStructure.CAN_NART=ENABLE;   // 使用报文自动传送
    
37.     CAN_InitStructure.CAN_RFLM=DISABLE;   // 报文不锁定,新的覆盖旧的  
    
38.     CAN_InitStructure.CAN_TXFP=DISABLE;   // 优先级由报文标识符决定
    
39.     CAN_InitStructure.CAN_Mode= mode;   //CAN工作模式设置
    4 T! I0 z8 H' t% d
40.     CAN_InitStructure.CAN_SJW=tsjw;   // 重新同步跳跃宽度(Tsjw)为tsjw+1个时间单位 CAN_SJW_1tq~CAN_SJW_4tq
    5 c# G: w* H7 b$ v6 X2 P
41.     CAN_InitStructure.CAN_BS1=tbs1;   // Tbs1范围CAN_BS1_1tq ~CAN_BS1_16tq
    
42.     CAN_InitStructure.CAN_BS2=tbs2;   // Tbs2范围CAN_BS2_1tq ~ CAN_BS2_8tq
    
43.     CAN_InitStructure.CAN_Prescaler=brp;   //分频系数(Fdiv)为brp+1
    
44.     CAN_Init(CAN1, &CAN_InitStructure);   // 初始化CAN1
    
45.    
    5 u+ B; [% g5 d/ p* W" ?
46.     // 初始化过滤器
    , }- p$ u- M& p; s) w+ D3 d9 b2 c
47.     CAN_FilterInitStructure.CAN_FilterNumber=0;   // 过滤器0
    4 P" ]9 R7 l& D" E
48.     CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;   // 掩码模式
    6 h. J# `) c/ A0 s
49.     CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;   // 32位
    
50.     CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;   // 32位ID
    
51.     CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    
52.     CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;   // 32位MASK
    
53.     CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    
54.     CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;   // 过滤器0关联到FIFO0
    
55.     CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;   // 激活过滤器0
    1 j3 B4 T  k9 w! z1 m, M) Z
56.     CAN_FilterInit(&CAN_FilterInitStructure);   // 过滤器初始化
    5 N/ q- ^! v0 w0 L. T
57. }

复制代码

4 ]/ f- E0 f+ q
4.2 CAN发送
' v% x7 F0 d7 N- y9 o

1. /*
   $ ^/ J; D  d. U
2. *==============================================================================
   + r( f) {8 t8 w* E5 [
3. *函数名称：Med_Can_Send_Msg
   ( p  @8 n1 l  F( i2 ]* q  [0 H
4. *函数功能：发送报文
   * M: i9 I1 O" v1 f8 t/ K
5. *输入参数：msg：数据段指针；len：数据长度
   % p- i# B2 x  x
6. *返回值：0：发送成功；1：发送失败
   6 v/ H, e0 S' A) ]! H4 m6 n1 x8 f
7. *备  注：固定ID为0x12
   
8. *==============================================================================
   
9. */
   7 \" {5 g7 l% k" O* H
10. u8 Med_Can_Send_Msg (u8* msg,u8 len)
    ! s6 o- w( l$ f: E0 d2 F% Q  `  L
11. {
    2 M- y+ p8 w/ x6 p( |* E
12.     u8 mbox;
    
13.     u16 i = 0;
    
14.     CanTxMsg TxMessage;   // 定义发送报文结构体
    ' M) ], z9 X$ j4 z  q
15.     TxMessage.StdId = 0x12;   // 标准标识符
    6 m8 E# J9 l7 s1 M( i! d% R
16.     TxMessage.ExtId = 0x12;   // 扩展标识符
    
17.     TxMessage.IDE = CAN_Id_Standard;   // 使用标准标识符
    6 n  F# U: ^/ K* O0 r6 C
18.     TxMessage.RTR = 0;   // 消息类型为数据帧，一帧8位
    3 N9 ^) u4 d( [6 U% D
19.     TxMessage.DLC = len;
    0 Q! D% I! C# A0 z3 O% R; S
20.     for(i = 0;i < len;i ++)
    
21.     {
    
22.         TxMessage.Data[i] = msg[i];   // 填充帧数据段
    
23.     }
    
24.     mbox = CAN_Transmit(CAN1,&TxMessage);   // 发送报文   
    
25.     i = 0;
    
26.    
    ! G/ S8 Q) s' \/ o
27.     // 等待发送结束
    6 }; ^; A/ w, ], N0 y. I) D$ r; y  f( Z
28.     while((CAN_TransmitStatus(CAN1,mbox) == CAN_TxStatus_Failed) && (i < 0XFFF))
    
29.     {
    
30.         i++;
    
31.     }
    3 M, H4 K% N5 n& X4 \
32.    
    ; x( A% F, k. z) t8 |* _  }6 _
33.     // 返回发送情况
    
34.     if(i >= 0XFFF)
    1 B7 [$ x+ m" s, ?' w5 c3 x
35.     {
    # {  m/ t4 m& M
36.         return 1;
    4 o3 u3 u1 r4 d" z, o1 y
37.     }
    ) T* K3 i4 |* _2 X- Q. G" o* [6 _
38.     return 0;  
    
39. }

复制代码

# E" `! s) m* S1 l4.3 CAN接收

1. /*
   / u7 Z; T( Y, A+ ^
2. *==============================================================================
   
3. *函数名称：Med_Can_Receive_Msg
   
4. *函数功能：接收报文
   
5. *输入参数：buf：数据缓存区指针
   ! s; X9 s5 [4 t3 {" M
6. *返回值：0：没有接收到数据；其他：接收数据长度
   & @$ {  E1 |, V: `
7. *备  注：无
   
8. *==============================================================================
   7 ?$ v' X" \, o7 t8 D
9. */
   
10. u8 Med_Can_Receive_Msg (u8 *buf)
    
11. {         
    
12.      u32 i;
    
13.     CanRxMsg RxMessage;   // 定义接收报文结构体
    / I' N! l) \$ D. D9 `2 `: f" }
14.    
    
15.     // 没有接收到数据,直接退出
    
16.     if( CAN_MessagePending(CAN1,CAN_FIFO0) == 0)
    ' X/ R9 l. ?0 m- p: r
17.     {
    
18.         return 0;
    - J& _/ K4 d6 ~; g1 M- r
19.     }
    8 b5 h4 ]) J' l* Z3 h8 J( h! d
20.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);   // 读取数据
    , k! O. V5 p2 a8 \" m4 @
21.    
    . @" Z) m1 T! c/ R1 _; d
22.     for(i = 0;i < RxMessage.DLC;i ++)
    : r$ w3 [, X8 ~6 `4 L, F
23.     {
      G7 D7 Z7 \9 D% W4 S
24.         buf[i] = RxMessage.Data[i];
    
25.     }
    / z. M4 t& M& Y3 F( Z4 X
26.    
    
27.     return RxMessage.DLC;
    % P8 [9 u% a1 L! l6 i2 O5 b) {
28. }

复制代码

4.4 CAN收发测试
& \+ X) }) d9 i利用按键WK UP控制报文的发送，按下一次发送一次报文。配置CAN波特率为500Kbps，环回模式。利用串口打印接收数据。需要注意的是，STM32只有CAN控制器，想要实现报文的收发，需要自己连接CAN收发器。首先初始化CAN

1. // 初始化CAN，500Kbps波特率
   
2.     Drv_Can_Init(CAN_SJW_1tq,CAN_BS1_9tq,CAN_BS2_8tq,4,CAN_Mode_LoopBack);

复制代码

然后编写主程序

1. u8 gKeyValue = 0;   // 获取按键值
   7 W8 {) c* ^8 x1 _2 X+ o
2. 
   1 z8 K* Q3 E* o3 n+ x2 R
3. u8 gSendData[8] = {'1','2','3','4','5','6','7','8'};   // 发送内容数组
   % l+ E5 s, I7 q4 T, J
4. u8 gReceData[8];   // 接收内容数组
   % I2 v7 D; p* g& N# |9 r
5. u8 gFlag = 0;   // 接收发送标志
   
6. 
   - Z0 a& {5 b  P; |! d2 v. Q
7. int main(void)
   ( {& q$ m: b' W7 v+ q
8. {
   $ B% T7 j5 @' C/ R6 r; ^1 u
9.     Med_Mcu_Iint();   // 系统初始化
   
10.    
    
11.     while(1)
    
12.   {
    
13.         gKeyValue = Med_KeyScan();
    
14.         
    
15.         // WK UP 按下发送消息
    
16.         if (gKeyValue == 1)
    7 N5 D, E4 q  `% h' v
17.         {
    ! E: E* G- M8 E" e& R
18.             gFlag = Med_Can_Send_Msg(gSendData,8);
    
19.             
    " g- s5 m/ b; Q1 C
20.             // 发送失败
    
21.             if (gFlag)
    
22.             {
    
23.                 printf ("Send Defeat!\r\n");
    ' \* {, j3 `! j+ B; G8 A
24.             }
    + _* ~2 m0 x% ?( @5 n( L; B
25.             else
    
26.             {
    
27.                 printf ("Send Success!\r\n");
    : b, m: p9 D3 }/ A4 N" D$ O" R/ Z
28.             }
    
29.         }
    
30.         
    4 h" e. {' X# C) `& D' k1 R
31.         // 接收报文
    : Y$ x" b, z1 N( D$ N
32.         gFlag = Med_Can_Receive_Msg(gReceData);
    1 Q5 @( k  X, w6 h& ~/ v& m) S; L8 y
33.         
    2 V5 f6 x% B" y1 {0 J$ J
34.         // 接收成功
    
35.         if (gFlag)
    1 I$ w& V6 c# u$ C2 v
36.         {
    
37.             printf ("Receive Data:%s\r\n",gReceData);
    ! b# u  u' h* j0 P, v% q/ n/ |! ~
38.         }
    
39.     }
    : f% x& N. G! M  ~8 U& u
40. }

复制代码

9 @$ }4 M+ d: X4 e4 F测试结果如下
  o, Q: D) \1 }

, u- t! y  g; r- g/ D9 o

测试结果

* C) M7 M$ g! x2 [1 V. C% t2 o
$ E# U/ c/ B- i: c3 L, E7 g

4.5 补充说明
! ?$ c' e2 q$ G* l' x4 V上面的CAN收发测试程序，发送的内容是字符串“12345678”。如果发送的是数字12345678。在串口打印接收数据时需要先将接收到的数据转换成字符，然后再打印。转换方法很简单，只需要对接收数组的每一位加48即可。
) {7 B. K( G5 X/ ?
& J7 D8 C9 s# t+ F& K. y! U( Y/ n
3 e1 S1 M/ O. x5 h  c
; X8 h7 ^; J; O, @5 D转载自： 二土电子
如有侵权请联系删除
, _, g" i5 b2 l3 ~/ U* s; T
" |; M; U6 T) k9 A