【国货之光】GD32E230F4使用硬件IIC+DMA读写24C04

#申请原创# @21小跑堂

在很久很久以前，我就写过GD32E230替换STM32F031的帖子，主要介绍了USART和SPI的外设移植开发，当时IIC使用的是软件i2c，没有介绍的价值。在使用IIC时，大多数我们都是采用软件的方式，因为软件的方式及其简单，一套组合拳几乎可以拿到任意MCU去使用。而STM32的硬件IIC也不稳定，经常容易卡死，我在STM32F031时侥幸将硬件IIC调试成功，但是后来使用STM32F103时却无法成功，真是个菜狗。但是由于项目需求，读写IIC的时间很难空出来，必须将时间腾出来给其他外设，我的软件IIC只能作废，需要重新编写硬件IIC的代码，并且需要带上DMA，将时间缩减到最小。于是就有了今天帖子。（这里准备添加STM32F031的硬件IIC链接的，结果找了一圈发现自己没写。以后有时间给大伙带上吧）
这篇帖子是准备在上个月就写的，但是因为设计PCB时未考虑硬件IIC的问题，导致IIC的引脚不在硬件GPIO上，又重新打板贴片，耽搁了两周。
我的硬件：
这里介绍我的硬件着实有点浪费感情，介绍这个的原因是我在调试的过程中遇到几个问题，均和我的硬件有关，虽然问题和IIC无关，但是我还是想分享一下，以后有朋友遇到也可规避。
MCU使用的是GDF32E230F4，外设情况如下：

flash只有16KB，封装是LGA20,资源少，封装小。这样就导致价格会很便宜，但是我没用过如此小的flash和资源如此少的MCU，这就导致我后面出现了事故。
我们的项目其实只用了一路SPI，一路485，一路IIC和两个外部中断，所用资源实在不多，但是用在这块片子上就闲的很拥挤了。所用IO如下所示：

3脚PA0用于后续的休眠唤醒，所剩资源仅仅只有PA1,PA2,PA3。因为考虑PCB版面走线和布局问题，我们直接取消外部晶振，将PF0和PF1作为IIC使用。
这里就出现了第一个问题，我们需要在收到RX引脚的第一个下降沿触发外部中断，为了走线方便，将烧录口SWDIO和RX对接，在烧录完程序之后SWDIO会用作普通GPIO，结果导致打板回来后无法烧录代码，把485芯片摘掉则无此问题，于是又要重新打板贴片，我就趁着这功夫调试了一下硬件IIC。
开始调试代码：
首先初始化所用的外设时钟：

1. void rcu_config(void)
   
2. {
   
3.     /* enable GPIOA,F clock */
   
4.     rcu_periph_clock_enable(RCU_GPIOA);
   
5.         rcu_periph_clock_enable(RCU_GPIOF);
   
6.     /* enable I2C0 clock */
   
7.     rcu_periph_clock_enable(RCU_I2C0);
   
8.     /* enable DMA0 clock */
   
9.     rcu_periph_clock_enable(RCU_DMA);
   
10. }

复制代码

然后初始化IIC。

1. void i2c_config(void)
   
2. {
   
3.     /* connect PF1 to I2C0_SCL */
   
4.     /* connect PF0 to I2C0_SDA */
   
5.     gpio_af_set(GPIOF, GPIO_AF_1, GPIO_PIN_0);
   
6.     gpio_af_set(GPIOF, GPIO_AF_1, GPIO_PIN_1);
   
7.     /* configure GPIO pins of I2C */
   
8.     gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_0);
   
9.     gpio_output_options_set(GPIOF, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_0);
   
10.     gpio_mode_set(GPIOF, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_1);
    
11.     gpio_output_options_set(GPIOF, GPIO_OTYPE_OD, GPIO_OSPEED_50MHZ, GPIO_PIN_1);
    
12. 
    
13.     /* configure I2C clock */
    
14.     i2c_clock_config(I2C0, I2C0_SPEED, I2C_DTCY_2);
    
15.     /* configure I2C address */
    
16.     i2c_mode_addr_config(I2C0, I2C_I2CMODE_ENABLE, I2C_ADDFORMAT_7BITS, I2C0_SLAVE_ADDRESS7);
    
17.     /* enable I2C0 */
    
18.     i2c_enable(I2C0);
    
19.     /* enable acknowledge */
    
20.     i2c_ack_config(I2C0, I2C_ACK_ENABLE);
    
21. }

复制代码

上面的GPIO的初始化一般没什么好说的，IO设置为开漏输出模式，因为IIC总线有读和写两个操作，开漏是最好的，这里说的是最好，其实设置为推挽输出也是可以的，这里有必要提一下，因为上周在论坛看到有的兄弟在调试SPI时，拿到的例程，GPIO设置为推挽输出，导致很疑惑，设置为输出如何去读SPI的数据。

这里有一个冷知识：只要使能了GPIO，无论你设置GPIO的模式为输入还是输出，在GPIO上有数据来时，GPIO的数据寄存器都能将数据存进寄存器内部，此时去读数据寄存器就能获取到数据，道理就是这么个道理，可能我描述的不是很准确，但是一定是可以的。
初始化GPIO之后就是调用库函数对IIC进行初始化。
i2c_clock_config（）函数的三个参数，第一个就是选定哪个I2C，第二个是设置I2C的速度，这里是以宏定义的方式定义的，速度为100000，第三个设置快速模式下的占空比，如果是速度在100KHz及以下，使用参数I2C_DTCY_2，如果是100KHz-1MHz，则使用I2C_DTCY_16_9。最高只支持1M。
IIC使用DMA写24C02：

1. void eeprom_buffer_write_dma_timeout(uint8_t* p_buffer, uint8_t write_address, uint16_t number_of_byte)
   
2. {
   
3.     uint8_t number_of_page = 0, number_of_single = 0, address = 0, count = 0;
   
4.     address = write_address % I2C_PAGE_SIZE;
   
5.     count = I2C_PAGE_SIZE - address;
   
6.     number_of_page =  number_of_byte / I2C_PAGE_SIZE;
   
7.     number_of_single = number_of_byte % I2C_PAGE_SIZE;
   
8. 
   
9.     /* if write_address is I2C_PAGE_SIZE aligned  */
   
10.     if(0 == address){
    
11.         while(number_of_page--){
    
12.             eeprom_page_write_dma_timeout(p_buffer, write_address, I2C_PAGE_SIZE);
    
13.             eeprom_wait_standby_state_timeout();
    
14.             write_address +=  I2C_PAGE_SIZE;
    
15.             p_buffer += I2C_PAGE_SIZE;
    
16.         }
    
17.         if(0 != number_of_single){
    
18.             eeprom_page_write_dma_timeout(p_buffer, write_address, number_of_single);
    
19.             eeprom_wait_standby_state_timeout();
    
20.         }
    
21.     }else{
    
22.         /* if write_address is not I2C_PAGE_SIZE aligned */
    
23.         if(number_of_byte < count){
    
24.             eeprom_page_write_dma_timeout(p_buffer, write_address, number_of_byte);
    
25.             eeprom_wait_standby_state_timeout();
    
26.         }else{
    
27.             number_of_byte -= count;
    
28.             number_of_page =  number_of_byte / I2C_PAGE_SIZE;
    
29.             number_of_single = number_of_byte % I2C_PAGE_SIZE;
    
30.             
    
31.             if(0 != count){
    
32.                 eeprom_page_write_dma_timeout(p_buffer, write_address, count);
    
33.                 eeprom_wait_standby_state_timeout();
    
34.                 write_address += count;
    
35.                 p_buffer += count;
    
36.             }
    
37.             /* write page */
    
38.             while(number_of_page--){
    
39.                 eeprom_page_write_dma_timeout(p_buffer, write_address, I2C_PAGE_SIZE);
    
40.                 eeprom_wait_standby_state_timeout();
    
41.                 write_address +=  I2C_PAGE_SIZE;
    
42.                 p_buffer += I2C_PAGE_SIZE;
    
43.             }
    
44.             /* write single */
    
45.             if(0 != number_of_single){
    
46.                 eeprom_page_write_dma_timeout(p_buffer, write_address, number_of_single);
    
47.                 eeprom_wait_standby_state_timeout();
    
48.             }
    
49.         }
    
50.     }  
    
51. }
    

复制代码

IIC使用DMA读24C02：

1. uint8_t eeprom_page_write_dma_timeout(uint8_t* p_buffer, uint8_t write_address, uint8_t number_of_byte)
   
2. {
   
3.     dma_parameter_struct dma_init_struct;
   
4.     uint8_t state = I2C_START;
   
5.     uint16_t timeout = 0;
   
6.     uint8_t i2c_timeout_flag = 0;
   
7. 
   
8.     while(!(i2c_timeout_flag)){
   
9.         switch(state){
   
10.         case I2C_START:
    
11.             /* i2c master sends start signal only when the bus is idle */
    
12.             while(i2c_flag_get(I2CX, I2C_FLAG_I2CBSY) && (timeout < I2C_TIME_OUT)){
    
13.                 timeout++;
    
14.             }
    
15.             if(timeout < I2C_TIME_OUT){
    
16.                 i2c_start_on_bus(I2CX);
    
17.                 timeout = 0;
    
18.                 state = I2C_SEND_ADDRESS;
    
19.             }else{
    
20.                 i2c_bus_reset();
    
21.                 timeout = 0;
    
22.                 state = I2C_START;
    
23.                 printf("i2c bus is busy in PAGE WRITE!\n");
    
24.             }
    
25.             break;
    
26.         case I2C_SEND_ADDRESS:
    
27.             /* i2c master sends START signal successfully */
    
28.             while((!i2c_flag_get(I2CX, I2C_FLAG_SBSEND)) && (timeout < I2C_TIME_OUT)){
    
29.                 timeout++;
    
30.             }
    
31.             if(timeout < I2C_TIME_OUT){
    
32.                 i2c_master_addressing(I2CX, eeprom_address, I2C_TRANSMITTER);
    
33.                 timeout = 0;
    
34.                 state = I2C_CLEAR_ADDRESS_FLAG;
    
35.             }else{
    
36.                 timeout = 0;
    
37.                 state = I2C_START;
    
38.                 printf("i2c master sends start signal timeout in PAGE WRITE!\n");
    
39.             }
    
40.             break;
    
41.         case I2C_CLEAR_ADDRESS_FLAG:
    
42.             /* address flag set means i2c slave sends ACK */
    
43.             while((!i2c_flag_get(I2CX, I2C_FLAG_ADDSEND)) && (timeout < I2C_TIME_OUT)){
    
44.                 timeout++;
    
45.             }
    
46.             if(timeout < I2C_TIME_OUT){
    
47.                 i2c_flag_clear(I2CX, I2C_FLAG_ADDSEND);
    
48.                 timeout = 0;
    
49.                 state = I2C_TRANSMIT_DATA;
    
50.             }else{
    
51.                 timeout = 0;
    
52.                 state = I2C_START;
    
53.                 printf("i2c master clears address flag timeout in PAGE WRITE!\n");
    
54.             }
    
55.             break;
    
56.         case I2C_TRANSMIT_DATA:
    
57.             /* wait until the transmit data buffer is empty */
    
58.             while((!i2c_flag_get(I2CX, I2C_FLAG_TBE)) && (timeout < I2C_TIME_OUT)){
    
59.                 timeout++;
    
60.             }
    
61.             if(timeout < I2C_TIME_OUT){
    
62.                 /* send the EEPROM's internal address to write to : only one byte address */
    
63.                 i2c_data_transmit(I2CX, write_address);
    
64.                 timeout = 0;
    
65.             }else{
    
66.                 timeout = 0;
    
67.                 state = I2C_START;
    
68.                 printf("i2c master sends EEPROM's internal address timeout in PAGE WRITE!\n");
    
69.             }
    
70.             /* wait until BTC bit is set */
    
71.             while(!i2c_flag_get(I2CX, I2C_FLAG_BTC));
    
72.             dma_deinit(DMA_CH1);
    
73.             dma_init_struct.direction = DMA_MEMORY_TO_PERIPHERAL;
    
74.             dma_init_struct.memory_addr = (uint32_t)p_buffer;
    
75.             dma_init_struct.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    
76.             dma_init_struct.memory_width = DMA_MEMORY_WIDTH_8BIT;
    
77.             dma_init_struct.number = number_of_byte;
    
78.             dma_init_struct.periph_addr = (uint32_t)&I2C_DATA(I2CX);
    
79.             dma_init_struct.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    
80.             dma_init_struct.periph_width = DMA_PERIPHERAL_WIDTH_8BIT;
    
81.             dma_init_struct.priority = DMA_PRIORITY_ULTRA_HIGH;
    
82.             dma_init(DMA_CH1, &dma_init_struct);
    
83.             /* enable I2CX DMA */
    
84.             i2c_dma_enable(I2CX, I2C_DMA_ON);
    
85.             /* enable DMA0 channel1 */
    
86.             dma_channel_enable(DMA_CH1);
    
87.             /* wait until full transfer finish flag is set */
    
88.             while(!dma_flag_get(DMA_CH1, DMA_FLAG_FTF));
    
89.             /* wait until BTC bit is set */
    
90.             while((!i2c_flag_get(I2CX, I2C_FLAG_BTC)) && (timeout < I2C_TIME_OUT)){
    
91.                 timeout++;
    
92.             }
    
93.             if(timeout < I2C_TIME_OUT){
    
94.                 timeout = 0;
    
95.                 state = I2C_STOP;
    
96.             }else{
    
97.                 timeout = 0;
    
98.                 state = I2C_START;
    
99.                 printf("i2c master sends data timeout in PAGE WRITE!\n");
    
100.             }
     
101.             break;
     
102.         case I2C_STOP:
     
103.             /* send a stop condition to I2C bus */
     
104.             i2c_stop_on_bus(I2CX);
     
105.             /* i2c master sends STOP signal successfully */
     
106.             while((I2C_CTL0(I2CX) & 0x0200) && (timeout < I2C_TIME_OUT)){
     
107.                 timeout++;
     
108.             }
     
109.             if(timeout < I2C_TIME_OUT){
     
110.                 timeout = 0;
     
111.                 state = I2C_END;
     
112.                 i2c_timeout_flag = I2C_OK;
     
113.             }else{
     
114.                 timeout = 0;
     
115.                 state = I2C_START;
     
116.                 printf("i2c master sends stop signal timeout in PAGE WRITE!\n");
     
117.             }
     
118.             break;
     
119.         default:
     
120.             state = I2C_START;
     
121.             i2c_timeout_flag = I2C_OK;
     
122.             timeout = 0;
     
123.             printf("i2c master sends start signal in PAGE WRITE!\n");
     
124.             break;
     
125.         }
     
126.     }
     
127.     return I2C_END;
     
128. }

复制代码

使用这两个函数只需传入需要操作的数组，页的地址和读写的数据量便可，这里贴一下测试的函数：

1. uint8_t i2c_24c02_test(void)
   
2. {
   
3.     uint16_t i;
   
4. 
   
5.     printf("\r\nAT24C02 writing...\r\n");
   
6.    
   
7.     /* initialize i2c_buffer_write */
   
8.     for(i = 0; i < BUFFER_SIZE; i++){
   
9.         i2c_buffer_write[i] = i;
   
10.         printf("0x%02X ", i2c_buffer_write[i]);
    
11.         if(15 == i%16){
    
12.             printf("\r\n");
    
13.         }
    
14.     }
    
15.     /* EEPROM data write */
    
16.     eeprom_buffer_write_dma_timeout(i2c_buffer_write, EEP_FIRST_PAGE, BUFFER_SIZE);
    
17.     printf("AT24C02 reading...\r\n");
    
18.     /* EEPROM data read */
    
19.     eeprom_buffer_read_dma_timeout(i2c_buffer_read, EEP_FIRST_PAGE, BUFFER_SIZE);
    
20.     /* compare the read buffer and write buffer */
    
21.     for(i = 0; i < BUFFER_SIZE; i++){
    
22.         if(i2c_buffer_read[i] != i2c_buffer_write[i]){
    
23.             printf("0x%02X ", i2c_buffer_read[i]);
    
24.             printf("Err:data read and write aren't matching.\n\r");
    
25.             return I2C_FAIL;
    
26.         }
    
27.         printf("0x%02X ", i2c_buffer_read[i]);
    
28.         if(15 == i%16){
    
29.             printf("\r\n");
    
30.         }
    
31.     }
    
32.     printf("I2C-AT24C02 test passed!\n\r");
    
33.     return I2C_OK;
    
34. }

复制代码

参数定义：

1. #define EEPROM_BLOCK0_ADDRESS    0xA0
   
2. #define BUFFER_SIZE              256
   
3. 
   
4. uint16_t eeprom_address;
   
5. uint8_t i2c_buffer_write[BUFFER_SIZE];
   
6. uint8_t i2c_buffer_read[BUFFER_SIZE];
   
7. uint8_t i2c_buffer_read1[BUFFER_SIZE];
   
8. 
   
9. #define I2C_TIME_OUT   (uint16_t)(5000)
   
10. #define I2C_TIME_OUT1  (uint32_t)(200000)
    
11. #define EEP_FIRST_PAGE 0x00
    
12. #define I2C_OK         1
    
13. #define I2C_FAIL       0
    
14. #define I2C_END        1
    
15. #define I2CX           I2C0

复制代码

一开始向发送数组中填充256个数据，然后调用写函数将256个数据写进24C02，因为24C02只有一页，所以页数设置为0，写完后再读出数据，校验写入和读出的数据是否一致。
这里我便遇到了第二个坑，写完之后调试不通过，代码卡死在IIC的时钟初始化i2c_clock_config(I2C0, I2C0_SPEED, I2C_DTCY_2);，继续进入这个函数，发下卡死在：


这里仅仅是一个数据的运算，卡死在这里明显不合理。这时候我想到了上周调试报错：\output\Project.axf: Error: L6406E: No space in execution regions with .ANY selector matching usart.o(.text.RS_485_SEND).当时是内存溢出了，于是我看了一下工程的map文件：

果然，已经快要顶不住了，于是果断修改keil的编译优化选项，将优化等级提升为1级，内存缩小很多，问题便可解除，因为之前没用过这么下的MCU，而且这次编译没报错，若不是上次报错让我找到原因，这次不知又要卡多久。

至此代码都是只能读写24c02，也就是操作一页。如果是更大的EEPROM器件，那么该如何操作。这里稍微吐槽一下：为啥我会用IIC来操作24C04，因为我的硬件板子上焊接的就是24C04，而为啥是24C04，并不是24C02不够用，只是因为04比02便宜，市场都畸形了吗？而我为啥要吐槽，是因为下文遇到的第三个问题。
扩充到24C04：
既然知道如何写一页，那么即使再大的容量，我们也有办法去操作，以24C04为例，只是比24C02多了一页，地址为0x01;那么我们增加一个宏定义：

定义一下第二页的地址，然后定义一个数组去接收我们读到的数据：

最后在测试程序中添加读写第二页的操作：

测试的时候再次翻车，第一次debug没问题，第二次debug的时候程序卡死在第一个写EEPROM的函数，我猜测难道又是数据超了，但是只增加了一个数组啊，代码量应该不会超标啊，于是把添加的代码全部删除，结果还是失败。
解决方法：烧录之前先擦除全部flash，再烧录便可成功。

这个原因是为啥，我还没找到，希望有知道的大佬可以给个答案，如果后续知道答案我再补上。


文至于此，问题都已解决，最后把源码贴出来，需要的自己索取。

游客，如果您要查看本帖隐藏内容请回复

硬件IIC啊，太香了，正好用得到。非常感谢！

看看

国货之光

学习了                       

正在用E230，先看看

写的详细，谢谢分享经验。

写的详细

学习学习

好的

大牛。厉害了

kankan

值得学习，挺详细

感谢

很好的资料，值得好好学习

#21ic问答#

硬件IIC，学习学习

这个不错的，需要好好学习一下。

mark一下

学习一下