开启辅助访问

RISC-V单片机中文网——全球首家只专注于RISC-V单片机行业应用的中文网站官方Q群

RISC-V单片机技术交流群

群号: 728522642

简介: 有人预言，RISC－V或将是继Intel和ARM之后第三大主流处理器体系。8位单片机时代传奇“前辈”是8051，32位单片机时代RISC－V将成为下一个8051！欢迎大家一起来学习 RISC－V单片机。

RISC-V单片机中文网——全球首家只专注于RISC-V单片机行业应用的中文网站»首页 › 国内RISC-V单片机 › CH32V CH573单片机芯片 › 第三十七章：CH32V103应用教程——I2C-软件模拟I2C读写E ...
返回列表 发新帖回复
查看: 1840|回复: 1
收起左侧

第三十七章：CH32V103应用教程——I2C-软件模拟I2C读写EEPROM

[复制链接]
草帽王子

  离线 

  • TA的每日心情
    慵懒
    2021-7-23 17:16

    • 签到天数: 17 天

    [LV.4]
    发表于 2021-4-27 21:13:46 | 显示全部楼层 |阅读模式
    ▶ 语音朗读

    有人预言,RISC-V或将是继Intel和Arm之后的第三大主流处理器体系。欢迎访问全球首家只专注于RISC-V单片机行业应用的中文网站

    您需要 登录 才可以下载或查看，没有帐号？立即注册

    x
    本帖最后由 草帽王子 于 2021-9-10 17:24 编辑

    前面章节第14章已经进行过硬件IIC读写EEPROM的实验，本章教程将使用软件模拟IIC读写EEPROM，并通过串口调试助手将读写结果打印显示。


    1、I2C简介及相关函数介绍

    内部集成电路总线（I2C）是一种两线式串行总线，可用于微控制器及其外围设备之间的通信。I2C总线由数据线SDA和时钟线SCL构成，可进行数据发送和接收，其通过上拉电阻接电源，当I2C总线空闲时，会输出高组态，此时数据线SDA和时钟线SCL均处于高电平。

    I2C总线在使用过程中具有以下状态和信号：
    • 空闲状态：数据线SDA和时钟线SCL均处于高电平；
    • 起始信号：时钟线SCL为高电平，数据线SDA由高电平向低电平跳变；
    • 停止信号：时钟线SCL为高电平，数据线SDA由低电平向高电平跳变；
    • 应答信号：应答信号分为ACK信号和NACK信号两种。主机在数据传输时会产生时钟，在产生第九个时钟时（即主机每发送完8位数据或地址），数据发送端会释放SDA的控制权，由数据接收端控制SDA，此时若SDA为高电平，则表示NACK应答信号，若SCL为低电平，则表示ACK应答信号。当为ACK信号时，发送方会继续发送下一个数据；为NACK信号时，则发送方会产生一个停止信号，结束数据传输。

    关于硬件I2C和软件模拟I2C的区别，第14章已经进行过介绍，在此不再赘述。

    关于I2C具体信息，可参考CH32V103应用手册。I2C标准库函数在第十四章节已介绍，在此不再赘述。


    2、硬件设计

    本章教程使用软件模拟I2C读写24C02，程序中配置PA1作为SDA线，PA2作为SCL线，连接方式如下：
    • PA1连接J5的SCL引脚
    • PA2连接J5的SDA引脚


    3、软件设计

    软件模拟I2C读写24C02相较于硬件I2C读写24C02在程序代码量上多了很多，具体程序如下：
    iic.h文件
    1. #ifndef __IIC_H
    2. #define __IIC_H

    4. #include "ch32v10x_conf.h"

    6. #define  IIC_SDA_H  GPIO_SetBits(GPIOA,GPIO_Pin_1)    //配置SDA接口高电平
    7. #define  IIC_SDA_L  GPIO_ResetBits(GPIOA,GPIO_Pin_1)  //配置SDA接口低电平

    9. #define  IIC_SCL_H  GPIO_SetBits(GPIOA,GPIO_Pin_2)    //配置SCL接口高电平
    10. #define  IIC_SCL_L  GPIO_ResetBits(GPIOA,GPIO_Pin_2)  //配置SCL接口低电平

    12. #define  I2C_SDA_READ()  GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1)  //读SDA口线状态

    14. void IIC_Init(void);         //IIC初始化函数
    15. void IIC_Idle_State(void);   //IIC空闲状态
    16. void IIC_Start(void);        //IIC开始信号函数
    17. void IIC_Stop(void);         //IIC停止信号函数
    18. void IIC_SendByte(u8 data);  //IIC发送一个字节
    19. u8   IIC_ReadByte(void);     //IIC读取一个字节
    20. u8   IIC_WaitAck(void);      //等待响应信号（ACK或者NACK）
    21. void IIC_ACK(void);          //IIC发出ACK信号
    22. void IIC_NACK(void);         //IIC发出NACK信号

    24. #endif
    复制代码
    iic.h文件主要进行相关宏定义和函数声明；
    iic.c文件
    1. #include "iic.h"

    3. //初始化IIC
    4. void IIC_Init(void)
    5. {
    6.     GPIO_InitTypeDef GPIO_InitStructure;

    8.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );

    10.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;//使用PA1和PA2作为模拟IIC引脚，PA1对应SDA，PA2对应SCL
    11.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD ;   //开漏输出模式
    12.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    13.     GPIO_Init(GPIOA, &GPIO_InitStructure);

    15.     IIC_Idle_State();
    16. }

    18. //IIC空闲状态
    19. //当IIC总线的SDA和SCL两条信号线同时处于高电平时，规定为IIC总线的空闲状态
    20. void IIC_Idle_State()
    21. {
    22.     IIC_SDA_H;
    23.     IIC_SCL_H;

    25.     Delay_Us(4);
    26. }

    28. //IIC开始信号
    29. //当IIC SCL线处于高电平时，SDA线由高电平向低电平跳变，为IIC开始信号，配置开始信号前必须保证IIC总线处于空闲状态
    30. void IIC_Start()
    31. {
    32.     IIC_SDA_H;
    33.     IIC_SCL_H;

    35.     Delay_Us(4);

    37.     IIC_SDA_L;
    38.     Delay_Us(4);
    39.     IIC_SCL_L;
    40.     Delay_Us(4);
    41. }

    43. //IIC停止信号
    44. //当IIC SCL线处于高电平时，SDA线由低电平向高电平跳变，为IIC停止信号
    45. void IIC_Stop()
    46. {
    47.     IIC_SDA_L;
    48.     IIC_SCL_H;

    50.     Delay_Us(4);

    52.     IIC_SDA_H;
    53. }

    55. //IIC发送一个字节数据（即8bit）
    56. void IIC_SendByte(u8 data)
    57. {
    58.     u8 i;
    59.     //先发送字节的高位bit7
    60.     for (i = 0; i < 8; i++)
    61.     {
    62.         if (data & 0x80)  //判断8位数据每一位的值（0或1）
    63.         {
    64.             IIC_SDA_H;
    65.         }
    66.         else
    67.         {
    68.             IIC_SDA_L;
    69.         }

    71.         Delay_Us(4);      //控制SCL线产生高低电平跳变，产生通讯时钟，同时利用延时函数在SCL为高电平期间读取SDA线电平逻辑
    72.         IIC_SCL_H;
    73.         Delay_Us(4);
    74.         IIC_SCL_L;

    76.         if (i == 7)
    77.         {
    78.             IIC_SDA_H;    //控制SDA线输出高电平，释放总线，等待接收方应答信号
    79.         }

    81.         data <<= 1;       //左移一个bit
    82.         Delay_Us(4);
    83.     }
    84. }

    86. //IIC读取一个字节
    87. u8 IIC_ReadByte(void)
    88. {
    89.     u8 i;
    90.     u8 value;

    92.     //读到第1个bit为数据的bit7
    93.     value = 0;
    94.     for(i = 0; i < 8; i++)
    95.     {
    96.         value <<= 1;
    97.         IIC_SCL_H;
    98.         Delay_Us(4);
    99.         if (I2C_SDA_READ()) //利用延时函数在SCL为高电平期间读取SDA线电平逻辑
    100.         {
    101.             value++;
    102.         }
    103.         IIC_SCL_L;
    104.         Delay_Us(4);
    105.     }
    106.     return value;
    107. }


    110. //IIC等待应答信号
    111. u8 IIC_WaitAck(void)
    112. {
    113.     uint8_t rvalue;

    115.     IIC_SDA_H;     //发送端释放SDA总线，由接收端控制SDA线
    116.     Delay_Us(4);
    117.     IIC_SCL_H;     //在SCL为高电平期间等待响应，若SDA线为高电平，表示NACK信号，反之则为ACK信号
    118.     Delay_Us(4);
    119.     if(I2C_SDA_READ())  //读取SDA线状态判断响应类型，高电平，返回去，为NACK信号，反之则为ACK信号
    120.     {
    121.         rvalue = 1;
    122.     }
    123.     else
    124.     {
    125.         rvalue = 0;
    126.     }
    127.     IIC_SCL_L;
    128.     Delay_Us(4);
    129.     return rvalue;
    130. }

    132. //产生应答信号ACK
    133. void IIC_ACK(void)
    134. {
    135.     IIC_SDA_L;
    136.     Delay_Us(4);
    137.     IIC_SCL_H;   //在SCL线为高电平期间读取SDA线为低电平，则为ACK响应
    138.     Delay_Us(4);
    139.     IIC_SCL_L;
    140.     Delay_Us(4);
    141.     IIC_SDA_H;
    142. }

    144. //产生非应答信号NACK
    145. void IIC_NACK(void)
    146. {
    147.     IIC_SDA_H;
    148.     Delay_Us(4);
    149.     IIC_SCL_H;   //在SCL线为高电平期间读取SDA线为高电平，则为NACK响应
    150.     Delay_Us(4);
    151.     IIC_SCL_L;
    152.     Delay_Us(4);
    153. }

    复制代码
    iic.c文件主要进行模拟I2C对应GPIO引脚初始化以及I2C在数据读写传输过程中各状态和信号的表示函数，具体如下：

    1、因为采用模拟I2C，且设置PA1对应SDA线，PA2对应SCL线，因此需要对PA1和PA2进行GPIO初始化设置，具体如下：
    1. //初始化IIC
    2. void IIC_Init(void)
    3. {
    4.     GPIO_InitTypeDef GPIO_InitStructure;

    6.     RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );

    8.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1|GPIO_Pin_2;//使用PA1和PA2作为模拟IIC引脚，PA1对应SDA，PA2对应SCL
    9.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD ;   //开漏输出模式
    10.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    11.     GPIO_Init(GPIOA, &GPIO_InitStructure);

    13.     IIC_Idle_State();
    14. }
    复制代码
    此处注意设置PA1和PA2的GPIO模式为开漏输出模式，因为I2C总线一般可以连接多个器件，如果选用推挽输出模式，可能会产生很大的电流从而导致器件毁坏，而开漏输出在不接上拉电阻情况下无法输出高电平，加上拉电阻时电流由上拉电阻决定，因此使用开漏输出模式。还有一个原因就是开漏输出可以匹配电平，满足电流型的驱动。

    2、I2C空闲状态函数，当IIC总线的SDA和SCL两条信号线同时处于高电平时，规定为IIC总线的空闲状态，函数具体如下：
    1. //IIC空闲状态
    2. //当IIC总线的SDA和SCL两条信号线同时处于高电平时，规定为IIC总线的空闲状态
    3. void IIC_Idle_State()
    4. {
    5.     IIC_SDA_H;
    6.     IIC_SCL_H;

    8.     Delay_Us(4);
    9. }
    复制代码

    3、I2C开始信号函数，当IIC SCL线处于高电平时，SDA线由高电平向低电平跳变，为IIC开始信号，配置开始信号前必须保证IIC总线处于空闲状态，函数具体如下：
    1. //IIC开始信号
    2. //当IIC SCL线处于高电平时，SDA线由高电平向低电平跳变，为IIC开始信号，配置开始信号前必须保证IIC总线处于空闲状态
    3. void IIC_Start()
    4. {
    5.     IIC_SDA_H;
    6.     IIC_SCL_H;

    8.     Delay_Us(4);

    10.     IIC_SDA_L;
    11.     Delay_Us(4);
    12.     IIC_SCL_L;
    13.     Delay_Us(4);
    14. }
    复制代码

    4、I2C停止信号函数，当IIC SCL线处于高电平时，SDA线由低电平向高电平跳变，为IIC停止信号，函数具体如下：
    1. //IIC停止信号
    2. //当IIC SCL线处于高电平时，SDA线由低电平向高电平跳变，为IIC停止信号
    3. void IIC_Stop()
    4. {
    5.     IIC_SDA_L;
    6.     IIC_SCL_H;

    8.     Delay_Us(4);

    10.     IIC_SDA_H;
    11. }
    复制代码

    5、I2C发送一个字节数据，一个字节数据即8位，对每一位值进行判断其为0还是1（从最高位起），并根据判断值控制SDA线高低电平变化，每判断完成一位，则左移一位。在此期间，要控制SCL线高低电平变化，具有通讯时钟的效果。同时利用延时函数在SCL线为高电平期间读取SDA线值大小。待8位数据传输完成之后，释放总线，等待接收方应答信号。具体函数如下：
    1. //IIC发送一个字节数据（即8bit）
    2. void IIC_SendByte(u8 data)
    3. {
    4.     u8 i;
    5.     //先发送字节的高位bit7
    6.     for (i = 0; i < 8; i++)
    7.     {
    8.         if (data & 0x80)  //判断8位数据每一位的值（0或1）
    9.         {
    10.             IIC_SDA_H;
    11.         }
    12.         else
    13.         {
    14.             IIC_SDA_L;
    15.         }

    17.         Delay_Us(4);      //控制SCL线产生高低电平跳变，产生通讯时钟，同时利用延时函数在SCL为高电平期间读取SDA线电平逻辑
    18.         IIC_SCL_H;
    19.         Delay_Us(4);
    20.         IIC_SCL_L;

    22.         if (i == 7)
    23.         {
    24.             IIC_SDA_H;    //控制SDA线输出高电平，释放总线，等待接收方应答信号
    25.         }

    27.         data <<= 1;       //左移一个bit
    28.         Delay_Us(4);
    29.     }
    30. }
    复制代码

    6、I2C读取一个字节数据，一个字节数据即8位，利用for循环在SCL为高电平期间对SDA数据线进行读取，依次判断每一位值为0还是1（共八位），最后将读取结果返回。具体函数如下：
    1. //IIC读取一个字节
    2. u8 IIC_ReadByte(void)
    3. {
    4.     u8 i;
    5.     u8 value;

    7.     //读到第1个bit为数据的bit7
    8.     value = 0;
    9.     for(i = 0; i < 8; i++)
    10.     {
    11.         value <<= 1;
    12.         IIC_SCL_H;
    13.         Delay_Us(4);
    14.         if (I2C_SDA_READ()) //利用延时函数在SCL为高电平期间读取SDA线电平逻辑
    15.         {
    16.             value++;
    17.         }
    18.         IIC_SCL_L;
    19.         Delay_Us(4);
    20.     }
    21.     return value;
    22. }
    复制代码

    7、I2C等待应答信号函数，当发送端发送完一个字节数据后，会释放对SDA线的控制权，及SDA线拉高，为1，此时由接收方控制SDA线，并控制其产生高低电平。在SCL线为高电平期间，发送端读取SDA线高低电平信号，若为低电平，表示ACK信号，若为高电平，表示NACK信号。具体函数如下：
    1. //IIC等待应答信号
    2. u8 IIC_WaitAck(void)
    3. {
    4.     uint8_t rvalue;

    6.     IIC_SDA_H;     //发送端释放SDA总线，由接收端控制SDA线
    7.     Delay_Us(4);
    8.     IIC_SCL_H;     //在SCL为高电平期间等待响应，若SDA线为高电平，表示NACK信号，反之则为ACK信号
    9.     Delay_Us(4);
    10.     if(I2C_SDA_READ())  //读取SDA线状态判断响应类型，高电平，返回去，为NACK信号，反之则为ACK信号
    11.     {
    12.         rvalue = 1;
    13.     }
    14.     else
    15.     {
    16.         rvalue = 0;
    17.     }
    18.     IIC_SCL_L;
    19.     Delay_Us(4);
    20.     return rvalue;
    21. }
    复制代码

    8、I2C应答信号函数和非应答信号函数。I2C 的数据和地址传输都带响应。响应包括“应答(ACK)”和“非应答(NACK)”两种 信号。作为数据接收端时，当设备(无论主从机)接收到 I2C 传输的一个字节数据或地址后， 若希望对方继续发送数据，则需要向对方发送“应答(ACK)”信号，发送方会继续发送下 一个数据；若接收端希望结束数据传输，则向对方发送“非应答(NACK)”信号，发送方接 收到该信号后会产生一个停止信号，结束信号传输。在SCL线为高电平期间读取SDA线为低电平，则为ACK响应；在SCL线为高电平期间读取SDA线为高电平，则为NACK响应。关于应答信号和非应答信号函数具体如下：
    1. //产生应答信号ACK
    2. void IIC_ACK(void)
    3. {
    4.     IIC_SDA_L;
    5.     Delay_Us(4);
    6.     IIC_SCL_H;   //在SCL线为高电平期间读取SDA线为低电平，则为ACK响应
    7.     Delay_Us(4);
    8.     IIC_SCL_L;
    9.     Delay_Us(4);
    10.     IIC_SDA_H;
    11. }

    13. //产生非应答信号NACK
    14. void IIC_NACK(void)
    15. {
    16.     IIC_SDA_H;
    17.     Delay_Us(4);
    18.     IIC_SCL_H;   //在SCL线为高电平期间读取SDA线为高电平，则为NACK响应
    19.     Delay_Us(4);
    20.     IIC_SCL_L;
    21.     Delay_Us(4);
    22. }
    复制代码
    以上就是iic.c文件的各个函数，其表示I2C协议的各个环节。
    eeprom.h文件
    1. #ifndef __EEPROM_H
    2. #define __EEPROM_H

    4. #include "ch32v10x_conf.h"

    6. #define AT24C01     127
    7. #define AT24C02     255
    8. #define AT24C04     511
    9. #define AT24C08     1023
    10. #define AT24C16     2047
    11. #define AT24C32     4095
    12. #define AT24C64     8191
    13. #define AT24C128    16383
    14. #define AT24C256    32767

    16. //CH32V103开发板使用的是24C02，所以定义TYPE为AT24C02
    17. #define TYPE AT24C02
    18. #define SIZE 256

    20. u8   AT24CXX_ReadOneByte(u16 raddr);
    21. void AT24CXX_WriteOneByte(u16 waddr,u8 data);
    22. void AT24CXX_WriteLenByte(u16 waddr,u32 data,u8 len);
    23. u32  AT24CXX_ReadLenByte(u16 raddr,u8 len);
    24. u8   AT24CXX_Check(void);
    25. void AT24CXX_Read(u16 raddr,u8 *pBuffer,u16 num);
    26. void AT24CXX_Write(u16 waddr,u8 *pBuffer,u16 num);
    27. u8   AT24CXX_Test(void);

    29. #endif
    复制代码
    eeprom.h文件包含各种宏定义和函数声明；
    eeprom.c文件
    1. #include "eeprom.h"
    2. #include "iic.h"

    4. //在AT24CXX指定地址读出一个数据
    5. //raddr :开始读数的地址
    6. //返回值  :读到的数据
    7. u8 AT24CXX_ReadOneByte(u16 raddr)
    8. {
    9.     u8 temp=0;
    10.     IIC_Start();
    11.     if(TYPE>AT24C16) //对芯片容量进行判断，芯片容量决定了设备地址和数据地址的分配方法
    12.     {
    13.         //当芯片容量大于16Kbit，设备地址则只起到一个标志读写操作的作用，由两位数据地址表示读写字节的地址
    14.         //因此此处首先发送0XA0，然后发送要写入地址的高八位，此处是将16位地址数据右移8位实现此操作
    15.         IIC_SendByte(0XA0);    //发送写命令
    16.         IIC_WaitAck();
    17.         IIC_SendByte(raddr>>8);//发送高地址
    18.         IIC_WaitAck();
    19.     }
    20.     else
    21.     {
    22.         //当芯片容量小于16K时，设备地址中可能用于页寻址的位
    23.         IIC_SendByte(0XA0+((raddr/256)<<1));   //发送器件地址0XA0,写数据
    24.     }
    25.     IIC_WaitAck();
    26.     IIC_SendByte(raddr%256);   //发送低地址
    27.     IIC_WaitAck();
    28.     IIC_Start();
    29.     IIC_SendByte(0XA1);        //进入接收模式
    30.     IIC_WaitAck();
    31.     temp=IIC_ReadByte();
    32.     IIC_Stop();                //产生一个停止信号
    33.     return temp;
    34. }

    36. //在AT24CXX指定地址写入一个数据
    37. //waddr :写入数据的目的地址
    38. //data  :要写入的数据
    39. void AT24CXX_WriteOneByte(u16 waddr,u8 data)
    40. {
    41.     IIC_Start();
    42.     if(TYPE>AT24C16)
    43.     {
    44.         IIC_SendByte(0XA0);    //发送写命令
    45.         IIC_WaitAck();
    46.         IIC_SendByte(waddr>>8);//发送高地址
    47.     }else
    48.     {
    49.         IIC_SendByte(0XA0+((waddr/256)<<1));   //发送器件地址0XA0,写数据
    50.     }
    51.     IIC_WaitAck();
    52.     IIC_SendByte(waddr%256);  //发送低地址
    53.     IIC_WaitAck();
    54.     IIC_SendByte(data);       //发送字节
    55.     IIC_WaitAck();
    56.     IIC_Stop();               //产生一个停止信号
    57.     Delay_Ms(10);
    58. }

    60. //在AT24CXX里面的指定地址开始读出长度为Len的数据，该函数用于读出16bit或者32bit的数据.
    61. //raddr :开始读出的地址
    62. //len   :要读出数据的长度2,4
    63. //返回值  :数据
    64. u32 AT24CXX_ReadLenByte(u16 raddr,u8 len)
    65. {
    66.     u8 t;
    67.     u32 temp=0;
    68.     for(t=0;t<len;t++)
    69.     {
    70.         temp<<=8;
    71.         temp+=AT24CXX_ReadOneByte(raddr+len-t-1);
    72.     }
    73.     return temp;
    74. }

    76. //在AT24CXX里面的指定地址开始写入长度为len的数据，该函数用于写入16bit或者32bit的数据.
    77. //waddr :开始写入的地址
    78. //data  :数据数组首地址
    79. //len   :要写入数据的长度2,4
    80. void AT24CXX_WriteLenByte(u16 waddr,u32 data,u8 len)
    81. {
    82.     u8 t;
    83.     for(t=0;t<len;t++)
    84.     {
    85.         AT24CXX_WriteOneByte(waddr+t,(data>>(8*t))&0xff);
    86.     }
    87. }

    89. //检查AT24CXX是否正常，这里用了24XX的最后一个地址(255)来存储标志字.如果用其他24C系列,这个地址要修改
    90. //返回1:检测失败
    91. //返回0:检测成功
    92. u8 AT24CXX_Check(void)
    93. {
    94.     u8 temp;
    95.     temp=AT24CXX_ReadOneByte(255);//避免每次开机都写AT24CXX
    96.     if(temp==0X55)return 0;
    97.     else //排除第一次初始化的情况
    98.     {
    99.         AT24CXX_WriteOneByte(255,0X55);
    100.         temp=AT24CXX_ReadOneByte(255);
    101.         if(temp==0X55)return 0;
    102.     }
    103.     return 1;
    104. }

    106. //在AT24CXX里面的指定地址开始读出指定个数的数据
    107. //raddr   :开始读出的地址 对24c02为0~255
    108. //pBuffer :数据数组首地址
    109. //num     :要读出数据的个数
    110. void AT24CXX_Read(u16 raddr,u8 *pBuffer,u16 num)
    111. {
    112.     while(num)
    113.     {
    114.         *pBuffer++=AT24CXX_ReadOneByte(raddr++);
    115.         num--;
    116.     }
    117. }

    119. //在AT24CXX里面的指定地址开始写入指定个数的数据
    120. //waddr   :开始写入的地址 对24c02为0~255
    121. //pBuffer :数据数组首地址
    122. //num     :要写入数据的个数
    123. void AT24CXX_Write(u16 waddr,u8 *pBuffer,u16 num)
    124. {
    125.     while(num--)
    126.     {
    127.         AT24CXX_WriteOneByte(waddr,*pBuffer);
    128.         waddr++;
    129.         pBuffer++;
    130.     }
    131. }


    134. //AT24C02 读写测试
    135. //正常返回1，异常返回0

    137. u8 AT24CXX_Test(void)
    138. {
    139.     u16 i;
    140.     u8 readbuf[SIZE];
    141.     u8 writebuf[SIZE];


    144.     /* 填充测试缓冲区 */
    145.     for (i = 0; i < SIZE; i++)
    146.     {
    147.         writebuf[i] = i;
    148.     }

    150.     AT24CXX_Write(0,(u8*)writebuf,SIZE);

    152.     AT24CXX_Read(0,(u8*)readbuf,SIZE);

    154.     for (i = 0; i < SIZE; i++)
    155.       {
    156.           if(readbuf[i] != writebuf[i])
    157.           {
    158.               printf("0x%4d ", readbuf[i]);
    159.               printf("错误:AT24C02读出与写入的数据不一致");
    160.           }

    162.           printf("%4d", readbuf[i]);

    164.           if ((i&15) == 15)
    165.           {
    166.               printf("\r\n");
    167.           }
    168.       }
    169.     printf("AT24C02读写测试成功\r\n");
    170.     return 1;

    172. }
    复制代码
    eeprom.c主要包含从EEPROM读取数据函数、向EEPROM写入数据函数以及EEPROM检测和测试函数，具体介绍如下：
    CH32V103开发板所用EEPROM芯片型号为AT24C02，其设备地址一共有7位，如下图，其中高4位固定为：1010b，低3位则由A0/A1/A2信号线的电平决定。根据CH32V103开发板原理图连接方式，A0、A1、A2均接GND，为0，所以设备地址为：1010000b。但由于I2C通讯通常将地址跟读写方向连在一起构成一个8位数，且当R/W位为0 时，表示写方向，加上7位地址，其值为“0xA0”，常称该值为I2C设备的“写地址”；当 R/W 位为 1 时，表示读方向，加上7位地址，其值为“0xA1”，常称该值为“读地址”。
    CH32V CH573单片机芯片-第三十七章：CH32V103应用教程——I2C-软件模拟I2C读写EEPROMrisc-v单片机中文社区(1)

    1、关于根据AT24C02指定地址读取一个数据流程，首先对芯片容量进行判断，芯片容量决定了设备地址和数据地址的分配方法。当芯片容量大于16Kbit，设备地址则只起到一个标志读写操作的作用，由两位数据地址表示读写字节的地址，因此此处首先发送0XA0，然后发送要写入地址的高八位，此处是将16位地址数据右移8位实现此操作；当芯片的容量小于16k的时候，设备地址中可能用于页寻址的位：当芯片型号为AT24C02，则设备地址中无页寻址的位，则raddr的高八位均为0，则((raddr/256)<<1)也为0，因此最后就是发送0XA0。

    当芯片型号为AT24C04，则设备地址中有一位页寻址的位，假如是1，则(raddr/256)为0X01，再左移一位为0x02，则最终发送的位0XA2。正好对应P0位为1,下面型号以此类推。关于从AT24Cxx中读取数据，却最先发送0XA0（写地址），解释如下：随机读需要设定需要读的地址,然后有一次伪写入过程,这个伪写入是为了修改存储器内部的工作指针。具体程序如下：
    1. //在AT24CXX指定地址读出一个数据
    2. //raddr :开始读数的地址
    3. //返回值  :读到的数据
    4. u8 AT24CXX_ReadOneByte(u16 raddr)
    5. {
    6.     u8 temp=0;
    7.     IIC_Start();
    8.     if(TYPE>AT24C16) //对芯片容量进行判断，芯片容量决定了设备地址和数据地址的分配方法
    9.     {
    10.         //当芯片容量大于16Kbit，设备地址则只起到一个标志读写操作的作用，由两位数据地址表示读写字节的地址
    11.         //因此此处首先发送0XA0，然后发送要写入地址的高八位，此处是将16位地址数据右移8位实现此操作
    12.         IIC_SendByte(0XA0);    //发送写命令
    13.         IIC_WaitAck();
    14.         IIC_SendByte(raddr>>8);//发送高地址
    15.         IIC_WaitAck();
    16.     }
    17.     else
    18.     {
    19.         //当芯片容量小于16K时，设备地址中可能用于页寻址的位
    20.         IIC_SendByte(0XA0+((raddr/256)<<1));   //发送器件地址0XA0,写数据
    21.     }
    22.     IIC_WaitAck();
    23.     IIC_SendByte(raddr%256);   //发送低地址
    24.     IIC_WaitAck();
    25.     IIC_Start();
    26.     IIC_SendByte(0XA1);        //进入接收模式
    27.     IIC_WaitAck();
    28.     temp=IIC_ReadByte();
    29.     IIC_Stop();                //产生一个停止信号
    30.     return temp;
    31. }
    复制代码

    2、关于根据AT24C02指定地址写入一个数据流程，与读取流程类似，在此不再介绍，具体程序如下：
    1. //在AT24CXX指定地址写入一个数据
    2. //waddr :写入数据的目的地址
    3. //data  :要写入的数据
    4. void AT24CXX_WriteOneByte(u16 waddr,u8 data)
    5. {
    6.     IIC_Start();
    7.     if(TYPE>AT24C16)
    8.     {
    9.         IIC_SendByte(0XA0);    //发送写命令
    10.         IIC_WaitAck();
    11.         IIC_SendByte(waddr>>8);//发送高地址
    12.     }else
    13.     {
    14.         IIC_SendByte(0XA0+((waddr/256)<<1));   //发送器件地址0XA0,写数据
    15.     }
    16.     IIC_WaitAck();
    17.     IIC_SendByte(waddr%256);  //发送低地址
    18.     IIC_WaitAck();
    19.     IIC_SendByte(data);       //发送字节
    20.     IIC_WaitAck();
    21.     IIC_Stop();               //产生一个停止信号
    22.     Delay_Ms(10);
    23. }
    复制代码
    其他函数大都在这两个函数基础上进行，在此不再介绍。
    main.c文件
    1. int main(void)
    2. {
    3.     u8 datatemp[size];

    5.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
    6.     Delay_Init();
    7.         USART_Printf_Init(115200);
    8.         IIC_Init();

    10.         printf("SystemClk:%d\r\n",SystemCoreClock);

    12.     if(AT24CXX_Check()==1)
    13.     {
    14.         /* 没有检测到EEPROM */
    15.         printf("24C02 Check Failed，Please Check!\n");

    17.     }
    18.     else
    19.     {
    20.         /* 没有检测到EEPROM */
    21.         printf("24C02 Check Succeed，Please Continue!\n");

    23.     }

    25.     if(AT24CXX_Test() == 0)
    26.     {
    27.         printf("24C02 Test Failed，Please Check!\n");
    28.     }
    29.     else
    30.     {
    31.         printf("24C02 Test Succeed，Please Check!\n");
    32.     }

    34.     AT24CXX_Write(0,(u8*)TEXT_Buffer,size);

    36.     AT24CXX_Read(0,datatemp,size);

    38.     printf("The Data Readed Is:%s\n",datatemp);

    40.         while(1)
    41.     {
    42.         }
    43. }
    复制代码
    main.c文件主要进行函数初始化以及AT24C02检测和读写测试。


    4、下载验证

    将编译好的程序下载到开发板并复位，同时将PA1连接J5的SCL引脚，PA2连接J5的SDA引脚，串口打印情况具体如下：

    CH32V CH573单片机芯片-第三十七章：CH32V103应用教程——I2C-软件模拟I2C读写EEPROMrisc-v单片机中文社区(2)
    IIC-（软件模拟IIC读写EEPROM）.rar
    CH32V CH573单片机芯片-第三十七章：CH32V103应用教程——I2C-软件模拟I2C读写EEPROMrisc-v单片机中文社区(3) 36、IIC-（软件模拟IIC读写EEPROM）.rar (499.7 KB, 下载次数: 22)
    链接：https://pan.baidu.com/s/1OjvqpaCxSnh3pwUNTnn5yA
    提取码：odia
    复制这段内容后打开百度网盘手机App，操作更方便哦

    完

    沁恒微电子, MounRiver, RISC-V, CH32V103




    上一篇：第三十六章：CH32V103应用教程——ADC-间断模式
    下一篇：第三十八章：I2C-7位地址模式，主机发送从机接收
    RISCV作者优文

    相关帖子

    全球首家只专注于RISC-V单片机行业应用的中文网站
    回复

    使用道具 举报

    RISC-V隐身侠  发表于 2021-5-28 00:13:59
    ▶ 语音朗读

    -

    Yes you are talented
    全球首家只专注于RISC-V单片机行业应用的中文网站
    回复 支持 反对

    使用道具

    返回列表 发新帖 回复
    高级模式
    B Color Image Link Quote Code Smilies

    本版积分规则

    关闭

    RISC-V单片机中文网上一条 /2 下一条



    版权及免责声明|RISC-V单片机中文网 |网站地图

    GMT+8, 2024-11-26 09:52 , Processed in 0.441124 second(s), 48 queries .

    快速回复 返回顶部 返回列表