在简单的学习过了STM32中的简单外设以及中断系统后，在本章节中开始介绍STM32芯片中各个通信接口的配置。在计算机中，按数据传输方式可分为串行通信以及并行通信；按数据同步方式可分为异步通信和同步通信；按数据传输方向课分为单工、半双工和全双工通信。
, R4 e$ ^2 b4 b& Q( q7 G" v5 I串行通信： 在一条数据线上，将数据按照二进制位依次传输，传输一位数据占据一个固定的时间长度。适用于计算机之间、计算机与外设之间的远距离通信，其具备占用传输线数量少、长距离传输时成本低的优点，但数据传输控制相比于并行通信复杂。
并行通信： 在多条数据线上，一个数据的多位同时进行传输，通常是8位、16位或32位数据一起进行传输。其具备控制简单、传输速度快的特点，但由于其占用数据线过多，长距离传输数据时成本较高，且接受设备出同时接收数据时容易出现错位即抗干扰能力弱。
( U5 T# [* _; d. I4 Q% U异步通信： 通信双方（发送和接收端）使用各自的时钟控制数据的发送和接收，但为了双方的收发协调，时钟需要尽可能的一致。其具备实现容易、成本低的特点，但通信过程中每个字符需要添加2~3位数据作为起止位，各帧之间需有间隔导致了传输效率不高。
5 Y; h& `/ m( U' o# l% o) x! m9 ?同步通信： 通信时需要建立发送方时钟对接收方时钟的直接控制，使得双方达到完全的同步。传输数据的位之间距离为“位间隔”的整数倍，且传送的字符间不留间隙，保持位同步关系。
+ ^& T/ O% X  ^$ _单工通信： 数据的传输仅能够沿着一个方向，不能反向传输。
半双工通信： 数据的传输可以沿着两个方向，但需要分时进行。
$ n" Z8 ^& _  |1 B2 B3 c全双工通信： 数据的传输可以同时双向的进行。
" m7 y9 d9 o. P; M! O( n通信速率： 衡量通信性能的参数，以波特率来表示，代表着每秒钟传输二进制编码的位数，单位为：位/秒。

4 `- S( s+ g$ x' r2 J1 O3 ]1、USART串口通信
1.1 USART介绍
串口通信（Serial communication）是外设和计算机之间经过数据线、地线以及电源线进行数据传输的一种通信方式，属于串行通信。串口是常用的接口标准，规定了电气标准，但没有规定接口插件电缆以及使用的协议。
A. 接口标准
! O1 R4 p0 }& I% b9 Y! q串口通信的接口标准包含了RS-232C、ES-232、RS-422A、RS-485等等，常用的是RS-232C标准，定义了数据终端设备（DTE）与数据通信设备（DCE）之间的物理接口标准。而在RS-232C标准下又有DB25（25针连接器）和DB9（9针连接器）之分，DB9的管脚说明如下表中所示：


2 v  N6 ^5 e1 N% s- w
B. 通信协议
RS23的通信协议遵循96-N-8-1格式。其中“96”表示通信波特率为9600；“N”表示无校验位；“8”表述数据位数为8位；“1”表示有1位停止位。
4 y0 x6 i1 a7 I$ M& T1 n# [% r9 }" `
  h% O9 ^  D1 ~' ^+ o& ^4 B在STM32中的USART（通用同步异步收发器），可以与外部设备进行全双工数据交换，UART（通用异步收发器）是在其基础上剪裁掉了同步通信功能。USART在STM32中应用最多的是对printf重定向，通过输出函数将信息打印到串口助手上显示出来。USART的内部结构框图如下所示：

0 P4 y! l; L* E* m1 h4 N) g. @1 S5 f& P1 w

引脚功能： TX（发送数据输出引脚），RX（接收数据输入引脚），SW_RX（数据接收引脚，内部引脚），nRTS（请求以发送，n表示低电平有效，仅适用于硬件流控制），nCTS（清除以发送，n表示低电平有效，仅适用于硬件流控制）。
数据寄存器： USART_DR，低9位有效，第9位数据是否有效取决于USART控制寄存器1（USART_CR1）的M位设置，当M位为0时表示8位数据字长，M位为1时表示9位数据字长，通常情况下使用8位数据字长。
控制器： USART中有专门控制发送的发送器、控制接收的接收器，以及唤醒单元、中断控制等。
波特率生成： 波特率越大，传输速度越快。
计算公式： 波特率= USART的时钟频率 / (16*USARTDIV)
其中USARTDIV是一个存放在波特率寄存器（USART_BRR）的一个无符号定点数。串口通信常用的波特率为4800、9600、115200等。
: W. K5 x2 k2 m* E/ L$ c* v
1.2 串口通信配置步骤
在对STM32F1的USART进行配置时，需要使用到USART库，包含stm32f10x_usart.c和stm32f10x_usart.h文件。
. C6 F7 Y$ l0 [- K4 L
8 }  e0 R6 {! q7 I! [2 g" A使能串口时钟和GPIO端口时钟；
STM32F103ZET6芯片中共有5个串口通信资源，其中串口1挂载在APB1总线上，串口2~5挂载在APB2总线上。使用串口时，分别使能对应总线上的串口以及GPIO的时钟即可。调用函数：RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOx, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_USARTx, ENABLE);
4 C7 g# J4 J& Q7 n
* o/ Y5 {* P. _* _1 p  ?. J配置GPIO端口，设置串口引脚为复用功能；
使用引脚的USART功能需要将GPIO设置为复用功能，并将串口的Tx引脚配置为复用推挽输出，Rx引脚配置为浮空输入，调用函数：
+ O. w2 u& |5 L% ?8 c
0 g( g5 D+ |! Y! }# P# b

1. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
     L% s7 N- |8 n8 G3 z
2. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   
3. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
   8 R6 {, H" `/ A' \" |7 U9 M! K  K
4. GPIO_Init(GPIOA, &GPIO_InitStructure);
   
5. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
   
6. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
   
7. GPIO_Init(GPIOA, &GPIO_InitStructure);

复制代码

初始化串口参数；
调用函数：void USART_Init(USART_TypeDef* USARTx, USART_InitTypeDef* USART_InitStruct);
其中USART_InitTypeDef是一个结构体类型，其中的成员变量如下：
; c3 `$ v. o8 Z3 [+ `* E

1. typedef struct
   
2. {
   $ j' D6 }3 W& j) W, j. ^9 j
3.         uint32_t USART_BaudRate;                                //波特率，4800 / 9600 / 115200
   3 @# ^; i% v8 l- @  [" h2 D! j  b
4.         uint16_t USART_WordLength;                        //字长，8 / 9
   
5.         uint16_t USART_StopBits;                                //停止位，0.5 / 1 / 1.5 / 2
   
6.         uint16_t USART_Parity;                                        //校验位 USART_Parity_NO（无校验）、USART_Parity_Even（偶校验）以及USART_Parity_Odd（奇校验）
   $ B6 p- I5 |' C; I% @
7.         uint16_t USART_Mode;                                        //USART模式 USART_Mode_Rx / USART_Mode_Tx
   
8.         uint16_t USART_HardwareFlowControl;        //硬件流控制 只有在硬件流模式下有效，常用无硬件流模式 USART_HardwareFlowControl_None
   
9. } USART_InitTypeDef;

复制代码

使能串口；
/ w  Q0 I' B: {, `( n# w9 q调用串口函数：void USART_Cmd(USART_TypeDef* USARTx, FunctionalState NewState);
设置串口中断类型并使能；
调用函数：void USART_ITConfig(USART_TypeDef* USARTx, uint16_t USART_IT, FunctionalState NewState);
其中USARTx选择串口，USART_IT选择中断类型，NewState选择使能或失能。串口中断的类型很多，需要依据具有的场景进行选择，例如在串口接收数据时，产生中断：USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
3 p0 f( g# K7 j# T+ X2 \串口发送数据时：USART_ITConfig(USART1, USART_IT_TC, ENABLE);
设置串口中断优先级，使能串口中断通道；
对串口中断进行了配置，需要初始化NVIC。
& q" M- I" ~! u. r% U1 _3 V编写串口中断服务函数。
* S1 k3 g6 j$ J! c7 l使用串口开启了中断功能，就需要在中断服务函数（USARTx_IRQHandler）判断由串口产生的中断是那种类型，然后实现相应的功能。判断中断类型，调用库函数：ITStatus USART_GetITStatus(USART_TypeDef* USARTx, uint16_t USART_IT);
串口中的接收函数：uint16_t USART_ReceiveData(USART_TYpeDef* USARTx);
" o+ X! M9 B% k% u发送函数：void USART_SendData(USART_TypeDef* USARTx, uint16_t Data);
$ C! N  z. {3 a" K# l: [9 G读取串口状态标志位：FlagStatus USART_GetFlagStatus(USART_TypeDef* USARTx, uint16_t USART_FLAG);
9 O. G5 [' H+ ~, y- S1.3 应用示例
使用STM32的USART1实现单片机与电脑端串口助手之间的通信，详细的代码如下：

! A) e/ \. R5 h/ g5 O. zusart.h

7 u4 F7 |& U+ p6 _$ R! z

1. #ifndef _usart_H
   3 D2 h( O' ]. q2 D
2. #define _usart_H
   
3. 
   / L, V# e. Y, C9 v1 g7 M: ?' s, D
4. #include "system.h"
   
5. 
   
6. void USART1_Init(u32 bound);
   
7. 
   2 p, u: c$ a1 e7 a& D+ N
8. #endif

复制代码

4 X, ?0 C( d: T8 s( S7 Cusart.c

1. #include "usart.h"        
   
2.          
   , G4 i) w8 M0 Y( k+ S' G
3. int fputc(int ch,FILE *p)
   5 r/ M3 r2 m6 U5 k, B
4. {
   0 |: Q  }' A* X7 @0 c
5.         USART_SendData(USART1, (u8)ch);
   + A  D  n+ a3 y5 l( C( g
6.         while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);
   
7.         return ch;
   
8. }
   % p, o7 y! L3 H: J: @( D  Y" d* I' O3 B
9. 
   - e6 O' U! m7 g% t6 `
10. void USART1_Init(u32 bound)
    
11. {
    
12.         GPIO_InitTypeDef GPIO_InitStructure;
    
13.         USART_InitTypeDef USART_InitStructure;
    8 v0 Q. a# f% l) p+ j: b2 q6 Z' j
14.         NVIC_InitTypeDef NVIC_InitStructure;
    
15.         
    
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
    
17.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
    5 q# q* \8 x0 F% M5 Y1 B
18. 
    $ {. M- h: [" k
19.         
      ^  h+ O9 X1 ~; }7 m0 ]
20.         // 配置GPIO端口
    $ N7 m; [% s8 |$ B
21.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_9;//TX                        
    ( B+ u4 o6 I! j1 E$ O3 {
22.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    5 I. R8 A6 L) g2 I
23.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_AF_PP;            
    
24.         GPIO_Init(GPIOA,&GPIO_InitStructure);  
    
25.         GPIO_InitStructure.GPIO_Pin=GPIO_Pin_10;//RX                        
    8 X7 T/ X6 y. v: V9 z% Y
26.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IN_FLOATING;                  
    9 Z' v+ B7 S3 O6 h9 v: z3 q
27.         GPIO_Init(GPIOA,&GPIO_InitStructure);
    5 p7 b( @$ t6 L2 v- N* _
28.         
    ! z9 B' N( W6 W6 A! R
29. 
    
30.    //USART1 初始化配置
    1 {& [8 r, }' a1 k
31.         USART_InitStructure.USART_BaudRate = bound;
    ! M7 m+ x9 Y4 F( t
32.         USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    
33.         USART_InitStructure.USART_StopBits = USART_StopBits_1;
    
34.         USART_InitStructure.USART_Parity = USART_Parity_No;
    9 s' j* |; K) R+ K- S" F8 I: I
35.         USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//ÎÞÓ²¼þÊý¾ÝÁ÷¿ØÖÆ
    2 \  a7 L* r+ H2 n5 w1 a
36.         USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;        
    
37.         USART_Init(USART1, &USART_InitStructure);
    . n7 C/ \) e5 @" B1 P9 E- y+ y
38.         
    ' d# @& c( K7 F* g6 v, e
39.         USART_Cmd(USART1, ENABLE);  
    $ Z4 I) O6 G* Y
40.         
    7 q( e' t, o6 y, @4 \
41.         USART_ClearFlag(USART1, USART_FLAG_TC);
    - W  ~( p& \& Z+ ]% w8 f8 w
42.                
    
43.         USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
    
44. 
    
45.         //Usart1 NVIC 配置
    
46.         NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    
47.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3;
    
48.         NVIC_InitStructure.NVIC_IRQChannelSubPriority =3;        
    6 U8 F$ ^  ]9 A+ U  H3 t
49.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                        
    ! M. G& B! E+ N
50.         NVIC_Init(&NVIC_InitStructure);        
    
51. }
    
52. 
    
53. 
    1 A: e1 ~' c2 ^9 f' }
54. void USART1_IRQHandler(void)                        
    1 j$ i, C& x/ P1 f
55. {
    + M6 E+ m6 h8 s5 ?5 |8 z' J4 ?
56.         u8 r;
    
57.         if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  
    
58.         {
    
59.                 r =USART_ReceiveData(USART1);
    8 o- l# u: O" n, ~/ w) U( @
60.                 USART_SendData(USART1,r);
    
61.                 while(USART_GetFlagStatus(USART1,USART_FLAG_TC) != SET);
    . X0 b8 D( v5 I& L8 `7 e
62.         }
    . [0 l# E+ s5 t1 u0 P! g$ ~9 z- ?
63.         USART_ClearFlag(USART1,USART_FLAG_TC);
    8 m" B/ ?9 ^/ O
64. }         

复制代码

4 r# n: ~8 T/ Q4 `1 m- J5 ?main.c

. ~( e2 ]+ n+ q

1. #include "system.h"
   5 I+ D- V! q. Q
2. #include "led.h"
   ! b+ R0 w3 C. C& E* H! f, M- X: @) E
3. #include "SysTick.h"
   
4. #include "usart.h"
   
5. 
   
6. int main()
   
7. {
   
8.         u8 i=0;
   
9.         SysTick_Init(72);
   & a7 q; K/ }. @( I7 R
10.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
11.         LED_Init();
    
12.         USART1_Init(9600);
    
13.         
    : A6 s0 m/ \; c- e* E+ ?
14.         while(1)
    
15.         {
    
16.                 i++;
    + H0 U& x: g  |# p" ]' g) ~7 c
17.                 if(i%20==0)
    
18.                 {
    
19.                         led1=!led1;
    , v; K2 Y! C) n2 G- `2 F
20.                 }
    - C: O; x4 s' M8 x: ~& S
21.                 delay_ms(10);
    
22.         }
    $ g7 e& U1 e( ?! e/ R6 {
23. }
      T& q2 v; e1 \6 B  Q3 j# B

复制代码

2、I2C与EEPROM通信
2.1 I2C通信及配置步骤
  B% K0 E, D2 z- Q7 a# B7 |* U! XI2C（Inter-Intergrated Circuit）是PHILIPS公司开发的串行总线，用于连接微控制器及其外围设备，属于同步通信。其具有控制方式简单，通信速率较高的优点。I2C总线由两根双向信号线组成，一根是数据线SDA，一根是时钟线SCL。使用I2C通信设备的连接如下图所示：


8 w3 U5 `7 S0 R9 C- z+ RI2C的物理层具备如下特点：
（1） 支持多设备，总线上可连接多个I2C设备，支持多主机和多从机设备；
" w$ m- ]' n  N& G. v' }（2） I2C总线只是用SDA和SCL两根线路，SDA传输数据，SCL用于数据收发同步时钟；
( w6 f. L3 t3 L% {% P. D) P# _# ~- `（3） 连接在I2C总线上的设备都拥有一个独一无二的地址，主机可使用改地址对不同设备之间进行访问；
/ S7 N4 x2 f8 P" L# {% n" g（4） I2C总线通过上拉电阻，当I2C设备空闲时，输出高阻态，当所有设备都空闲时，由上拉电阻将总线拉升为高电平；
（5） 多主机设备同时使用I2C总线时，为了防止数据冲突，会采用仲裁方式决定占用情况；
（6） 三种传输模式：标准模式（速率100kbit/s）、快速模式（400kbit/s）以及高速模式（3.4Mbit/s）;
4 ^: h; p$ N6 o, v$ z2 _- }2 }（7） 连接到相同I2C总线上的设备数量受到总线最大电容400pF的限制。
I2C的协议层包含了：
（1） 数据有效性规定；
! }  K; S! g& @1 fI2C总线在传输数据时，SCL时钟信号为高电平的过程中，数据线上的数据需要保持稳定；在时钟信号为低电平时，数据线上允许有高/低电平的变化。



（2） 起始和停止信号；
SCL时钟线为高电平是，SDA数据线由高电平向低电平的变化表示起始信号；SCL为高电平是，SDA有低电平向高电平的变化表示终止信号。


5 n$ Q8 J- e4 n
（3） 应答信号；
当主机发送器件传输一个字节的数据后，其尾部需跟一个校验位，检验位是接收端通过控制SDA来实现，可以提示发送端数据已被接收完成。校验位就是数据或地址传输过程中的响应，包括“应答（ACK）”和“非应答（NACK）”两种信号。作为数据接收端，设备接收到数据后，如果要继续接收数据，则需要向对方发送ACK信号即特定的低电平脉冲；若不要继续接收数据，则需要向对方发送NACK信号即特定的高电平脉冲。


/ X6 C$ Z& {( T" \) G
: }4 e. Z, m+ d6 G) P（4） 总线寻址方式；
  D5 ^/ o; Q& u7 p% zI2C总线寻址方式按照从机地址位数可分为：7位寻址和10位寻址。
0 z: P) [5 Z3 y' o, P
0 E; E% I* L5 K% E' S1 w

9 @) [) R9 T( ]  |" BD7~D0组成从机的地址，D0为数据传输方向位，置0时表示主机向从机写数据，置1时表示主机由从机读取数据。
+ w& ?( z+ W" D（5） 数据传输。
I2C总线上传输的数据比较广泛，包含有地址信号以及数据信号，在一个起始信号发出后，紧接着需要传输一个从机地址，每一次数据的传输由主机产生的终止信号结束。在总线的一次数据传输中，有下以下的方式：
A. 主机向从机发送数据，数据传输方向在整个过程中不变；
. m( ~7 W2 r1 U7 F9 O- vB. 主机在第一个字节后，变为从从机读取数据；
C. 传输过程中，需要改变数据流动方向时，起始信号和从机地址被重复产生一次，但两次读/写方向位相反。
# ?1 t1 X: T$ e' b0 ~8 b
+ A' C6 p" {' `7 m6 f1 j2 K2.2 EEPROM（AT24C02）
AT24C02是一个2K位串行CMOS，内部含有256个8位字节，有一个16字节页写缓冲器。AT24C02通过I2C总线进行操作，拥有写保护功能，芯片内部存储的数据可以保证在掉电的情况下不丢失，一般用来存储一些比较重要的数据。

' c  v! E1 G9 r/ u# q

' p8 N( q' S! C# k0 t" WAT24C02芯片的地址有7位，高4位为1010，低3位由A0/A1/A2信号线的高/低电平决定。I2C通信中传输地址或数据都是以字节为单位的，在传输地址时，芯片的地址占据7位，还有1位用来选择读/写方向。
) l! Y' O! \0 X8 S0 R4 |# O" a
9 o: K2 h" q$ M$ Q
" R, R* }7 i( z/ n9 |4 o
1 [+ q$ A7 g3 }# s/ _7 X( |2.3 应用示例
" ^4 m! {+ s% r7 J+ `24cxx.h

5 f: V) Q8 b/ O8 y/ ~/ j: `

1. #ifndef _24cxx_H
   7 G! J# `5 ?  Z, _1 d" ]8 c
2. #define _24cxx_H
   + k0 d. C; Y8 r) L0 [5 a
3. 
   
4. #include "system.h"
   
5. #include "iic.h"
   
6. 
   
7. #define AT24C01                127
   ; w( o5 ]  M- E9 L1 g6 ?+ v
8. #define AT24C02                255
   
9. #define AT24C04                511
   
10. #define AT24C08                1023
    & S4 Q9 Y" p0 \$ H6 X* G
11. #define AT24C16                2047
    
12. #define AT24C32                4095
    : `2 q8 |. c& ?# }$ O9 B0 p2 m
13. #define AT24C64                8191
    : u% F  w7 p& {) m
14. #define AT24C128        16383
    
15. #define AT24C256        32767
    
16. 
    
17. #define EE_TYPE AT24C02
    : t. _2 ~/ O1 P; l4 [# G3 d7 i1 b
18. 
    
19. void AT24CXX_Init(void);
    
20. u8 AT24CXX_ReadOneByte(u16 ReadAddr);
    ) ~6 }5 T& ?* V$ e
21. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite);
    / |2 M5 Y8 i( [8 E% M: p
22. void AT24CXX_WritelenByte(u16 WriteAddr,u8 DataToWrite,u8 len);
    % b# U' |0 W- w- e
23. u32 AT24CXX_readLenByte(u16 ReadAddr,u8 Len);
    & A8 d( D7 x: y8 @- d$ ~1 @
24. u8 AT24CXX_Check(void);
    + a5 H' \) ?( A1 U
25. void AT24CXX_read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead);
    
26. void AT24CXX_write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite);
    
27. 
    0 e+ L; b+ P' @3 _/ C9 ?
28. #endif
    ( V0 H- K, F3 B: m! P' K# }1 C& L

复制代码

24cxx.c
, m$ W8 ?2 A' q1 y* m+ Y
! S  t! X) A- D, R& |+ a

1. #include "24cxx.h"
   
2. #include "SysTick.h"
   / x4 C' h( @( f2 P3 ?, o) x; K
3. 
   
4. void AT24CXX_Init(void)
   
5. {
   & h- C+ V6 z7 @+ _# d
6.         IIC_Init();
   3 A) y( o  C. ]# S
7. }
   
8. 
   0 l9 ]  W: ~& V" I: y0 N7 v7 G/ H
9. u8 AT24CXX_ReadOneByte(u16 ReadAddr)        //从从机AT24Cxx读取一个字节数据
   ' j9 _3 k% n1 A: o9 S+ i$ ~" z
10. {
    
11.         u8 temp=0;
    5 l& `' @: L9 [. q
12.         IIC_start();
    + Y, v9 s4 O. f+ {! R
13.         if(EE_TYPE>AT24C16)
    * k) z: u; Y5 ]+ K- I
14.         {
    
15.                 IIC_send_byte(0xA0);                                 //发送写命令
    5 z, c; e  L8 y& V- x/ z" j
16.                 IIC_wait_ack();                                         //等待应答
    
17.                 IIC_send_byte(ReadAddr>>8);                //发送高地址
    
18.         }
    
19.         else
    " K  m3 N; A; c$ l1 ^' U: E7 G
20.         {
    4 C. u( X- r) Y
21.                 IIC_send_byte(0xA0+((ReadAddr/256)<<1));        //发送器件地址，写数据
    3 a( I4 n# T5 `! F. T
22.         }
    ! r& {3 x8 M$ J4 t: L6 C
23.         IIC_wait_ack();
    8 r# j# {  H* B
24.         IIC_send_byte(ReadAddr%256);                        //发送低地址
    
25.         IIC_wait_ack();
    4 T2 {3 e( ~4 ~. y1 I# `, b
26.         IIC_start();
    
27.         IIC_send_byte(0xA1);                                        //进入接收模式
    4 m  T" A" w/ D8 q2 b/ l+ w
28.         IIC_wait_ack();
    
29.         temp=IIC_read_byte(0);
    
30.         IIC_stop();
    : x+ n, L, v# U
31.         return temp;
    
32. }
    " |' x) c9 n5 H+ u- }; ^/ G
33. //在AT24Cxx指定地址写入数据
    - d. m2 C: [* J: e+ B$ F5 W7 D
34. void AT24CXX_WriteOneByte(u16 WriteAddr,u8 DataToWrite)
    9 P2 j: _7 Z9 d
35. {
    / B" E6 F( f  d
36.         IIC_start();
    
37.         if(EE_TYPE>AT24C16)
    
38.         {
    ' {5 z0 Q* i+ c1 [
39.                 IIC_send_byte(0xA0);                                 //发送写命令
    6 q1 K0 g" w1 ^6 a
40.                 IIC_wait_ack();                                        //等待应答
    
41.                 IIC_send_byte(WriteAddr>>8);                 //发送高地址
    
42.         }
    5 ]8 B9 q& s2 d0 c
43.         else
    
44.         {
    & a/ g. }5 S; Q; I! Z" C5 E
45.                 IIC_send_byte(0xA0+((WriteAddr/256)<<1));         //发送器件地址，写数据
    " j, [9 N) ^# A* r, I8 o
46.         }
    
47.         IIC_wait_ack();
    
48.         IIC_send_byte(WriteAddr%256);
    
49.         IIC_wait_ack();
    
50.         IIC_send_byte(DataToWrite);
    
51.         IIC_wait_ack();
    2 d% k! R" i; h. s! X
52.         IIC_stop();
    " D) H$ U0 U0 I$ _8 w
53.         delay_ms(10);
    : A3 H% k4 V1 Y
54. }
    " q1 y; r7 C8 n7 ]& z4 N
55. //向AT24CXX指定位置写入长度为len的数据
    0 h" a- s# k8 a9 C4 ]1 P
56. void AT24CXX_WritelenByte(u16 WriteAddr,u8 DataToWrite,u8 len)
    - j, L% h1 e) o1 Z) ^
57. {
    ) o; Y9 h) W6 ]- T  X# Y- p
58.         u8 t;
    
59.         for(t=0;t<len;t++)
    
60.         {
    4 l- z+ O) o" \3 K: }
61.                 AT24CXX_WriteOneByte(WriteAddr+t,(DataToWrite>>(8*t))&0xff);
      o/ C+ [' W; v+ w
62.         }
    0 B6 a0 [. I/ S* D# ~9 z. p
63. }
    
64. //从ATC24XX中指定地址开始读长度为len的数据
    " `$ r9 t: s8 D+ o8 v2 a
65. u32 AT24CXX_readLenByte(u16 ReadAddr,u8 Len)
    
66. {
    ' u6 y8 u  F) X. ~( U
67.         u8 t;
    
68.         u32 temp=0;
    
69.         for(t=0;t<Len;t++)
    
70.         {
    
71.                 temp<<=8;
    # V# Y7 }* W% f- K
72.                 temp+=AT24CXX_ReadOneByte(ReadAddr+Len-t-1);
    * c8 w$ i( F5 x9 l
73.         }
    
74.         return temp;
    0 s6 r$ W, y/ _
75. }
    
76. //检查ATC24XX工作是否正常，0正常，1不正常
    3 A# ]9 A# r5 e- A) R% N5 D
77. u8 AT24CXX_Check(void)
    
78. {
    , g* k4 M4 s0 l- w  N
79.         u8 temp;
    ! }4 W. ~  q( }/ E' j
80.         temp=AT24CXX_ReadOneByte(255);
    4 }' n- l/ t  n8 M5 x
81.         if (temp==0x36)                                       
    
82.                 return 0;
    + j- f( ^& G) \# H7 O" {
83.         else
    
84.         {
    
85.                 AT24CXX_WriteOneByte(255,0x36);
    ) d2 E2 F. I# `, ]5 }0 \# s
86.                 temp=AT24CXX_ReadOneByte(255);
    
87.                 if (temp==0x36)
    : j* `: M, ]8 ?+ n  [6 C0 R
88.                         return 0;
    
89.         }
    
90.         return 1;
    ' t+ O6 i( J% i
91. }
    
92. //从指定地址开始读出指定额数据，pBuffer存放数据的数组首地址，NumToRead需要读出数据的个数
    " {* \5 ^4 c! P0 b0 C! E- I  Y
93. void AT24CXX_read(u16 ReadAddr,u8 *pBuffer,u16 NumToRead)
    ) ^) h: k# n' h# M( k; g+ ?( L. j+ S
94. {
    
95.         while(NumToRead)
    
96.         {
    
97.                 *pBuffer++=AT24CXX_ReadOneByte(ReadAddr++);
    / i. E  Q  V' O0 T0 n
98.                 NumToRead--;
      r. A! s" q4 q4 A) N! F
99.         }
    
100. }
     6 J% Z+ z% a4 n- b# X5 C' ^
101. //指定地址写入指定个数的数据
     - e8 Y- D2 a5 R
102. void AT24CXX_write(u16 WriteAddr,u8 *pBuffer,u16 NumToWrite)
     
103. {
     
104.         while(NumToWrite--)
     
105.         {
     : o+ T% `( X$ T1 k$ m* ~
106.                 AT24CXX_WriteOneByte(WriteAddr,*pBuffer);
     " |; x5 o2 l9 Z, x; |
107.                 WriteAddr++;
     / g$ `- X* {! X( `. U
108.                 pBuffer++;
     
109.         }
     
110. }

复制代码

. d$ X( R$ L: f) r$ N: v  Wiic.h
2 K$ C1 g) U! Z5 R: D8 f
8 I1 ?# t3 a9 s2 u+ q) [

1. #ifndef _iic_H
   
2. #define _iic_H
   2 N7 M7 O2 b6 N+ x* W: x) B) W7 w9 _
3. 
   . ]: L+ W/ ^) K0 k" R$ k: M* D
4. #include "system.h"
   
5. 
   % \: H/ L+ M- E+ x" N( U# D% V! {
6. /*IIC_SCL时钟端口、引脚定义*/
   
7. #define IIC_SCL_PORT                          GPIOB
   
8. #define IIC_SCL_PIN                                 (GPIO_Pin_10)
   
9. #define IIC_SCL_PORT_RCC                 RCC_APB2Periph_GPIOB
   
10. 
    % S; @" g' p9 r# f
11. /*IIC_SDA数据端口、引脚定义*/
    3 |- I$ L7 E6 L2 I) J* C" h
12. #define IIC_SDA_PORT                                 GPIOB
    
13. #define IIC_SDA_PIN                                  (GPIO_Pin_11)
    
14. #define IIC_SDA_PORT_RCC                RCC_APB2Periph_GPIOB
    # o& B% o2 K6 A$ v: z4 w* {$ ?
15. 
    
16. /*IO操作*/
    
17. #define IIC_SCL  PBout(10)//SCL
    
18. #define IIC_SDA  PBout(11)//SDA
    
19. #define READ_SDA PBin(11)//ÊäÈëSDA
    $ D7 Z7 w: H% S3 i# o& ^# p
20. 
    - O( ~  M# I9 H; D8 G
21. //IIC操作函数
    # [3 C. f; l1 }4 y
22. u8 IIC_read_byte(u8 ack);
    , ]) D! X" _7 r) f: r
23. void IIC_send_byte(u8 byte);
    
24. void IIC_noack(void);
    8 E5 C" z7 J2 T0 Z5 E1 [
25. void IIC_ack(void);
    
26. u8 IIC_wait_ack(void);
    ! C7 u# e4 A8 S; a
27. void IIC_stop(void);//Í£Ö¹ÐźÅ
    : U* y- B. u, O6 B& P3 q0 B# u. I
28. void IIC_start(void);
    $ Q) v* K/ r( i6 j
29. void SDA_IN(void);
    
30. void SDA_OUT(void);
    ) K. I# T8 y! ?: V& A  g4 y* G
31. void IIC_Init(void);
    : h8 j* A8 Q1 v2 g6 D. y) r7 h$ W
32. 
    6 X& I0 ~& [" d3 n
33. #endif
    & o6 j2 j3 _+ X) s

复制代码

iic.c

4 c! T, t) h. O4 `

1. #include "iic.h"
   6 v) {, i. C. `3 _
2. #include "SysTick.h"
   
3. 
   / E! V6 ?" t2 T2 J; E9 [& c) a
4. void IIC_Init(void)
   
5. {
   3 g3 O+ a) o9 [8 M( f9 K6 {: F
6.         GPIO_InitTypeDef GPIO_InitStructure;
   
7.         RCC_APB2PeriphClockCmd(IIC_SCL_PORT_RCC|IIC_SDA_PORT_RCC,ENABLE);
   
8.         
   
9.         GPIO_InitStructure.GPIO_Pin=IIC_SCL_PIN;
   
10.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    / q; ]( F+ \: M! C8 M  d( t
11.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    6 V6 t% `( y* R* ^: g
12.         GPIO_Init(IIC_SCL_PORT,&GPIO_InitStructure);
    + F) `/ x/ i5 X  T$ t; v5 [. R
13. 
    0 a, b# P# s4 w
14.         GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;
    
15.         GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
    " X& X- d. [  s; y3 L
16.         
    - b" h8 Z" ~  \9 ]" ^2 l
17.         IIC_SCL=1;
    
18.         IIC_SDA=1;
    9 i* P: R: O3 @) G
19.         
    
20. }
    
21. 
    & b; H, Q' e+ A" G# k
22. 
    
23. /*模拟IIC工作时序*/
    
24. void SDA_OUT(void)
    
25. {
    7 N" H" P3 A# [. ~* |, z% z
26.         GPIO_InitTypeDef GPIO_InitStructure;
    + ^- l& ~- l9 {; X
27.         
    8 v1 [" N8 R0 e$ _: |$ [6 U. |- G! z
28.         GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;
    
29.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
30.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
    
31.         GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
    & w6 f& n: W2 T  \4 H& g' m# U3 J- L
32. }
    3 _- r5 l2 x. m" G! t; l
33. void SDA_IN(void)
    
34. {
    
35.         GPIO_InitTypeDef GPIO_InitStructure;
    + L# ^9 _3 f- x
36.         
    
37.         GPIO_InitStructure.GPIO_Pin=IIC_SDA_PIN;
    
38.         GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    
39.         GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU;
    . J: J. a1 q2 k8 K
40.         GPIO_Init(IIC_SDA_PORT,&GPIO_InitStructure);
    7 Z1 C/ D# A* A4 D- K5 D
41. }
    
42. void IIC_start(void)                //起始信号
    8 C* F% Z7 }+ Q- Q
43. {
    2 g) W( n" I: B: T" K5 F
44.         SDA_OUT();
    
45.         IIC_SDA=1;
    0 s" a' J& ]4 {; `; S5 [5 B$ f6 K
46.         IIC_SCL=1;
    / }' w7 t' u# R6 ?9 @
47.         delay_us(5);
    
48.         IIC_SDA=0;
    8 x- ^( x% Z# N5 s, b* H  e
49.         delay_us(6);
    * \% f) m* a# Y; j
50.         IIC_SCL=0;
    & r) _/ i- N8 {& ^  y$ Q2 _  c
51. }
    " g: L8 N! P2 C, H4 x
52. void IIC_stop(void)                        //终止信号
    ( c* G/ h5 H( M# D9 Z$ V5 [8 p
53. {
    ) E! u" Z. @8 U6 r6 _9 D: U
54.         SDA_OUT();
    
55.         IIC_SCL=0;
    # P: i1 B' s2 ^" h1 ?0 `% {
56.         IIC_SDA=0;
    : b" q: B% N# }7 u$ u4 d+ r
57.         IIC_SCL=1;
    
58.         delay_us(6);
    3 a) T6 Y2 a: s, m" N
59.         IIC_SDA=1;
    
60.         delay_us(6);
    
61. }
    : H9 A( R5 P, J' {
62. 
    
63. //等待应答信号的到来，1接收应答失败，0接收应答成功
    5 z7 K' D4 \/ ^5 v
64. u8 IIC_wait_ack(void)
    " k  S& H- w0 P7 {' i5 e/ S
65. {
    
66.         u8 tempTime=0;
    
67.         IIC_SDA=1;
    ; p* Z  K. D7 p6 [
68.         delay_us(1);
    
69.         SDA_IN();                         //SDA设置输入
    
70.         IIC_SCL=1;
    
71.         delay_us(1);
    
72.         while(READ_SDA)
    - r8 s+ R+ q9 b5 B" v* x9 F2 x
73.         {
    
74.                 tempTime++;
    
75.                 if(tempTime>250)                //接收应答失败
    " v/ v9 f2 T; {! W; C8 t( ?
76.                 {
    
77.                         IIC_stop();
    
78.                         return 1;
    9 _, Y# ]7 P3 y( V; @3 `0 u% P
79.                 }
    5 ?) t7 [# O6 F2 K' N  T  ~6 u3 y- g
80.         }
    
81.         IIC_SCL=0;
    2 o7 S6 I7 c" z! Q
82.         return 0;
    4 H' t- Y/ P8 I" Q
83. }
    . m3 X& v5 a3 [( I9 a' `7 X
84. 
    3 X6 x0 q. l& A% H0 b' p
85. //产生应答信号
    
86. void IIC_ack(void)
    - E/ g+ C% {  ^0 J, x5 N7 i
87. {
    1 i5 [+ R" p8 W" F" [& o
88.         IIC_SCL=0;
    
89.         SDA_OUT();
    
90.         IIC_SDA=0;
    
91.         delay_us(2);
    
92.         IIC_SCL=1;
    
93.         delay_us(5);
    3 [% R+ P% ^' e+ ~4 X( }5 M
94.         IIC_SCL=0;
    
95. }
    8 p) r# d& B: p) [7 g
96. 
    ) u; U& X: O6 J5 s4 a
97. //产生非应答信号
    
98. void IIC_noack(void)
    
99. {
    ) Z. s; ~: \) r5 P7 R# p5 y- _( w
100.         IIC_SCL=0;
     
101.         SDA_OUT();
     
102.         IIC_SDA=1;
     ) e, I7 g. K1 p' ?% R
103.         delay_us(2);
     
104.         IIC_SCL=1;
     
105.         delay_us(5);
     
106.         IIC_SCL=0;
     ' D4 J& F8 X  A; m  G
107. }
     
108. 
     
109. //发送单字节信息
     , P# R, X- i' \  s
110. void IIC_send_byte(u8 byte)        
     
111. {
     7 H0 ^$ c& o" b7 O: k- N1 D' r% U
112.         u8 t;
     
113.         SDA_OUT();
     ; O/ p7 _; u9 G
114.         IIC_SCL=0;                                //开始数据传输
     . K1 X7 F/ F+ [9 E# @
115.         for(t=0;t<8;t++)
     0 E: v# l0 N" \! }6 Q/ A) v
116.         {
     % E8 G; H" l3 X0 N
117.                 if((byte&0x80)>0)                //每一次发送最高位
     
118.                         IIC_SDA=1;
     0 G9 e' G2 V# W7 ~* X4 N
119.                 else
     
120.                         IIC_SDA=0;
     . Q8 p% {+ p. R7 E
121.                 byte<<=1;        //发送位左移到最高位
     
122.                 delay_us(2);  
     
123.                 IIC_SCL=1;
     
124.                 delay_us(2);
     : A! i* H- U8 n
125.                 IIC_SCL=0;
     
126.                 delay_us(2);
     
127.         }
     7 [& x/ F) e* z  `+ M
128. }
     
129. 
     1 B5 U; x7 D) H" `( I& I
130. //读取单字节信息
     
131. u8 IIC_read_byte(u8 ack)
     
132. {
     + z) Q# ^* V0 ]2 K7 O
133.         u8 i,receive=0;
     . B/ i, J+ ]+ o* P. W
134.         SDA_IN();        //设置为输入
     
135.         
     
136.         for(i=0;i<8;i++)
     / e6 `  l. p( Y* J7 ]
137.         {
     ) u0 R6 l' G, k" Z
138.                 IIC_SCL=0;
     
139.                 delay_us(2);
     2 j- k1 B6 u6 n4 M! T& _( {
140.                 IIC_SCL=1;
     4 O) C( H: m  v
141.                 receive<<=1;
     9 F' X' _0 N, w. \& p" f5 a5 s% z
142.                 if(READ_SDA)
     
143.                         receive++;
     
144.                 delay_us(1);
     
145.         }
     . S3 B! v+ m) W2 ^: X* x0 S: h$ {
146.         //读取完成后，发送应答信息
     
147.         if(!ack)
     4 b& l; Q$ P9 I6 {, X
148.         {
     2 E- [3 O6 v: m& y
149.                 IIC_noack();
     
150.         }
     * ]& A7 n4 \. S1 l" u
151.         else
     
152.         {
     
153.                 IIC_ack();
     
154.         }
     $ `4 u( q! E; w' `
155.         return receive;
     
156. }

复制代码

: Z2 c( t9 F8 l7 ]main.c

9 Q) e! e& O4 H2 Q& F

1. #include "system.h"
   & R9 f* |! j4 f9 C8 }
2. #include "led.h"
   
3. #include "SysTick.h"
   1 ?$ p; B" i4 X% ]$ D8 U
4. #include "usart.h"
   + G* C* A( {" h. P$ [+ X
5. #include "24cxx.h"
   ; T! q# w( Z1 g) W
6. #include "key.h"
   
7. 
   
8. int main()
   
9. {
   
10.         u8 i=0;
    
11.         u8 key;
    2 S# [9 c9 x$ ]
12.         u8 k=0;
    
13.         
    
14.         SysTick_Init(72);
    
15.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    
16.         LED_Init();
    # G# }7 h; y& H% y) X- R3 E
17.         USART1_Init(9600);
    0 M! a  g: {- E4 x4 L9 S! y
18.         KEY_Init();
    
19.         AT24CXX_Init();
    
20.         while(AT24CXX_Check())
    
21.         {
    
22.                 printf("AT24C02检测不正常\r\n");
    
23.                 delay_ms(500);
    
24.         }
    . Y" P4 `0 u+ ]  |& ^1 b
25.         printf("AT24C02检测正常\r\n");
    3 U0 J# C: N2 A% R; a6 k% _. c' z9 j6 S
26.         
    # ^6 i& S. t0 `, e
27.         while(1)
    
28.         {
    
29.                 key=KEY_Scan(0);
    
30.                 if(key==KEY_UP)
    
31.                 {
    " c- z  I( ~1 o/ \# J; ?6 y
32.                         k++;
    
33.                         if(k>255)
    
34.                         {
    
35.                                 k=255;
    1 C# l  o5 X2 {- f
36.                         }
    # a. }# s* C" p" Q% d4 v
37.                         AT24CXX_WriteOneByte(0,k);
    7 c+ |' ]8 H3 y% @
38.                         printf("写入的数据为：%d\r\n",k);
    
39.                 }
    9 f1 Y8 X- R0 [  a2 m* v
40.                 if(key==KEY_DOWN)
    # G1 A2 t6 a0 D5 h6 v9 M9 @
41.                 {
    % d+ n; U7 C: @9 ~
42.                         k=AT24CXX_ReadOneByte(0);
    4 e9 D; ?3 l1 e5 c4 p0 y
43.                         printf("读取的数据为：%d\r\n",k);
    5 e; }3 e; j0 Z8 R+ m
44.                 }
    3 |$ Q, R  ~2 M
45.                 i++;
    # Y4 m( m$ M( }+ }+ L& ]4 f, k. \
46.                 if(i%20==0)
    2 \" S2 `1 C. A. \! \9 G' q
47.                 {
    % j3 C8 i; Q, D! ], b: f+ A# O( h
48.                         led1=!led1;
    % t, Y! j) ^% h+ t
49.                 }
    
50.                 delay_ms(10);
    
51.         }
    + K* d8 w( Y, v, c! R9 T
52. }

复制代码

; `: T" s+ _6 G9 w" M# Y3、CAN通信
3.1 CAN介绍
, p" @7 e9 X1 z- WCAN（Controller Area Network），控制器局域网络，是ISO国际标准化串行通信协议。为了减少线束的数量、通过多个LAN进行大量数据的高速通信的实际需要，1986年德国电气商博世公司开发了面向汽车的CAN通信协议。CAN是国际上应用最广泛的现场总线之一，为分布式系统实现各节点之间实时、可靠的数据通信提供了有利的技术支持。
' ~# N( ?& c$ fCAN通信只需要两个信号线，CAN_H和CAN_L，CAN控制器根据两根信号线上的电位差来判断总线电平。总线电平被分为显性电平和隐性电平，发送方通过使总线电平发生变化，从而将信息发送给接收方。
6 Q+ D' m1 ]- ~# lCAN通信具备以下特点：
1、 多主控制；
总线空闲时，所有单元均可发生消息，当两个以上的单元同时发生消息时，依据标识符（ID）决定优先级。ID并不是表示发送的目的地址，而是表示访问总线消息的优先级。两个以上的单元开始发送消息时，对消息ID的每个位进行逐个仲裁比较。仲裁获胜的单元继续发送消息，仲裁失败的单元停止发送进行接收工作。
2、 系统柔软性；
( [+ ~0 @' M+ Q# U2 O与总线相连的单元没有类似“地址”的信息，因此在总线上增加单元时，总线上的其它单元软硬件及应用层不需要被改变。
3、 通信速度快、距离远；
最高1Mbps（距离小于40m），最远10km（速率低于5Kbps）。
4、 错误检测、错误通知和错误恢复功能；
% C6 A, a. p. g$ a7 u) T总线上的所有单元都可检测错误，出现错误的单元会立即通知其它单元，正在发送消息的单元检测出错误后，会强制结束当前的发送。强制结束发送的单元会不断重新发送此消息直到成功发送为止。
; N: e& y' N5 h3 L  s/ S" }5、 故障封闭功能；
1 S/ _6 J5 a- f/ z可以判断出错的类型是总线上暂时的数据错误（外部噪声）或持续的数据错误（单元内部故障、驱动器故障、断线等）。当总线持续数据错误时，可将引起此故障的单元从总线上隔离。
6、 可连接节点多；
可以同时连接多个单元设备，连接总数理论上无限制，但实际上可连接的单元数受到总线时延和电气负载的限制。降低通信速度，可连接的单元数增加；提高通信速度，可连接单元数减少。

) X, L$ {& u0 ]5 k# m7 n( ]对于CAN通信的两种标准：ISO11898（高速）可以组建一个高速、短距离的闭环网络，该标准下总线最大长度40m，通信速率最高1Mbps，总线两端需各有一个120欧姆的电阻作为阻抗匹配功能，以减少回波反射。ISO11519-2（低速）可以组建一个低速、远距离的开环网络，该标准下总线最大长度1km，通信速率最高125kbps，两根总线独立不形成闭环，两根总线上各自串联一个2.2千欧的电阻。
6 \5 i7 F; [0 o' _" y7 a在IS01898标准下，显性电平对应逻辑0，CAN_H和CAN_L压差为2.5V左右；隐性电平对应逻辑1，CAN_H和CAN_L压差为0V。在总线上显性电平具有优先权，只要有一个单元输出显性电平，总线上即为显性电平。隐性电平具有包容性，只有所有的单元都输出隐性电平，总线上才为隐性电平。
CAN总线和CAN控制器之间需要一个CAN收发器将信号进行转换，通信主要通过5种类型的帧进行，分别为数据帧、遥控帧、错误帧、过载帧以及帧间隔。其中数据帧由7个段构成，分别为帧起始（数据帧的开始段）、仲裁段（帧优先级的段）、控制段（数据的字节数及保留位的段）、数据段（数据内容，0~8字节数据）、CRC段（检查帧错误的段）、ACK段（确认正常接收段）以及帧结束段（数据帧结束的段）。

$ U7 f* R: a1 h! {- ]在STM32F1芯片中自带bxCAN控制器（Basic Extended CAN），基本扩展CAN，支持2.0A和B版本的CAN协议。目的是以最小的CPU负载，高效的管理大量传入消息，并按需要的优先级实现消息发送。
. f. I/ l- o* X6 M* E4 n6 e
: \: C  J: ~! @0 [# [" O3.2 CAN通信配置步骤
  @0 X, r& B1 N6 S0 e使用库函数对CAN进行配置需要使用到库文件stm32f10x_can.h和stm32f10x_can.c，详细的步骤如下：
. q) s% D! @4 e1、 使能CAN时钟，将对应的引脚复用映射为CAN功能；
CAN1和CAN2都是挂载在APB1总线上的设备，其发送和接收引脚对应不同的IO口，因此在使能时钟后，还需要使能对应IO口的时钟，并将其设置为复用功能。配置代码如下：
# O! q2 v. A6 |, @1 h
" _0 z. h. P1 w  M2 O) X

1. RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, EANBLE);
   
2. RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, EANBLE);
   
3. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
   
4. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;                        //上拉输入模式
   
5. GPIO_Init(GPIOA, & GPIO_InitStructure);
   . j: w! Y  ^; `. O
6. GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
   ) D0 z1 X: m( X7 d, [; e
7. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;                //复用推挽输出
   " ~6 n  ~& U+ n
8. GPIO_InitStructure.GPIO_Speede = GPIO_Speed_50MHz;
   6 ^. E) I0 r/ ^& b. {
9. GPIO_Init(GPIOA, & GPIO_InitStructure);

复制代码

2 f4 \) R, s# ~1 q$ x4 _2、 设置CAN工作模式、波特率等；
* A. P* s6 ^6 w! ]) h调用函数：uint8_t CAN_Init(CAN_TypeDef* CANx, CAN_InitTypeDef* CAN_InitStruct);
/ j7 }- N3 Q+ f/ z参数CAN_InitStruct为结构体指针变量，其成员变量包含CAN工作模式以及波特率初始化的变量：
8 C9 u  w3 T& \6 t- E1 J
1 \5 m1 r1 b  ~9 |4 F2 u

1. typedef struct
   " B1 K3 u' T/ i, f
2. {
   
3.                 uint16_t CAN_prescaler;                //设置CAN外设时钟分频
   5 h1 x  _4 U% W. p: l6 e3 L
4.                 uint8_t CAN_Mode;                        //正常模式（CAN_Mode_Normal）、回环模式（CAN_Mode_LoopBack）、静默模式（CAN_Mode_Silent）以及回环静默模式（CAN_Mode_Silent_LoopBack）
   
5.                 uint8_t CAN_SJW;                                //设置CAN重新同步时单次可增加或缩短的最大长度，可配置为1-4tp（CAN_SJW_1/2/3/4tp）
     U# r$ \' R; v" z' I9 E
6.                 uint8_t CAN_BS1;                                //设置位时序BS1长度，CAN_BS1_1/2/3/…/16tp
   
7.                 uint8_t CAN_BS2;                                //设置位时序BS2长度，CAN_BS1_1/2/3/…/8tp
   
8.                 FunctionalState CAN_TTCM;        //是否使用时间触发功能
   
9.                 FunctionalState CAN_ABOM;        //是否使用自动离线管理
   . X/ U. S) B/ `9 F% z7 a; `! T
10.                 FunctionalState CAN_AWUM;        //是否使用自动唤醒功能
    
11.                 FunctionalState CAN_NART;        //是否使用自动重传功能
    " ]/ B. A+ X6 f
12.                 FunctionalState CAN_RFLM;        //是否使用锁定接收FIFO
    
13.                 FunctionalState CAN_TXFP;                //设置发送报文的优先级判断方法，使能时以报文存入发送邮箱的先后顺序发送，失能时按照报文ID优先级发送
    
14. }

复制代码

6 a8 ], f$ v6 _$ R" `! r2 BCAN的波特率 = Fpclk1 / ((CAN_BS1+CAN_BS2+1)*CAN_Prescaler)
3、 设置CAN筛选器（过滤器）；
8 O4 E: Z$ a+ v, i4 K( J% Y3 j: H调用函数：void CAN_FilterInit(CAN_FilterInitTypeDef* CAN_FilterInitStruct);
! O, Z  H7 ^0 g) D$ h* F  b其中结构体CAN_FilterInitTypeDef的成员变量为：

1. typeder struct
   
2. {
   ; l$ N- H; P2 Q; M$ a4 v7 G
3.                 uint16_t CAN_FilterIdHigh;                        //存储需要筛选的ID高16位
   
4.                 uint16_t CAN_FilterIdLow;                        //存储需要筛选的ID低16位
   5 U* X$ K1 X3 p$ D' H( M
5.                 uint16_t CAN_FilterMaskIdHigh;                //存储需要筛选ID或掩码
   
6.                 uint16_t CAN_FilterMaskIdLow;                //存储需要筛选ID或掩码
   $ o; P( H& p. H4 m1 E
7.                 uint16_t CAN_FilterFIFOAssignment;        //设置报文被存储到那一个接收FIFO，FIFO
   : w( ^: }$ i6 e: f, k( t
8. 0或FIFO1
   + S% D3 U1 y( L7 g" O
9.                 uint8_t CAN_FilterNumber;                        //设置筛选器编号，0~27
   . n$ O1 W& {, [- g" N2 \- [
10.                 uint8_t CAN_FilterMode;                        //设置筛选器工作模式，列表模式（CAN_FilterMode_IdList）和掩码模式（CAN_FilterMode_IdMask）
    
11.                 uint8_t CAN_FilterScale;                        //设置筛选器位宽，CAN_FilterScale_32bit及CAN_FilterScale_64bit
    * v6 k  E" L2 @% m3 q: c
12. }

复制代码

  P6 D, z2 N, _* [" A% u& _# ]2 j4、 选择CAN中断类型，开启中断；
调用函数：void CAN_ITConfig(CAN_TypeDef* CANx, uint32_t CAN_IT, FunctionalState NewState);
5、 CAN发送和接收消息；
发送消息函数：uint8_t CAN_Transmit(CAN_TypeDef* CANx, CanTxMsg* TxMessage);
其中结构体变量CanTxMsg包含的成员变量为：

1. typedef struct
   3 G4 Y0 `: R2 r9 Y1 d
2. {
   . T5 Z# p/ _" `6 g: X) D
3.                 uint32_t StdId;                //报文11位标准标识符，0~0x7FF
   
4.                 uint32_t ExtId;                //报文29位扩展标识符，0~0x1FFFFFFF
   1 D' l( Y! N: V+ D7 i
5.                 uint8_t IDE;                        //扩展标志位，CAN_ID_STD（标准帧）和CAN_ID_EXT（扩展帧）
   # q& g# g2 s$ ]) u
6.                 uint8_t RTR;                        //报文类型标志位，CAN_RTR_Data（数据帧）和CAN_RTR_Remote（遥控帧）
   
7.                 uint8_t DLC;                        //数据帧的长度，0~8，当报文是遥控帧是DLC=0
     n9 f; B% |: |; `: c- N/ H
8.                 uint8_t Data[8];                //数据帧中数据段的数据
   3 J: o: t/ a7 Z$ Z. b2 }3 ^
9. }

复制代码

8 w) m0 t- q6 c( j接收消息函数：void CAN_Receive(CAN_TypeDef* CANx, uint8_t FIFONumber, CanRxMsg* RxMessage);
1 ^) O/ s1 A* _1 ?  v0 K9 ?. v其中结构体变量CanRxMsg包含的成员变量为：

0 v: o! _# a* M3 B& A* Z' V

1. typedef struct
   6 y8 G- q& O6 g6 X
2. {
   
3.                 uint32_t StdId;                //报文11位标准标识符，0~0x7FF
   
4.                 uint32_t ExtId;                //报文29位扩展标识符，0~0x1FFFFFFF
   
5.                 uint8_t IDE;                        //扩展标志位，CAN_ID_STD（标准帧）和CAN_ID_EXT（扩展帧）
   
6.                 uint8_t RTR;                        //报文类型标志位，CAN_RTR_Data（数据帧）和CAN_RTR_Remote（遥控帧）
   / O& I! \0 r4 _: k
7.                 uint8_t DLC;                        //数据帧的长度，0~8，当报文是遥控帧是DLC=0
   
8.                 uint8_t Data[8];                //数据帧中数据段的数据
   
9.                 uint8_t FMI;                        //存储筛选器编号，表示经过哪一个筛选器存储进接收FIFO的
   
10. }

复制代码

6、 CAN状态的获取
调用函数：CAN_TransmitStatus(); CAN_MessagePending(); CAN_GetFlagStatus()；
# k$ G. Y" R' i6 M
3.3 应用示例
; q7 y. Z& g6 JSTM32使用按键切换CAN1的通信模式（数据发送、接收），将数据通过串口打印出，详细的代码模块如下：

can.h
' G- r. ?( J; y; \8 ~' l
% L- ]* T+ X- S$ r/ ]

1. #ifndef _can_H
   , `1 N* o7 s3 ^: ^" _
2. #define _can_H
   + {* b" F$ n# u5 s
3. 
   ; m  y! r$ t# H. Q% g# q3 c: }7 `
4. #include "system.h"
   
5.                                                             
   
6. 
   8 A1 Q. q7 P: C/ u
7. #define CAN_RX0_INT_ENABLE 0                                                   //使能中断
   ( I* Z, O3 [5 h% k0 x2 s
8. 
   & B% M8 W: f7 d1 A! u. S7 E
9. void CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode);        //CAN初始化
   # i0 k2 _0 M* r
10. 
    ) W6 c! c4 f* v- B8 i
11. u8 CAN_Send_Msg(u8* msg,u8 len);                                                        //发送数据
      o$ D7 A. T, z% I: B
12. 
    ; J; B+ F2 G$ t0 h1 D' c/ n
13. u8 CAN_Receive_Msg(u8 *buf);                                                                //接收数据
    ) ~! Z4 U& G. O3 h8 `
14. 
    5 }" t2 Z8 ^" L
15. 
      J6 x. S; a5 L3 }* D: t
16. #endif

复制代码

+ Z' g7 x1 `! |  E! p9 Q0 H' t7 `can.c
! c" P5 L+ G2 O& g: `6 [
$ `9 W5 L9 t' p: p0 Y, C6 F0 J' J

1. #include "can.h"
   
2. #include "usart.h"
   
3. 
   
4. 
   
5. void CAN_Mode_Init(u8 tsjw,u8 tbs2,u8 tbs1,u16 brp,u8 mode)
   
6. {
   
7.         GPIO_InitTypeDef GPIO_InitStructure;
   / R4 x) l* J% c# O: R* c
8.         CAN_InitTypeDef        CAN_InitStructure;
   
9.         CAN_FilterInitTypeDef  CAN_FilterInitStructure;
   + Q2 H) Q+ c' m& f; |
10.         
    
11. #if CAN_RX0_INT_ENABLE
    5 P! y" W1 l  K( L: q
12.         NVIC_InitTypeDef                  NVIC_InitStructure;
    
13. #endif
    
14.         
    
15.         RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
    
16.         RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);   
    
17.         
    
18.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;                 
    
19.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;         
    
20.         GPIO_Init(GPIOA, &GPIO_InitStructure);        
    ( F' u. S4 R6 d/ Z) A( c
21. 
    
22.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;                  
    
23.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;         
    6 |% I9 j$ h" Y1 ^- w8 ~( e
24.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    , }' E5 ~2 w! d, L0 Q; w( e2 }5 g" s
25.         GPIO_Init(GPIOA, &GPIO_InitStructure);
    
26.         
    ' C, v# R* a  V5 r4 Q, [; j& B6 e1 |
27.            CAN_InitStructure.CAN_TTCM=DISABLE;         
    6 a3 y# x) u( Z) M; p8 D
28.           CAN_InitStructure.CAN_ABOM=DISABLE;         
    : A/ ~/ {# K9 {3 a, `5 n& C! e
29.           CAN_InitStructure.CAN_AWUM=DISABLE;
    + _0 \+ \) `2 v: o2 P; F% s
30.           CAN_InitStructure.CAN_NART=ENABLE;
      [8 ?1 E' F" m. t( s+ Q
31.           CAN_InitStructure.CAN_RFLM=DISABLE;         
    
32.           CAN_InitStructure.CAN_TXFP=DISABLE;         
    $ K* y  o, C8 f) K
33.           CAN_InitStructure.CAN_Mode= mode;         
    ) [* w( g  k! u2 `
34.           CAN_InitStructure.CAN_SJW=tsjw;        
    8 \$ W' ^, U# I' M4 r* d/ k* H
35.           CAN_InitStructure.CAN_BS1=tbs1;
    1 _! n' `" a7 z0 N# N0 i- l, l* Q
36.           CAN_InitStructure.CAN_BS2=tbs2;
    
37.           CAN_InitStructure.CAN_Prescaler=brp;  
    
38.           CAN_Init(CAN1, &CAN_InitStructure);  
    $ O. v5 U# `4 a
39.         
      y! h! M) N' r
40.         //ÅäÖùýÂËÆ÷
    
41.          CAN_FilterInitStructure.CAN_FilterNumber=0;         
    
42.           CAN_FilterInitStructure.CAN_FilterMode=CAN_FilterMode_IdMask;
    # {, p8 A6 y8 M+ Z* ?0 h& |- i
43.           CAN_FilterInitStructure.CAN_FilterScale=CAN_FilterScale_32bit;
    * y2 ]9 A: {. [4 Q; w/ M* L  E  H
44.           CAN_FilterInitStructure.CAN_FilterIdHigh=0x0000;
    0 c$ i! t" Z% h, M0 _
45.           CAN_FilterInitStructure.CAN_FilterIdLow=0x0000;
    0 M; G, S0 Y  N; m! ~+ R
46.           CAN_FilterInitStructure.CAN_FilterMaskIdHigh=0x0000;
    * }% g, R" O, M/ \6 `! h+ ~/ A% x
47.           CAN_FilterInitStructure.CAN_FilterMaskIdLow=0x0000;
    
48.            CAN_FilterInitStructure.CAN_FilterFIFOAssignment=CAN_Filter_FIFO0;
    
49.           CAN_FilterInitStructure.CAN_FilterActivation=ENABLE;
    
50.           CAN_FilterInit(&CAN_FilterInitStructure);
    
51.         
    ) q: Z6 F$ E. [; O7 `
52. #if CAN_RX0_INT_ENABLE
    - O# S3 {- r0 t% }7 g( U
53.         CAN_ITConfig(CAN1,CAN_IT_FMP0,ENABLE);                           
    
54. 
    
55.         NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
    
56.         NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;   
    
57.         NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;           
    
58.         NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    & [  s$ c6 R' }  M* j* [3 i8 e
59.         NVIC_Init(&NVIC_InitStructure);
    4 b  d" `: ^0 E; a8 F
60. #endif
    
61. }
    
62. 
    
63. #if CAN_RX0_INT_ENABLE        
    2 c/ b$ y/ N" A, M7 W/ d2 a( b% J( D
64.                     
    
65. void USB_LP_CAN1_RX0_IRQHandler(void)
    7 @' U, N% X0 r) ~2 y
66. {
    
67.           CanRxMsg RxMessage;
    
68.         int i=0;
    5 z& K  p0 V3 K) Y: n. h: g+ w
69.     CAN_Receive(CAN1, 0, &RxMessage);
    
70.         for(i=0;i<8;i++)
    
71.         printf("rxbuf[%d]:%d\r\n",i,RxMessage.Data<i>);
    
72. }
    ! z- w( Z/ X  {# F4 D! D
73. #endif
    
74. 
    
75. u8 CAN_Send_Msg(u8* msg,u8 len)
    
76. {        
    7 h7 B7 ^) n( @
77.         u8 mbox;
    
78.         u16 i=0;
    
79.         CanTxMsg TxMessage;
    5 |# K4 _" I5 w1 s0 Z% N
80.         TxMessage.StdId=0x12;         
    $ r/ E- s5 L  D- s, ?
81.         TxMessage.ExtId=0x12;         
    ; y5 a& ?) d2 O5 A; l
82.         TxMessage.IDE=0;               
    
83.         TxMessage.RTR=0;               
    
84.         TxMessage.DLC=len;                                                
    
85.         for(i=0;i<len;i++)
    & N7 X. X& O+ |* ?
86.                 TxMessage.Data<i>=msg<i>;                                 
    
87.         mbox= CAN_Transmit(CAN1, &TxMessage);   
    
88.         i=0;
    4 r% u8 q7 H% s- z& s# h+ ?9 l9 W
89.         while((CAN_TransmitStatus(CAN1, mbox)==CAN_TxStatus_Failed)&&(i<0XFFF)) i++;
    
90.         if(i>=0XFFF) return 1;
    
91.         return 0;               
    9 w! h3 B1 l; Y- o( m
92. }
    $ _# j3 W* T/ `3 h; V( `
93. 
    - x  A5 |' A& {+ g; \' p
94. u8 CAN_Receive_Msg(u8 *buf)
    ; ~* C8 n7 u, l% k  S$ ?) U( R
95. {                                      
    
96.          u32 i;
    
97.         CanRxMsg RxMessage;
    8 X: j1 Z' u8 ^( L" c5 W6 j
98.     if( CAN_MessagePending(CAN1,CAN_FIFO0)==0)return 0;         
    ; c* S$ Q$ v4 a- y3 P3 a3 @& |
99.     CAN_Receive(CAN1, CAN_FIFO0, &RxMessage);
    ) F! i; g' [3 L6 Y8 ~8 B3 r
100.     for(i=0;i<RxMessage.DLC;i++)
     
101.     buf<i>=RxMessage.Data<i>;  
     
102.         return RxMessage.DLC;        
     ' h: W" V: s, w8 C) s& T
103. }</i></i></i></i></i>

复制代码

main.c
" ~9 F/ N2 _8 \
8 o1 t0 q# ]6 T

1. #include "system.h"
   
2. #include "SysTick.h"
   
3. #include "led.h"
   
4. #include "usart.h"
   2 Z6 o! Z; f& a& D) D- M$ d) f
5. #include "key.h"
   
6. #include "can.h"
   3 t: m7 P/ i* g# {5 ?6 o* K% ]
7. 
   - ~2 w" E9 z# ]
8. int main()
   & @, z6 o/ W( J: I
9. {
   
10.         u8 i=0,j=0;
    
11.         u8 key;
    2 D$ h, g  a" Z' u8 T! e- v. n% }
12.         u8 mode=0;
    
13.         u8 res;
    
14.         u8 tbuf[8],char_buf[8];
    / ?9 E: z. p, s; \
15.         u8 rbuf[8];
    
16. 
    1 [* `0 Z! @6 P! `* g
17.         SysTick_Init(72);
    0 _1 u! d" u  M: ^
18.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);  
    : Q/ Q( @4 s, b. D' Z
19.         LED_Init();
    % w4 v, m# S3 h# W2 a) L- g
20.         USART1_Init(9600);
    
21.         KEY_Init();
    # U+ y5 G1 X! V1 C# O" C0 U$ s+ L
22.         CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,CAN_Mode_Normal);/
    9 m" i  W) y3 F& |: j
23.         
    3 }9 R  \% D; o. P* o1 t, u8 r
24.         while(1)
    ) W8 p* {- \  r/ r. Z
25.         {
    
26.                 key=KEY_Scan(0);
    
27.                 if(key==KEY_UP)  
    
28.                 {
    
29.                         mode=!mode;
    ' _) \0 p( N; k; C
30.                         CAN_Mode_Init(CAN_SJW_1tq,CAN_BS2_8tq,CAN_BS1_9tq,4,mode);
    
31.                         if(mode==0)
    , I" Z4 m7 W. v" S1 b/ q! F2 T
32.                         {
    
33.                                 printf("Normal Mode\r\n");
    
34.                         }
    
35.                         else
    
36.                         {
    
37.                                 printf("LoopBack Mode\r\n");
    # k- Q$ z4 b/ S, h: I2 U. m- p+ e
38.                         }
    " G0 @  K' _/ K7 Z
39.         
    
40.                 }
    3 ?& w! H: b! l0 l1 R: ^! J
41.                 if(key==KEY_DOWN)
    ! x9 z. o; Y( Q. J; c
42.                 {
    8 R  u0 r! L# p1 H) a1 I# o
43.                         for(j=0;j<8;j++)
    
44.                         {
    3 k/ W8 G3 r% Y4 x% B
45.                                 tbuf[j]=j;
      r# s0 `3 G9 q) L: ?
46.                                 char_buf[j]=tbuf[j]+0x30;
    & Q7 A$ x$ E3 x& U
47.                         }
    & a0 u7 h+ L3 Y) B( [4 p9 J
48.                         res=CAN_Send_Msg(tbuf,8);
    # b; }$ Y  J2 J5 e
49.                         if(res)
    
50.                         {
    ' ^4 z9 X- p2 R9 B# C+ ^' k
51.                                 printf("Send Failed!\r\n");
    
52.                         }
    2 S. t. _* V4 {3 ^
53.                         else
    % X# l+ a& f6 M% d3 r9 ]7 h
54.                         {
    
55.                                 printf("发送数据：%s\r\n",char_buf);
    
56.                         }
    ' i- o8 j. M; F" v/ f
57.                         
    * U3 M. T( f- P1 h3 H
58.                 }
    5 r' [; [1 ], L( A5 Q' A
59.                 res=CAN_Receive_Msg(rbuf);
    
60.                 if(res)
    9 Y. N8 r' S8 [/ ~- G
61.                 {
    8 [, R4 y$ l! u4 t
62.                         for(j=0;j<res;j++)
    ) N+ j0 N6 @: F4 X
63.                         {
    ; b0 \8 `$ i3 I
64.                                 char_buf[j]=rbuf[j]+0x30;
    
65.                         }
    
66.                         printf("接收数据：%s\r\n",char_buf);
    ' e1 {  O& j$ l4 A2 u. `
67.                 }
    1 c" C9 `2 B  r
68.                
    
69.                 i++;
    # z8 \( Q9 j* [
70.                 if (i%20==0)
    & u: W5 {1 I: w8 f; s& x
71.                 {
    $ `0 Z7 N" B. E! n8 o: S8 U
72.                         led1=!led1;
    
73.                 }
    
74.                
    
75.                 delay_ms(10);
    
76.         }
    ' P1 A3 h2 y: J2 O
77. }
    

复制代码

% r( ~4 u2 B/ ^& b
3 V" m* ^, K$ i( {/ c