STM32 使用IO口模拟I2C时序

最新推荐文章于 2024-07-19 23:39:50 发布

ForeverIT

最新推荐文章于 2024-07-19 23:39:50 发布

阅读量7.9k

点赞数 14

分类专栏：单片机文章标签： stm32 I2C IO EEPROM AT24C02

本文链接：https://blog.csdn.net/foreverit/article/details/105453989

版权

单片机专栏收录该内容

12 篇文章 13 订阅

订阅专栏

上一篇《I2C协议详解》

我们了解了I2C的操作流程，这一篇，我们就使用I2C，来对EEPROM进行操作吧。

我们做两种选择：

1.时序由IO口模拟高低电平，需要了解协议并按照协议操作相应的IO口。

2.时序由硬件自行产生，不需要人工干预；

由硬件产生的I2C时序，我们借助Stm32Cube配置实现便可，我们这一篇，抛开Stm32Cube，手撕代码，根据I2C的时序，一步步地实现I2C对EEPROM的读写吧。

我们分为几个步骤来对EEPROM进行操作：

1. 发动"看硬件原理图"技能，确定I2C连线；

2. 发动"乾坤大拷贝"技能，配置对应的IO口；

3. 发动"手撕代码"技能，写出相应时序；

1. 发动"看硬件原理图"技能，确定I2C连线；

第9页，找到EEPROM那一块，EEPROM用的是AT24C02，只有2K Bits，不是很大。AT24C02由ATMEL公司生产，其命名规则为 AT24Cxx，xx可以=02,04,32,64,128,256,512,1M 等等，xx也表示容量，单位是 Bits，注意，是位，不是字节，要换成字节要除以8，所以，AT24C02只有 256 个字节。别问我怎么知道的，AT24C02的规格书告诉我的，要记得看原理图，看规格书喔~~~

再找呀找呀找朋友，找到 SCL连到PB6，SDA连到PB9。咋找？搜索呗，搜引脚 I2C1_SCL就行了。

确定了I2C连线，SCL=PB6，SDA=PB9，接下来，我们就

2. 发动"乾坤大拷贝"技能，配置对应的IO口；

先新建两个文件，io_i2c.c/io_i2c.h，我们就在这里面写i2c时序。

并且把文件添加进工程项目里参与编译。

配置IO口，详见《STM32CubeMx 创建第一个工程》，把那段代码拷贝过来，改一下配置就行了。

void IOI2C_GpioInit(void)

{

    GPIO_InitTypeDef GPIO_InitStruct;


    __HAL_RCC_GPIOB_CLK_ENABLE();

    /*Configure GPIO pin Output Level */

    // PB6 = SCL/PB9 = SDA

    HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6|GPIO_PIN_9, GPIO_PIN_SET);


    /*Configure GPIO pin : PC7 */

    GPIO_InitStruct.Pin = GPIO_PIN_6|GPIO_PIN_9;

    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;            // 记不记得i2c要上拉？

    GPIO_InitStruct.Pull = GPIO_PULLUP;                                    // 

    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;

    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

}

记得在初始化时调用一下它喔：

MX_GPIO_Init();

  MX_DMA_Init();

  MX_UART4_Init();

  MX_TIM1_Init();

  MX_TIM2_Init();

  /* USER CODE BEGIN 2 */

    USR_UartInit();

      IOI2C_GpioInit();            // 我在这，快看这里~

  /* USER CODE END 2 */


  printf("Start System: Io I2C.\r\n");

3. 发动"手撕代码"技能，写出相应时序，I2C时序，请参照《I2C协议详解》。

看图，会有高电平持续一段时间，低电平持续一段时间的操作，这个持续一段时间，就是延时，关于延时，详细参照《STM32精准延时》。

这个持续多长时间怎么算呢？

根据I2C时钟频率，可以算出周期，再根据周期，算出持续多长时间。

For Example：

100kHz的频率，也就是1秒钟内，有100,000个时钟周期。

那1个时钟周期，也就是 1/100,000秒 = 1,000/100,000毫秒 = 1,000,000/100,000微秒，根据小学数学，算出，100kHz频率的时钟周期是 10微秒，一高一低一周期，那么，延时 = 5us。

在《STM32精准延时》篇中，我们做了个us级的精准延时，用上：

#define I2C_Delay                USER_Delay1us(5)

如果要其它延时呢？

delay = 1,000,000 / freq / 2 = 500,000 / freq

算出来delay与时钟频率的关系：

1us = 500kHz，2us = 250kHz，3us = 166.67kHz，4us = 125kHz，5us = 100kHz，

6us = 83.33kHz，7us = 71.4kHz，8us = 62.5kHz，9us = 55.56kHz，10us = 50kHz。

选一个，但要符合芯片的最高支持速率喔。图：400k

知道延时，也知道SCL对应的IO口pb6，那么，要在SCL上生成一个周期为 10us 的方波，怎么写程序呢？

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET);        // 高电平

USER_Delay1us(5);            // 持续5us

HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET);        // 低电平

USER_Delay1us(5);            // 持续5us

我们还可以把IO口拉高拉低写成宏定义：

#define    SwI2cSetScl()            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_SET)

#define    SwI2cClrScl()            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_6, GPIO_PIN_RESET)

#define    SwI2cCheckScl()            HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_6)


#define    SwI2cSetSda()            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_SET)

#define    SwI2cClrSda()            HAL_GPIO_WritePin(GPIOB, GPIO_PIN_9, GPIO_PIN_RESET)

#define    SwI2cCheckSda()            HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_9)

这样的好处是，如果后面，你不想用 pb6 和 pb9 作为 scl 和 sda，你想换两根io口，只需要改初始化和这些宏定义就行了。

现在，可以开始写时序了。

a、START： SCL为高电平，SDA从高电平跳变至低电平，表示开始发送数据：

    SwI2cSetSda();

    SwI2cSetScl();

    I2C_Delay;

    SwI2cClrSda();

    I2C_Delay;

    SwI2cClrScl();

    I2C_Delay;

b、TRANSMIT： START之后，就可以发送数据了，数据在SCL高电平有效，发送8-Bit数据（1BYTE），

i2c传输数据，是从高位最先传输的，比如，0xaa = 10101010b，先传 bit7=1，接下来再传bit6=0……最后传bit0=0：

   uint8_t bit_sel;

    bit_sel = 0x80;

    while (bit_sel) {

        if (bit_sel & data)

            SwI2cSetSda();

        else

            SwI2cClrSda();


        I2C_Delay;

        SwI2cSetScl();

        I2C_Delay;

        SwI2cClrScl();


        bit_sel >>= 1;

    }

data&0x80，data&0x40，data&0x20，data&0x10， data&0x08，data&0x04，data&0x02，data&0x01，

这一系列的操作，就把data从bit7取到bit0，按照要求，设置 sda 高低电平，记得，scl一个周期取一次sda值，高电平有效。

3、ACK：在第9个SCL周期，次设备将SDA拉低，主设备检测SDA为低电平，表示收到数据；如果在一个时钟周期内都没有ACK，说明从设备有问题，主设备必须发STOP，表示传输结束。

 // ack

    SwI2cSetSda();                // 释放sda线，等待从设备把sda接低

    SwI2cSetScl();

    I2C_Delay;

    ack = SwI2cCheckSda();            // 检测 sda 电平

    SwI2cClrScl();

    I2C_Delay;


    if(ack)        // 从设备在一个时钟周期内没有响应。

    {

        // 发送 stop 信号，传输结束

        debug_msg("io_i2c not ack. \r\n");            // 打印

        return I2CSW_BUSY;                                // 返回错误信息

    }

如果继续有数据要发，重复b、c步骤，如果没有，发STOP。

d、STOP：SCL为高电平，SDA从低电平跳变至高电平，表示发送数据结束；

    SwI2cClrSda();

    SwI2cSetScl();

    I2C_Delay;

    SwI2cSetSda();

    I2C_Delay;

好啦，I2C时序就这样了，我们接着就用 I2C时序，来对 AT24C02 进行操作。

首先，需要一个设备地址，因为I2C总线上允许挂多个设备，设备地址，用于识别哪个设备。

看原理图+AT24C02 datasheet

A2/A1/A0引脚接地，为000，最低位(LSB)为低电平是写，高电平为读。

所以，地址为 0xA0（写），0xA1（读）。

根据datasheet描述，AT24C02的操作一般有 字节写、页写、随机读、连续读。

字节写和页写：

字节写：就是写一个字节。

START -> 设备地址 -> 寄存器地址（写eeprom哪个存储单元） -> 数据 -> STOP

页写：就是写一页。

START -> 设备地址 -> 寄存器地址（起始） -> 一连串数据 -> STOP

页写中的一连串数据，到底是多大的串呢？最大8BYTE，别问我怎么知道，DATASHEET。

根据描述，页写，其实跟字节写很相似，只不过是，寄存器地址的低3位，会自动增加。

页写存储单元 0x10，8个字节数据，

0x10 = 0001 0000b，寄存器低3位自动增加就是：

0001 0000b = 数据1，0001 0001b = 数据2，……，0001 0111b = 数据8

页写存储单元 0x12，8个字节数据呢？

0x12 = 0001 0010b，寄存器低3位自动增加就是：

0001 0010b = 数据1，0001 0011b = 数据2，……，0001 0111b = 数据5

0001 0000b = 数据6，0001 0001b = 数据7

结合上面的文字描述，存储单元地址到0001 0111b后，回滚到0001 0000b了，这是需要注意的地方，所以，页写，要注意处理页的边界问题。

写的代码如下：

1、存储单元地址传入*pMemAddr和memAddrLen，因为AT24C32/64/128/256，它的存储单元地址是16位的，这样这个函数也用在其它EEPROM上，而不需要再写一个函数了。

2、这里暂未对页写的页边界进行处理，因为其它EEPROM的页不是8个字节，页的处理，留在EEPROM写的时候做。

3、如果需要写一个字节，这个函数的最后一个参数 len 写1就行了。

uint8_t IOI2C_WriteBlock(uint8_t devAddr, uint8_t *pMemAddr, uint8_t memAddrLen, const uint8_t *pData, uint16_t len)

{

    uint8_t ctl;

    uint8_t startLimit = I2C_TIME_OUT;


    //Validate input parameter

    if (pData == NULL)

        return FALSE;

    

    if (len == 0)

        return FALSE;


    // I2C Start, Wait while device is busy

    ctl = devAddr | I2C_WR;

    while (IOI2C_Start(ctl) != IOI2C_OK) {    

        startLimit--;

        if(!startLimit) {

            debug_msg("IOI2C_WriteBlock start error.\r\n");

            return IOI2C_BUSY;

        }

        

    }


    // send slave write sub-address

    while (memAddrLen--) {

        if (IOI2C_TransmitByte(*pMemAddr++) != IOI2C_OK) {

            debug_msg("IOI2C_WriteBlock write mem address error.\r\n");

            return IOI2C_BUSY;

        }

    }

    

    // write data from buffer into slave device

    while(len--)

    {

        if(IOI2C_TransmitByte(*pData++) != IOI2C_OK)        // Data address

        {

            debug_msg("IOI2C_WriteBlock write data(%d) error.\r\n", len);

            return IOI2C_BUSY;

        }    

    }

    

    IOI2C_Stop();                    // end stop operation

    return IOI2C_OK;

}

随机读和连续读：

随机读，就是随便读个字节，读哪就是哪。

START->设备地址->存储单元地址->START->设备地址->读->STOP

连续读，就是随便读n个字节，读哪块算哪块，就是在随便读的基础上不停地读，直到读够了再发STOP

START->设备地址->存储单元地址->START->设备地址->读->读->读->……->读->STOP

直接撕代码：

1、存储单元地址传入*pMemAddr和memAddrLen，因为AT24C32/64/128/256，它的存储单元地址是16位的，这样这个函数也用在其它EEPROM上，而不需要再写一个函数了。

2、既然叫随便读，那就不存在着页边界的问题了。

3、如果需要读一个字节，这个函数的最后一个参数 len 写1就行了。

4、每读完一个字节，第9个SCL，需要主设备向从设备发ACK，告诉从设备收到，下一个。

uint8_t IOI2C_ReadBlock(uint8_t devAddr, uint8_t *pMemAddr, uint8_t memAddrLen, uint8_t *pData, uint16_t len)

{

    uint8_t ctl;

    uint8_t startLimit = I2C_TIME_OUT;


    //Validate input parameter

    if (pData == NULL)

        return FALSE;

    

    if (len == 0)

        return FALSE;


    // I2C Start, Wait while device is busy

    ctl = devAddr | I2C_WR;

    while (IOI2C_Start(ctl) != IOI2C_OK) {    

        startLimit--;

        if(!startLimit) {

            debug_msg("IOI2C_ReadBlock start error.\r\n");

            return IOI2C_BUSY;

        }

        

    }


    // send slave read sub-address

    while (memAddrLen--) {

        if (IOI2C_TransmitByte(*pMemAddr++) != IOI2C_OK) {

            debug_msg("IOI2C_ReadBlock write mem address error.\r\n");

            return IOI2C_BUSY;

        }

    }


    // Repeat start for read operation

    ctl = devAddr | I2C_RD;

    if (IOI2C_Start(ctl) != IOI2C_OK)

    {

        debug_msg("IOI2C_ReadBlock Repeat Start Error.\r\n");

        return IOI2C_BUSY;

    }    


    //Read data from slave device into buffer

    while(--len)

    {    

        *pData++ = IOI2C_GetByte();        // Read data into buffer

         IOI2C_SendAck();                // send ack to slave

    }    


    *pData = IOI2C_GetByte();            // Read last data byte

    IOI2C_Stop();                    // end stop operation


    return IOI2C_OK;

}

其实写完这两个函数，基本上也差不多了，在应用中调用这两个函数，便可对EEPROM进行读写，不过为了程序可读性和可移植性，我们再来写个at24c02.c和at24c02.h，将 at24c32 的读写逻辑封装一下，在这个封装里面，我们会处理"页写"的回滚逻辑，为了保证可靠性，我们会多读或者多写几次。

套路：新建文件 -> 加入编译器，往上看，新建 io_i2c.c 里有步骤。

开始继续手撕代码，我们就实现以下5个函数：

uint8_t AT24C02_ReadByte(uint8_t memAddr)

{

    uint8_t data, count=0;

    uint8_t result = IOI2C_BUSY;


    do {

        result = I2C_READBUF(&memAddr, &data, 1);

        if(++count > 1)

            printf("AT24C04_ReadByte error,count = %d \r\n",count);

    } while ((count < CHECK_LIMIT) && (IOI2C_OK != result));


    return data;

}


uint8_t AT24C02_WriteByte(uint8_t memAddr, uint8_t data)

{

    uint8_t count=0;

    uint8_t result = IOI2C_BUSY;

    

    do {

        result = I2C_WRITEBUF(&memAddr, &data, 1);

        if(++count > 1)

            printf("AT24C04_WriteByte error,count = %d \r\n",count);        

    } while ((count < CHECK_LIMIT) && (IOI2C_OK != result));


    return result;

}


uint8_t AT24C02_ReadBuffer(uint8_t memAddr, uint8_t *buff, uint16_t len)

{

    uint8_t count=0;

    uint8_t result = IOI2C_BUSY;


    do {

        result = I2C_READBUF(&memAddr, buff, len);

        if(++count > 1)

            printf("AT24C04_ReadBuffer error,count = %d \r\n",count);        

    } while ((count < CHECK_LIMIT) && (IOI2C_OK != result));

    

    return result;

}


uint8_t AT24C02_WriteBuffer(uint8_t memAddr, uint8_t *buff, uint16_t len)

{

    uint8_t dataCnt, count=0;

    uint8_t result = IOI2C_BUSY;

    uint8_t pagesize;


    // Write buffer of data

    while (len) {

        // Number of bytes available in current page.

        pagesize = PAGE_SIZE - (memAddr % PAGE_SIZE);

        // Is current page has enough byte for the buffer.

        if (len > pagesize)

        {

            // Open new page?

            if (pagesize == PAGE_SIZE)        // No

            {

                // CASE3: The rest of the buffer is more than a page size.

                dataCnt = PAGE_SIZE;            // Yes

            }

            else

            {

                // CASE2: Current page has not enough byte for the buffer,

                //        write some data in this page and the rest in other

                //          page(s).

                dataCnt = pagesize;                // No

            }

        }

        else

        {

            // CASE1: Current page has enough byte for the buffer.

            // CASE4: Finished up the rest of the buffer.

            dataCnt = len;                        // Yes

        }


        // Write to EEPROM and make sure success

        count = 0;

        do {

            result = I2C_WRITEBUF(&memAddr, buff, dataCnt);

            if(++count > 1)

                printf("AT24C04_WriteBuffer error,count = %d \r\n",count);        

        } while ((count < CHECK_LIMIT) && (IOI2C_OK != result));

        

        buff += dataCnt;                         // Adjust pointer to B_Count

        memAddr += dataCnt;                        // Adjust register address

        len -= dataCnt;                        // Adjust buffer count


        delay_ms(10);

    }


    return result;

}


void AT24C02_Debug(uint8_t func, uint16_t pa1, uint16_t pa2, uint16_t pa3)

{

    uint16_t cnt;

    uint8_t temp[256];


    printf("AT24C02_Debug: func(%d), pa1(%d), pa2(%d), pa3(%d).\r\n",

        func, pa1, pa2, pa3);

    

    switch (func) {

        case 0: {

            printf("func0: read at24c02 byte: addr(0x%x) data(0x%x).\r\n",

                pa1, AT24C02_ReadByte((uint8_t)pa1) );

        }

            break;


        case 1: {

            memset(temp, 0, 256);

            AT24C02_ReadBuffer((uint8_t)pa1, temp, pa2);

            printf("func1: read buffer: addr(0x%x) len(%d).", pa1, pa2);

            for (cnt = 0; cnt < (uint8_t)pa2; cnt++) {

                if (cnt % 16 == 0)

                    printf("\r\n");

                printf("0x%x, ", temp[cnt]);

            }

            printf("\r\n");

        }

            break;



        case 2: {

            printf("func2: at24c02 write: addr(0x%x) data(0x%x).\r\n", pa1, pa2);

            AT24C02_WriteByte((uint8_t)pa1, (uint8_t)pa2);

        }

            break;


        case 3: {

            for (cnt = 0; cnt < 256; cnt++)

                temp[cnt] = cnt;

            printf("func3: write buffer: addr(0x%x) len(%d).\r\n", pa1, pa2);

            AT24C02_WriteBuffer((uint8_t)pa1, temp, pa2);

        }

            break;


        default:

            printf("func0: read at24c04 byte.\r\n");

            printf("func1: read at24c04 buffer.\r\n");

            printf("func2: write at24c04 byte.\r\n");

            printf("func3: write at24c04 buffer.\r\n");

            break;

            

    }

}

好了，在Debug函数里，调用

static void DebugCmdProceed(void)

{

    switch(debArray[0])

    {

        case DEBCMD_TEST:

            printf("DEBCMD_TEST: Parm1: %d / parm2: %d \r\n", debArray[1], debArray[2]);

            break;


        case DEBCMD_EEPROM:

            AT24C02_Debug((uint8_t)debArray[1], debArray[2], debArray[3], debArray[4]);

            break;

    }

}

编译、烧录、运行、连上串口调试助手、执行：

1.、写字节

@cmd 0x1 2 0 0xac

@cmd 0x1 2 1 0xac

@cmd 0x1 2 2 0xac

2、读字节

@cmd 0x1 0 0

@cmd 0x1 0 1

@cmd 0x1 0 2

看，读回的就是写进去的吧？

3.、写一串，就往0x13存储单元写14个字节吧。

@cmd 0x1 3 0x13 14

4、读一串，就从0x12读16个字节吧。

@cmd 0x1 1 0x12 16

看0x13起，14个字节，就是写入的。

整个工程及代码呢，请上百度网盘上下载：

链接：https://pan.baidu.com/s/19usUcgZPX8cCRTKt_NPcfg

密码：07on

文件夹：\Stm32CubeMx\Code\IoI2c.rar

本章自己手撕的代码主要是 io_i2c.c/io_i2c.h 和 at24c02.c/at24c02.h

问题：

上面讲到使用延时，编写I2C的时序，根据计算得出，延时和时钟频率的关系是：

1us = 500kHz，2us = 250kHz，3us = 166.67kHz，4us = 125kHz，5us = 100kHz，

6us = 83.33kHz，7us = 71.4kHz，8us = 62.5kHz，9us = 55.56kHz，10us = 50kHz。

那么，如果，我想要用 400kHz 呢？300kHz呢？懵了吧？

下一篇，我带你进入，硬件I2C的世界，不管你用 400k，300k都没有问题。

上一篇：《I2C协议详解》

下一篇：《STM32 使用硬件I2C接口读写EEPROM》

ForeverIT

关注

14
点赞
踩
56

收藏

觉得还不错? 一键收藏
1
评论
STM32 使用IO口模拟I2C时序

上一篇《I2C协议详解》我们了解了I2C的操作流程，这一篇，我们就使用I2C，来对EEPROM进行操作吧。我们做两种选择：1.时序由IO口模拟高低电平，需要了解协议并按照协议操作相应的IO口。2.时序由硬件自行产生，不需要人工干预；由硬件产生的I2C时序，我们借助Stm32Cube配置实现便可，我们这一篇，抛开Stm32Cube，手撕代码，根据I2C的时序，一步步地实现I2C对...
复制链接

扫一扫

专栏目录