针对这种EEPROM器件，根据芯片手册配置，不超过16字节读写正常，超过就不对，会覆盖之前的内容，就是说永远只写前16个地址，后面的地址没有写上，看了半天也不知道是怎么回事？有没有哪位用过，给个提示。主控制器用的STM32F103。读写控制代码如下：#define         ADDR_24LC02_Write         0xA0
#define         ADDR_24LC02_Read         0xA1
#define         BufferSize                         34       


HAL_I2C_Mem_Write(&hi2c2, ADDR_24LC02_Write, 0, I2C_MEMADD_SIZE_8BIT, WriteBuffer, BufferSize, 0x10);
HAL_I2C_Mem_Read(&hi2c2, ADDR_24LC02_Read, 0, I2C_MEMADD_SIZE_8BIT, ReadBuffer, BufferSize, 0x10);


WriteBuffer写入数据依次为1-34；ReadBuffer读取仅有33,34,19,20,21,22,23,24,25,26,27,28,29,30,31,32。只能读到16个地址数，我认为是写的时候只写了16个地址，数据一直在前16个地址上覆盖。

EEPROM不能直接跨页写，要跨页的话，得重新指定一次新的页地址，同时得有一次停止位。
理解一下这段代码，其中NumOfPage、NumOfSingle两个变量，以及I2C_FLASH_PAGESIZE。

1. /**
   
2.   * @brief  Writes buffer of data to the I2C EEPROM.
   
3.   * @param  pBuffer : pointer to the buffer  containing the data to be
   
4.   *   written to the EEPROM.
   
5.   * @param  WriteAddr : EEPROM's internal address to write to.
   
6.   * @param  NumByteToWrite : number of bytes to write to the EEPROM.
   
7.   * @retval None
   
8.   */
   
9. void I2C_EE_BufferWrite(uint8_t* pBuffer, uint16_t WriteAddr, uint16_t NumByteToWrite)
   
10. {
    
11.   uint8_t NumOfPage = 0, NumOfSingle = 0, count = 0;
    
12.   uint16_t Addr = 0;
    
13. 
    
14.   Addr = WriteAddr % I2C_FLASH_PAGESIZE;
    
15.   count = I2C_FLASH_PAGESIZE - Addr;
    
16.   NumOfPage =  NumByteToWrite / I2C_FLASH_PAGESIZE;
    
17.   NumOfSingle = NumByteToWrite % I2C_FLASH_PAGESIZE;
    
18. 
    
19.   /* If WriteAddr is I2C_FLASH_PAGESIZE aligned  */
    
20.   if(Addr == 0)
    
21.   {
    
22.     /* If NumByteToWrite < I2C_FLASH_PAGESIZE */
    
23.     if(NumOfPage == 0)
    
24.     {
    
25.       I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    
26.       I2C_EE_WaitEepromStandbyState();
    
27.     }
    
28.     /* If NumByteToWrite > I2C_FLASH_PAGESIZE */
    
29.     else  
    
30.     {
    
31.       while(NumOfPage--)
    
32.       {
    
33.         I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_FLASH_PAGESIZE);
    
34.         I2C_EE_WaitEepromStandbyState();
    
35.         WriteAddr +=  I2C_FLASH_PAGESIZE;
    
36.         pBuffer += I2C_FLASH_PAGESIZE;
    
37.       }
    
38. 
    
39.       if(NumOfSingle!=0)
    
40.       {
    
41.         I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    
42.         I2C_EE_WaitEepromStandbyState();
    
43.       }
    
44.     }
    
45.   }
    
46.   /* If WriteAddr is not I2C_FLASH_PAGESIZE aligned  */
    
47.   else
    
48.   {
    
49.     /* If NumByteToWrite < I2C_FLASH_PAGESIZE */
    
50.     if(NumOfPage== 0)
    
51.     {
    
52.       /* If the number of data to be written is more than the remaining space
    
53.       in the current page: */
    
54.       if (NumByteToWrite > count)
    
55.       {
    
56.         /* Write the data conained in same page */
    
57.         I2C_EE_PageWrite(pBuffer, WriteAddr, count);
    
58.         I2C_EE_WaitEepromStandbyState();      
    
59.         
    
60.         /* Write the remaining data in the following page */
    
61.         I2C_EE_PageWrite((uint8_t*)(pBuffer + count), (WriteAddr + count), (NumByteToWrite - count));
    
62.         I2C_EE_WaitEepromStandbyState();        
    
63.       }      
    
64.       else      
    
65.       {
    
66.         I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    
67.         I2C_EE_WaitEepromStandbyState();        
    
68.       }     
    
69.     }
    
70.     /* If NumByteToWrite > I2C_FLASH_PAGESIZE */
    
71.     else
    
72.     {
    
73.       NumByteToWrite -= count;
    
74.       NumOfPage =  NumByteToWrite / I2C_FLASH_PAGESIZE;
    
75.       NumOfSingle = NumByteToWrite % I2C_FLASH_PAGESIZE;
    
76.       
    
77.       if(count != 0)
    
78.       {  
    
79.         I2C_EE_PageWrite(pBuffer, WriteAddr, count);
    
80.         I2C_EE_WaitEepromStandbyState();
    
81.         WriteAddr += count;
    
82.         pBuffer += count;
    
83.       }
    
84.       
    
85.       while(NumOfPage--)
    
86.       {
    
87.         I2C_EE_PageWrite(pBuffer, WriteAddr, I2C_FLASH_PAGESIZE);
    
88.         I2C_EE_WaitEepromStandbyState();
    
89.         WriteAddr +=  I2C_FLASH_PAGESIZE;
    
90.         pBuffer += I2C_FLASH_PAGESIZE;  
    
91.       }
    
92.       if(NumOfSingle != 0)
    
93.       {
    
94.         I2C_EE_PageWrite(pBuffer, WriteAddr, NumOfSingle);
    
95.         I2C_EE_WaitEepromStandbyState();
    
96.       }
    
97.     }
    
98.   }  
    
99. }
    
100. 
     
101. /**
     
102.   * @brief  Writes more than one byte to the EEPROM with a single WRITE cycle.
     
103.   * @note   The number of byte can't exceed the EEPROM page size.
     
104.   * @param  pBuffer : pointer to the buffer containing the data to be
     
105.   *   written to the EEPROM.
     
106.   * @param  WriteAddr : EEPROM's internal address to write to.
     
107.   * @param  NumByteToWrite : number of bytes to write to the EEPROM.
     
108.   * @retval None
     
109.   */
     
110. void I2C_EE_PageWrite(uint8_t* pBuffer, uint16_t WriteAddr, uint8_t NumByteToWrite)
     
111. {
     
112.   /* While the bus is busy */
     
113.   while(I2C_GetFlagStatus(I2C_EE, I2C_FLAG_BUSY));
     
114.   
     
115.   /* Send START condition */
     
116.   I2C_GenerateSTART(I2C_EE, ENABLE);
     
117.   
     
118.   /* Test on EV5 and clear it */
     
119.   while(!I2C_CheckEvent(I2C_EE, I2C_EVENT_MASTER_MODE_SELECT));
     
120.   
     
121.   /* Send EEPROM address for write */
     
122.   I2C_Send7bitAddress(I2C_EE, EEPROM_ADDRESS, I2C_Direction_Transmitter);
     
123. 
     
124.   /* Test on EV6 and clear it */
     
125.   while(!I2C_CheckEvent(I2C_EE, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));  
     
126. 
     
127. #ifdef EE_M24C08
     
128.   
     
129.   /* Send the EEPROM's internal address to write to : only one byte Address */
     
130.   I2C_SendData(I2C_EE, WriteAddr);
     
131.   
     
132. #elif defined(EE_M24C64_32)
     
133.   
     
134.   /* Send the EEPROM's internal address to write to : MSB of the address first */
     
135.   I2C_SendData(I2C_EE, (uint8_t)((WriteAddr & 0xFF00) >> 8));
     
136. 
     
137.   /* Test on EV8 and clear it */
     
138.   while(!I2C_CheckEvent(I2C_EE, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
     
139.   
     
140.   /* Send the EEPROM's internal address to write to : LSB of the address */
     
141.   I2C_SendData(I2C_EE, (uint8_t)(WriteAddr & 0x00FF));
     
142.   
     
143. #endif /* EE_M24C08 */  
     
144. 
     
145.   /* Test on EV8 and clear it */
     
146.   while(! I2C_CheckEvent(I2C_EE, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
     
147. 
     
148.   /* While there is data to be written */
     
149.   while(NumByteToWrite--)  
     
150.   {
     
151.     /* Send the current byte */
     
152.     I2C_SendData(I2C_EE, *pBuffer);
     
153. 
     
154.     /* Point to the next byte to be written */
     
155.     pBuffer++;
     
156.   
     
157.     /* Test on EV8 and clear it */
     
158.     while (!I2C_CheckEvent(I2C_EE, I2C_EVENT_MASTER_BYTE_TRANSMITTED));
     
159.   }
     
160. 
     
161.   /* Send STOP condition */
     
162.   I2C_GenerateSTOP(I2C_EE, ENABLE);
     
163. }
     
164. 
     
165. /**
     
166.   * @brief  Wait for EEPROM Standby state
     
167.   * @param  None
     
168.   * @retval None
     
169.   */
     
170. void I2C_EE_WaitEepromStandbyState(void)      
     
171. {
     
172.   __IO uint16_t SR1_Tmp = 0;
     
173. 
     
174.   do
     
175.   {
     
176.     /* Send START condition */
     
177.     I2C_GenerateSTART(I2C_EE, ENABLE);
     
178. 
     
179.     /* Read I2C_EE SR1 register to clear pending flags */
     
180.     SR1_Tmp = I2C_ReadRegister(I2C_EE, I2C_Register_SR1);
     
181. 
     
182.     /* Send EEPROM address for write */
     
183.     I2C_Send7bitAddress(I2C_EE, EEPROM_ADDRESS, I2C_Direction_Transmitter);
     
184. 
     
185.   }while(!(I2C_ReadRegister(I2C_EE, I2C_Register_SR1) & 0x0002));
     
186.   
     
187.   /* Clear AF flag */
     
188.   I2C_ClearFlag(I2C_EE, I2C_FLAG_AF);
     
189.   
     
190.   /* STOP condition */   
     
191.   I2C_GenerateSTOP(I2C_EE, ENABLE);  
     
192. }

复制代码

仔细看一下那两个读写函数  最后那个0x10应该是数据长度  改一下就好了

mylovemcu 发表于 2020-4-26 09:15
仔细看一下那两个读写函数  最后那个0x10应该是数据长度  改一下就好了

HAL_StatusTypeDef HAL_I2C_Mem_Write(I2C_HandleTypeDef *hi2c, uint16_t DevAddress, uint16_t MemAddress, uint16_t MemAddSize, uint8_t *pData, uint16_t Size, uint32_t Timeout)
最后那个是超时吧... ...

toofree 发表于 2020-4-26 09:11
EEPROM不能直接跨页写，要跨页的话，得重新指定一次新的页地址，同时得有一次停止位。
理解一下这段代码， ...

围观大佬

if(HAL_I2C_Mem_Write(&hi2c2, ADDR_24LC02_Write, 0, I2C_MEMADD_SIZE_8BIT, WriteBuffer, 16, 0x10) == HAL_OK)
                {
                        HAL_Delay(10);               
               
                        if(HAL_I2C_Mem_Write(&hi2c2, ADDR_24LC02_Write, 16, I2C_MEMADD_SIZE_8BIT, WriteBuffer+16, 16, 0x10) == HAL_OK)
                        {
                                HAL_Delay(10);
                               
                                if(HAL_I2C_Mem_Write(&hi2c2, ADDR_24LC02_Write, 32, I2C_MEMADD_SIZE_8BIT, WriteBuffer+32, 16, 0x10) == HAL_OK)
                                {
                                        HAL_Delay(10);
                                }
                        }
                }
我想了一个最简单的办法，适合不需要太多存储的情况，既然不能跨页连写，那么我就采用随机写，连续读的方式，就不用修改那么多。

楼主，注意看手册中E2的每页大小，页数。写入的时候需要换页，读取可以不用。

EEPROM参数里有个页写时间，一般是5ms，意思是每次写换页要等5ms才能切换下一页，所以写要注意时序。读没要求。

EEPROM参数里有个页写时间，一般是5ms，意思是每次写换页要等5ms才能切换下一页，所以写要注意时序。读没要求。

Dandjinh 发表于 2020-4-26 10:36
EEPROM参数里有个页写时间，一般是5ms，意思是每次写换页要等5ms才能切换下一页，所以写要注意时序。读没要 ...

意思是写完一次后加长HAL_Delay时间？

toofree 发表于 2020-4-26 09:11
EEPROM不能直接跨页写，要跨页的话，得重新指定一次新的页地址，同时得有一次停止位。
理解一下这段代码， ...

这个是以前的库吧，我现在用HAL库，是不是就很难移植了

新手上路

toofree 发表于 2020-4-26 09:11
EEPROM不能直接跨页写，要跨页的话，得重新指定一次新的页地址，同时得有一次停止位。
理解一下这段代码， ...

官方IIC好用不

likang1202 发表于 2020-4-27 18:10
官方IIC好用不

好用啊，
对于EEPROM操作，5ms的延时最重要，一定要数据对照手册。