IIC实验
本章，我们将介绍如何使用STM32H750的普通IO口模拟IIC时序，并实现和24C02之间的双向通信，并把结果显示在TFTLCD模块上
5 V( u2 ?9 V5 F  j
) |6 x/ X9 b; X. Y35.1 IIC及24C02简介
8 K' ]: A& i) M35.1.1 IIC简介
* I" `" n# m6 ^7 K6 \IIC(Inter-Integrated Circuit)总线是一种由PHILIPS公司开发的两线式串行总线，用于连接微控制器以及其外围设备。它是由数据线SDA和时钟SCL构成的串行总线，可发送和接收数据，在CPU与被控IC之间、IC与IC之间进行双向传送。
, T/ Z: S, c* C2 EIIC总线有如下特点：
) t% U- E8 D7 }. [, A6 g①总线由数据线SDA和时钟线SCL构成的串行总线，数据线用来传输数据，时钟线用来同步数据收发。
5 K1 u, D3 s& `% a, a& e) J: p②总线上每一个器件都有一个唯一的地址识别，所以我们只需要知道器件的地址，根据时序就可以实现微控制器与器件之间的通信。
6 Y* a! C5 ^, Z4 Z3 J③数据线SDA和时钟线SCL都是双向线路，都通过一个电流源或上拉电阻连接到正的电压，所以当总线空闲的时候，这两条线路都是高电平。
) o2 T/ k* C# s! G3 F④总线上数据的传输速率在标准模式下可达100kbit/s 在快速模式下可达400kbit/s在高速模式下可达3.4Mbit/s。
⑤总线支持设备连接。在使用IIC通信总线时，可以有多个具备IIC通信能力的设备挂载在上面，同时支持多个主机和多个从机，连接到总线的接口数量只由总线电容400pF的限制决定。IIC总线挂载多个器件的示意图，如下图所示：



1 I, R' J7 K  k% p0 l: C3 y9 }' G图35.1.1.1 IIC总线挂载多个器件
- x' V2 Y3 N# @( Q* C" m下面来学习IIC总线协议，IIC总线时序图如下所示：
5 V* a0 I  J* B9 x( Z5 ?8 m

. S' ^$ l$ E, p( O/ T- C
图35.1.1.2 IIC总线时序图
/ |' n+ u# e. q) u8 C3 i. d$ h* W为了便于大家更好的了解IIC协议，我们从起始信号、停止信号、应答信号、数据有效性、数据传输以及空闲状态等6个方面讲解，大家需要对应图35.1.1.2的标号来理解。
+ ^$ `1 m% A9 A3 W+ M7 x' C① 起始信号
当SCL为高电平期间，SDA由高到低的跳变。起始信号是一种电平跳变时序信号，而不是一个电平信号。该信号由主机发出，在起始信号产生后，总线就会处于被占用状态，准备数据传输。
② 停止信号
) B$ @& n* R/ p4 [当SCL为高电平期间，SDA由低到高的跳变。停止信号也是一种电平跳变时序信号，而不是一个电平信号。该信号由主机发出，在停止信号发出后，总线就会处于空闲状态。
③ 应答信号
. y6 o+ `9 g$ d发送器每发送一个字节，就在时钟脉冲9期间释放数据线，由接收器反馈一个应答信号。 应答信号为低电平时，规定为有效应答位（ACK简称应答位），表示接收器已经成功地接收了该字节。应答信号为高电平时，规定为非应答位（NACK），一般表示接收器接收该字节没有成功。
观察上图标号③就可以发现，有效应答的要求是从机在第9个时钟脉冲之前的低电平期间将SDA线拉低，并且确保在该时钟的高电平期间为稳定的低电平。如果接收器是主机，则在它收到最后一个字节后，发送一个NACK信号，以通知被控发送器结束数据发送，并释放SDA线，以便主机接收器发送一个停止信号。
④ 数据有效性
0 A6 u8 b# P5 l( WIIC总线进行数据传送时，时钟信号为高电平期间，数据线上的数据必须保持稳定，只有在时钟线上的信号为低电平期间，数据线上的高电平或低电平状态才允许变化。数据在SCL的上升沿到来之前就需准备好。并在下降沿到来之前必须稳定。
⑤ 数据传输
在IIC总线上传送的每一位数据都有一个时钟脉冲相对应（或同步控制），即在SCL串行时钟的配合下，在SDA上逐位地串行传送每一位数据。数据位的传输是边沿触发。
⑥ 空闲状态
3 e! R; Q6 l) K4 T) B/ O, n0 RIIC总线的SDA和SCL两条信号线同时处于高电平时，规定为总线的空闲状态。此时各个器件的输出级场效应管均处在截止状态，即释放总线，由两条信号线各自的上拉电阻把电平拉高。
8 }6 `8 t3 L. v2 u4 Z6 a了解这些知识后，下面介绍一下IIC的基本的读写通讯过程，包括主机写数据到从机即写操作，主机到从机读取数据即读操作。下面先看一下写操作通讯过程图，见图35.1.1.3所示：

' w1 I; Q$ `  A. Y8 Z/ d
0 K8 A; y2 ~% I2 _- Y' M
% ^. L/ ?7 c& y) f5 ?图35.1.1.3 写操作通讯过程图
! c8 s  {1 _( U7 H5 G主机首先在IIC总线上发送起始信号，那么这时总线上的从机都会等待接收由主机发出的数据。主机接着发送从机地址+0(写操作)组成的8bit数据，所有从机接收到该8bit数据后，自行检验是否是自己的设备的地址，假如是自己的设备地址，那么从机就会发出应答信号。主机在总线上接收到有应答信号后，才能继续向从机发送数据。注意：IIC总线上传送的数据信号是广义的，既包括地址信号，又包括真正的数据信号。
接着讲解一下IIC总线的读操作过程，先看一下读操作通讯过程图，见图35.1.1.4所示。


( m$ g5 x8 n! s4 i0 y
图35.1.1.4 读操作通讯过程图
. s* e; `, ]% k主机向从机读取数据的操作，一开始的操作与写操作有点相似，观察两个图也可以发现，都是由主机发出起始信号，接着发送从机地址+1(读操作)组成的8bit数据，从机接收到数据验证是否是自身的地址。 那么在验证是自己的设备地址后，从机就会发出应答信号，并向主机返回8bit数据，发送完之后从机就会等待主机的应答信号。假如主机一直返回应答信号，那么从机可以一直发送数据，也就是图中的（n byte + 应答信号）情况，直到主机发出非应答信号，从机才会停止发送数据。
24C02的数据传输时序是基于IIC总线传输时序，下面讲解一下24C02的数据传输时序。
35.1.2 24C02简介
24C02是一个2K bit的串行EEPROM存储器，内部含有256个字节。在24C02里面还有一个8字节的页写缓冲器。该设备的通信方式IIC，通过其SCL和SDA与其他设备通信，芯片的引脚图如图35.1.2.1所示。
& ?# m" Z3 h. f. R- B  H6 d


4 K! Q6 v5 r. U/ h图35.1.2.1 24C02引脚图
上图中有一个WP，这个是写保护引脚，接高电平只读，接地允许读和写，我们的板子设计是把该引脚接地。每一个设备都有自己的设备地址，24C02也不例外，但是24C02的设备地址是包括不可编程部分和可编程部分，可编程部分是根据上图的硬件引脚A0、A1和A2所决定。设备地址最后一位用于设置数据的传输方向，即读操作/写操作，0是写操作，1是读操作，具体格式如下图35.1.2.2所示：
( }& d$ D+ ]8 y9 c( ~: Q
1 ^# z* F9 B4 h1 h
8 q, k1 x( E' V
图35.1.2.2 24C02设备地址格式图
& t) s) `; W8 v; f6 g根据我们的板子设计，A0、A1和A2均接地处理，所以24C02设备的读操作地址为：0xA1；写操作地址为：0xA0。
$ R/ P0 Q4 ^( B1 M. O在前面已经说过IIC总线的基本读写操作，那么我们就可以基于IIC总线的时序的上，理解24C02的数据传输时序。
5 Y# {! F8 ~6 F- R5 l下面把实验中到的数据传输时序讲解一下，分别是对24C02的写时序和读时序。24C02写时序图见图35.1.2.3所示。
, p0 e8 I: Q: E) _6 C% p$ V
5 v! j& K- u' |0 l

% k# Y$ p8 _$ X3 w5 W, n" j+ N% S图35.1.2.3 24C02写时序图
上图展示的主机向24C02写操作时序图，主机在IIC总线发送第1个字节的数据为24C02的设备地址0xA0，用于寻找总线上找到24C02，在获得24C02的应答信号之后，继续发送第2个字节数据，该字节数据是24C02的内存地址，再等到24C02的应答信号，主机继续发送第3字节数据，这里的数据即是写入在第2字节内存地址的数据。主机完成写操作后，可以发出停止信号，终止数据传输。
& Y/ D1 \( P! x- D" l7 ]/ p) h% m# a- S上面的写操作只能单字节写入到24C02，效率比较低，所以24C02有页写入时序，大大提高了写入效率，下面看一下24C02页写时序图，图35.1.2.4所示。
& ^4 W( X! K* ^3 C& ^% n  C


) i9 J2 A6 _4 k
图35.1.2.4 24C02页写时序
在单字节写时序时，每次写入数据时窦需要先写入设备的内存地址才能实现，在页写时序中，只需要告诉24C02第一个内存地址1，后面数据会按照顺序写入到内存地址2，内存地址3等，大大节省了通信时间，提高了时效性。因为24C02每次只能写8bit数据，所以它的页大小也就是1字节。页写时序的操作方式跟上面的单字节写时序差不多，所以不作过多解释了。参考以上说明去理解页写时序。
说完两种写入方式之后，下面看一下图35.1.2.5关于24C02的读时序。
6 @" w9 K( ~9 T1 W2 _
" k. e; q9 @" }+ K+ x- s
$ Z& F1 h. o2 P* b8 U1 c
图35.1.2.5 24C02读时序图
24C02读取数据的过程是一个复合的时序，其中包含写时序和读时序。先看第一个通信过程，这里是写时序，起始信号产生后，主机发送24C02设备地址0xA0，获取从机应答信号后，接着发送需要读取的内存地址；在读时序中，起始信号产生后，主机发送24C02设备地址0xA1,获取从机应答信号后，接着从机返回刚刚在写时序中内存地址的数据，以字节为单位传输在总线上，假如主机获取数据后返回的是应答信号，那么从机会一直传输数据，当主机发出的是非应答信号并以停止信号发出为结束，从机就会结束传输。
4 r) J6 A* ~" M% Y3 r0 C以上的时序的发生基于软件IIC的实现，不用硬件IIC实现，虽然STM32H750带有IIC总线接口，但是ST把硬件IIC设计得非常复杂，所以使用起来很不方便，所以我们采用软件模拟。

( D) w+ Z" C; f: ?. b; E, ?35.2 硬件设计
1.例程功能
& \+ l; M: c. \每按下KEY1，MCU通过IIC总线向24C02写入数据，通过按下KEY0来控制24C02读取数据。同时在LCD上面显示相关信息。LED0闪烁用于提示程序正在运行。
2.硬件资源
1）RGB灯
RED : LED0 - PB4
* y7 @( j9 Q+ R% Z! \9 R& ^4 {2）串口1(PA9/PA10连接在板载USB转串口芯片CH340上面)
3）正点原子2.8/3.5/4.3/7/10寸TFTLCD模块(仅限MCU屏，16位8080并口驱动)
& C: Y0 q$ U1 Y, L( a. J4）独立按键
KEY0 - PA1
KEY1 - PA15
5）24C02
IIC_SCL - PB10
IIC_SDA - PB11
8 _5 T! n, o: p) b  r5 U0 K3.原理图
" r( \4 T% V! K& h* b我们主要来看看24C02和开发板的连接，如下图所示：

; X$ n/ Y, A# Y. E
) \$ C( q' w0 [
, B* ~; C1 G" {图35.2.1 24C02与开发板连接示意图
24C02的SCL和SDA分别连接在STM32的PB10和PB11上。本实验通过软件模拟IIC信号建立起与24C02的通信，进行数据发送与接收，使用按键KEY0和KEY1去触发，LCD屏幕进行显示。

# u0 k! p$ Y' l, M8 t% }- O35.3 程序设计
# E& c+ A, }# o6 S) ?/ c( G  y1 PIIC实验中使用的是软件模拟IIC，所以用到的是HAL中GPIO相关函数，前面也有介绍到，这里就不做展开了。下面介绍一下使用IIC传输数据的配置步骤：
使用IIC传输数据的配置步骤
7 @9 `2 D. u  J, Z3 r1）使能IIC的SCL和SDA对应的GPIO时钟。
本实验中IIC使用的SCL和SDA分别是PB10和PB11，因此需要先使能GPIOB的时钟，代码如下：
__HAL_RCC_GPIOB_CLK_ENABLE();
; }9 S; ~" J" [6 {! H) a. Q2）设置对应GPIO工作模式（SCL推挽输出 SDA开漏输出）
SDA线的GPIO模式使用开漏输出模式（硬件已接外部上拉电阻，也可以用内部的上拉电阻），而SCL线的GPIO模式使用推挽输出模式，通过函数HAL_GPIO_Init设置实现。
3）参考IIC总线协议，编写信号函数（起始信号，停止信号，应答信号）
: |' ^# p$ g1 N6 O2 I0 T* M起始信号：SCL为高电平时，SDA由高电平向低电平跳变。
9 D& c' Z7 l; C6 [* [/ Y& P停止信号：SCL为高电平时，SDA由低电平向高电平跳变。
应答信号：接收到IC数据后，向IC发出特定的低电平脉冲表示已接收到数据。
4）编写IIC的读写函数
通过参考时序图，在一个时钟周期内发送1bit数据或者读取1bit数据。读写函数均以一字节数据进行操作。
有了读和写函数，我们就可以对外设进行驱动了。
2 G/ \5 z) _: u35.3.1 程序流程图
# t' o. P' v9 ^+ u( Y; P2 P

) N  {$ \6 j7 o' V: q
( W- p" |/ c( G8 t图35.3.1.1 IIC实验程序流程图

35.3.2 程序解析
本实验中，我们通过GPIO使用软件来模拟IIC，所以不需要用到HAL库的IIC驱动源码。在工程文件中，我们新增了myiic.c存放iic底层驱动代码，24cxx.c文件夹存放24C02驱动。
1.IIC底层驱动代码
7 I" o9 v0 i" ?' B8 W% @! N  @这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。IIC驱动源码包括两个文件：myiic.c和myiic.h。
# [, H' o  p2 {* ]4 ]" z下面我们直接介绍IIC相关的程序，首先先介绍 myiic.h文件，其定义如下：
- x$ M6 \+ E/ S0 c' N3 Z/ Z

1. /* 引脚 定义 */
   8 W) s$ [# g* D' e: H  Q' K
2. #define IIC_SCL_GPIO_PORT                 GPIOB
   + l( K: A9 n* O+ r' H% E
3. #define IIC_SCL_GPIO_PIN                    GPIO_PIN_10
   
4. #define IIC_SCL_GPIO_CLK_ENABLE()        do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
   7 v( G/ O& |* m0 s1 m! [
5. 
   * o7 E% i8 ~* K7 l" B* t7 A. G- s, @
6. #define IIC_SDA_GPIO_PORT                GPIOB
   . J" S' ?( a* @
7. #define IIC_SDA_GPIO_PIN                 GPIO_PIN_11
   6 @! f: J+ |! o7 |% G8 w& b
8. #define IIC_SDA_GPIO_CLK_ENABLE()         do{ __HAL_RCC_GPIOB_CLK_ENABLE(); }while(0)
   
9. 
   
10. /* IO操作 */
    
11. #define IIC_SCL(x)    do{ x ? \
    
12.        HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_SET) : \
    0 T; Y, u- [8 B3 x" y0 U
13.        HAL_GPIO_WritePin(IIC_SCL_GPIO_PORT, IIC_SCL_GPIO_PIN, GPIO_PIN_RESET); \
    + |, {7 Z7 l$ n! F. X1 {( \
14.                           }while(0)       /* SCL */
    . K/ R2 Z& @# @4 y2 _
15. 
    
16. #define IIC_SDA(x)    do{ x ? \
    & n- s1 [4 y6 ]2 o
17.        HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_SET) : \
    
18.        HAL_GPIO_WritePin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN, GPIO_PIN_RESET); \
    & e7 p% k" g7 `% \3 X! Q5 }- C, P
19.                           }while(0)       /* SDA */
    
20. /* 读取SDA */
    
21. #define IIC_READ_SDA     HAL_GPIO_ReadPin(IIC_SDA_GPIO_PORT, IIC_SDA_GPIO_PIN)
    
22. 我们通过宏定义标识符的方式去定义SCL和SDA两个引脚，同时通过宏定义的方式定义了IIC_SCL() 和IIC_SDA()设置这两个管脚可以输出0或者1，主要还是通过HAL库的GPIO操作函数实现的。另外方便在iic操作函数中调用读取SDA管脚的数据，这里直接宏定义IIC_READ_SDA实现，在后面iic模拟信号实现中会频繁调用。
    
23. 接下来我们看一下myiic.c代码中的初始化函数，代码如下：
    * B7 A' y- y: J  ~9 F) P/ P( X" z! V1 o
24. /**
    + `2 S0 ^( C# }, W4 _+ F
25. * @brief              初始化IIC
    % [7 S( ~+ X; t  V5 [: `
26. * @param              无
    
27. * @retval            无
    9 |6 [% ^) I+ s5 l, \' r, H- I% q
28. */
    4 m3 |' e9 |  V/ R: ^
29. void iic_init(void)
      t# [9 F" q/ O8 G
30. {
    % X$ B. M* S% }' @) \$ `
31.     GPIO_InitTypeDef gpio_init_struct;
    
32. 
    ' X; }- n4 _$ k( }$ V
33.     IIC_SCL_GPIO_CLK_ENABLE();          /* SCL引脚时钟使能 */
    
34.     IIC_SDA_GPIO_CLK_ENABLE();          /* SDA引脚时钟使能 */
    
35. 
    
36.     gpio_init_struct.Pin = IIC_SCL_GPIO_PIN;
    & P, u( R" U& u
37.     gpio_init_struct.Mode = GPIO_MODE_OUTPUT_PP;                        /* 推挽输出 */
    
38.     gpio_init_struct.Pull = GPIO_PULLUP;                           /* 上拉 */
    : D0 ^( l' Z6 G/ Y
39.     gpio_init_struct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;         /* 快速 */
    & S1 h0 L, x5 d5 b" o* T
40.     HAL_GPIO_Init(IIC_SCL_GPIO_PORT, &gpio_init_struct);        /* SCL */
    / |- w6 L* `7 c! X2 f7 a
41. 
    + k7 T" b/ x. H) l
42. gpio_init_struct.Pin = IIC_SDA_GPIO_PIN;
    ! d) B- c' b6 [1 A
43. gpio_init_struct.Mode = GPIO_MODE_OUTPUT_OD;                        /* 开漏输出 */
      E. H  }8 b" h
44.     HAL_GPIO_Init(IIC_SDA_GPIO_PORT, &gpio_init_struct);        /* SDA */
    5 F4 l' ^3 c& n( r+ }: w% @! W
45. /* SDA引脚模式设置,开漏输出,上拉, 这样就不用再设置IO方向了, 开漏输出的时候(=1),
    
46. 也可以读取外部信号的高低电平 */
    " O1 {$ ?' h. E' A( D  D
47. 
    8 a! m2 x5 E8 _" J- t0 M( ?; V
48.     iic_stop();     /* 停止总线上所有设备 */
    
49. }

复制代码

# i, _$ L! M3 g4 B3 H6 U在iic_init函数中主要工作就是对于GPIO的初始化，用于iic通信，不过这里需要注意的一点是SDA线的GPIO模式要使用开漏模式，特别注意：假如是STM32F103必须外接上拉电阻！
接下来介绍在上面已经在文字上说明过的IIC模拟信号：起始信号、停止信号、应答信号，下面以代码方法实现，大家可以对着图去看代码，有利于理解。
0 R& b) h: f; u& @; [* ~# b

1. /**
   & F* u( m% f# a! o
2. * @brief             IIC延时函数,用于控制IIC读写速度
   ) r+ Y! V( p6 G+ e* b
3. * @param             无
   
4. * @retval             无
   % U4 C* L% q/ ^8 q% G
5. */
   % D7 d0 K- ^, b+ D/ V0 T
6. static void iic_delay(void)
   " m4 g) ]( [3 Q8 r' Y
7. {
   * k/ R! H$ X" O5 Q7 `% s$ }* S' c1 H1 r
8.     delay_us(2);    /* 2us的延时, 读写速度在250Khz以内 */
   
9. }
   + ]5 z  b6 m4 X0 M1 F
10. 
    
11. /**
    
12. * @brief              产生IIC起始信号
    6 Q2 c2 W. A" f2 t
13. * @param              无
    7 _6 ]7 ^; t9 S( y0 G  e. q' v$ K
14. * @retval             无
    
15. */
    1 Y% C& D" P; Q* M( f
16. void iic_start(void)
    
17. {
    
18.     IIC_SDA(1);
    
19.     IIC_SCL(1);
    
20.     iic_delay();
    . a9 m' Z; R: u( h
21.     IIC_SDA(0);     /* START信号: 当SCL为高时, SDA从高变成低, 表示起始信号 */
    ' o5 I6 j- _5 S1 d
22.     iic_delay();
    ; H+ W  L" P" k$ }. D; ~; S
23.     IIC_SCL(0);     /* 钳住I2C总线，准备发送或接收数据 */
    % a8 P8 _( t2 ^8 a8 M4 ^% C" |
24.     iic_delay();
    
25. }
    . c+ r0 y3 Q( l  n# Q/ u& ?
26. 
    & M% Y- e/ o% z4 F# s* s. M, }
27. /**
    
28. * @brief             产生IIC停止信号
    6 b; a* B# v$ }: @
29. * @param              无
    ' E" B+ y. ~* l
30. * @retval             无
    
31. */
    ; [- v! M" y4 Q/ o2 w
32. void iic_stop(void)
    % f, ~! }8 ^7 P! O- J- g# n
33. {
    - q+ }* ^$ y# `) V5 c  ^( `/ L
34.     IIC_SDA(0);     /* STOP信号: 当SCL为高时, SDA从低变成高, 表示停止信号 */
    
35.     iic_delay();
    5 W- ?4 h* R$ t: Q8 ]  ?
36.     IIC_SCL(1);
    
37.     iic_delay();
    $ D; j7 R9 S9 o$ A
38.     IIC_SDA(1);     /* 发送I2C总线结束信号 */
    $ F* c; S( S3 F" r+ E9 r2 g1 S" Y/ w' X
39.     iic_delay();
    : B7 q2 ^& ]/ Y/ f: s& Q
40. }

复制代码

在这里首先定义一个iic_delay函数，目的就是控制IIC的读写速度，通过示波器检测读写速度在250KHz内，所以一秒钟传送500Kb数据，换算一下即一个bit位需要2us，在这个延时时间内可以让器件进行获得一个稳定性的数据采集。
为了大家更加清晰了解代码实现的过程，下面单独把起始信号和停止信号从iic总线时序图中抽取出来，如图35.3.2.1所示：

5 |) W) ~* E  q
0 `) d* m/ C3 e' ^
图35.3.2.1 起始信号与停止信号图
iic_start函数中，通过调用myiic.h中通过宏定义好的可以输出高低电平的SCL和SDA来模拟iic总线中起始信号的发送，在SCL时钟线为高电平的时候，SDA数据线从高电平状态转化到低电平状态，最后拉低时钟线，准备发送或者接收数据。
) t3 f9 r" l% Q  O; Fiic_stop函数中，也是按着模拟iic总线中停止信号的逻辑，在SCL时钟线为高电平的时候，SDA数据线从低电平状态转化到高电平状态。
接下来讲解一下iic的发送函数，其定义如下：

* |+ z' T& K& A0 k

1. /**
   
2. * @brief             IIC发送一个字节
   . w7 y1 }( J9 v, R5 n$ p' ]
3. * @param               data: 要发送的数据
   
4. * @retval              无
   
5. */
   
6. void iic_send_byte(uint8_t data)
   
7. {
   
8.     uint8_t t;
   + E* H0 \, f6 ^0 W
9. 
   
10.     for (t = 0; t < 8; t++)
    
11.     {
    
12.         IIC_SDA((data & 0x80) >> 7);    /* 高位先发送 */
    
13.         iic_delay();
    
14.         IIC_SCL(1);
    
15.         iic_delay();
    
16.         IIC_SCL(0);
    ) D* @) D/ h7 L1 S- l: l9 V+ I7 y5 g- ~
17.         data <<= 1;     /* 左移1位,用于下一次发送 */
    5 {$ u) Z( C7 M
18.     }
    
19.     IIC_SDA(1);         /* 发送完成, 主机释放SDA线 */
    
20. }

复制代码

在iic的发送函数iic_send_byte中，我们把需要发送的数据作为形参，形参大小为1个字节。在iic总线传输中，一个时钟信号就发送一个bit，所以该函数需要循环八次，模拟八个时钟信号，才能把形参的8个位数据都发送出去。这里使用的是形参data和0x80与运算的方式，判断其最高位的逻辑值，假如为1即需要控制SDA输出高电平，否则为0控制SDA输出低电平。为了更好说明，数据发送的过程，单独拿出数据传输时序图，见图35.3.2.2。


+ }% m9 n, W- _& P% L& ~
图35.3.2.2数据传输时序图
通过上图就可以很清楚了解数据传输时的细节，经过第一步的SDA高低电平的确定后，接着需要延时，确保SDA输出的电平稳定，在SCL保持高电平期间，SDA线上的数据是有效的，此过程也是需要延时，使得从设备能够采集到有效的电平。然后准备下一位的数据，所以这里需要的是把data左移一位，等待下一个时钟的到来，从设备进行读取。把上述的操作重复8次就可以把data的8个位数据发送完毕，循环结束后，把SDA线拉高，等待接收从设备发送过来的应答信号。
9 l5 \2 x4 U7 [! q8 R接着讲解一下iic的读取函数iic_read_byte，它的定义如下：

6 g/ o! s/ g9 n- G6 `- H) I5 x

1. /**
   
2. * @brief       IIC读取一个字节
   
3. * @param       ack:  ack=1时，发送ack; ack=0时，发送nack
   . P, b9 v% s  m1 d9 @& X
4. * @retval      接收到的数据
   
5. */
   
6. uint8_t iic_read_byte(uint8_t ack)
   9 H. k$ a* e3 L# r  \
7. {
   6 x) w, Q& k2 L% g7 y
8.     uint8_t i, receive = 0;
   / d5 V7 p* u, Q$ R6 O0 [
9. 
   
10.     for (i = 0; i < 8; i++ )    /* 接收1个字节数据 */
    4 T2 u# o9 G# E$ `" }0 Y  T
11.     {
    * B$ K* G) I, u" x' w) k; \* U
12.         receive <<= 1;  /* 高位先输出,所以先收到的数据位要左移 */
    
13.         IIC_SCL(1);
    $ F& q5 J) \" r
14.         iic_delay();
    / M3 s) ]9 ~  J6 e7 e" O, Y: Z
15. 
    
16.         if (IIC_READ_SDA)
    & L" D/ c/ m# X0 ?; J2 G
17.         {
    
18.             receive++;
    
19.         }
    
20. 
    
21.         IIC_SCL(0);
    3 C7 Y: c; ]# G) M* \% U
22.         iic_delay();
    / l( x$ T; [, j# V; A+ \: A6 V
23.     }
    
24.     if (!ack)
    " H3 R' _' D2 M8 Y7 P# _' d' `
25.     {
    
26.         iic_nack();     /* 发送nACK */
    / F2 t2 C3 M; Q; ~. ?
27.     }
    
28.     else
    + M2 l. b1 l. h2 B* c) v8 g, a
29.     {
    + j7 D4 U( T/ I+ U% v
30.         iic_ack();      /* 发送ACK */
    ) }% C- A) B5 c' N' w% ?+ y7 e
31.     }
    
32. 
    - r: o: `/ P, f) f
33.     return receive;
    - X: |" q. \. w! G; s
34. }

复制代码

, E/ q6 n" k& [3 ?6 ^1 miic_read_byte函数具体实现的方式跟iic_send_byte函数有所不同。首先可以明确的是时钟信号是通过主机发出的，而且接收到的数据大小为1字节，但是IIC传输的单位是bit，所以就需要执行8次循环，才能把一字节数据接收完整。
具体实现过程：首先需要一个变量receive存放接收到的数据，在每一次循环开始前都需要对receive进行左移1位操作，那么receive的bit0位每一次赋值前都是空的，用来存放最新接收到的数据位，然后在SCL线进行高低电平切换时输出IIC时钟，在SCL高电平期间加入延时，确保有足够的时间能让数据发送并进行处理，使用宏定义IIC_READ_SDA就可以判断读取到的高低电平，假如SDA为高电平，那么receive++即在bit0置1，否则不做处理即保持原来的0状态。当SCL线拉低后，需要加入延时，便于从机切换SDA线输出数据。在8次循环结束后，我们就获得了8bit数据，把它作为返回值返回，然而按照时序图，作为主机就需要发送应答或者非应答信号，去回复从机。
8 |- ~/ {5 p% H; H/ b9 F上面提及到应答信号和非应答信号是在读时序中发生的，此外在写时序中也存在有一个信号响应，当发送完8bit数据后，这里是一个等待从机应答信号的操作，这里我们也定义了，下面看一下它们的定义：
9 F, Y  `1 O* I( i/ c6 d

1. /**
   
2. * @brief             等待应答信号到来
   0 @5 v) u. |7 b' w
3. * @param              无
   & h# l5 u5 D" E# l8 G  v
4. * @retval             1，接收应答失败
   
5. *                       0，接收应答成功
   
6. */
   1 n: ?4 `) _( L* R  {( h8 K
7. uint8_t iic_wait_ack(void)
   
8. {
   % K* M& W) P8 B4 D9 _; k1 N: k
9.     uint8_t waittime = 0;
   1 S/ j1 J# _' X% f( {
10.     uint8_t rack = 0;
    
11. 
    7 n% S, A2 d5 t% e1 [8 R- j8 o: ]
12.     IIC_SDA(1);     /* 主机释放SDA线(此时外部器件可以拉低SDA线) */
    
13.     iic_delay();
    
14.     IIC_SCL(1);     /* SCL=1, 此时从机可以返回ACK */
    
15.     iic_delay();
    
16. 
    # U! p- i. O: s9 N0 ]. j& w
17.     while (IIC_READ_SDA)    /* 等待应答 */
    
18.     {
    ! m$ z9 ?0 v" V6 `9 M
19.         waittime++;
    
20. 
    ' X( z( y& n, `5 q5 [+ p
21.         if (waittime > 250)
    
22.         {
      Y' ~4 m3 M+ Q# X8 w( x
23.             iic_stop();
    2 E2 @5 {5 N0 t* E; l; K7 I
24.             rack = 1;
    ! ?8 r# I+ \" U4 M  r
25.             break;
    
26.         }
    
27.     }
    
28. 
    0 y2 w! n* Q2 \3 ^& D
29.     IIC_SCL(0);     /* SCL=0, 结束ACK检查 */
      X! D% I  D; w' X
30.     iic_delay();
    ( J4 h$ |0 I! R. i6 A! U
31.     return rack;
    3 W( _2 I7 x6 b" |3 |
32. }
    
33. 
    2 N  \  g, F% R
34. /**
    
35. * @brief             产生ACK应答
    
36. * @param              无
    " I% L+ a7 `8 t3 r+ e/ w# ]- p
37. * @retval             无
    
38. */
    * H* |6 w1 B$ B2 t9 G
39. void iic_ack(void)
    
40. {
    
41.     IIC_SDA(0);     /* SCL 0 -> 1  时 SDA = 0,表示应答 */
    3 Q( ?+ q! W: O. v7 d
42.     iic_delay();
    
43.     IIC_SCL(1);     /* 产生一个时钟 */
    
44.     iic_delay();
    ( O( v3 t( ^/ W. {
45.     IIC_SCL(0);
    
46.     iic_delay();
    
47.     IIC_SDA(1);     /* 主机释放SDA线 */
    
48.     iic_delay();
    
49. }
    5 H2 Y& k8 h! A+ H& k! C. k) ~
50. 
    
51. /**
    1 q* q/ q4 V- C  y
52. * @brief             不产生ACK应答
    
53. * @param             无
    
54. * @retval             无
    
55. */
    
56. void iic_nack(void)
    ' W& @+ D7 \( R" v
57. {
    
58.     IIC_SDA(1);     /* SCL 0 -> 1  时 SDA = 1,表示不应答 */
    
59.     iic_delay();
    
60.     IIC_SCL(1);     /* 产生一个时钟 */
    
61.     iic_delay();
    - T( P) k4 O# H
62.     IIC_SCL(0);
    ) b; S4 P% K: ?' H- |) Y
63.     iic_delay();
    8 h. `! d/ f$ E' I
64. }
    " N6 h# L$ M; \2 ~2 ~

复制代码

首先先讲解一下iic_wait_ack函数，该函数主要用在写时序中，当启动起始信号，发送完8bit数据到从机时，我们就需要等待以及处理接收从机发送过来的响应信号或者非响应信号，一般就是在iic_send_byte函数后面调用。
; |* j  d- y( T4 `具体实现：首先先释放SDA，把电平拉高，延时等待从机操作SDA线，然后主机拉高时钟线并延时，确保有充足的时间让主机接收到从机发出的SDA信号，这里使用的是IIC_READ_SDA宏定义去读取，根据IIC协议，主机读取SDA的值为低电平，就表示“应答信号”；读到SDA的值为高电平，就表示“非应答信号”。在这个等待读取的过程中加入了超时判断，假如超过这个时间没有接收到数据，那么主机直接发出停止信号，跳出循环，返回等于1的变量。在正常等待到应答信号后，主机会把SCL时钟线拉低并延时，返回是否接收到应答信号。
当主机作为作为接收端时，调用iic_read_byte函数之后，按照iic通信协议，需要给从机返回应答或者是非应答信号，这里就是用到了iic_ack和iic_nack函数。
( j3 }, ^+ N% Q4 M具体实现：从上面的说明已经知道了SDA为低电平即应答信号，高电平即非应答信号，那么还是老规矩，首先先根据返回“应答”或者“非应答”两种情况拉低或者拉高SDA，并延时等待SDA电平稳定，然后主机拉高SCL线并延时，确保从机能有足够时间去接收SDA线上的电平信号。然后主机拉低时钟线并延时，完成这一位数据的传送。最后把SDA拉高，呈高阻态，方便后续通信用到。
2. 24C02驱动代码
这里我们只讲解核心代码，详细的源码请大家参考光盘本实验对应源码。24CXX驱动源码包括两个文件：24cxx.c和24cxx.h。
" W# n; Z& ]+ ^+ c+ Z3 ^2 k- ^" ~+ t在上一小节已经对IIC协议中的需要用到的信号都用函数封装好了，那么现在就要定义符合24C02时序的函数。为了使代码功能更加健全，所以在24cxx.h中宏定义了不同容量大小的24C系列型号，具体定义如下：
/ d/ w! c4 M& o1 d3 V) ~

1. #define AT24C01     127
   7 k5 L6 s: Z* x1 a3 V
2. #define AT24C02     255
   0 \1 c6 R# \( z
3. #define AT24C04     511
   
4. #define AT24C08     1023
   2 F. _/ T( b4 e6 d
5. #define AT24C16     2047
   
6. #define AT24C32     4095
   . p3 Z! W# O& D" j5 B& r" b2 [
7. #define AT24C64     8191
   % Y, a4 ^, R. E; |8 r; ~) S/ W' S
8. #define AT24C128    16383
   2 p( ]+ u0 o5 E. o3 t+ M
9. #define AT24C256    32767
   
10. 
    3 W" d% K9 C7 ^* l' v3 c: }
11. /* 开发板使用的是24c02，所以定义EE_TYPE为AT24C02 */
    * ?& ^7 m6 X2 L- s0 }4 i$ O) r
12. #define EE_TYPE     AT24C02
    5 U, n5 l: E8 H" {
13. 在24cxx.c文件中，读/写操作函数对于不同容量大小的24Cxx芯片都有相对应的代码块解决处理。下面先看一下at24cxx_write_one_byte函数，实现在AT24Cxx芯片指定地址写入一个数据，代码如下：
    
14. /**
    + L' |# v$ y$ r. w4 l
15. * @brief             在AT24CXX指定地址写入一个数据
    
16. * @param               addr: 写入数据的目的地址
    8 H1 D6 l4 N8 k; G& Z: t8 W( Z+ M
17. * @param               data: 要写入的数据
    ; _3 g: T& @4 z. d6 f; i" C
18. * @retval              无
    2 U+ E3 }9 _  L, _
19. */
    
20. void at24cxx_write_one_byte(uint16_t addr, uint8_t data)
    * a% N( b/ L! ?( H- H
21. {
    + f3 L( v+ R3 k4 Q" p, W$ }
22.     /* 原理说明见:at24cxx_read_one_byte函数, 本函数完全类似 */
    
23.     iic_start();                                 /* 发送起始信号 */
    
24. 
    
25.     if (EE_TYPE > AT24C16)                     /* 24C16以上的型号, 分2个字节发送地址 */
    
26.     {
    
27.         iic_send_byte(0XA0);                   /* 发送写命令, IIC规定最低位是0, 表示写入 */
    
28.         iic_wait_ack();                         /* 每次发送完一个字节,都要等待ACK */
    " F2 }# Q* f1 u% j$ F* Y
29.         iic_send_byte(addr >> 8);        /* 发送高字节地址 */
    
30.     }
    : K0 m* ]. y' L7 e
31.     else
    
32.     {   /* 发送器件 0XA0 + 高位a8/a9/a10地址,写数据 */
    
33.         iic_send_byte(0XA0 + ((addr >> 8) << 1));   
    + S; z2 S# z6 A" `0 k7 ~: u( p2 j: m( a
34.     }
    ' B; j& y5 y8 M8 J
35. 
    8 A" E+ s! c2 ~+ }1 B
36.     iic_wait_ack();                       /* 每次发送完一个字节,都要等待ACK */
      ?: H3 L1 U8 E) F% p
37.     iic_send_byte(addr % 256);          /* 发送低位地址 */
    
38.     iic_wait_ack();                       /* 等待ACK, 此时地址发送完成了 */
    
39. 
    
40.     /* 因为写数据的时候,不需要进入接收模式了,所以这里不用重新发送起始信号了 */
    
41.     iic_send_byte(data);            /* 发送1字节 */
    
42.     iic_wait_ack();                  /* 等待ACK */
    
43.     iic_stop();                     /* 产生一个停止条件 */
    
44.     delay_ms(10);                 /* 注意: EEPROM 写入比较慢,必须等到10ms后再写下一个字节 */
    
45. }

复制代码

该函数的操作流程跟前面已经分析过的24C02单字节写时序一样，首先调用iic_start函数产生起始信号，然后调用iic_send_byte函数发送第1个字节数据设备地址，等待24Cxx设备返回应答信号；收到应答信号后，继续发送第2个1字节数据内存地址addr；等待接收应答后，最后发送第3个字节数据写入内存地址的数据data，24Cxx设备接收完数据，返回应答信号，主机调用iic_stop函数产生停止信号终止数据传输，最终需要延时10ms，等待eeprom写入完毕。
4 B! ~" p) F% ]0 J我们的函数兼容24Cxx系列多种容量，就在发送设备地址处做了处理，这里说一下为什么需要这样子设计。大家请看一下24Cxx芯片内存组织表，见表35.3.2.1所示。

9 {1 b7 J0 L8 j) i

表35.3.2.1 24Cxx芯片内存组织表
主机发送的设备地址和内存地址共同确定了要写入的地方，这里分析一下24C16的使用的是iic_send_byte(0XA0+((addr>>8)<<1))和iic_send_byte(addr % 256)确定写入位置，由于它内存大小一共2048字节，所以只需要定义11个寻址地址线，2048 = 2^11。主机下发读写命令的时候带了3位，后面再跟1个字节（8位）的地址，正好11位，就不需要再发后续的地址字节了。
而容量大于24C16的芯片，需要单独发送2个字节（甚至更多）的地址，如24C32，它的大小为4096，需要12个寻址地址线支持，4096 = 2^12。24C16是2个字节刚刚好，而它需要三个字节才能确定写入的位置。24C32芯片规定设备写地址0xA0/读地址0xA1，后面接着发送8位高地址，最后才发送8位低地址。与函数里面的操作是一致。
# ?( J& i/ s0 _! `( k接下来看一下at24cxx_read_one_byte函数，其定义如下：
+ v, U; `" S; A% t  Q

1. /**
   ' F8 l  c$ }7 y1 m
2. * @brief             在AT24CXX指定地址读出一个数据
   ) Q/ H/ B8 V& X/ U2 P9 m
3. * @param               readaddr: 开始读数的地址
   
4. * @retval              读到的数据
   ! L8 t( t; O3 a) q/ w4 o& B  f, N
5. */
   % l5 a+ j( Y) X+ A
6. uint8_t at24cxx_read_one_byte(uint16_t addr)
   
7. {
   8 t7 }5 q2 h1 U+ A; I" C
8.     uint8_t temp = 0;
   9 v' B6 ^4 Z) g' d
9.     iic_start();                /* 发送起始信号 */
   9 I3 k! b' V; G  u
10. 
    
11.     /* 根据不同的24CXX型号, 发送高位地址
    " K  l/ H& Q7 c; x
12.      * 1, 24C16以上的型号, 分2个字节发送地址
    6 a- Y/ D5 s1 Q2 g: {) z% [+ @
13.      * 2, 24C16及以下的型号, 分1个低字节地址 + 占用器件地址的bit1~bit3位 用于表示高位
    
14. 地址, 最多11位地址
    & F' A  {7 a. a' o6 N
15.      *    对于24C01/02, 其器件地址格式(8bit)为: 1  0  1  0  A2  A1  A0  R/W
    + o8 r* V- H) s& u
16.      *    对于24C04,    其器件地址格式(8bit)为: 1  0  1  0  A2  A1  a8  R/W
    6 E7 r  A. B# |  T6 \' [, W" E) w+ m
17.      *    对于24C08,    其器件地址格式(8bit)为: 1  0  1  0  A2  a9  a8  R/W
    
18.      *    对于24C16,    其器件地址格式(8bit)为: 1  0  1  0  a10 a9  a8  R/W
    1 t4 `: s0 O8 r) W1 I9 _
19.      *    R/W      : 读/写控制位 0,表示写; 1,表示读;
    7 g' ]0 M8 d' W0 E4 R+ B; U
20.      *    A0/A1/A2 : 对应器件的1,2,3引脚(只有24C01/02/04/8有这些脚)
    
21.      *    a8/a9/a10: 对应存储整列的高位地址, 11bit地址最多可以表示2048个位置,可以寻址
    
22. 24C16及以内的型号
    5 X! @5 e# e9 E5 ^! u6 S) |
23.      */   
    
24.     if (EE_TYPE > AT24C16)        /* 24C16以上的型号, 分2个字节发送地址 */
    7 Q) {0 K  b* l- V# W' u; J# o2 {
25.     {
    " b: C3 S% L$ I$ I
26.         iic_send_byte(0XA0);      /* 发送写命令, IIC规定最低位是0, 表示写入 */
    
27.         iic_wait_ack();            /* 每次发送完一个字节,都要等待ACK */
    
28.         iic_send_byte(addr >> 8);/* 发送高字节地址 */
    # c4 B6 m" Q, k% c. |! A# y" H
29.     }
    & r! q, M8 P  ?" \4 C2 R. p
30.     else
    
31. {
    
32. /* 发送器件 0XA0 + 高位a8/a9/a10地址,写数据 */
    4 ^  g; {! t1 l8 U( A
33.         iic_send_byte(0XA0 + ((addr >> 8) << 1));   
    # C5 t; R4 N4 c0 l4 ?
34.     }
    ( l, K& [' \/ V% `7 P
35. 
    
36.     iic_wait_ack();                       /* 每次发送完一个字节,都要等待ACK */
    & t- n( a% H+ N, z4 U6 N2 j
37.     iic_send_byte(addr % 256);  /* 发送低位地址 */
    5 _6 F3 \& R0 q4 h6 a
38.     iic_wait_ack();               /* 等待ACK, 此时地址发送完成了 */
    
39. 
    + p+ v# l, n8 h8 i8 O
40.     iic_start();                   /* 重新发送起始信号 */
    . C. l+ m, y. R; k" b) H
41.     iic_send_byte(0XA1);                 /* 进入接收模式, IIC规定最低位是0, 表示读取 */
      B4 l0 n8 O5 @4 P: D8 C. \" L
42.     iic_wait_ack();                       /* 每次发送完一个字节,都要等待ACK */
    
43.     temp = iic_read_byte(0);            /* 接收一个字节数据 */
    
44.     iic_stop();                           /* 产生一个停止条件 */
    
45.     return temp;
    6 }+ x; {# |8 A" p4 d* [7 [
46. }

复制代码

% I4 c$ B* |( [" K. e* ^8 H这里的函数的实现跟前面第35.1.2小节24C02数据传输中的读时序一致，主机首先调用iic_start函数产生起始信号，然后调用iic_send_byte函数发送第1个字节数据设备写地址，使用iic_wait_ack函数等待24Cxx设备返回应答信号；收到应答信号后，继续发送第2个1字节数据内存地址addr；等待接收应答后，重新调用iic_start函数产生起始信号，这一次的设备方向改变了，调用iic_send_byte函数发送设备读地址，然后使用iic_wait_ack函数去等待设备返回应答信号，同时使用iic_read_byte去读取从从机发出来的数据。由于iic_read_byte函数的形参是0，所以在获取完1个字节的数据后，主机发送非应答信号，停止数据传输，最终调用iic_stop函数产生停止信号，返回从从机addr中读取到的数据。
0 l! P! ]& F+ T* g为了方便检测24Cxx芯片是否正常工作，在这里也定义了一个检测函数，代码如下：
1 e2 N$ n8 W' U2 ~( @
2 k) a2 Q3 m. y) a

1. /**
   
2. * @brief             检查AT24CXX是否正常
   
3. *   @note              检测原理: 在器件的末地址写如0X55, 然后再读取, 如果读取值为0X55
   
4. *                       则表示检测正常. 否则,则表示检测失败.
   $ M: U# V  M- N: y+ S, i8 q
5. *
   
6. * @param              无
   ( Z2 M4 k* z$ K* Q9 h
7. * @retval             检测结果
   / I2 n! S& v$ P+ O9 S
8. *                      0: 检测成功
   
9. *                      1: 检测失败
   ) V: q/ A, `; r  r0 p* D/ e
10. */
    5 O2 c2 M, o: {1 o! a1 b8 h  f; P
11. uint8_t at24cxx_check(void)
    7 Q9 [+ S; e  h( m  L* n0 ]
12. {
    . N% A# K6 N* J2 E  i4 E
13.     uint8_t temp;
    " k" z5 c6 ?3 n0 t; q! c5 n
14.     uint16_t addr = EE_TYPE;
    ) c: i3 e7 z# i, n: j' ^5 G! x: q1 w
15.     temp = at24cxx_read_one_byte(addr); /* 避免每次开机都写AT24CXX */
    1 s2 j* X* O7 X$ _2 t, f7 ?
16. 
      |. `3 f' j; B8 l% ?: I2 c
17.     if (temp == 0X55)   /* 读取数据正常 */
    
18.     {
    ; j+ e6 V$ D8 v
19.         return 0;
    
20.     }
    
21.     else    /* 排除第一次初始化的情况 */
    ! G" R+ s- T: H5 H
22.     {
    
23.         at24cxx_write_one_byte(addr, 0X55); /* 先写入数据 */
    & P* [" H9 J* Q" R" ^) q6 ^
24.         temp = at24cxx_read_one_byte(255);  /* 再读取数据 */
    " ~3 c2 P2 t2 `" B
25.         if (temp == 0X55)return 0;
    
26.     }
    
27.     return 1;
    
28. }
    7 |7 }9 ?# j% b; F( D0 P" p

复制代码

学到这个地方相信大家，对于这个操作并不陌生了，在前面的RTC实验也有相似的操作，可以翻回去看看。这里利用的是EEPROM芯片掉电不丢失的特性，在第一次写入了某个值之后，再去读一下是否写入成功，这种方式去检测芯片是否正常工作。
此外方便多字节写入和读取，还定义了在指定地址读取指定个数的函数以及在指令地址写入指定个数的函数，代码如下：
' @! _0 e1 E  g% ~
5 p  I: i& T, r" |. J" [

1. /**
   ; `+ ~. j( h4 D
2. * @brief               在AT24CXX里面的指定地址开始读出指定个数的数据
     a5 }+ @; L5 b$ H
3. * @param               addr    : 开始读出的地址 对24c02为0~255
   
4. * @param               pbuf    : 数据数组首地址
   ! [/ U# x3 m6 K  q# O# n
5. * @param               datalen : 要读出数据的个数
   $ \  I: C, [' O4 i# F
6. * @retval              无
   % ^2 f( {! k$ ~
7. */
   % [, |/ x' K- X
8. void at24cxx_read(uint16_t addr, uint8_t *pbuf, uint16_t datalen)
   1 R6 X! B% ^% K
9. {
   
10.     while (datalen--)
    
11.     {
    
12.         *pbuf++ = at24cxx_read_one_byte(addr++);
    
13.     }
    ' {1 k" q& ~: N" @' c
14. }
    4 o" V4 j) q! w8 R5 I5 I4 w, B" k
15. 
    ' z% E  ]) v8 f! e8 Q* y
16. /**
    
17. * @brief               在AT24CXX里面的指定地址开始写入指定个数的数据
    3 |; e( f! S9 Y- R
18. * @param               addr    : 开始写入的地址 对24c02为0~255
    / ?/ E& d3 Z  x  u$ S/ C( A
19. * @param               pbuf    : 数据数组首地址
    3 V* T4 G. d+ d% U
20. * @param               datalen : 要写入数据的个数
    
21. * @retval              无
    
22. */
    
23. void at24cxx_write(uint16_t addr, uint8_t *pbuf, uint16_t datalen)
    ( T* t+ `7 J4 R
24. {
    
25.     while (datalen--)
    / }; u# H; i8 t6 S& n, L; s
26.     {
    
27.         at24cxx_write_one_byte(addr, *pbuf);
    0 m- o3 y2 ]( o: p8 t% y; Y( i$ Y- W3 ?
28.         addr++;
    
29.         pbuf++;
    8 J. o# {% t; b* i% o! L
30.     }
    - S! [2 o2 E! ?
31. }

复制代码

- M8 J* G- G) W7 n1 P对于这两个函数都是调用前面的单字节操作函数去实现的，利用for循环，连续调用单字节操作函数去实现，这里就不多讲。
9 N" ]+ l9 H7 }" S. N7 A  i3. main.c代码
在main.c里面编写如下代码：
1 R3 n% S' ^: b8 P7 @0 @# \/* 要写入到24c02的字符串数组 */
9 z5 O9 t, C3 T/ n* ~6 n/ y0 m

1. const uint8_t g_text_buf[] = {"MiniPRO STM32H7 IIC TEST"};
   
2. #define TEXT_SIZE       sizeof(g_text_buf)  /* TEXT字符串长度 */
   3 M' v0 R1 H" O# Q* M' j( U
3. 
   - ?/ y  i' |% p; B
4. int main(void)
   
5. {
   5 a/ `7 _- e/ n* t: ^4 i$ j$ r
6.     uint8_t key;
   ' x6 G- C! e, u/ b; O  N
7.     uint16_t i = 0;
   ) @( Q' K2 t. H) Q  B0 z; N) w
8.     uint8_t datatemp[TEXT_SIZE];
   
9. 
   
10.     sys_cache_enable();                                   /* 打开L1-Cache */
    
11.     HAL_Init();                                             /* 初始化HAL库 */
    4 S& Y8 l% \1 \  T) R: m
12.     sys_stm32_clock_init(240, 2, 2, 4);                /* 设置时钟, 480Mhz */
    3 ^3 V/ Q3 {" j. O
13.     delay_init(480);                                       /* 延时初始化 */
    
14.     usart_init(115200);                            /* 串口初始化为115200 */
    + x" {% K) h. z1 e) H
15.     usmart_dev.init(240);                                 /* 初始化USMART */
    
16.     mpu_memory_protection();                             /* 保护相关存储区域 */
    5 k! p8 p( B4 ^& L' P! }9 G
17.     led_init();                                             /* 初始化LED */
    - u! o. X, C8 g5 d
18.     lcd_init();                                             /* 初始化LCD */
    " ]# j/ N* O+ K) J, Q# ^" J
19.     key_init();                                             /* 初始化按键 */
    
20.     at24cxx_init();                                        /* 初始化24CXX */
    
21. 
    - ^! s2 \& j) p$ H% T3 n( B
22.     lcd_show_string(30, 50, 200, 16, 16, "STM32", RED);
    
23.     lcd_show_string(30, 70, 200, 16, 16, "IIC TEST", RED);
    : K; n- p, u8 b) a+ x: V& x# x
24. lcd_show_string(30, 90, 200, 16, 16, "ATOM@ALIENTEK", RED);
    
25. /* 显示提示信息 */
    1 Y2 m' e# _$ Q9 _+ d
26.     lcd_show_string(30, 110, 200, 16, 16, "KEY1:Write  KEY0:Read", RED);   
    , f3 ]7 r6 {/ ^& I. W( m
27. 
    
28.     while (at24cxx_check()) /* 检测不到24c02 */
    
29.     {
    
30.         lcd_show_string(30, 130, 200, 16, 16, "24C02 Check Failed!", RED);
    . T  z/ {- H$ ^: o" q
31.         delay_ms(500);
    * n, z/ k4 z  g$ n9 D1 k+ }9 m
32.         lcd_show_string(30, 130, 200, 16, 16, "Please Check!      ", RED);
    
33.         delay_ms(500);
    
34.         LED0_TOGGLE();      /* 红灯闪烁 */
    
35.     }
    
36. 
    8 P+ a! |# K" h4 M6 F- ~) L
37.     lcd_show_string(30, 130, 200, 16, 16, "24C02 Ready!", RED);
    
38. 
    ) H, e/ j' W5 p! C* E+ B2 M: q3 f# H
39.     while (1)
    : h$ G  `+ z. \3 X9 J( }+ m& }" s
40.     {
    7 @5 g" s, g$ A8 x9 _/ l
41.         key = key_scan(0);
    5 R* s8 x2 h& b: \' ]+ ~
42. 
    
43.         if (key == KEY1_PRES)   /* KEY1按下,写入24C02 */
    
44.         {
    ) c4 F6 q6 z+ t* G
45.             lcd_fill(0, 150, 239, 319, WHITE);  /* 清除半屏 */
    $ j( K/ N8 z* z' N" q( X
46.             lcd_show_string(30, 150, 200, 16, 16, "Start Write 24C02....", BLUE);
    ( j0 b* W$ }) C8 D/ d
47.             at24cxx_write(0, (uint8_t *)g_text_buf, TEXT_SIZE);
    
48. /* 提示传送完成 */
    0 z' I) v1 d" ^
49.             lcd_show_string(30, 150, 200, 16, 16, "24C02 Write Finished!", BLUE);
    ) H' K. ^0 r. R5 b3 X* Y
50.         }
    
51. 
    3 G1 T" ~9 v% }! |( z- {1 T
52.         if (key == KEY0_PRES)   /* KEY0按下,读取字符串并显示 */
    
53.         {
    ( _! ]( `8 {2 R5 z
54.             lcd_show_string(30, 150, 200, 16, 16, "Start Read 24C02.... ", BLUE);
    
55.             at24cxx_read(0, datatemp, TEXT_SIZE);
    * L0 _/ o4 Q# e/ z. T$ Y
56. /* 提示传送完成 */
    
57.             lcd_show_string(30, 150, 200, 16, 16, "The Data Readed Is:  ", BLUE);   /* 显示读到的字符串 */
      ?& i; e, j/ d3 M# r6 T. A
58.             lcd_show_string(30, 170, 200, 16, 16, (char *)datatemp, BLUE);         
    & e- P( b! z, G, K
59.         }
    
60. 
    2 Y! u% x! h5 i/ q
61.         i++;
    3 L: ]9 V; U, Z& m
62. 
    ) t' F; T1 t7 j& n: x5 k! J+ o
63.         if (i == 20)
    5 ?; F) A5 x+ r
64.         {
    
65.             LED0_TOGGLE();  /* 红灯闪烁 */
    
66.             i = 0;
    
67.         }
    
68. 
    
69.         delay_ms(10);
      w$ i2 Y3 c, M, j
70.     }
    ( l2 `2 A, N9 s" E
71. }

复制代码

& d' E7 B* c( N5 {4 Bmain函数的流程大致是：在main函数外部定义要写入24C02的字符串数组g_text_buf。在完成系统级和用户级初始化工作后，检测24c02是否存在，然后通过KEY0去读取0地址存放得数据并把数据显示在LCD上；另外还可以通过KEY1去0地址处写入g_text_buf数据并在LCD界面中显示传输中，完成后并显示“24C02 Write Finished!”。

/ j# C0 K9 \$ d35.4 下载验证
+ k$ ?' m$ k% {. s8 T- X9 U将程序下载到开发板后，可以看到LED0不停的闪烁，提示程序已经在运行了，先按下KEY1写入数据，然后再按KEY0读取数据，最终LCD显示的内容如图35.4.1所示：

. i, d5 g& W* F# V9 z$ y% A

' P8 {+ |" i8 H( o图35.4.1 IIC实验程序运行效果图
假如大家需要验证24C02的自检函数，可以用跟杜邦线把PB10和PB11短接，看是否能看到报错。
. p  c6 @6 x* q1 g' s! ?- P该实验还支持USMART，在这里我们可以方便测试24C02的读写功能，可以操作24C02的任意地址，不过在0~255这个范围，读写测试图如图35.4.2所示。
" _  e) Y$ U, {- [$ H8 ~9 C
. w2 V- O1 W5 @% b! \+ I" s
" y! ~- W! ^) s) Y
9 R1 K  W- ~- Z/ j( H$ m4 c图35.4.2 24C02读写测试图
7 ]9 _/ t3 v; W/ ^; o6 ]- d图中，我们首先调用at24cxx_read_one_byte函数在123地址处读取数据，获取到的值为0XFF。然后通过调用at24cxx_write_one_byte函数在123地址处写入的值为0x12，最后继续调用at24cxx_read_one_byte函数在123地址处读取数据，获取到的值为0x12，表明实验成功。
, G$ L3 c& C4 v至此，我们整个IIC实验就结束了，本章内容比较多，需要大家花多点时间去理解，一定要自己去用一下IIC通信协议。市面上很多器件都是具有IIC通信接口的，可以尝试去驱动它们，这样才能学以致用。
& d3 r; s8 p) ?, D" M4 X2 F( b————————————————
版权声明：正点原子

2 _% q# }, ^) r9 N; o6 ~
; f2 e- A8 ^# T5 R9 R