【MCXC444分享】eeprom读写测试

TLLED

测试I2C读写EEPROM存储器AT24C02。

一、硬件部分

1.1、测试使用扩展板EEPROM部分电路



1.2、连接到开发板的对应的接口



1.3、硬件连接图


二、程序部分

2.1、配置I2C1端口
PTE0和PTE1对应的接口是I2C1，在软件中配置I2C1接口。


2.2、at24cxx.c

1. #include "pin_mux.h"
   
2. #include "fsl_debug_console.h"
   
3. #include "fsl_i2c.h"
   
4. #include "i2c/bsp_i2c.h"
   
5. #include "i2c/at24cxx.h"
   
6. #include "systick/systick.h"
   
7. 
   
8. #define I2C_PAGE_SIZE       8
   
9. #define I2C_AT24_BASEADDR                           I2C1
   
10. #define I2C_AT24_CLOCK_FREQ                         CLOCK_GetFreq(I2C1_CLK_SRC)
    
11. 
    
12. const uint8_t i2c_at24cxx_address = (0xA0>>1);
    
13. 
    
14. at24cxx_config_t atconfig        = {0};
    
15. at24cxx_handle_t at24Handle    = {0};
    
16. 
    
17. status_t AT24_ReadReg(at24cxx_handle_t *handle, uint8_t reg, uint8_t *val, uint32_t bytesNumber)
    
18. {
    
19.     assert(handle != NULL);
    
20.     assert(val != NULL);
    
21. 
    
22.     if ((handle->I2C_ReceiveFunc) == NULL)
    
23.     {
    
24.         return kStatus_Fail;
    
25.     }
    
26.     else
    
27.     {
    
28.         return handle->I2C_ReceiveFunc(handle->slaveAddress, reg, 1, val, bytesNumber);
    
29.     }
    
30. }
    
31. 
    
32. status_t AT24_WriteReg(at24cxx_handle_t *handle, uint8_t addr, uint8_t *val, uint32_t len)
    
33. {
    
34.     assert(handle != NULL);
    
35. 
    
36.     if ((handle->I2C_SendFunc) == NULL)
    
37.     {
    
38.         return kStatus_Fail;
    
39.     }
    
40.     else
    
41.     {
    
42.         return handle->I2C_SendFunc(handle->slaveAddress, addr, 1, val, len);
    
43.     }
    
44. }
    
45. status_t AT24_Init(at24cxx_handle_t *at24_handle, at24cxx_config_t *config)
    
46. {
    
47.         assert(at24_handle != NULL);
    
48.         assert(config != NULL);
    
49.         assert(config->I2C_SendFunc != NULL);
    
50.         assert(config->I2C_ReceiveFunc != NULL);
    
51. 
    
52.         uint8_t tmp[1] = {0};
    
53. 
    
54.         /* Initialize the I2C access function. */
    
55.         at24_handle->I2C_SendFunc    = config->I2C_SendFunc;
    
56.         at24_handle->I2C_ReceiveFunc = config->I2C_ReceiveFunc;
    
57.         /* Set Slave Address. */
    
58.         at24_handle->slaveAddress = config->slaveAddress;
    
59.         
    
60.         return kStatus_Success;
    
61. }
    
62. 
    
63. status_t i2c_at24cxx_send(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *txBuff, uint32_t txBuffSize)
    
64. {
    
65.         return I2C_Send(I2C_AT24_BASEADDR, deviceAddress, subAddress, subaddressSize, txBuff, txBuffSize);
    
66. }
    
67. 
    
68. 
    
69. status_t i2c_at24cxx_receive(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *rxBuff, uint32_t rxBuffSize)
    
70. {
    
71.     return I2C_Receive(I2C_AT24_BASEADDR, deviceAddress, subAddress, subaddressSize, rxBuff, rxBuffSize);
    
72. }
    
73. 
    
74. 
    
75. int at24cxx_read(uint32_t addr, uint8_t *buf, uint32_t len)
    
76. {
    
77.         return AT24_ReadReg(&at24Handle, addr, buf, len);
    
78. }
    
79. 
    
80. int at24cxx_write_page(uint32_t addr, uint8_t *buf, uint32_t len)
    
81. {
    
82.         return AT24_WriteReg(&at24Handle, addr, buf, len);
    
83. }
    
84. 
    
85. void at24cxx_write(uint32_t write_address, uint8_t *p_buffer, uint32_t number_of_byte)
    
86. {
    
87.         uint8_t number_of_page = 0, number_of_single = 0, address = 0, count = 0;
    
88. 
    
89.         address = write_address % I2C_PAGE_SIZE;
    
90.         count = I2C_PAGE_SIZE - address;
    
91.         number_of_page =  number_of_byte / I2C_PAGE_SIZE;
    
92.         number_of_single = number_of_byte % I2C_PAGE_SIZE;
    
93.         
    
94.         /* if write_address is I2C_PAGE_SIZE aligned */
    
95.         if(0 == address)
    
96.         {
    
97.                 while(number_of_page--)
    
98.                 {
    
99.                         at24cxx_write_page(write_address, p_buffer, I2C_PAGE_SIZE);
    
100.                         SysTick_Delay_ms(10);
     
101.                         write_address +=  I2C_PAGE_SIZE;
     
102.                         p_buffer += I2C_PAGE_SIZE;
     
103.                 }
     
104.                 if(0 != number_of_single)
     
105.                 {
     
106.                         at24cxx_write_page(write_address, p_buffer, number_of_single);
     
107.                         SysTick_Delay_ms(10);
     
108.                 }
     
109.         }
     
110.         else
     
111.         {
     
112.                 /* if write_address is not I2C_PAGE_SIZE aligned */
     
113.                 if(number_of_byte < count)
     
114.                 {
     
115.                         at24cxx_write_page(write_address, p_buffer, number_of_byte);
     
116.                         SysTick_Delay_ms(10);
     
117.                 }
     
118.                 else
     
119.                 {
     
120.                         number_of_byte -= count;
     
121.                         number_of_page =  number_of_byte / I2C_PAGE_SIZE;
     
122.                         number_of_single = number_of_byte % I2C_PAGE_SIZE;
     
123.                         if(0 != count)
     
124.                         {
     
125.                                 at24cxx_write_page(write_address, p_buffer, count);
     
126.                                 SysTick_Delay_ms(10);
     
127.                                 write_address += count;
     
128.                                 p_buffer += count;
     
129.                         }
     
130.                         /* write page */
     
131.                         while(number_of_page--)
     
132.                         {
     
133.                                 at24cxx_write_page(write_address, p_buffer, I2C_PAGE_SIZE);
     
134.                                 SysTick_Delay_ms(10);
     
135.                                 write_address +=  I2C_PAGE_SIZE;
     
136.                                 p_buffer += I2C_PAGE_SIZE;
     
137.                         }
     
138.                         /* write single */
     
139.                         if(0 != number_of_single)
     
140.                         {
     
141.                                 at24cxx_write_page(write_address, p_buffer, number_of_single);
     
142.                                 SysTick_Delay_ms(10);
     
143.                         }
     
144.                 }
     
145.         }
     
146. }
     
147. 
     
148. void test_at24cxx(void)
     
149. {
     
150.         uint16_t i=0;
     
151.         uint8_t addr=0;
     
152.         uint8_t rxbuf[256];
     
153.         uint8_t txbuf[256];
     
154.         
     
155.         PRINTF("\r\neeprom test!\r\n");
     
156.         
     
157.         for(i=0;i<256;i++)
     
158.         {
     
159.                 txbuf[i]=i;
     
160.         }
     
161.         //write
     
162.         at24cxx_write(0x00, txbuf,256);
     
163.         
     
164.         PRINTF("\r\n write! txbuf:\r\n");
     
165.         for(i=0;i<256;i++)
     
166.         {
     
167.                 PRINTF("%d ",txbuf[i]);
     
168.         }
     
169.         PRINTF("\r\n");
     
170.         
     
171.         SysTick_Delay_ms(10);
     
172. 
     
173.         //read
     
174.         if(at24cxx_read(0x00, rxbuf, 256)!= kStatus_Success)
     
175.         {
     
176.                 PRINTF("\r\n read failed!\r\n");
     
177.         }
     
178.         else
     
179.         {
     
180.                 PRINTF("\r\nread ok! rxbuf:\r\n");
     
181.                 for(i=0;i<256;i++)
     
182.                 {
     
183.                         PRINTF("%d ",rxbuf[i]);
     
184.                 }
     
185.                 PRINTF("\r\n");
     
186.         }
     
187. }
     
188. 
     
189. int init_at24cxx(void)
     
190. {
     
191.         uint8_t i=0;
     
192.         status_t result;
     
193.         
     
194.         BOARD_I2C1_ReleaseBus();
     
195.         init_i2c1_pins();
     
196. 
     
197.         I2C_Init(I2C_AT24_BASEADDR, I2C_AT24_CLOCK_FREQ);
     
198.         
     
199.         /* Configure the I2C function */
     
200.         atconfig.I2C_SendFunc    = i2c_at24cxx_send;
     
201.         atconfig.I2C_ReceiveFunc = i2c_at24cxx_receive;
     
202.         atconfig.slaveAddress    = i2c_at24cxx_address;
     
203.         
     
204.         /* Initialize sensor devices */
     
205.         result = AT24_Init(&at24Handle, &atconfig);
     
206.         return result;
     
207. }

复制代码

2.3、at24cxx.h

1. #ifndef __24CXX_H__
   
2. #define __24CXX_H__
   
3. 
   
4. #include <stdint.h>
   
5. #include "fsl_common.h"
   
6. 
   
7. /*! @brief Define I2C access function. */
   
8. typedef status_t (*I2C_SendFunc_t)(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *txBuff, uint32_t txBuffSize);
   
9. typedef status_t (*I2C_ReceiveFunc_t)(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *rxBuff, uint32_t rxBuffSize);
   
10. 
    
11. typedef struct _at24cxx_handle
    
12. {
    
13.     /* Pointer to the user-defined I2C Send Data function. */
    
14.     I2C_SendFunc_t I2C_SendFunc;
    
15.     /* Pointer to the user-defined I2C Receive Data function. */
    
16.     I2C_ReceiveFunc_t I2C_ReceiveFunc;
    
17.     /* The I2C slave address . */
    
18.     uint8_t slaveAddress;
    
19. } at24cxx_handle_t;
    
20. 
    
21. /*! @brief at24cxx configure structure.*/
    
22. typedef struct _at24cxx_config
    
23. {
    
24.     /* Pointer to the user-defined I2C Send Data function. */
    
25.     I2C_SendFunc_t I2C_SendFunc;
    
26.     /* Pointer to the user-defined I2C Receive Data function. */
    
27.     I2C_ReceiveFunc_t I2C_ReceiveFunc;
    
28.     /* The I2C slave address. */
    
29.     uint8_t slaveAddress;
    
30. } at24cxx_config_t;
    
31. 
    
32. 
    
33. //API funtctions
    
34. int init_at24cxx(void);
    
35. void test_at24cxx(void);
    
36. int at24cxx_read(uint32_t addr, uint8_t *buf, uint32_t len);
    
37. void at24cxx_write(uint32_t write_address, uint8_t *p_buffer, uint32_t number_of_byte);
    
38. #endif
    
39. 
    

复制代码

2.4、main.c

1. #include "pin_mux.h"
   
2. #include "clock_config.h"
   
3. #include "board.h"
   
4. #include "fsl_debug_console.h"
   
5. #include "fsl_gpio.h"
   
6. #include "slcd/slcd.h"
   
7. #include "led/led.h"
   
8. #include "systick/systick.h"
   
9. #include "slcd_engine.h"
   
10. #include "adc/adc.h"
    
11. #include "i2c/eeprom.h"
    
12. #include "i2c/fxls8974.h"
    
13. #include "i2c/at24cxx.h"
    
14. #include "fsl_uart.h"
    
15. #include "stdio.h"
    
16. 
    
17. void init_board(void)
    
18. {
    
19.         
    
20.         SysTick_Init();
    
21.         BOARD_InitPins();
    
22.         BOARD_BootClockRUN();
    
23.         BOARD_InitDebugConsole();
    
24.         init_at24cxx();
    
25. }
    
26. 
    
27. int main(void)
    
28. {
    
29.         uint32_t m_adv=0;
    
30.         float vl= 0.0f;
    
31.         
    
32.         init_board();
    
33.         while (1)
    
34.         {
    
35.                 test_at24cxx();
    
36.                 SysTick_Delay_ms(1000);
    
37.         }
    
38. }
    

复制代码

三、运行结果

下载程序，串口打印读写测试数据

阅读全文