手把手教你编写嵌入式驱动程序（根据时序图）

发表于 2025-1-16 15:29

本帖最后由 DKENNY 于 2025-1-16 15:27 编辑

#申请原创# #技术资源# @21小跑堂

前言
   一般来说，一些常用的芯片在开发时，即使不熟悉，也可以参考网上现有的例程，对于一些不常用的芯片，DataSheet就是使用这款芯片的唯一资料，那么这时候就需要根据DataSheet的时序图写出对应的驱动程序。
   这篇文章，我将手把手地教你怎么看芯片的数据手册，并根据时序图写出对应的驱动代码，以AT24C02这个模块为例，这款芯片是使用I2C协议通信的一款EEPROM模块。

1、手册分析
   我们获取这个模块的手册后（由于本文章主要是驱动代码的实现，主要就分析关于通信方面的了），我们看看其接线及引脚分布图，可以确定这款芯片是使用I2C协议进行通信的。
52242655191316d94f1371c62f2cbfcd

接下来，看看相关的引脚描述，可以确定我们对应的GPIO的配置方法。
4045acc71bf811ef25c6bd855b50a86e

可以看到，这个模块的SDA引脚是配置成开漏输出的。这里我们是从软件层面重新编写这个驱动，我们先不考虑。
我们知道I2C协议给每个主机（从机）都会分配一个地址，主从机之间的通信也是通过这个地址进行的，我们往下看手册，看看这个模块的地址是怎么确定的。
89eb96078eff2c581d4686bdadac85ac

可以看到，AT24CXX整个系列通信关于地址及数据发送是有区别的，我这里整理了一个表格。

型号	内部组织	随机字地址位	设备地址位配置	读/写选择位
AT24C01A	16 页，每页 8 字节	7 位	1 0 1 0 A2 A1 A0	第 8 位
AT24C02	32 页，每页 8 字节	8 位	1 0 1 0 A2 A1 A0	第 8 位
AT24C04	32 页，每页 16 字节	9 位	1 0 1 0 A2 A1 -	第 8 位
AT24C08A	64 页，每页 16 字节	10 位	1 0 1 0 A2 - -	第 8 位
AT24C16A	128 页，每页 16 字节	11 位	1 0 1 0 - - -	第 8 位

   说明：
      - 内部组织：显示每个 EEPROM 的存储结构。
      - 随机字地址位：表示访问随机存储位置所需的位数。
      - 设备地址位配置：展示设备地址的固定部分和可配置部分。
      - 读/写选择位：第 8 位用于选择读或写操作。如果该位为高，则为读操作；如果为低，则为写操作。

   一般来说，AT24CXX 系列 EEPROM 的器件地址取决于具体的型号和配置。通常，AT24CXX 的器件地址是由固定部分和可配置部分组成。
      - 固定部分：一般为（即 0xA0 的高四位）。
      - 可配置部分：根据 A0、A1、A2 引脚的连接状态，器件地址的后面三位会有相应的变化。例如：
      - 如果 A0、A1、A2 都接地（低），则器件地址为（0xA0）。
      - 如果 A0 接高，而 A1、A2 接地，则器件地址为（0xA1）。
   以此类推，改变 A0、A1 和 A2 的状态可以得到不同的地址。
   最终的 I2C 地址通常在 0xA0 到 0xA7 之间，具体取决于硬件的连接方式。

   我这里使用的AT24C02，大小是2K的EEPROM芯片。我就以这个芯片进行下面的驱动程序编写。

2、I2C 协议-基本时序分析及驱动编写
   一般我们使用某个模块进行通信，主要就是遵循该芯片的通信协议，根据该协议的时序实现数据接发收。
   AT24C02的手册上已经将I2C协议的通信时序列举出来了，下面根据这些时序实现功能。
   下面是I2C总线通信时序，我们主要是分步式的实现通信的每个时序。
59d23743cb27f4b6ae520ca37cd737c0

如下的通信时序，因为是使用GPIO模拟的，可初始化任意两个引脚（除DEBUG相关引脚）进行实现。可参考以下代码。

复制

void I2C_Init(void)

{                         

    GPIO_Config_T gpioConfig;

    RCM_EnableAPB2PeriphClock(RCM_APB2_PERIPH_GPIOB);    //使能GPIOB

       

    gpioConfig.pin = I2C_PIN_SCL|I2C_PIN_SDA;

    gpioConfig.mode = GPIO_MODE_OUT_PP ;                //推挽输出

    gpioConfig.speed = GPIO_SPEED_50MHz;

    GPIO_Config(GPIOB, &gpioConfig);

    GPIO_SetBit(GPIOB,I2C_PIN_SCL|I2C_PIN_SDA);         //PB6,PB7置高电平

}

2.1 start/stop 通信时序的实现
对于任一协议来说，时序的改变，无非就是引脚拉高或拉低嘛，我们主要操作GPIO进行引脚电平切换就行了。
155224b4be100085372c4875b7ffbfab

状态	描述	代码
1	初始状态	I2C_SDA_SET; I2C_SCL_SET;
2	SDA拉低	I2C_SDA_RESET;
3	SCL拉低	I2C_SCL_RESET;
4	初始状态	I2C_SCL_RESET; I2C_SDA_RESET;
5	SCL拉高	I2C_SCL_SET;
6	SDA拉高	I2C_SDA_SET;

实际实现的代码如下：

复制

void I2C_Start(void)

{

    SDA_OUT();              //SDA输出,由主机发送start,设置为输出模式

    I2C_SDA_SET;

    I2C_SCL_SET;

    Delay_us(4);

    I2C_SDA_RESET;

    Delay_us(4);

    I2C_SCL_RESET;

}

复制

void I2C_Stop(void)

{

    SDA_OUT();              //SDA输出,由主机发送stop,设置为输出模式

    I2C_SCL_RESET;

    I2C_SDA_RESET;

    Delay_us(4);

    I2C_SCL_SET; 

    I2C_SDA_SET;

    Delay_us(4);                                   

}

   START/STOP的时序，一般是由主机控制，所以这两个时序也是针对于主机的，由主机发送，故SDA引脚设置为输出。
   一般对于运行速度快的单片机，时序变化时，需要加一些延时操作，我这里统一加一些延时操作。

2.2 数据发送通信时序实现
   手册上有明确表明，不同的芯片其对应的发送单位不一样。AT24C02规定的就是，一次发送8位的数据。
4dceaac369e40c90bf260b9a60b50960

实际的数据发送是一个时钟位对应一个bit，所以如果我们要发一个数据（8bit），需要拆分，然后一个bit一个bit的发送。
c886d480f16717ce5b3615c32ef0ddce

状态	描述	代码
1	初始状态	I2C_SCL_RESET; I2C_SDA_RESET;
2	拉高SCL	I2C_SCL_SET;
3	拉低SCL	I2C_SCL_RESET;
4	准备下一次数据传输

实现代码如下：

复制

void I2C_Send_Byte(uint8_t txd)

{

    uint8_t t;

    SDA_OUT();

    I2C_SCL_RESET;

    I2C_SDA_RESET;

    // 发送8次

    for (t = 0; t < 8; t++)

    {

        I2C_SDA_WRITE((txd & 0x80)>>7);

        txd <<= 1;

        Delay_us(2);    

        I2C_SCL_SET;

        Delay_us(2); 

        I2C_SCL_RESET;    

        Delay_us(2);

    }

}

上面的表格只列举出了实现的时序，并没有加入SDA数据发送的操作，其实，时序图上已经很明确了。
46deaa2041cca5aafedd232b8942d5be

当SCL线处于高电平时，这时SDA当前的电平状态就是SDA发送的数据。我们代码已经实现了这个功能，也就是在SCL拉高之前，先设置SDA引脚的电平状态，当SCL拉高之后，当前SDA的电平就是发送的数据。这里我们只发送了一位，所以还需要进行7次的操作，这样从高位到低位一位一位地发送，就实现了I2C发送一个字节的功能。
5b62fa73a4d6b1f18260ec3946e03e6a

2.3 ACK 通信时序实现
23db2bcbf1ede5b2f9159c9f6dc14c70

状态	描述	代码
1	初始状态	I2C_SCL_RESET; I2C_SDA_RESET;
2	SCL拉高	I2C_SCL_SET;
3	SCL拉低	I2C_SCL_RESET;

实现代码如下：

复制

void I2C_Ack(void)

{

    SDA_OUT();

    I2C_SCL_RESET;

    I2C_SDA_RESET;

    Delay_us(2);

    I2C_SCL_SET;

    Delay_us(2);

    I2C_SCL_RESET;

}

数据如果是自己发送的话，都需要把SDA引脚配置成输出模式，这个应该很好理解。

2.4 数据接收通信时序实现
数据读取的操作与数据发送是一样的，跟发送的一样，我们只需要在时钟线稳定的时候，读取GPIO当前电平就行了，同样是下面这一段时序。
c886d480f16717ce5b3615c32ef0ddce

状态	描述	代码
1	初始状态	I2C_SCL_RESET; I2C_SDA_RESET;
2	拉高SCL	I2C_SCL_SET;
3	拉低SCL	I2C_SCL_RESET;
4	准备下一次数据读取

实现代码如下：

复制

uint8_t I2C_Read_Byte(void)

{

    unsigned char i,receive=0;  // receive 默认值为0

    I2C_SCL_RESET;

    I2C_SDA_RESET;

    SDA_IN();                   //SDA设置为输入

    for (i = 0; i < 8; i++ )

    {

        I2C_SCL_SET;

        receive <<= 1;

        if(I2C_READ_SDA)

        {

            receive++;  

        }

        Delay_us(1);

        I2C_SCL_RESET;

        Delay_us(1);

    }

    I2C_Ack();              //发送ACK



    return receive;

}

上面我们注意到，时序都是同一个，只不过实现的代码不一样，一个是发送，一个是接收。
这里的操作，是因为读取的SDA引脚如果是高电平（也就是“1”），这里也同步加1（默认是0），这样就确保了数据接收的一致性。
cf017c127f1198854d4c2ee381b29ce2

2.5 WaitAck通信时序实现
手册上只有Ack时序，并没有关于WaitAck相关的部分，我们可以设计一下，怎么实现WaitAck这部分。首先分析一下，Ack信号，其实就是在一个I2C的时钟周期内，SDA电平一直稳定为低电平，在了解这部分后，我们就可以实现这部分的代码了。
23db2bcbf1ede5b2f9159c9f6dc14c70

代码实现如下：

复制

uint8_t I2C_Wait_Ack(void)

{

    SDA_IN();               //SDA设置为输入  

    I2C_SDA_SET;

    Delay_us(1);

    I2C_SCL_SET;

    Delay_us(1);

    while(I2C_READ_SDA)

    {

    }

    I2C_SCL_RESET;          //时钟输出0        

    return 0;

}

等待Ack响应，就是由另一个I2C模块发送Ack信号嘛，所以我们这里将SDA引脚设置为输入状态，一直监听SDA引脚，等待它拉低。
这里也存在一个问题，也就是如果接收不到Ack信号，整个I2C就会一直占用总线，造成总线繁忙，所以，我们可以改一下代码，在里面加一些定时操作，如果在某段时间内，还没有接收到Ack响应，就停止此次数据传输。

复制

uint8_t I2C_Wait_Ack(void)

{

    uint8_t uTime = 0;

    SDA_IN();               //SDA设置为输入  

    I2C_SDA_SET;

    Delay_us(1);

    I2C_SCL_SET;

    Delay_us(1);

    while(I2C_READ_SDA)

    {

         uTime++;

        if(uTime > 250)

        {

            I2C_Stop();

            return 1;

        }

    }

    I2C_SCL_RESET;          //时钟输出0        

    return 0;

}

3、AT24C02-基本时序分析及驱动编写
上面我们已经完成了I2C协议的基本时序编写，下面我们就可以编写该模块的驱动代码了。

3.1 写实现(Write)
我们首先看看写时序。
381bacf7175c3b4bd674179204a1fa2c

手册上也有关于这部分的说明。
12bed71818d0d78aa027999400177d1e

这里还有一个比较重要的就是，模块内存是怎么分配的。
8914908e7325b991cd26db6424cbcde2

可以看到，AT24C02的大小是2K，对应分配是256*8，我们可以这么分析。
前面提过，AT24C02 内部组织为 8 页，每页有 32 个字节。对于 AT24C02，这里的页地址实际上是 0，因为地址范围在 0 到 255 之间。除了前面的固定值0xA0以外，我们还有3个位（A0,A1,A2）可供选择，这3个位正好表示0~7，所以我们用末3位作为地址的页数（8页，正好表示为0~7），这样数据就正好铺满整个AT24C02模块且不会出现数据覆盖或者冲突的情况。

A0	A1	A2	范围
0	0	0	第1页(0~255)
0	0	1	第2页(256~511)
0	1	0	第3页(512~767)
0	1	1	第4页(768~1023)
1	0	0	第5页(1024~1279)
1	0	1	第6页(1280~1535)
1	1	0	第7页(1536~1791)
1	1	1	第8页(1792~2047)

接下来，我们就可以编写代码，实现发送（写）一个字节。

复制

void AT24C02_WriteOneByte(uint16_t WriteAddr,uint8_t DataToWrite)

{

    I2C_Start();

  

    /*AT24C02 的设备地址为 0XA0，后面的页地址和具体地址的处理是为了正确定位要写入的数据位置。*/

    

    I2C_Send_Byte(0XA0+((WriteAddr/256)<<1));  // 发送高地址

    I2C_Wait_Ack();

    I2C_Send_Byte(WriteAddr%256);   //发送低地址

    I2C_Wait_Ack();

    I2C_Send_Byte(DataToWrite);     //发送字节                               

    I2C_Wait_Ack();

    I2C_Stop();//产生一个停止条件 

    Delay_ms(10);

}

后面有个10ms的延时，是因为EEPROM 在写入数据后需要一定的时间来将数据保存到非易失性存储器中，因此需要延时。
实现单个字节的发送以后，我们可以继续做一个扩展，直接写一段数据。

复制

void AT24C02_Write(uint16_t WriteAddr,uint8_t *pBuffer,uint16_t NumToWrite)

{

    while(NumToWrite--)

    {

        AT24C02_WriteOneByte(WriteAddr,*pBuffer);

        WriteAddr++;

        pBuffer++;

    }

}

3.2 读实现(Read)
我们已经实现了写(Write)的代码，读也是类似的。同样我们看这个模块的读时序。
47739310cda1b260e926a1ff513e6560

先分析一下，我们可以看到在进行读操作之前，需要先发送设备地址与要读取数据的地址，再进行读操作，下面我们编写代码。

复制

uint8_t AT24C02_ReadOneByte(uint16_t ReadAddr)

{                  

    uint8_t temp=0;

  

    I2C_Start();

    I2C_Send_Byte(0XA0+((ReadAddr/256)<<1));   //发送器件地址0XA0,写数据 



    I2C_Wait_Ack();

    I2C_Send_Byte(ReadAddr%256);   //发送低地址

    I2C_Wait_Ack();

    I2C_Start();

    I2C_Send_Byte(0XA1);           //进入接收模式               

    I2C_Wait_Ack();

    temp=I2C_Read_Byte();

    I2C_Stop();                     //产生一个停止条件        

    return temp;

}

同样我们可以进一步扩展，实现Read操作。

复制

void AT24C02_Read(uint16_t ReadAddr,uint8_t *pBuffer,uint16_t NumToRead)

{

    while(NumToRead)

    {

        *pBuffer++=AT24C02_ReadOneByte(ReadAddr++);    

        NumToRead--;

    }

}

   到这里，我们的读写通信时序已经完全实现了。

4、总结
   其实，不管是这篇文章的标准I2C通信协议，还是SPI、UART、1-WIRE协议也好，其本质都是通过一定的物理连接和协议规则，实现设备之间的数据传输和通信。
   希望这篇文章能够对你们有些帮助，有问题，我们可以及时交流~

本文章依据手册：

AT24CXX.pdf (484.85 KB, 下载次数: 8)

发表于 2025-1-17 09:16

经大佬指点，文章中的WaitAck代码实现逻辑存在问题，主机可能无法正确接收到从机的ACK响应，代码修改如下。

复制

uint8_t I2C_Wait_Ack(void)

{

    uint32_t ucErrTime = 0;



    // 1. 将SCL拉低，确保在接收ACK之前SCL为低电平

    I2C_SCL_RESET(); // 拉低SCL



    // 2. 将SDA设置为输入，准备接收ACK

    SDA_IN(); // 设置SDA为输入

    I2C_SDA_SET(); // 将SDA线拉高，释放总线



    // 3. 等待从机拉低SDA线

    while (I2C_READ_SDA())

    {

        ucErrTime++;

        if (ucErrTime > 250) // 超时处理

        {

            I2C_Stop(); // 如果超时，发送停止信号

            return 1; // 返回1表示未收到ACK

        }

        Delay_us(1); // 等待一段时间再检查

    }



    // 4. 从机已经拉低SDA线，接下来拉高SCL以读取ACK

    I2C_SCL_SET(); // 拉高SCL

    Delay_us(1); // 等待一段时间以确保SCL稳定



    // 5. 再次拉低SCL以结束ACK接收

    I2C_SCL_RESET(); // 拉低SCL

    return 0; // 返回0表示成功接收到ACK

}

发表于 2025-1-16 16:03

看时序图写代码这个技能真的很重要

发表于 2025-1-16 16:04

相对于SPI，IIC的协议看起来太复杂了

发表于 2025-1-16 16:45

LightCatcher 发表于 2025-1-16 16:04
相对于SPI，IIC的协议看起来太复杂了

协议都是类似的

发表于 2025-1-16 16:45

LightCatcher 发表于 2025-1-16 16:04
相对于SPI，IIC的协议看起来太复杂了

发表于 2025-1-16 18:18

等待从机ACK逻辑错误，在IIC的世界里如果当前的SCL是高电平那么从机没有任何权限去改变SDA的电平状态，楼主的程序在读ACK前先把SCL拉高了

发表于 2025-1-16 18:31

在红圈这里你一拉低SCL从机就已经给ACK了，所以你等待ACK函数里的延时等待毫无意义，把SCL拉高后从机想发ACK也发不出来了，碰上个反应迟钝的从机你就等不到ACK了。

发表于 2025-1-16 19:21

qinlu123 发表于 2025-1-16 18:18
等待从机ACK逻辑错误，在IIC的世界里如果当前的SCL是高电平那么从机没有任何权限去改变SDA的电平状态，楼主 ...

这里的代码只针对于主机哦，这个是主机等待从机的 ACK 逻辑，从机等待主机的 ACK 可见如下代码。

复制

uint8_t I2C_Slave_Wait_Ack(void)

{

    uint16_t timeout = 1000; // 设置超时计数

    SDA_IN();                // 将 SDA 设置为输入模式以读取 ACK

    Delay_us(1);             // 稍微延时以稳定信号



    // 等待主机拉高 SCL

    while (!I2C_READ_SCL) {

        if (--timeout == 0) {

            return 1;        // 返回超时错误

        }

    }



    // 检查 SDA 状态以判断是否接收到 ACK

    if (I2C_READ_SDA) {

        return 1;            // 主机未发送 ACK

    }



    return 0;               // 返回成功，表明收到了 ACK

}

发表于 2025-1-16 19:37

qinlu123 发表于 2025-1-16 18:31
在红圈这里你一拉低SCL从机就已经给ACK了，所以你等待ACK函数里的延时等待毫无意义，把SCL拉高后从机想发A ...

感谢指正，确实存在这个问题，在主机发送数据后，从机立马响应的话，主机就会错过这个 ACK 。目前我并没有找到更好的方法去解决这个问题，我能想到的只能修改这个参数，去尽可能的减少一些不必要的延时。

发表于 2025-1-17 08:07

DKENNY 发表于 2025-1-16 19:37
感谢指正，确实存在这个问题，在主机发送数据后，从机立马响应的话，主机就会错过这个 ACK 。目前我并没 ...

从机灵敏的话主机不会错过ACK的，主机拉低SCL后从机就会拉低总线发出ACK，等到主机拉高SCL再拉低SCL后从机才会释放总线，你的程序会让反应迟钝的从机发不出ACK但这样的从机几乎没有，去看你发的时序图。

发表于 2025-1-17 08:19

uint8_t Receive_ACK(struct I2C_Device *IIcBus)
{
    uint32_t i;

    IIcBus->Set_SCL(0);//一定把时钟设为低电平再释放总线等待ACK
    IIcBus->Set_SDA(1);//释放总线
    while(IIcBus->Get_SDA()!=0)
    {
        i++;
        if(i>10)
        {
            return 0;
        }
        IIcBus->delayus(Delay_Time);
    }
    IIcBus->Set_SCL(1);
    IIcBus->delayus(Delay_Time);
    IIcBus->Set_SCL(0);
    return 1;
}

发表于 2025-1-17 09:11

qinlu123 发表于 2025-1-17 08:19
[md]```
uint8_t Receive_ACK(struct I2C_Device *IIcBus)
{

感谢大佬指点

发表于 2025-1-17 09:27

无论IIC还是SPI都类似玩的木头人不许动的游戏，时钟线低电平相当于抓人的人背过脸去所有信号都可以随意乱动，当时钟线为高电平时就相当于那个人转过脸来了，所有人必须保持当前动作不许乱动了。

发表于 2025-1-17 09:38

qinlu123 发表于 2025-1-17 09:27
无论IIC还是SPI都类似玩的木头人不许动的游戏，时钟线低电平相当于抓人的人背过脸去所有信号都可以随意乱动 ...

学到了学到了

发表于 2025-1-17 13:58

qinlu123 发表于 2025-1-17 09:27
无论IIC还是SPI都类似玩的木头人不许动的游戏，时钟线低电平相当于抓人的人背过脸去所有信号都可以随意乱动 ...

这个举例简单明了

发表于 2025-1-20 16:48

qinlu123 发表于 2025-1-17 09:27
无论IIC还是SPI都类似玩的木头人不许动的游戏，时钟线低电平相当于抓人的人背过脸去所有信号都可以随意乱动 ...

这个例子举的好

发表于 2025-1-22 09:48

梦境漫游者发表于 2025-1-16 16:03
看时序图写代码这个技能真的很重要

这个确实，很多就是看不懂，
有没有好的方法，看时序图

发表于 2025-1-23 13:47

再改进一下，把delay函数去掉，利用定时器中断去处理，这样效率更高

[开发工具] 手把手教你编写嵌入式驱动程序（根据时序图）

打赏榜单

评论

相关帖子

浏览过的版块

技术新星奖章

以坛为家

涓涓之细流

技术奇才奖章

缘定三生