gd32 i2c 中断 主机&从机双向通信例程

已于 2024-08-13 15:23:32 修改
阅读量447 收藏
点赞数 15
分类专栏： gd32 文章标签： 单片机 嵌入式硬件
于 2024-08-07 15:23:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43026921/article/details/140991868
版权

Master
I2C0_SCL PB8 AF4
I2C0_SDA PB9 AF4

Slave
I2C1_SCL PB10 AF4
I2C1_SDA PB11 AF4

//主机中断发送
void i2c_master_transmit_it(uint32_t address, uint8_t* buff, uint32_t size);
//主机中断接收
void i2c_master_receive_it(uint32_t address, uint8_t* buff, uint32_t size, uint32_t* size_out);

//从机中断发送
void i2c_slave_transmit_it(uint8_t* buff, uint32_t size);
//从机中断接收
void i2c_slave_receive_it(uint8_t* buff, uint32_t* size_out);

main.c

/*!
    \file    main.c
    \brief   running LED

    \version 2023-03-31, V1.0.0, firmware for GD32H7xx
*/


#include "gd32h7xx.h"
#include "systick.h"

#include "string.h"
#include "stdio.h"


#define I2C_SLAVE_ADDRESS7 0x82


/*!
    \brief      enable the CPU Chache
    \param[in]  none
    \param[out] none
    \retval     none
*/
static void cache_enable(void)
{
    /* Enable I-Cache */
    SCB_EnableICache();

    /* Enable D-Cache */
//    SCB_EnableDCache();
}

void led_config()
{
    rcu_periph_clock_enable(RCU_GPIOJ);

    gpio_mode_set(GPIOJ, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_8);
    gpio_output_options_set(GPIOJ, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_8);

    gpio_mode_set(GPIOJ, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE, GPIO_PIN_9);
    gpio_output_options_set(GPIOJ, GPIO_OTYPE_PP, GPIO_OSPEED_60MHZ, GPIO_PIN_9);

    gpio_bit_set(GPIOJ, GPIO_PIN_8);
    gpio_bit_set(GPIOJ, GPIO_PIN_9);

}

void usart_config()
{
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_USART0);

    gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_6);
    gpio_af_set(GPIOB, GPIO_AF_7, GPIO_PIN_7);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_6);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_6);

    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_7);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_7);

    usart_deinit(USART0);
    usart_word_length_set(USART0, USART_WL_8BIT);
    usart_stop_bit_set(USART0, USART_STB_1BIT);
    usart_parity_config(USART0, USART_PM_NONE);
    usart_baudrate_set(USART0, 921600U);
    usart_transmit_config(USART0, USART_TRANSMIT_ENABLE);
    usart_receive_config(USART0, USART_RECEIVE_ENABLE);
    usart_enable(USART0);
}

void usart_transmit(char* buff, int size)
{
    for (int i = 0; i < size; ++i) {
        usart_data_transmit(USART0, buff[i]);
        while (RESET == usart_flag_get(USART0, USART_FLAG_TBE)) {}
    }
}

/*
 * Master
 * I2C0_SCL PB8  AF4
 * I2C0_SDA PB9  AF4
 */
void i2c0_config()
{
    rcu_periph_clock_enable(RCU_GPIOB);

    gpio_af_set(GPIOB, GPIO_AF_4, GPIO_PIN_8 | GPIO_PIN_9);
    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_8 | GPIO_PIN_9);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_100_220MHZ, GPIO_PIN_8 | GPIO_PIN_9);

    rcu_periph_clock_enable(RCU_I2C0);

    i2c_deinit(I2C0);
    i2c_timing_config(I2C0, 0x3, 0x9, 0x0);
    i2c_master_clock_config(I2C0, 0x96, 0xda);
    i2c_enable(I2C0);

    nvic_irq_enable(I2C0_EV_IRQn, 2, 0);
    nvic_irq_enable(I2C0_ER_IRQn, 2, 1);
}

uint8_t* master_tx_buff;
uint8_t* master_rx_buff;
uint32_t* master_rx_recv_cnt;

void I2C0_EV_IRQHandler()
{
    if (RESET != i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_STPDET)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_STPDET);
    } else if (RESET != i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_TI)) {
        i2c_data_transmit(I2C0, *master_tx_buff++);
    } else if (RESET != i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_RBNE)) {
        *master_rx_buff++ = i2c_data_receive(I2C0);
        *master_rx_recv_cnt += 1;
    } else if (RESET != i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_TC)) {
        i2c_stop_on_bus(I2C0);
        i2c_interrupt_disable(I2C0, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_TI | I2C_INT_RBNE | I2C_INT_TC);
    }
}

void I2C0_ER_IRQHandler()
{
    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_BERR)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_BERR);
    }

    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_LOSTARB)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_LOSTARB);
    }

    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_OUERR)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_OUERR);
    }

    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_PECERR)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_PECERR);
    }

    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_TIMEOUT)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_TIMEOUT);
    }

    if (i2c_interrupt_flag_get(I2C0, I2C_INT_FLAG_SMBALT)) {
        i2c_interrupt_flag_clear(I2C0, I2C_INT_FLAG_SMBALT);
    }

    i2c_interrupt_disable(I2C0, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_RBNE | I2C_INT_TI | I2C_INT_TC);
}

void i2c_master_transmit_it(uint32_t address, uint8_t* buff, uint32_t size)
{
    master_tx_buff = buff;

    i2c_master_addressing(I2C0, address, I2C_MASTER_TRANSMIT);
    i2c_transfer_byte_number_config(I2C0, size);
    i2c_interrupt_enable(I2C0, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_TI | I2C_INT_TC);

    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY)) { } //等待总线空闲
    I2C_STAT(I2C0) |= I2C_STAT_TBE;
    i2c_start_on_bus(I2C0);
}

void i2c_master_receive_it(uint32_t address, uint8_t* buff, uint32_t size, uint32_t* size_out)
{
    master_rx_buff = buff;
    master_rx_recv_cnt = size_out;
    *master_rx_recv_cnt = 0;

    i2c_master_addressing(I2C0, address, I2C_MASTER_RECEIVE);
    i2c_transfer_byte_number_config(I2C0, size);
    i2c_interrupt_enable(I2C0, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_RBNE | I2C_INT_TC);

    while(i2c_flag_get(I2C0, I2C_FLAG_I2CBSY)) { } //等待总线空闲
    i2c_start_on_bus(I2C0);
}

/*
 * Slave
 * I2C1_SCL PB10 AF4
 * I2C1_SDA PB11 AF4
 */
void i2c1_config()
{
    rcu_periph_clock_enable(RCU_GPIOB);

    gpio_af_set(GPIOB, GPIO_AF_4, GPIO_PIN_10 | GPIO_PIN_11);
    gpio_mode_set(GPIOB, GPIO_MODE_AF, GPIO_PUPD_PULLUP, GPIO_PIN_10 | GPIO_PIN_11);
    gpio_output_options_set(GPIOB, GPIO_OTYPE_OD, GPIO_OSPEED_100_220MHZ, GPIO_PIN_10 | GPIO_PIN_11);

    rcu_periph_clock_enable(RCU_I2C1);

    i2c_deinit(I2C1);
    i2c_address_config(I2C1, I2C_SLAVE_ADDRESS7, I2C_ADDFORMAT_7BITS);
    i2c_enable(I2C1);

    nvic_irq_enable(I2C1_EV_IRQn, 2, 2);
    nvic_irq_enable(I2C1_ER_IRQn, 2, 3);
}

uint8_t* slave_tx_buff;
uint8_t* slave_rx_buff;
uint32_t* slave_rx_recv_cnt;

void I2C1_EV_IRQHandler()
{
    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_ADDSEND)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_ADDSEND);
    } else if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_RBNE)) {
        *slave_rx_buff++ = i2c_data_receive(I2C1);
        *slave_rx_recv_cnt += 1;
    } else if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_TI)) {
        i2c_data_transmit(I2C1, *slave_tx_buff++);
    } else if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_STPDET)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_STPDET);
        i2c_interrupt_disable(I2C1, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_ADDM | I2C_INT_TI | I2C_INT_RBNE);
    }
}

void I2C1_ER_IRQHandler()
{
    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_BERR)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_BERR);
    }

    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_LOSTARB)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_LOSTARB);
    }

    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_OUERR)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_OUERR);
    }

    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_PECERR)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_PECERR);
    }

    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_TIMEOUT)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_TIMEOUT);
    }

    if (i2c_interrupt_flag_get(I2C1, I2C_INT_FLAG_SMBALT)) {
        i2c_interrupt_flag_clear(I2C1, I2C_INT_FLAG_SMBALT);
    }

    i2c_interrupt_disable(I2C1, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_ADDM | I2C_INT_RBNE | I2C_INT_TI);
}

void i2c_slave_transmit_it(uint8_t* buff, uint32_t size)
{
    slave_tx_buff = buff;
    I2C_STAT(I2C1) |= I2C_STAT_TBE;
    i2c_interrupt_enable(I2C1, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_ADDM | I2C_INT_TI);
}

void i2c_slave_receive_it(uint8_t* buff, uint32_t* size_out)
{
    slave_rx_recv_cnt = size_out;
    *slave_rx_recv_cnt = 0;
    slave_rx_buff = buff;
    i2c_interrupt_enable(I2C1, I2C_INT_ERR | I2C_INT_STPDET | I2C_INT_ADDM | I2C_INT_RBNE);
}


/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* enable the CPU Cache */
    cache_enable();

    /* configure systick */
    systick_config();


    led_config();
    usart_config();


    i2c0_config();
    i2c1_config();



    while(1) {

        //-----------------------------------------------------------------------

        uint8_t tx1[8] = {0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88};
        uint8_t rx1[8] = {0};
        uint32_t rx1_recv_bytes = 0;

        i2c_slave_receive_it(rx1, &rx1_recv_bytes);
        i2c_master_transmit_it(I2C_SLAVE_ADDRESS7, tx1, 8);
        delay_1ms(10);

        //上位机应接收到 "0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88"
        usart_transmit(rx1, rx1_recv_bytes);

        //-----------------------------------------------------------------------

        uint8_t tx2[4] = {0x44, 0x33, 0x22, 0x11};
        uint8_t rx2[4] = {0};
        uint32_t rx2_recv_bytes = 0;

        i2c_slave_receive_it(rx2, &rx2_recv_bytes);
        i2c_master_transmit_it(I2C_SLAVE_ADDRESS7, tx2, 4);
        delay_1ms(10);

        //上位机应接收到 "0x44, 0x33, 0x22, 0x11"
        usart_transmit(rx2, rx2_recv_bytes);

        //-----------------------------------------------------------------------

        uint8_t tx3[4] = {0x12, 0x34, 0x56, 0x78};
        uint8_t rx3[4] = {0};
        uint32_t rx3_recv_bytes = 0;

        i2c_slave_transmit_it(tx3, 4);
        i2c_master_receive_it(I2C_SLAVE_ADDRESS7, rx3, 4,  &rx3_recv_bytes);
        delay_1ms(10);

        //上位机应接收到 "0x12, 0x34, 0x56, 0x78"
        usart_transmit(rx3, rx3_recv_bytes);


        //-----------------------------------------------------------------------


        uint8_t tx4[4] = {0xaa, 0xbb, 0xcc, 0xdd};
        uint8_t rx4[4] = {0};
        uint32_t rx4_recv_bytes = 0;

        i2c_slave_transmit_it(tx4, 4);
        i2c_master_receive_it(I2C_SLAVE_ADDRESS7, rx4, 4,  &rx4_recv_bytes);

        delay_1ms(10);

        //上位机应接收到 "0xaa, 0xbb, 0xcc, 0xdd"
        usart_transmit(rx4, rx4_recv_bytes);


        delay_1ms(1000);
    }
}
BusyBox0
关注
  • 15
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【嵌入式 – GD32开发实战指南(ARM版本)】第1部分 基础篇 - 第21章 I2C
不问归期的博客
09-17 2898
I2C总线是PHLIPS公司推出的一种双线式半双工串行总线，是具备多主机系统所需的总线裁决和高低速器件同步功能的高性能串行总线。用于连接微控器及外围设备。I2C总线只有两根双向信号线。一根是数据线SDA，另一根是时钟线SCL。 物理层1）它只使用两条总线线路 ：一条双向串行数据线（SDA），一条串行时钟线（SCL）。见下图。2）每个连接到总线的设备都有一个独立的地址，主机可以利用这个地址进行不同设备之间的访问。3）多主机同时使用总线时，为了防止数据冲突，会利用仲裁方式决定由哪个设备占用总线。
单片机GD32F303RCT6 (Macos环境)开发 （十七）—— i2c1从机中断接收发送数据
weixin_43932857的博客
05-11 1539
1、将i2c1设置为从机模式，与树莓派连接。5、 I2C1_EventIRQ_Handler()、I2C1_ErrorIRQ_Handler() 在i2c.c定义。同时修改i2c.h文件，定义I2C1_MODE为I2C1_MODE_SLAVE，编译烧录后，i2c1即为从机模式。7、代码路径：https://gitee.com/xiaoguo-tec_0/gd32-iap-code.git。树莓派发送数据：i2ctransfer -f -y 1 w4@0x18 0x08 0x09 0xA0 0xA3。
硬件I2C主机中断收发程序
01-19
基于GD32F350芯片实现硬件I2C主机中断收发程序，经过测试程序运行稳定。
【GD32F407】i2c主机发送，从机中断接收
Enosji的博客
03-01 4771
前言 现在手里负责的一个项目需要用i2c和主芯片进行通信主动发送，中断接收，这就需要支持i2c主机模式和从机模式，先查看原理图 这里我们用到了两条i2c总线进行数据的交替传输，避免在使用一条总线是发送数据和接收数据冲突 初始化i2c控制器 s32_k i2cDevInit(u8 byBusId, TI2cBus *pTI2cBus) { //PCLK = 36000000 BOOL retFlg = FALSE; int I2xSCL = pTI2cBus->byFastMode ?
GD32VF103 I2C从机模板
MQWYY3的博客
02-23 2539
GD32VF103 I2C从机模板 由TaterLi 2019年12月15日 作为I2C从机程序,关键变量aReceiveBuffer以及关键常量I2C0_SLAVE_ADDRESS7,第一个是I2C设备寄存器内容,第二个是I2C地址. 当上位机读写寄存器时候,实际上读写的是aReceiveBuffer的内容,除了0x00这个之外,其他全部可以读写.算是比较方便实现某些功能. 编译器:toolchain-gd32v 9.2.0 [GCC] #include "gd32vf103.h" #in.
GD32F450 硬件iic读写AT24之中断实现
Lin4722的博客
07-16 2290
目录 1.前言 2.原理 1.前言 最近公司有用到GD32的芯片做产品，有用到IIC 的芯片。所以就想研究一下GD32的IIC用中断怎么实现。结果这一写就是一天半，一直读不到数据。最后终于是写好了，一起来看看吧。 2.原理 图1 写入数据 如图1，为写入数据的时序图，先发送器件地址，再发送数据地址，然后就可以一直写入数据。最后写完了发送一个停止位就可以了。 图2 读取数据 如图2所示，为数据读取时序图。读取时先要写模式发送要读取的地址，然后再用读模式连续读取。 3.硬...
【技术分享】GD32硬件I2C调试中的问题与解决过程
ic2121的博客
05-12 3459
下一步开始的工作就是I2C接口驱动的移植，这里使用I2C_EEPROM例程进行融合，然后修改芯片地址即可（开发板上的EEPROM芯片是AT24Cxx，地址是0xA0，我手上的MPL3115A2气压计芯片地址是0xC0），可直接使用开发板上的I2C引脚，并且不需要将EEPROM芯片断开，通过地址即可进行选择读取。左边的目录多了cycle_buffer.c和cycle_buffer.h两个文件，这两个是增加的串口环形缓冲区的封装接口，跟I2C功能不相关，也跟单片机的底层驱动不相关，因此可以忽略。
RT-thread+GD32F450+i2c
04-07
在实现I2C通信时，首先需要对GD32F450的I2C外设进行初始化，设置时钟分频因子、数据速率、中断使能等参数。然后，根据I2C协议，需要编写发送和接收数据的函数，这些函数通常会调用MCU的I2C寄存器API。例如，启动传输...
GD32F30x_Demo_Suites_V2.1.0.rar
06-01
GD32F30x的I2C接口支持主模式和从模式，可配置为快速模式（Fast Mode Plus，400kHz）和标准模式（100kHz）。示例程序会包含初始化I2C、发送和接收数据、处理从设备响应的代码。 6. **中断**：中断是MCU处理外部事件...
GD32F4xx_Demo_Suites_V2.2.0.rar
06-01
3. **I2C（集成电路间通信）**：I2C是一种多主机、双向二线制总线，用于低速设备间的通信。GD32F4的I2C实例会展示如何初始化总线、读写从设备寄存器、处理总线冲突和错误条件。 4. **I2S（集成电路音频接口）**：I2...
GD32硬件IIC+DMA程序
01-11
GD32硬件IIC+DMA程序，使用的IIC时序如下。 写寄存器操作为： START+ACK（从机的ACK信号）+IIC设备地址+（从机的ACK信号）+START+ACK（从机的ACK信号）+IIC写寄存器地址+ACK（从机的ACK信号）+IIC写数据（4Byte，每个数据后都有ACK）+STOP 读寄存器操作为： START+ACK（从机的ACK信号）+IIC设备地址+（从机的ACK信号）+START+ACK（从机的ACK信号）+IIC读寄存器地址+ACK（从机的ACK信号）+IIC读数据（4Byte，前n个数据后都有（主机发送的）ACK,最后1byte数据后如果发ACK，表示还有数据要读，如果最后1byte数据后为NACK，后面紧接着就是停止位）+STOP
GD32E230F4项目
05-11
5. **IIC通讯**：I2C（Inter-Integrated Circuit）是一种多主机、双向、二线制的通信协议，常用于连接微控制器和传感器、实时时钟、EEPROM等低速设备。在GD32E230项目中，IIC可能用于与KTH7812等设备通信。 6. **...
【GD32】从0开始学GD32单片机（8）—— I2C外设详解+主机从机发送和接收例程
热门推荐
JackieCoo的博客
09-25 1万+
介绍GD32的I2C外设，包含主机从机发送和接收例程
GD32f303的硬件IIC.从机配置与接收流程
time_grid的博客
07-11 8523
1、要注意硬件IIC配置相当坑，看起来没关系的两个函数，只要初始化配置化调用写反了就可能导致问题。比如：最终使能IIC的函数< i2c_enable(I2Cx) >与配置应答的函数< i2c_ack_config(I2Cx, I2C_ACK_ENABLE) >写反了就会导致配置失败。非常离谱。 2、在写自己的中断函数时要注意好逻辑，从机发与从机收是两个套路。而且< i2c_interrupt_flag_clear() >函数不是万能的。要注意这个函数只能清除哪些标志位。二、我的硬件IIc.从机
GD32 单片机 硬件I2C死锁解决方法
lvmingzhou的专栏
11-03 2091
【代码】GD32 单片机 硬件I2C死锁解决方法。
GD 32 IIC 驱动代码
最新发布
qq_45973003的博客
08-05 989
学会IIC驱动的原理，时序和代码实现宏定义的作用是简化程序，防止程序出现魔鬼数字，本质是温文本展开，注意优先级问题// 宏定义SCL 与 SDA#define GET_I2C_SDA() gpio_input_bit_get(GPIOB,GPIO_PIN_7) // 读取SDA端口#define SET_I2C_SCL() gpio_bit_set(GPIOB, GPIO_PIN_6) // 时钟线SCL输出高电平。
GD32450i-EVAL学习笔记 5 - I2C Master（硬件）
pq的博客
08-07 2847
GD32F450最多支持3组硬件I2C，支持标速（100KHz）和快速（400KHz）。 1. GPIO初始化 以I2C0为例
基于GD32F450芯片的IIC读写EEPROM详解，写篇
a_happy_ant的博客
12-02 4456
本文采用的是GD32F450芯片，基于此芯片的官网例程来对IIC读写EEPROM进行详解。 对于初学者来说，感觉IIC很复杂，时许逻辑很绕，无从下手。感觉很多概念不理解，但是不要慌，此文给你详解。 上来不多说，直接贴代码！ void eeprom_page_write(uint8_t* p_buffer, uint8_t write_address, uint8_t number_of_byte) { /* wait until I2C bus is idle */ while(i2c_fl
gd32 i2c dma
12-08
gd32是一款中国国产的微控制器系列，其中包括了i2c和dma两个功能模块。 i2c，全称为Inter-Integrated Circuit，是一种串行通信协议，用于在微控制器和外部设备之间进行通信。gd32系列提供了i2c模块，使得它可以与其他i2c兼容的设备进行交互。通过gd32的i2c模块，我们可以实现多个设备之间的数据传输和通信。gd32 i2c模块支持主从模式，可以作为主设备来控制其他从设备，也可以作为从设备被其他主设备所控制。使用i2c，我们可以连接各种外设，如传感器、存储器等，从而实现数据的读写和交换。gd32的i2c模块提供了一些寄存器和配置选项，使得用户可以根据自己的需求进行设置和操作。 dma，全称为Direct Memory Access，是一种用于数据传输的技术。通常情况下，当微控制器需要进行数据传输时，需要通过CPU进行中断处理，这样会占用CPU的很多时间和资源。而dma模块的作用就是用来解放CPU，实现直接的数据传输。gd32的dma模块通过配置源地址、目的地址和传输数据的长度等参数，可以实现大容量数据的快速传输。当dma传输完成后，会触发一个中断信号，从而通知CPU。 综上所述，gd32的i2c和dma功能模块能够提供可靠、高效的数据通信和传输方式。用户可以根据需要来配置和使用这两个功能模块，从而实现各种各样的应用，如外设控制、数据传输、通信等。gd32的i2c和dma模块的灵活性和易用性，使得它成为了很多嵌入式系统的理想选择。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值