I2C库函数

  1. typedef struct {
  2. uint32_t I2C_ClockSpeed; /*!< 设置 SCL 时钟频率,此值要低于 400000*/
  3. uint16_t I2C_Mode; /*!< 指定工作模式,可选 I2C 模式及 SMBUS 模式 */
  4. uint16_t I2C_DutyCycle; /*指定时钟占空比,可选 low/high = 2:1 及 16:9 模式*/
  5. uint16_t I2C_OwnAddress1; /*!< 指定自身的 I2C 设备地址 */
  6. uint16_t I2C_Ack; /*!< 使能或关闭响应(一般都要使能) */
  7. uint16_t I2C_AcknowledgedAddress; /*!< 指定地址的长度,可为 7 位及 10 位 */
  8. } I2C_InitTypeDef;

说明:

  1. I2C_ClockSpeed本成员设置的是 I2C 的传输速率,在调用初始化函数时,函数会根据我们输入的数值经过运算后把时钟因子写入到 I2C 的时钟控制寄存器 CCR。而我们写入的这个参数值不得高于 400KHz。 实际上由于 CCR 寄存器不能写入小数类型的时钟因子,影响到 SCL 的实际频率可能会低于本成员设置的参数值,这时除了通讯稍慢一点以外,不会对 I2C 的标准通讯造成其它影响。
  2. I2C_Mode本成员是选择 I2C 的使用方式,有 I2C 模式(I2C_Mode_I2C )和 SMBus 主、从模式(I2C_Mode_SMBusHost、 I2C_Mode_SMBusDevice ) 。 I2C 不需要在此处区分主从模式,直
    接设置 I2C_Mode_I2C 即可。
  3. (3) I2C_DutyCycle本成员设置的是 I2C 的 SCL 线时钟的占空比。 该配置有两个选择,分别为低电平时间
    比高电平时间为 2:1 ( I2C_DutyCycle_2)和 16:9 (I2C_DutyCycle_16_9)。其实这两个模式
    的比例差别并不大,一般要求都不会如此严格,这里随便选就可以。
  4. I2C_OwnAddress1本成员配置的是 STM32 的 I2C 设备自己的地址,每个连接到 I2C 总线上的设备都要有
    一 个 自 己 的 地 址 , 作 为 主 机 也 不 例 外 。 地 址 可 设 置 为 7 位 或 10 位 ( 受 下 面I2C_AcknowledgeAddress 成员决定),只要该地址是 I2C 总线上唯一的即可。STM32 的 I2C 外设可同时使用两个地址,即同时对两个地址作出响应,这个结构成员I2C_OwnAddress1 配置的是默认的、 OAR1 寄存器存储的地址,若需要设置第二个地址寄存器 OAR2,可使用 I2C_OwnAddress2Config 函数来配置, OAR2 不支持 10 位地址,只有7 位。
  5. I2C_Ack_Enable本成员是关于 I2C 应答设置,设置为使能则可以发送响应信号。本实验配置为允许应
    答(I2C_Ack_Enable),这是绝大多数遵循 I2C 标准的设备的通讯要求,改为禁止应答(I2C_Ack_Disable)往往会导致通讯错误。
  6. I2C_AcknowledgeAddress本成员选择 I2C 的寻址模式是 7 位还是 10 位地址。这需要根据实际连接到 I2C 总线上设备的地址进行选择,这个成员的配置也影响到 I2C_OwnAddress1 成员,只有这里设置成10 位模式时,I2C_OwnAddress1 才支持 10 位地址。配置完这些结构体成员值,调用库函数 I2C_Init 即可把结构体的配置写入到寄存器中。

I2C-读写EEPROM

bsp_i2c_ee.h

  1. #ifndef __I2C_EE_H
  2. #define __I2C_EE_H
  3. #include "stm32f10x.h"
  4. /**************************I2C参数定义,I2C1或I2C2********************************/
  5. #define EEPROM_I2Cx I2C1
  6. #define EEPROM_I2C_APBxClock_FUN RCC_APB1PeriphClockCmd
  7. #define EEPROM_I2C_CLK RCC_APB1Periph_I2C1
  8. #define EEPROM_I2C_GPIO_APBxClock_FUN RCC_APB2PeriphClockCmd
  9. #define EEPROM_I2C_GPIO_CLK RCC_APB2Periph_GPIOB
  10. #define EEPROM_I2C_SCL_PORT GPIOB
  11. #define EEPROM_I2C_SCL_PIN GPIO_Pin_6
  12. #define EEPROM_I2C_SDA_PORT GPIOB
  13. #define EEPROM_I2C_SDA_PIN GPIO_Pin_7
  14. /* STM32 I2C 快速模式 */
  15. #define I2C_Speed 400000 //*
  16. /* 这个地址只要与STM32外挂的I2C器件地址不一样即可 */
  17. #define I2Cx_OWN_ADDRESS7 0X0A
  18. /* AT24C01/02每页有8个字节 */
  19. #define I2C_PageSize 8
  20. /* AT24C04/08A/16A每页有16个字节 */
  21. //#define I2C_PageSize 16
  22. /*等待超时时间*/
  23. #define I2CT_FLAG_TIMEOUT ((uint32_t)0x1000)
  24. #define I2CT_LONG_TIMEOUT ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))
  25. /*信息输出*/
  26. #define EEPROM_DEBUG_ON 0
  27. #define EEPROM_INFO(fmt,arg...) printf("<<-EEPROM-INFO->> "fmt"\n",##arg)
  28. #define EEPROM_ERROR(fmt,arg...) printf("<<-EEPROM-ERROR->> "fmt"\n",##arg)
  29. #define EEPROM_DEBUG(fmt,arg...) do{\
  30. if(EEPROM_DEBUG_ON)\
  31. printf("<<-EEPROM-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
  32. }while(0)
  33. /*
  34. * AT24C02 2kb = 2048bit = 2048/8 B = 256 B
  35. * 32 pages of 8 bytes each
  36. *
  37. * Device Address
  38. * 1 0 1 0 A2 A1 A0 R/W
  39. * 1 0 1 0 0 0 0 0 = 0XA0
  40. * 1 0 1 0 0 0 0 1 = 0XA1
  41. */
  42. /* EEPROM Addresses defines */
  43. #define EEPROM_Block0_ADDRESS 0xA0 /* E2 = 0 */
  44. //#define EEPROM_Block1_ADDRESS 0xA2 /* E2 = 0 */
  45. //#define EEPROM_Block2_ADDRESS 0xA4 /* E2 = 0 */
  46. //#define EEPROM_Block3_ADDRESS 0xA6 /* E2 = 0 */
  47. void I2C_EE_Init(void);
  48. void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite);
  49. uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr);
  50. uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite);
  51. uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead);
  52. void I2C_EE_WaitEepromStandbyState(void);
  53. #endif /* __I2C_EE_H */

bsp_i2c_ee.c

  1. /**
  2. ******************************************************************************
  3. * @file bsp_i2c_ee.c
  4. * @author STMicroelectronics
  5. * @version V1.0
  6. * @date 2013-xx-xx
  7. * @brief i2c EEPROM(AT24C02)应用函数bsp
  8. ******************************************************************************
  9. * @attention
  10. *
  11. * 实验平台:野火 F103-霸道 STM32 开发板
  12. * 论坛 :http://www.firebbs.cn
  13. * 淘宝 :https://fire-stm32.taobao.com
  14. *
  15. ******************************************************************************
  16. */
  17. #include "./i2c/bsp_i2c_ee.h"
  18. #include "./usart/bsp_usart.h"
  19. uint16_t EEPROM_ADDRESS;
  20. static __IO uint32_t I2CTimeout = I2CT_LONG_TIMEOUT;
  21. static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode);
  22. /**
  23. * @brief I2C I/O配置
  24. * @param 无
  25. * @retval 无
  26. */
  27. static void I2C_GPIO_Config(void)
  28. {
  29. GPIO_InitTypeDef GPIO_InitStructure;
  30. /* 使能与 I2C 有关的时钟 */
  31. EEPROM_I2C_APBxClock_FUN ( EEPROM_I2C_CLK, ENABLE );
  32. EEPROM_I2C_GPIO_APBxClock_FUN ( EEPROM_I2C_GPIO_CLK, ENABLE );
  33. /* I2C_SCL、I2C_SDA*/
  34. GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_PIN;
  35. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  36. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; // 开漏输出
  37. GPIO_Init(EEPROM_I2C_SCL_PORT, &GPIO_InitStructure);
  38. GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SDA_PIN;
  39. GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  40. GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD; // 开漏输出
  41. GPIO_Init(EEPROM_I2C_SDA_PORT, &GPIO_InitStructure);
  42. }
  43. /**
  44. * @brief I2C 工作模式配置
  45. * @param 无
  46. * @retval 无
  47. */
  48. static void I2C_Mode_Configu(void)
  49. {
  50. I2C_InitTypeDef I2C_InitStructure;
  51. /* I2C 配置 */
  52. I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  53. /* 高电平数据稳定,低电平数据变化 SCL 时钟线的占空比 */
  54. I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  55. I2C_InitStructure.I2C_OwnAddress1 =I2Cx_OWN_ADDRESS7;
  56. I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;
  57. /* I2C的寻址模式 */
  58. I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  59. /* 通信速率 */
  60. I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;
  61. /* I2C 初始化 */
  62. I2C_Init(EEPROM_I2Cx, &I2C_InitStructure);
  63. /* 使能 I2C */
  64. I2C_Cmd(EEPROM_I2Cx, ENABLE);
  65. }
  66. /**
  67. * @brief I2C 外设(EEPROM)初始化
  68. * @param 无
  69. * @retval 无
  70. */
  71. void I2C_EE_Init(void)
  72. {
  73. I2C_GPIO_Config();
  74. I2C_Mode_Configu();
  75. /* 根据头文件i2c_ee.h中的定义来选择EEPROM的设备地址 */
  76. #ifdef EEPROM_Block0_ADDRESS
  77. /* 选择 EEPROM Block0 来写入 */
  78. EEPROM_ADDRESS = EEPROM_Block0_ADDRESS;
  79. #endif
  80. #ifdef EEPROM_Block1_ADDRESS
  81. /* 选择 EEPROM Block1 来写入 */
  82. EEPROM_ADDRESS = EEPROM_Block1_ADDRESS;
  83. #endif
  84. #ifdef EEPROM_Block2_ADDRESS
  85. /* 选择 EEPROM Block2 来写入 */
  86. EEPROM_ADDRESS = EEPROM_Block2_ADDRESS;
  87. #endif
  88. #ifdef EEPROM_Block3_ADDRESS
  89. /* 选择 EEPROM Block3 来写入 */
  90. EEPROM_ADDRESS = EEPROM_Block3_ADDRESS;
  91. #endif
  92. }
  93. /**
  94. * @brief 将缓冲区中的数据写到I2C EEPROM中
  95. * @param
  96. * @arg pBuffer:缓冲区指针
  97. * @arg WriteAddr:写地址
  98. * @arg NumByteToWrite:写的字节数
  99. * @retval 无
  100. */
  101. void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite)
  102. {
  103. u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;
  104. Addr = WriteAddr % I2C_PageSize;
  105. count = I2C_PageSize - Addr;
  106. NumOfPage = NumByteToWrite / I2C_PageSize;
  107. NumOfSingle = NumByteToWrite % I2C_PageSize;
  108. /* If WriteAddr is I2C_PageSize aligned */
  109. if(Addr == 0)
  110. {
  111. /* If NumByteToWrite < I2C_PageSize */
  112. if(NumOfPage == 0)
  113. {
  114. I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  115. I2C_EE_WaitEepromStandbyState();
  116. }
  117. /* If NumByteToWrite > I2C_PageSize */
  118. else
  119. {
  120. while(NumOfPage--)
  121. {
  122. I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
  123. I2C_EE_WaitEepromStandbyState();
  124. WriteAddr += I2C_PageSize;
  125. pBuffer += I2C_PageSize;
  126. }
  127. if(NumOfSingle!=0)
  128. {
  129. I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  130. I2C_EE_WaitEepromStandbyState();
  131. }
  132. }
  133. }
  134. /* If WriteAddr is not I2C_PageSize aligned */
  135. else
  136. {
  137. /* If NumByteToWrite < I2C_PageSize */
  138. if(NumOfPage== 0)
  139. {
  140. I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  141. I2C_EE_WaitEepromStandbyState();
  142. }
  143. /* If NumByteToWrite > I2C_PageSize */
  144. else
  145. {
  146. NumByteToWrite -= count;
  147. NumOfPage = NumByteToWrite / I2C_PageSize;
  148. NumOfSingle = NumByteToWrite % I2C_PageSize;
  149. if(count != 0)
  150. {
  151. I2C_EE_PageWrite(pBuffer, WriteAddr, count);
  152. I2C_EE_WaitEepromStandbyState();
  153. WriteAddr += count;
  154. pBuffer += count;
  155. }
  156. while(NumOfPage--)
  157. {
  158. I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
  159. I2C_EE_WaitEepromStandbyState();
  160. WriteAddr += I2C_PageSize;
  161. pBuffer += I2C_PageSize;
  162. }
  163. if(NumOfSingle != 0)
  164. {
  165. I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
  166. I2C_EE_WaitEepromStandbyState();
  167. }
  168. }
  169. }
  170. }
  171. /**
  172. * @brief 写一个字节到I2C EEPROM中
  173. * @param
  174. * @arg pBuffer:缓冲区指针
  175. * @arg WriteAddr:写地址
  176. * @retval 无
  177. */
  178. uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr)
  179. {
  180. /* Send STRAT condition */
  181. I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  182. I2CTimeout = I2CT_FLAG_TIMEOUT;
  183. /* Test on EV5 and clear it */
  184. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  185. {
  186. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
  187. }
  188. I2CTimeout = I2CT_FLAG_TIMEOUT;
  189. /* Send EEPROM address for write */
  190. I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  191. /* Test on EV6 and clear it */
  192. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  193. {
  194. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
  195. }
  196. /* Send the EEPROM's internal address to write to */
  197. I2C_SendData(EEPROM_I2Cx, WriteAddr);
  198. I2CTimeout = I2CT_FLAG_TIMEOUT;
  199. /* Test on EV8 and clear it */
  200. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  201. {
  202. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
  203. }
  204. /* Send the byte to be written */
  205. I2C_SendData(EEPROM_I2Cx, *pBuffer);
  206. I2CTimeout = I2CT_FLAG_TIMEOUT;
  207. /* Test on EV8 and clear it */
  208. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  209. {
  210. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
  211. }
  212. /* Send STOP condition */
  213. I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
  214. return 1;
  215. }
  216. /**
  217. * @brief 在EEPROM的一个写循环中可以写多个字节,但一次写入的字节数
  218. * 不能超过EEPROM页的大小,AT24C02每页有8个字节
  219. * @param
  220. * @arg pBuffer:缓冲区指针
  221. * @arg WriteAddr:写地址
  222. * @arg NumByteToWrite:写的字节数
  223. * @retval 无
  224. */
  225. uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
  226. {
  227. I2CTimeout = I2CT_LONG_TIMEOUT;
  228. while(I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))
  229. {
  230. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
  231. }
  232. /* Send START condition */
  233. I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  234. I2CTimeout = I2CT_FLAG_TIMEOUT;
  235. /* Test on EV5 and clear it */
  236. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  237. {
  238. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
  239. }
  240. /* Send EEPROM address for write */
  241. I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  242. I2CTimeout = I2CT_FLAG_TIMEOUT;
  243. /* Test on EV6 and clear it */
  244. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  245. {
  246. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
  247. }
  248. /* Send the EEPROM's internal address to write to */
  249. I2C_SendData(EEPROM_I2Cx, WriteAddr);
  250. I2CTimeout = I2CT_FLAG_TIMEOUT;
  251. /* Test on EV8 and clear it */
  252. while(! I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  253. {
  254. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  255. }
  256. /* While there is data to be written */
  257. while(NumByteToWrite--)
  258. {
  259. /* Send the current byte */
  260. I2C_SendData(EEPROM_I2Cx, *pBuffer);
  261. /* Point to the next byte to be written */
  262. pBuffer++;
  263. I2CTimeout = I2CT_FLAG_TIMEOUT;
  264. /* Test on EV8 and clear it */
  265. while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  266. {
  267. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
  268. }
  269. }
  270. /* Send STOP condition */
  271. I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
  272. return 1;
  273. }
  274. /**
  275. * @brief 从EEPROM里面读取一块数据
  276. * @param
  277. * @arg pBuffer:存放从EEPROM读取的数据的缓冲区指针
  278. * @arg WriteAddr:接收数据的EEPROM的地址
  279. * @arg NumByteToWrite:要从EEPROM读取的字节数
  280. * @retval 无
  281. */
  282. uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
  283. {
  284. I2CTimeout = I2CT_LONG_TIMEOUT;
  285. //*((u8 *)0x4001080c) |=0x80;
  286. while(I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))
  287. {
  288. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
  289. }
  290. /* Send START condition */
  291. I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  292. //*((u8 *)0x4001080c) &=~0x80;
  293. I2CTimeout = I2CT_FLAG_TIMEOUT;
  294. /* Test on EV5 and clear it */
  295. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  296. {
  297. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
  298. }
  299. /* Send EEPROM address for write */
  300. I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  301. I2CTimeout = I2CT_FLAG_TIMEOUT;
  302. /* Test on EV6 and clear it */
  303. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  304. {
  305. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
  306. }
  307. /* Clear EV6 by setting again the PE bit */
  308. I2C_Cmd(EEPROM_I2Cx, ENABLE);
  309. /* Send the EEPROM's internal address to write to */
  310. I2C_SendData(EEPROM_I2Cx, ReadAddr);
  311. I2CTimeout = I2CT_FLAG_TIMEOUT;
  312. /* Test on EV8 and clear it */
  313. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  314. {
  315. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(12);
  316. }
  317. /* Send STRAT condition a second time */
  318. I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  319. I2CTimeout = I2CT_FLAG_TIMEOUT;
  320. /* Test on EV5 and clear it */
  321. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  322. {
  323. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
  324. }
  325. /* Send EEPROM address for read */
  326. I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Receiver);
  327. I2CTimeout = I2CT_FLAG_TIMEOUT;
  328. /* Test on EV6 and clear it */
  329. while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
  330. {
  331. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
  332. }
  333. /* While there is data to be read */
  334. while(NumByteToRead)
  335. {
  336. if(NumByteToRead == 1)
  337. {
  338. /* Disable Acknowledgement */
  339. I2C_AcknowledgeConfig(EEPROM_I2Cx, DISABLE);
  340. /* Send STOP Condition */
  341. I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
  342. }
  343. /* Test on EV7 and clear it */
  344. I2CTimeout = I2CT_LONG_TIMEOUT;
  345. while(I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)
  346. {
  347. if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
  348. }
  349. {
  350. /* Read a byte from the EEPROM */
  351. *pBuffer = I2C_ReceiveData(EEPROM_I2Cx);
  352. /* Point to the next location where the byte read will be saved */
  353. pBuffer++;
  354. /* Decrement the read bytes counter */
  355. NumByteToRead--;
  356. }
  357. }
  358. /* Enable Acknowledgement to be ready for another reception */
  359. I2C_AcknowledgeConfig(EEPROM_I2Cx, ENABLE);
  360. return 1;
  361. }
  362. /**
  363. * @brief Wait for EEPROM Standby state
  364. * @param 无
  365. * @retval 无
  366. */
  367. void I2C_EE_WaitEepromStandbyState(void)
  368. {
  369. vu16 SR1_Tmp = 0;
  370. do
  371. {
  372. /* Send START condition */
  373. I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  374. /* Read I2C1 SR1 register */
  375. SR1_Tmp = I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1);
  376. /* Send EEPROM address for write */
  377. I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  378. }while(!(I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1) & 0x0002));
  379. /* Clear AF flag */
  380. I2C_ClearFlag(EEPROM_I2Cx, I2C_FLAG_AF);
  381. /* STOP condition */
  382. I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
  383. }
  384. /**
  385. * @brief Basic management of the timeout situation.
  386. * @param errorCode:错误代码,可以用来定位是哪个环节出错.
  387. * @retval 返回0,表示IIC读取失败.
  388. */
  389. static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
  390. {
  391. /* Block communication and all processes */
  392. EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode);
  393. return 0;
  394. }
  395. /*********************************************END OF FILE**********************/

main.c

/**
  ******************************************************************************
  * @file    main.c
  * @author  fire
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   I2C EEPROM(AT24C02)测试,测试信息通过USART1打印在电脑的超级终端
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */

#include "stm32f10x.h"
#include "./led/bsp_led.h"
#include "./usart/bsp_usart.h"
#include "./i2c/bsp_i2c_ee.h"
#include <string.h>

#define  EEP_Firstpage      0x00
uint8_t I2c_Buf_Write[256];
uint8_t I2c_Buf_Read[256];
uint8_t I2C_Test(void);

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{ 
  LED_GPIO_Config();

  LED_BLUE;
  /* 串口初始化 */
    USART_Config();

    printf("\r\n 这是一个I2C外设(AT24C02)读写测试例程 \r\n");

    /* I2C 外设初(AT24C02)始化 */
    I2C_EE_Init();

  //EEPROM 读写测试
    if(I2C_Test() ==1)
    {
            LED_GREEN;
    }
    else
    {
            LED_RED;
    }

  while (1)
  {      
  }
}

/**
  * @brief  I2C(AT24C02)读写测试
  * @param  无
  * @retval 正常返回1,异常返回0
  */
uint8_t I2C_Test(void)
{
    uint16_t i;

    printf("写入的数据\n\r");

    for ( i=0; i<=255; i++ ) //填充缓冲
  {   
    I2c_Buf_Write[i] = i;

    printf("0x%02X ", I2c_Buf_Write[i]);
    if(i%16 == 15)    
        printf("\n\r");    
   }

  //将I2c_Buf_Write中顺序递增的数据写入EERPOM中 
    I2C_EE_BufferWrite( I2c_Buf_Write, EEP_Firstpage, 256);

  EEPROM_INFO("\n\r写成功\n\r");

   EEPROM_INFO("\n\r读出的数据\n\r");
  //将EEPROM读出数据顺序保持到I2c_Buf_Read中
    I2C_EE_BufferRead(I2c_Buf_Read, EEP_Firstpage, 256); 

  //将I2c_Buf_Read中的数据通过串口打印
    for (i=0; i<256; i++)
    {    
        if(I2c_Buf_Read[i] != I2c_Buf_Write[i])
        {
            EEPROM_ERROR("0x%02X ", I2c_Buf_Read[i]);
            EEPROM_ERROR("错误:I2C EEPROM写入与读出的数据不一致\n\r");
            return 0;
        }
    printf("0x%02X ", I2c_Buf_Read[i]);
    if(i%16 == 15)    
        printf("\n\r");

    }
  EEPROM_INFO("I2C(AT24C02)读写测试成功\n\r");

  return 1;
}
/*********************************************END OF FILE**********************/

教程:https://www.bilibili.com/video/BV1yW411Y7Gw?p=52
硬件i2c.zip

软件模拟I2C

bsp_i2c_ee.h

#ifndef __I2C_EE_H
#define    __I2C_EE_H


#include "stm32f10x.h"


/* 
 * AT24C02 2kb = 2048bit = 2048/8 B = 256 B
 * 32 pages of 8 bytes each
 *
 * Device Address
 * 1 0 1 0 A2 A1 A0 R/W
 * 1 0 1 0 0  0  0  0 = 0XA0
 * 1 0 1 0 0  0  0  1 = 0XA1 
 */

/* AT24C01/02每页有8个字节 
 * AT24C04/08A/16A每页有16个字节 
 */


#define EEPROM_DEV_ADDR            0xA0        /* 24xx02的设备地址 */
#define EEPROM_PAGE_SIZE          8              /* 24xx02的页面大小 */
#define EEPROM_SIZE                  256              /* 24xx02总容量 */


uint8_t ee_CheckOk(void);
uint8_t ee_ReadBytes(uint8_t *_pReadBuf, uint16_t _usAddress, uint16_t _usSize);
uint8_t ee_WriteBytes(uint8_t *_pWriteBuf, uint16_t _usAddress, uint16_t _usSize);
void ee_Erase(void);
uint8_t ee_Test(void);


#endif /* __I2C_EE_H */

bsp_i2c_ee.c

/**
  ******************************************************************************
  * @file    bsp_i2c_ee.c
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   i2c EEPROM(AT24C02)应用函数bsp
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 

#include "bsp_i2c_ee.h"
#include "bsp_i2c_gpio.h"
#include "bsp_usart.h" 

/*
*********************************************************************************************************
*    函 数 名: ee_CheckOk
*    功能说明: 判断串行EERPOM是否正常
*    形    参:无
*    返 回 值: 1 表示正常, 0 表示不正常
*********************************************************************************************************
*/
uint8_t ee_CheckOk(void)
{
    if (i2c_CheckDevice(EEPROM_DEV_ADDR) == 0)
    {
        return 1;
    }
    else
    {
        /* 失败后,切记发送I2C总线停止信号 */
        i2c_Stop();        
        return 0;
    }
}

/*
*********************************************************************************************************
*    函 数 名: ee_ReadBytes
*    功能说明: 从串行EEPROM指定地址处开始读取若干数据
*    形    参:_usAddress : 起始地址
*             _usSize : 数据长度,单位为字节
*             _pReadBuf : 存放读到的数据的缓冲区指针
*    返 回 值: 0 表示失败,1表示成功
*********************************************************************************************************
*/
uint8_t ee_ReadBytes(uint8_t *_pReadBuf, uint16_t _usAddress, uint16_t _usSize)
{
    uint16_t i;

    /* 采用串行EEPROM随即读取指令序列,连续读取若干字节 */

    /* 第1步:发起I2C总线启动信号 */
    i2c_Start();

    /* 第2步:发起控制字节,高7bit是地址,bit0是读写控制位,0表示写,1表示读 */
    i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);    /* 此处是写指令 */

    /* 第3步:等待ACK */
    if (i2c_WaitAck() != 0)
    {
        goto cmd_fail;    /* EEPROM器件无应答 */
    }

    /* 第4步:发送字节地址,24C02只有256字节,因此1个字节就够了,如果是24C04以上,那么此处需要连发多个地址 */
    i2c_SendByte((uint8_t)_usAddress);

    /* 第5步:等待ACK */
    if (i2c_WaitAck() != 0)
    {
        goto cmd_fail;    /* EEPROM器件无应答 */
    }

    /* 第6步:重新启动I2C总线。前面的代码的目的向EEPROM传送地址,下面开始读取数据 */
    i2c_Start();

    /* 第7步:发起控制字节,高7bit是地址,bit0是读写控制位,0表示写,1表示读 */
    i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_RD);    /* 此处是读指令 */

    /* 第8步:发送ACK */
    if (i2c_WaitAck() != 0)
    {
        goto cmd_fail;    /* EEPROM器件无应答 */
    }    

    /* 第9步:循环读取数据 */
    for (i = 0; i < _usSize; i++)
    {
        _pReadBuf[i] = i2c_ReadByte();    /* 读1个字节 */

        /* 每读完1个字节后,需要发送Ack, 最后一个字节不需要Ack,发Nack */
        if (i != _usSize - 1)
        {
            i2c_Ack();    /* 中间字节读完后,CPU产生ACK信号(驱动SDA = 0) */
        }
        else
        {
            i2c_NAck();    /* 最后1个字节读完后,CPU产生NACK信号(驱动SDA = 1) */
        }
    }
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 1;    /* 执行成功 */

cmd_fail: /* 命令执行失败后,切记发送停止信号,避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 0;
}

/*
*********************************************************************************************************
*    函 数 名: ee_WriteBytes
*    功能说明: 向串行EEPROM指定地址写入若干数据,采用页写操作提高写入效率
*    形    参:_usAddress : 起始地址
*             _usSize : 数据长度,单位为字节
*             _pWriteBuf : 存放读到的数据的缓冲区指针
*    返 回 值: 0 表示失败,1表示成功
*********************************************************************************************************
*/
uint8_t ee_WriteBytes(uint8_t *_pWriteBuf, uint16_t _usAddress, uint16_t _usSize)
{
    uint16_t i,m;
    uint16_t usAddr;

    /* 
        写串行EEPROM不像读操作可以连续读取很多字节,每次写操作只能在同一个page。
        对于24xx02,page size = 8
        简单的处理方法为:按字节写操作模式,没写1个字节,都发送地址
        为了提高连续写的效率: 本函数采用page wirte操作。
    */

    usAddr = _usAddress;    
    for (i = 0; i < _usSize; i++)
    {
        /* 当发送第1个字节或是页面首地址时,需要重新发起启动信号和地址 */
        if ((i == 0) || (usAddr & (EEPROM_PAGE_SIZE - 1)) == 0)
        {
            /* 第0步:发停止信号,启动内部写操作 */
            i2c_Stop();

            /* 通过检查器件应答的方式,判断内部写操作是否完成, 一般小于 10ms             
                CLK频率为200KHz时,查询次数为30次左右
            */
            for (m = 0; m < 1000; m++)
            {                
                /* 第1步:发起I2C总线启动信号 */
                i2c_Start();

                /* 第2步:发起控制字节,高7bit是地址,bit0是读写控制位,0表示写,1表示读 */
                i2c_SendByte(EEPROM_DEV_ADDR | EEPROM_I2C_WR);    /* 此处是写指令 */

                /* 第3步:发送一个时钟,判断器件是否正确应答 */
                if (i2c_WaitAck() == 0)
                {
                    break;
                }
            }
            if (m  == 1000)
            {
                goto cmd_fail;    /* EEPROM器件写超时 */
            }

            /* 第4步:发送字节地址,24C02只有256字节,因此1个字节就够了,如果是24C04以上,那么此处需要连发多个地址 */
            i2c_SendByte((uint8_t)usAddr);

            /* 第5步:等待ACK */
            if (i2c_WaitAck() != 0)
            {
                goto cmd_fail;    /* EEPROM器件无应答 */
            }
        }

        /* 第6步:开始写入数据 */
        i2c_SendByte(_pWriteBuf[i]);

        /* 第7步:发送ACK */
        if (i2c_WaitAck() != 0)
        {
            goto cmd_fail;    /* EEPROM器件无应答 */
        }

        usAddr++;    /* 地址增1 */        
    }

    /* 命令执行成功,发送I2C总线停止信号 */
    i2c_Stop();
    return 1;

cmd_fail: /* 命令执行失败后,切记发送停止信号,避免影响I2C总线上其他设备 */
    /* 发送I2C总线停止信号 */
    i2c_Stop();
    return 0;
}


void ee_Erase(void)
{
    uint16_t i;
    uint8_t buf[EEPROM_SIZE];

    /* 填充缓冲区 */
    for (i = 0; i < EEPROM_SIZE; i++)
    {
        buf[i] = 0xFF;
    }

    /* 写EEPROM, 起始地址 = 0,数据长度为 256 */
    if (ee_WriteBytes(buf, 0, EEPROM_SIZE) == 0)
    {
        printf("擦除eeprom出错!\r\n");
        return;
    }
    else
    {
        printf("擦除eeprom成功!\r\n");
    }
}


/*--------------------------------------------------------------------------------------------------*/
static void ee_Delay(__IO uint32_t nCount)     //简单的延时函数
{
    for(; nCount != 0; nCount--);
}


/*
 * eeprom AT24C02 读写测试
 * 正常返回1,异常返回0
 */
uint8_t ee_Test(void) 
{
  uint16_t i;
    uint8_t write_buf[EEPROM_SIZE];
  uint8_t read_buf[EEPROM_SIZE];

/*-----------------------------------------------------------------------------------*/  
  if (ee_CheckOk() == 0)
    {
        /* 没有检测到EEPROM */
        printf("没有检测到串行EEPROM!\r\n");

        return 0;
    }
/*------------------------------------------------------------------------------------*/  
  /* 填充测试缓冲区 */
    for (i = 0; i < EEPROM_SIZE; i++)
    {        
        write_buf[i] = i;
    }
/*------------------------------------------------------------------------------------*/  
  if (ee_WriteBytes(write_buf, 0, EEPROM_SIZE) == 0)
    {
        printf("写eeprom出错!\r\n");
        return 0;
    }
    else
    {        
        printf("写eeprom成功!\r\n");
    }

  /*写完之后需要适当的延时再去读,不然会出错*/
  ee_Delay(0x0FFFFF);
/*-----------------------------------------------------------------------------------*/
  if (ee_ReadBytes(read_buf, 0, EEPROM_SIZE) == 0)
    {
        printf("读eeprom出错!\r\n");
        return 0;
    }
    else
    {        
        printf("读eeprom成功,数据如下:\r\n");
    }
/*-----------------------------------------------------------------------------------*/  
  for (i = 0; i < EEPROM_SIZE; i++)
    {
        if(read_buf[i] != write_buf[i])
        {
            printf("0x%02X ", read_buf[i]);
            printf("错误:EEPROM读出与写入的数据不一致");
            return 0;
        }
    printf(" %02X", read_buf[i]);

        if ((i & 15) == 15)
        {
            printf("\r\n");    
        }        
    }
  printf("eeprom读写测试成功\r\n");
  return 1;
}
/*********************************************END OF FILE**********************/

bsp_i2c_gpio.h

#ifndef _BSP_I2C_GPIO_H
#define _BSP_I2C_GPIO_H


#include <inttypes.h>


#define EEPROM_I2C_WR    0        /* 写控制bit */
#define EEPROM_I2C_RD    1        /* 读控制bit */


/* 定义I2C总线连接的GPIO端口, 用户只需要修改下面4行代码即可任意改变SCL和SDA的引脚 */
#define EEPROM_GPIO_PORT_I2C    GPIOB            /* GPIO端口 */
#define EEPROM_RCC_I2C_PORT     RCC_APB2Periph_GPIOB        /* GPIO端口时钟 */
#define EEPROM_I2C_SCL_PIN        GPIO_Pin_6            /* 连接到SCL时钟线的GPIO */
#define EEPROM_I2C_SDA_PIN        GPIO_Pin_7            /* 连接到SDA数据线的GPIO */


/* 定义读写SCL和SDA的宏,已增加代码的可移植性和可阅读性 */
#if 0    /* 条件编译: 1 选择GPIO的库函数实现IO读写 */
    #define EEPROM_I2C_SCL_1()  GPIO_SetBits(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SCL_PIN)        /* SCL = 1 */
    #define EEPROM_I2C_SCL_0()  GPIO_ResetBits(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SCL_PIN)        /* SCL = 0 */

    #define EEPROM_I2C_SDA_1()  GPIO_SetBits(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SDA_PIN)        /* SDA = 1 */
    #define EEPROM_I2C_SDA_0()  GPIO_ResetBits(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SDA_PIN)        /* SDA = 0 */

    #define EEPROM_I2C_SDA_READ()  GPIO_ReadInputDataBit(EEPROM_GPIO_PORT_I2C, EEPROM_I2C_SDA_PIN)    /* 读SDA口线状态 */
#else    /* 这个分支选择直接寄存器操作实现IO读写 */
    /* 注意:如下写法,在IAR最高级别优化时,会被编译器错误优化 */
    #define EEPROM_I2C_SCL_1()  EEPROM_GPIO_PORT_I2C->BSRR = EEPROM_I2C_SCL_PIN                /* SCL = 1 */
    #define EEPROM_I2C_SCL_0()  EEPROM_GPIO_PORT_I2C->BRR = EEPROM_I2C_SCL_PIN                /* SCL = 0 */

    #define EEPROM_I2C_SDA_1()  EEPROM_GPIO_PORT_I2C->BSRR = EEPROM_I2C_SDA_PIN                /* SDA = 1 */
    #define EEPROM_I2C_SDA_0()  EEPROM_GPIO_PORT_I2C->BRR = EEPROM_I2C_SDA_PIN                /* SDA = 0 */

    #define EEPROM_I2C_SDA_READ()  ((EEPROM_GPIO_PORT_I2C->IDR & EEPROM_I2C_SDA_PIN) != 0)    /* 读SDA口线状态 */
#endif


void i2c_Start(void);
void i2c_Stop(void);
void i2c_SendByte(uint8_t _ucByte);
uint8_t i2c_ReadByte(void);
uint8_t i2c_WaitAck(void);
void i2c_Ack(void);
void i2c_NAck(void);
uint8_t i2c_CheckDevice(uint8_t _Address);


#endif

bsp_i2c_gpio.c

/**
  ******************************************************************************
  * @file    bsp_i2c_ee.c
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   用gpio模拟i2c总线, 适用于STM32系列CPU。该模块不包括应用层命令帧,仅包括I2C总线基本操作函数。
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 

/*
    应用说明:
    在访问I2C设备前,请先调用 i2c_CheckDevice() 检测I2C设备是否正常,该函数会配置GPIO

*/
#include "bsp_i2c_gpio.h"
#include "stm32f10x.h"


static void i2c_CfgGpio(void);


/*
*********************************************************************************************************
*    函 数 名: i2c_Delay
*    功能说明: I2C总线位延迟,最快400KHz
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
static void i2c_Delay(void)
{
    uint8_t i;

    /* 
         下面的时间是通过逻辑分析仪测试得到的。
    工作条件:CPU主频72MHz ,MDK编译环境,1级优化

        循环次数为10时,SCL频率 = 205KHz 
        循环次数为7时,SCL频率 = 347KHz, SCL高电平时间1.5us,SCL低电平时间2.87us 
         循环次数为5时,SCL频率 = 421KHz, SCL高电平时间1.25us,SCL低电平时间2.375us 
    */
    for (i = 0; i < 10; i++);
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Start
*    功能说明: CPU发起I2C总线启动信号
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Start(void)
{
    /* 当SCL高电平时,SDA出现一个下跳沿表示I2C总线启动信号 */
    EEPROM_I2C_SDA_1();
    EEPROM_I2C_SCL_1();
    i2c_Delay();
    EEPROM_I2C_SDA_0();
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Start
*    功能说明: CPU发起I2C总线停止信号
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Stop(void)
{
    /* 当SCL高电平时,SDA出现一个上跳沿表示I2C总线停止信号 */
    EEPROM_I2C_SDA_0();
    EEPROM_I2C_SCL_1();
    i2c_Delay();
    EEPROM_I2C_SDA_1();
}

/*
*********************************************************************************************************
*    函 数 名: i2c_SendByte
*    功能说明: CPU向I2C总线设备发送8bit数据
*    形    参:_ucByte : 等待发送的字节
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_SendByte(uint8_t _ucByte)
{
    uint8_t i;

    /* 先发送字节的高位bit7 */
    for (i = 0; i < 8; i++)
    {        
        if (_ucByte & 0x80)
        {
            EEPROM_I2C_SDA_1();
        }
        else
        {
            EEPROM_I2C_SDA_0();
        }
        i2c_Delay();
        EEPROM_I2C_SCL_1();
        i2c_Delay();    
        EEPROM_I2C_SCL_0();
        if (i == 7)
        {
             EEPROM_I2C_SDA_1(); // 释放总线
        }
        _ucByte <<= 1;    /* 左移一个bit */
        i2c_Delay();
    }
}

/*
*********************************************************************************************************
*    函 数 名: i2c_ReadByte
*    功能说明: CPU从I2C总线设备读取8bit数据
*    形    参:无
*    返 回 值: 读到的数据
*********************************************************************************************************
*/
uint8_t i2c_ReadByte(void)
{
    uint8_t i;
    uint8_t value;

    /* 读到第1个bit为数据的bit7 */
    value = 0;
    for (i = 0; i < 8; i++)
    {
        value <<= 1;
        EEPROM_I2C_SCL_1();
        i2c_Delay();
        if (EEPROM_I2C_SDA_READ())
        {
            value++;
        }
        EEPROM_I2C_SCL_0();
        i2c_Delay();
    }
    return value;
}

/*
*********************************************************************************************************
*    函 数 名: i2c_WaitAck
*    功能说明: CPU产生一个时钟,并读取器件的ACK应答信号
*    形    参:无
*    返 回 值: 返回0表示正确应答,1表示无器件响应
*********************************************************************************************************
*/
uint8_t i2c_WaitAck(void)
{
    uint8_t re;

    EEPROM_I2C_SDA_1();    /* CPU释放SDA总线 */
    i2c_Delay();
    EEPROM_I2C_SCL_1();    /* CPU驱动SCL = 1, 此时器件会返回ACK应答 */
    i2c_Delay();
    if (EEPROM_I2C_SDA_READ())    /* CPU读取SDA口线状态 */
    {
        re = 1;
    }
    else
    {
        re = 0;
    }
    EEPROM_I2C_SCL_0();
    i2c_Delay();
    return re;
}

/*
*********************************************************************************************************
*    函 数 名: i2c_Ack
*    功能说明: CPU产生一个ACK信号
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_Ack(void)
{
    EEPROM_I2C_SDA_0();    /* CPU驱动SDA = 0 */
    i2c_Delay();
    EEPROM_I2C_SCL_1();    /* CPU产生1个时钟 */
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();
    EEPROM_I2C_SDA_1();    /* CPU释放SDA总线 */
}

/*
*********************************************************************************************************
*    函 数 名: i2c_NAck
*    功能说明: CPU产生1个NACK信号
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
void i2c_NAck(void)
{
    EEPROM_I2C_SDA_1();    /* CPU驱动SDA = 1 */
    i2c_Delay();
    EEPROM_I2C_SCL_1();    /* CPU产生1个时钟 */
    i2c_Delay();
    EEPROM_I2C_SCL_0();
    i2c_Delay();    
}

/*
*********************************************************************************************************
*    函 数 名: i2c_CfgGpio
*    功能说明: 配置I2C总线的GPIO,采用模拟IO的方式实现
*    形    参:无
*    返 回 值: 无
*********************************************************************************************************
*/
static void i2c_CfgGpio(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

    RCC_APB2PeriphClockCmd(EEPROM_RCC_I2C_PORT, ENABLE);    /* 打开GPIO时钟 */

    GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_PIN | EEPROM_I2C_SDA_PIN;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;      /* 开漏输出 */
    GPIO_Init(EEPROM_GPIO_PORT_I2C, &GPIO_InitStructure);

    /* 给一个停止信号, 复位I2C总线上的所有设备到待机模式 */
    i2c_Stop();
}

/*
*********************************************************************************************************
*    函 数 名: i2c_CheckDevice
*    功能说明: 检测I2C总线设备,CPU向发送设备地址,然后读取设备应答来判断该设备是否存在
*    形    参:_Address:设备的I2C总线地址
*    返 回 值: 返回值 0 表示正确, 返回1表示未探测到
*********************************************************************************************************
*/
uint8_t i2c_CheckDevice(uint8_t _Address)
{
    uint8_t ucAck;

    i2c_CfgGpio();        /* 配置GPIO */


    i2c_Start();        /* 发送启动信号 */

    /* 发送设备地址+读写控制bit(0 = w, 1 = r) bit7 先传 */
    i2c_SendByte(_Address | EEPROM_I2C_WR);
    ucAck = i2c_WaitAck();    /* 检测设备的ACK应答 */

    i2c_Stop();            /* 发送停止信号 */

    return ucAck;
}

bsp_led.h

#ifndef __LED_H
#define    __LED_H


#include "stm32f10x.h"


/* 定义LED连接的GPIO端口, 用户只需要修改下面的代码即可改变控制的LED引脚 */
// R-红色
#define LED1_GPIO_PORT        GPIOB                          /* GPIO端口 */
#define LED1_GPIO_CLK         RCC_APB2Periph_GPIOB        /* GPIO端口时钟 */
#define LED1_GPIO_PIN        GPIO_Pin_5                    /* 连接到SCL时钟线的GPIO */

// G-绿色
#define LED2_GPIO_PORT        GPIOB                          /* GPIO端口 */
#define LED2_GPIO_CLK         RCC_APB2Periph_GPIOB        /* GPIO端口时钟 */
#define LED2_GPIO_PIN        GPIO_Pin_0                    /* 连接到SCL时钟线的GPIO */

// B-蓝色
#define LED3_GPIO_PORT        GPIOB                          /* GPIO端口 */
#define LED3_GPIO_CLK         RCC_APB2Periph_GPIOB        /* GPIO端口时钟 */
#define LED3_GPIO_PIN        GPIO_Pin_1                    /* 连接到SCL时钟线的GPIO */


/** the macro definition to trigger the led on or off 
  * 1 - off
  *0 - on
  */
#define ON  0
#define OFF 1

/* 使用标准的固件库控制IO*/
#define LED1(a)    if (a)    \
                    GPIO_SetBits(LED1_GPIO_PORT,LED1_GPIO_PIN);\
                    else        \
                    GPIO_ResetBits(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2(a)    if (a)    \
                    GPIO_SetBits(LED2_GPIO_PORT,LED2_GPIO_PIN);\
                    else        \
                    GPIO_ResetBits(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3(a)    if (a)    \
                    GPIO_SetBits(LED3_GPIO_PORT,LED3_GPIO_PIN);\
                    else        \
                    GPIO_ResetBits(LED3_GPIO_PORT,LED3_GPIO_PIN)


/* 直接操作寄存器的方法控制IO */
#define    digitalHi(p,i)         {p->BSRR=i;}     //输出为高电平        
#define digitalLo(p,i)         {p->BRR=i;}     //输出低电平
#define digitalToggle(p,i) {p->ODR ^=i;} //输出反转状态


/* 定义控制IO的宏 */
#define LED1_TOGGLE         digitalToggle(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_OFF           digitalHi(LED1_GPIO_PORT,LED1_GPIO_PIN)
#define LED1_ON               digitalLo(LED1_GPIO_PORT,LED1_GPIO_PIN)

#define LED2_TOGGLE         digitalToggle(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_OFF           digitalHi(LED2_GPIO_PORT,LED2_GPIO_PIN)
#define LED2_ON               digitalLo(LED2_GPIO_PORT,LED2_GPIO_PIN)

#define LED3_TOGGLE         digitalToggle(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_OFF           digitalHi(LED3_GPIO_PORT,LED3_GPIO_PIN)
#define LED3_ON               digitalLo(LED3_GPIO_PORT,LED3_GPIO_PIN)

/* 基本混色,后面高级用法使用PWM可混出全彩颜色,且效果更好 */

//红
#define LED_RED  \
                    LED1_ON;\
                    LED2_OFF\
                    LED3_OFF

//绿
#define LED_GREEN        \
                    LED1_OFF;\
                    LED2_ON\
                    LED3_OFF

//蓝
#define LED_BLUE    \
                    LED1_OFF;\
                    LED2_OFF\
                    LED3_ON


//黄(红+绿)                    
#define LED_YELLOW    \
                    LED1_ON;\
                    LED2_ON\
                    LED3_OFF
//紫(红+蓝)
#define LED_PURPLE    \
                    LED1_ON;\
                    LED2_OFF\
                    LED3_ON

//青(绿+蓝)
#define LED_CYAN \
                    LED1_OFF;\
                    LED2_ON\
                    LED3_ON

//白(红+绿+蓝)
#define LED_WHITE    \
                    LED1_ON;\
                    LED2_ON\
                    LED3_ON

//黑(全部关闭)
#define LED_RGBOFF    \
                    LED1_OFF;\
                    LED2_OFF\
                    LED3_OFF

void LED_GPIO_Config(void);

#endif /* __LED_H */

bsp_led.c

/**
  ******************************************************************************
  * @file    bsp_led.c
  * @author  fire
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   led应用函数接口
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */

#include "./led/bsp_led.h"   

 /**
  * @brief  初始化控制LED的IO
  * @param  无
  * @retval 无
  */
void LED_GPIO_Config(void)
{        
        /*定义一个GPIO_InitTypeDef类型的结构体*/
        GPIO_InitTypeDef GPIO_InitStructure;

        /*开启LED相关的GPIO外设时钟*/
        RCC_APB2PeriphClockCmd( LED1_GPIO_CLK | LED2_GPIO_CLK | LED3_GPIO_CLK, ENABLE);
        /*选择要控制的GPIO引脚*/
        GPIO_InitStructure.GPIO_Pin = LED1_GPIO_PIN;    

        /*设置引脚模式为通用推挽输出*/
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   

        /*设置引脚速率为50MHz */   
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; 

        /*调用库函数,初始化GPIO*/
        GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);    

        /*选择要控制的GPIO引脚*/
        GPIO_InitStructure.GPIO_Pin = LED2_GPIO_PIN;

        /*调用库函数,初始化GPIO*/
        GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);

        /*选择要控制的GPIO引脚*/
        GPIO_InitStructure.GPIO_Pin = LED3_GPIO_PIN;

        /*调用库函数,初始化GPIOF*/
        GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);

        /* 关闭所有led灯    */
        GPIO_SetBits(LED1_GPIO_PORT, LED1_GPIO_PIN);

        /* 关闭所有led灯    */
        GPIO_SetBits(LED2_GPIO_PORT, LED2_GPIO_PIN);     

    /* 关闭所有led灯    */
        GPIO_SetBits(LED3_GPIO_PORT, LED3_GPIO_PIN);
}

/*********************************************END OF FILE**********************/

main.c

/**
  ******************************************************************************
  * @file    main.c
  * @author  fire
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   AT24C02测试(软件模拟I2C)
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */

#include "stm32f10x.h"
#include "./usart/bsp_usart.h"
#include "./led/bsp_led.h" 
#include "./i2c/bsp_i2c_ee.h"

 /**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{

    LED_GPIO_Config();

    LED_BLUE;

    /* 串口初始化 */
        USART_Config();

        printf("eeprom 软件模拟i2c测试例程 \r\n");        

    if(ee_Test() == 1)
      {
            LED_GREEN;
    }
    else
    {
        LED_RED;
    }
    while(1);
}
/*********************************************END OF FILE**********************/

教程:https://www.bilibili.com/video/BV1yW411Y7Gw?p=53
模拟i2c.zip

I2C-存储小数

bsp_i2c_ee.h

#ifndef __I2C_EE_H
#define    __I2C_EE_H


#include "stm32f10x.h"


/**************************I2C参数定义,I2C1或I2C2********************************/
#define             EEPROM_I2Cx                                I2C1
#define             EEPROM_I2C_APBxClock_FUN                   RCC_APB1PeriphClockCmd
#define             EEPROM_I2C_CLK                             RCC_APB1Periph_I2C1
#define             EEPROM_I2C_GPIO_APBxClock_FUN              RCC_APB2PeriphClockCmd
#define             EEPROM_I2C_GPIO_CLK                        RCC_APB2Periph_GPIOB     
#define             EEPROM_I2C_SCL_PORT                        GPIOB   
#define             EEPROM_I2C_SCL_PIN                         GPIO_Pin_6
#define             EEPROM_I2C_SDA_PORT                        GPIOB 
#define             EEPROM_I2C_SDA_PIN                         GPIO_Pin_7


/*等待超时时间*/
#define I2CT_FLAG_TIMEOUT         ((uint32_t)0x1000)
#define I2CT_LONG_TIMEOUT         ((uint32_t)(10 * I2CT_FLAG_TIMEOUT))


/*信息输出*/
#define EEPROM_DEBUG_ON         0

#define EEPROM_INFO(fmt,arg...)           printf("<<-EEPROM-INFO->> "fmt"\n",##arg)
#define EEPROM_ERROR(fmt,arg...)          printf("<<-EEPROM-ERROR->> "fmt"\n",##arg)
#define EEPROM_DEBUG(fmt,arg...)          do{\
                                          if(EEPROM_DEBUG_ON)\
                                          printf("<<-EEPROM-DEBUG->> [%d]"fmt"\n",__LINE__, ##arg);\
                                          }while(0)


/* 
 * AT24C02 2kb = 2048bit = 2048/8 B = 256 B
 * 32 pages of 8 bytes each
 *
 * Device Address
 * 1 0 1 0 A2 A1 A0 R/W
 * 1 0 1 0 0  0  0  0 = 0XA0
 * 1 0 1 0 0  0  0  1 = 0XA1 
 */

/* EEPROM Addresses defines */
#define EEPROM_Block0_ADDRESS 0xA0   /* E2 = 0 */
//#define EEPROM_Block1_ADDRESS 0xA2 /* E2 = 0 */
//#define EEPROM_Block2_ADDRESS 0xA4 /* E2 = 0 */
//#define EEPROM_Block3_ADDRESS 0xA6 /* E2 = 0 */


void I2C_EE_Init(void);
void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite);
uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr);
uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite);
uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead);
void I2C_EE_WaitEepromStandbyState(void);


#endif /* __I2C_EE_H */

bsp_i2c_ee.c

/**
  ******************************************************************************
  * @file    bsp_i2c_ee.c
  * @author  STMicroelectronics
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   i2c EEPROM(AT24C02)应用函数bsp
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */ 

#include "./i2c/bsp_i2c_ee.h"
#include "./usart/bsp_usart.h"        

/* STM32 I2C 快速模式 */
#define I2C_Speed              400000  //*

/* 这个地址只要与STM32外挂的I2C器件地址不一样即可 */
#define I2Cx_OWN_ADDRESS7      0X0A   

/* AT24C01/02每页有8个字节 */
#define I2C_PageSize           8

/* AT24C04/08A/16A每页有16个字节 */
//#define I2C_PageSize           16    


uint16_t EEPROM_ADDRESS;

static __IO uint32_t  I2CTimeout = I2CT_LONG_TIMEOUT;   


static uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode);


/**
  * @brief  I2C I/O配置
  * @param  无
  * @retval 无
  */
static void I2C_GPIO_Config(void)
{
  GPIO_InitTypeDef  GPIO_InitStructure; 

    /* 使能与 I2C 有关的时钟 */
    EEPROM_I2C_APBxClock_FUN ( EEPROM_I2C_CLK, ENABLE );
    EEPROM_I2C_GPIO_APBxClock_FUN ( EEPROM_I2C_GPIO_CLK, ENABLE );


  /* I2C_SCL、I2C_SDA*/
  GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SCL_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;           // 开漏输出
  GPIO_Init(EEPROM_I2C_SCL_PORT, &GPIO_InitStructure);

  GPIO_InitStructure.GPIO_Pin = EEPROM_I2C_SDA_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;           // 开漏输出
  GPIO_Init(EEPROM_I2C_SDA_PORT, &GPIO_InitStructure);    


}


/**
  * @brief  I2C 工作模式配置
  * @param  无
  * @retval 无
  */
static void I2C_Mode_Configu(void)
{
  I2C_InitTypeDef  I2C_InitStructure; 

  /* I2C 配置 */
  I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;

    /* 高电平数据稳定,低电平数据变化 SCL 时钟线的占空比 */
  I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;

  I2C_InitStructure.I2C_OwnAddress1 =I2Cx_OWN_ADDRESS7; 
  I2C_InitStructure.I2C_Ack = I2C_Ack_Enable ;

    /* I2C的寻址模式 */
  I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;

    /* 通信速率 */
  I2C_InitStructure.I2C_ClockSpeed = I2C_Speed;

    /* I2C 初始化 */
  I2C_Init(EEPROM_I2Cx, &I2C_InitStructure);

    /* 使能 I2C */
  I2C_Cmd(EEPROM_I2Cx, ENABLE);   
}


/**
  * @brief  I2C 外设(EEPROM)初始化
  * @param  无
  * @retval 无
  */
void I2C_EE_Init(void)
{

  I2C_GPIO_Config(); 

  I2C_Mode_Configu();

/* 根据头文件i2c_ee.h中的定义来选择EEPROM要写入的地址 */
#ifdef EEPROM_Block0_ADDRESS
  /* 选择 EEPROM Block0 来写入 */
  EEPROM_ADDRESS = EEPROM_Block0_ADDRESS;
#endif

#ifdef EEPROM_Block1_ADDRESS  
  /* 选择 EEPROM Block1 来写入 */
  EEPROM_ADDRESS = EEPROM_Block1_ADDRESS;
#endif

#ifdef EEPROM_Block2_ADDRESS  
  /* 选择 EEPROM Block2 来写入 */
  EEPROM_ADDRESS = EEPROM_Block2_ADDRESS;
#endif

#ifdef EEPROM_Block3_ADDRESS  
  /* 选择 EEPROM Block3 来写入 */
  EEPROM_ADDRESS = EEPROM_Block3_ADDRESS;
#endif
}


/**
  * @brief   将缓冲区中的数据写到I2C EEPROM中
  * @param   
  *        @arg pBuffer:缓冲区指针
  *        @arg WriteAddr:写地址
  *     @arg NumByteToWrite:写的字节数
  * @retval  无
  */
void I2C_EE_BufferWrite(u8* pBuffer, u8 WriteAddr, u16 NumByteToWrite)
{
  u8 NumOfPage = 0, NumOfSingle = 0, Addr = 0, count = 0;

  Addr = WriteAddr % I2C_PageSize;
  count = I2C_PageSize - Addr;
  NumOfPage =  NumByteToWrite / I2C_PageSize;
  NumOfSingle = NumByteToWrite % I2C_PageSize;

  /* If WriteAddr is I2C_PageSize aligned  */
  if(Addr == 0) 
  {
    /* If NumByteToWrite < I2C_PageSize */
    if(NumOfPage == 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    /* If NumByteToWrite > I2C_PageSize */
    else  
    {
      while(NumOfPage--)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize); 
        I2C_EE_WaitEepromStandbyState();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;
      }

      if(NumOfSingle!=0)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
        I2C_EE_WaitEepromStandbyState();
      }
    }
  }
  /* If WriteAddr is not I2C_PageSize aligned  */
  else 
  {
    /* If NumByteToWrite < I2C_PageSize */
    if(NumOfPage== 0) 
    {
      I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
      I2C_EE_WaitEepromStandbyState();
    }
    /* If NumByteToWrite > I2C_PageSize */
    else
    {
      NumByteToWrite -= count;
      NumOfPage =  NumByteToWrite / I2C_PageSize;
      NumOfSingle = NumByteToWrite % I2C_PageSize;    

      if(count != 0)
      {  
        I2C_EE_PageWrite(pBuffer, WriteAddr, count);
        I2C_EE_WaitEepromStandbyState();
        WriteAddr += count;
        pBuffer += count;
      } 

      while(NumOfPage--)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_PageSize);
        I2C_EE_WaitEepromStandbyState();
        WriteAddr +=  I2C_PageSize;
        pBuffer += I2C_PageSize;  
      }
      if(NumOfSingle != 0)
      {
        I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle); 
        I2C_EE_WaitEepromStandbyState();
      }
    }
  }  
}


/**
  * @brief   写一个字节到I2C EEPROM中
  * @param   
  *        @arg pBuffer:缓冲区指针
  *        @arg WriteAddr:写地址 
  * @retval  无
  */
uint32_t I2C_EE_ByteWrite(u8* pBuffer, u8 WriteAddr) 
{
  /* Send STRAT condition */
  I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);

  I2CTimeout = I2CT_FLAG_TIMEOUT;  
  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))  
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(0);
  } 

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);

  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(1);
  }  
  /* Send the EEPROM's internal address to write to */
  I2C_SendData(EEPROM_I2Cx, WriteAddr);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(2);
  } 

  /* Send the byte to be written */
  I2C_SendData(EEPROM_I2Cx, *pBuffer); 

  I2CTimeout = I2CT_FLAG_TIMEOUT;  
  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
  } 

  /* Send STOP condition */
  I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);

  return 1;
}


/**
  * @brief   在EEPROM的一个写循环中可以写多个字节,但一次写入的字节数
  *          不能超过EEPROM页的大小,AT24C02每页有8个字节
  * @param   
  *        @arg pBuffer:缓冲区指针
  *        @arg WriteAddr:写地址
  *     @arg NumByteToWrite:写的字节数
  * @retval  无
  */
uint32_t I2C_EE_PageWrite(u8* pBuffer, u8 WriteAddr, u8 NumByteToWrite)
{
  I2CTimeout = I2CT_LONG_TIMEOUT;

  while(I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))   
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(4);
  } 

  /* Send START condition */
  I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))  
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(5);
  } 

  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))  
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(6);
  } 

  /* Send the EEPROM's internal address to write to */    
  I2C_SendData(EEPROM_I2Cx, WriteAddr);  

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(! I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(7);
  } 

  /* While there is data to be written */
  while(NumByteToWrite--)  
  {
    /* Send the current byte */
    I2C_SendData(EEPROM_I2Cx, *pBuffer); 

    /* Point to the next byte to be written */
    pBuffer++; 

    I2CTimeout = I2CT_FLAG_TIMEOUT;

    /* Test on EV8 and clear it */
    while (!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
    {
      if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(8);
    } 
  }

  /* Send STOP condition */
  I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);

  return 1;
}


/**
  * @brief   从EEPROM里面读取一块数据 
  * @param   
  *        @arg pBuffer:存放从EEPROM读取的数据的缓冲区指针
  *        @arg WriteAddr:接收数据的EEPROM的地址
  *     @arg NumByteToWrite:要从EEPROM读取的字节数
  * @retval  无
  */
uint32_t I2C_EE_BufferRead(u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
{  

  I2CTimeout = I2CT_LONG_TIMEOUT;

  //*((u8 *)0x4001080c) |=0x80; 
  while(I2C_GetFlagStatus(EEPROM_I2Cx, I2C_FLAG_BUSY))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(9);
   }

  /* Send START condition */
  I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
  //*((u8 *)0x4001080c) &=~0x80;

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(10);
   }

  /* Send EEPROM address for write */
  I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(11);
   }

  /* Clear EV6 by setting again the PE bit */
  I2C_Cmd(EEPROM_I2Cx, ENABLE);

  /* Send the EEPROM's internal address to write to */
  I2C_SendData(EEPROM_I2Cx, ReadAddr);  


  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(12);
   }

  /* Send STRAT condition a second time */  
  I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_MODE_SELECT))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(13);
   }

  /* Send EEPROM address for read */
  I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Receiver);

  I2CTimeout = I2CT_FLAG_TIMEOUT;
  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED))
  {
    if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(14);
   }

  /* While there is data to be read */
  while(NumByteToRead)  
  {
    if(NumByteToRead == 1)
    {
      /* Disable Acknowledgement */
      I2C_AcknowledgeConfig(EEPROM_I2Cx, DISABLE);

      /* Send STOP Condition */
      I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE);
    }

    /* Test on EV7 and clear it */    
    I2CTimeout = I2CT_LONG_TIMEOUT;

    while(I2C_CheckEvent(EEPROM_I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED)==0)  
    {
        if((I2CTimeout--) == 0) return I2C_TIMEOUT_UserCallback(3);
    } 
    {      
      /* Read a byte from the EEPROM */
      *pBuffer = I2C_ReceiveData(EEPROM_I2Cx);

      /* Point to the next location where the byte read will be saved */
      pBuffer++; 

      /* Decrement the read bytes counter */
      NumByteToRead--;        
    }   
  }

  /* Enable Acknowledgement to be ready for another reception */
  I2C_AcknowledgeConfig(EEPROM_I2Cx, ENABLE);

    return 1;
}


/**
  * @brief  Wait for EEPROM Standby state 
  * @param  无
  * @retval 无
  */
void I2C_EE_WaitEepromStandbyState(void)      
{
  u16 SR1_Tmp = 0;

  do
  {
    /* Send START condition */
    I2C_GenerateSTART(EEPROM_I2Cx, ENABLE);
    /* Read I2C1 SR1 register */
    SR1_Tmp = I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1);
    /* Send EEPROM address for write */
    I2C_Send7bitAddress(EEPROM_I2Cx, EEPROM_ADDRESS, I2C_Direction_Transmitter);
  }while(!(I2C_ReadRegister(EEPROM_I2Cx, I2C_Register_SR1) & 0x0002));

  /* Clear AF flag */
  I2C_ClearFlag(EEPROM_I2Cx, I2C_FLAG_AF);
  /* STOP condition */    
  I2C_GenerateSTOP(EEPROM_I2Cx, ENABLE); 
}




/**
  * @brief  Basic management of the timeout situation.
  * @param  errorCode:错误代码,可以用来定位是哪个环节出错.
  * @retval 返回0,表示IIC读取失败.
  */
static  uint32_t I2C_TIMEOUT_UserCallback(uint8_t errorCode)
{
  /* Block communication and all processes */
  EEPROM_ERROR("I2C 等待超时!errorCode = %d",errorCode);

  return 0;
}
/*********************************************END OF FILE**********************/

main.c

/**
  ******************************************************************************
  * @file    main.c
  * @author  fire
  * @version V1.0
  * @date    2013-xx-xx
  * @brief   I2C EEPROM(AT24C02)测试,存储小数
  ******************************************************************************
  * @attention
  *
  * 实验平台:野火 F103-霸道 STM32 开发板 
  * 论坛    :http://www.firebbs.cn
  * 淘宝    :https://fire-stm32.taobao.com
  *
  ******************************************************************************
  */

#include "stm32f10x.h"
#include "./usart/bsp_usart.h"
#include "./i2c/bsp_i2c_ee.h"
#include "./led/bsp_led.h"
#include <string.h>


uint8_t cal_flag = 0;
uint8_t k;

/*存储小数和整数的数组,各7个*/
long double double_buffer[7] = {0};
int int_bufffer[7] = {0};

#define DOUBLE_ADDR       10
#define LONGINT_ADDR      70

/**
  * @brief  主函数
  * @param  无
  * @retval 无
  */
int main(void)
{ 
    LED_GPIO_Config();

    /* 串口初始化 */
    USART_Config();

    printf("\r\n 这是一个EEPROM 读写小数和长整数实验 \r\n");

    /* I2C 外设初(AT24C02)始化 */
    I2C_EE_Init();          


      /*读取数据标志位*/
    I2C_EE_BufferRead(&cal_flag, 0, 1);

    if( cal_flag != 0xCD )    /*若标志等于0xcd,表示之前已有写入数据*/
    {      
        printf("\r\n没有检测到数据标志,FLASH没有存储数据,即将进行小数写入实验\r\n");
        cal_flag =0xCD;

        /*写入标志到0地址*/
        I2C_EE_BufferWrite(&cal_flag, 0, 1); 

        /*生成要写入的数据*/
        for( k=0; k<7; k++ )
        {
           double_buffer[k] = k +0.1;
           int_bufffer[k]=k*500+1 ;
        }

        /*写入小数数据到地址10*/
        I2C_EE_BufferWrite((void*)double_buffer,DOUBLE_ADDR, sizeof(double_buffer));
        /*写入整数数据到地址60*/
        I2C_EE_BufferWrite((void*)int_bufffer, LONGINT_ADDR, sizeof(int_bufffer));

        printf("向芯片写入数据:");
        /*打印到串口*/
        for( k=0; k<7; k++ )
        {
          printf("小数tx = %LF\r\n",double_buffer[k]);
          printf("整数tx = %d\r\n",int_bufffer[k]);
        }

        printf("\r\n请复位开发板,以读取数据进行检验\r\n");      

    }    
    else
    {      
           printf("\r\n检测到数据标志\r\n");

        /*读取小数数据*/
        I2C_EE_BufferRead((void*)double_buffer, DOUBLE_ADDR, sizeof(double_buffer));

        /*读取整数数据*/
        I2C_EE_BufferRead((void*)int_bufffer, LONGINT_ADDR, sizeof(int_bufffer));


        printf("\r\n从芯片读到数据:\r\n");            
        for( k=0; k<7; k++ )
        {
            printf("小数 rx = %LF \r\n",double_buffer[k]);
            printf("整数 rx = %d \r\n",int_bufffer[k]);                
        }

    }   


  while (1)
  {      
  }
}

/*********************************************END OF FILE**********************/

教程:https://www.bilibili.com/video/BV1yW411Y7Gw?p=54
AT24C02存储小数.zip