gd32 spi dma全双工发送接收例程

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

Master
SPI0_NSS PA4 AF5
SPI0_SCK PA5 AF5
SPI0_MISO PA6 AF5
SPI0_MOSI PA7 AF5

Slave
SPI4_NSS PK1 AF5
SPI4_SCK PK0 AF5
SPI4_MOSI PJ10 AF5
SPI4_MISO PJ11 AF5

spi_master_transmit_receive_dma 主机发送接收
spi_slave_transmit_receive_dma 从机发送接收

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"


/*!
    \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
 * SPI0_NSS  PA4 AF5
 * SPI0_SCK  PA5 AF5
 * SPI0_MISO PA6 AF5
 * SPI0_MOSI PA7 AF5
 */
void spi0_config()
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_SPI0);

    gpio_af_set(GPIOA, GPIO_AF_5, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
    gpio_mode_set(GPIOA, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);
    gpio_output_options_set(GPIOA, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7);


    spi_i2s_deinit(SPI0);

    spi_parameter_struct spi_init_struct;
    spi_struct_para_init(&spi_init_struct);
    spi_init_struct.device_mode = SPI_MASTER;
    spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.data_size = SPI_DATASIZE_8BIT;
    spi_init_struct.nss = SPI_NSS_SOFT;
    spi_init_struct.endian = SPI_ENDIAN_MSB;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
    spi_init_struct.prescale = SPI_PSC_64;
    spi_init(SPI0, &spi_init_struct);

    spi_byte_access_enable(SPI0);
    spi_nss_output_enable(SPI0);
    spi_nss_internal_high(SPI0);
    spi_dma_enable(SPI0, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI0, SPI_DMA_RECEIVE);

    spi_enable(SPI0);
}

void spi0_dma_config()
{
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMAMUX);


    nvic_irq_enable(DMA0_Channel0_IRQn, 1, 1);
    nvic_irq_enable(DMA0_Channel1_IRQn, 1, 0);


    dma_deinit(DMA0, DMA_CH1); //SPI0_RX
    dma_single_data_parameter_struct dma_init_struct_rx;
    dma_single_data_para_struct_init(&dma_init_struct_rx);
    dma_init_struct_rx.request = DMA_REQUEST_SPI0_RX;
    dma_init_struct_rx.direction = DMA_PERIPH_TO_MEMORY;
    dma_init_struct_rx.memory0_addr = (uint32_t)0;
    dma_init_struct_rx.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct_rx.periph_memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct_rx.number = 0;
    dma_init_struct_rx.periph_addr = (uint32_t)&SPI_RDATA(SPI0);
    dma_init_struct_rx.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct_rx.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH1, &dma_init_struct_rx);
    dma_circulation_disable(DMA0, DMA_CH1); //用循环模式接收会出现问题，每次接收的第一个数据都是0x00
    dma_interrupt_enable(DMA0, DMA_CH1, DMA_INT_FTF);


    dma_deinit(DMA0, DMA_CH0); //SPI0_TX
    dma_single_data_parameter_struct dma_init_struct_tx;
    dma_single_data_para_struct_init(&dma_init_struct_tx);
    dma_init_struct_tx.request = DMA_REQUEST_SPI0_TX;
    dma_init_struct_tx.direction = DMA_MEMORY_TO_PERIPH;
    dma_init_struct_tx.memory0_addr = (uint32_t)0;
    dma_init_struct_tx.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct_tx.periph_memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct_tx.number = 0;
    dma_init_struct_tx.periph_addr = (uint32_t)&SPI_TDATA(SPI0);
    dma_init_struct_tx.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct_tx.priority = DMA_PRIORITY_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH0, &dma_init_struct_tx);
    dma_circulation_disable(DMA0, DMA_CH0);
    dma_interrupt_enable(DMA0, DMA_CH0, DMA_INT_FTF);
}

//主机DMA发送接收
void spi_master_transmit_receive_dma(uint8_t* tx_buff, uint8_t* rx_buff, int size)
{
    dma_memory_address_config(DMA0, DMA_CH1, DMA_MEMORY_0, rx_buff);
    dma_transfer_number_config(DMA0, DMA_CH1, size);
    dma_channel_enable(DMA0, DMA_CH1);

    dma_memory_address_config(DMA0, DMA_CH0, DMA_MEMORY_0, tx_buff);
    dma_transfer_number_config(DMA0, DMA_CH0, size);
    dma_channel_enable(DMA0, DMA_CH0);

    spi_nss_internal_low(SPI0);
    spi_master_transfer_start(SPI0, SPI_TRANS_START);
}


//主机发送DMA callback
void DMA0_Channel0_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH0, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH0, DMA_INT_FLAG_FTF);


        spi_master_transfer_start(SPI0, SPI_TRANS_IDLE);
        spi_nss_internal_high(SPI0);
    }
}

//主机接收DMA callback
void DMA0_Channel1_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH1, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH1, DMA_INT_FLAG_FTF);



    }
}



/*
 * Slave
 * SPI4_NSS  PK1 AF5
 * SPI4_SCK  PK0 AF5
 * SPI4_MOSI PJ10  AF5
 * SPI4_MISO PJ11  AF5
 */
void spi4_config()
{
    rcu_periph_clock_enable(RCU_GPIOK);
    rcu_periph_clock_enable(RCU_GPIOJ);
    rcu_periph_clock_enable(RCU_SPI4);

    gpio_af_set(GPIOK, GPIO_AF_5, GPIO_PIN_0 | GPIO_PIN_1);
    gpio_mode_set(GPIOK, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_0 | GPIO_PIN_1);
    gpio_output_options_set(GPIOK, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_0 | GPIO_PIN_1);

    gpio_af_set(GPIOJ, GPIO_AF_5, GPIO_PIN_10 | GPIO_PIN_11);
    gpio_mode_set(GPIOJ, GPIO_MODE_AF, GPIO_PUPD_NONE, GPIO_PIN_10 | GPIO_PIN_11);
    gpio_output_options_set(GPIOJ, GPIO_OTYPE_PP, GPIO_OSPEED_100_220MHZ, GPIO_PIN_10 | GPIO_PIN_11);


    spi_i2s_deinit(SPI4);

    spi_parameter_struct spi_init_struct;
    spi_struct_para_init(&spi_init_struct);
    spi_init_struct.device_mode = SPI_SLAVE;
    spi_init_struct.trans_mode = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.data_size = SPI_DATASIZE_8BIT;
    spi_init_struct.nss = SPI_NSS_HARD;
    spi_init_struct.endian = SPI_ENDIAN_MSB;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
    spi_init_struct.prescale = SPI_PSC_64;
    spi_init(SPI4, &spi_init_struct);

    spi_byte_access_enable(SPI4);
    spi_dma_enable(SPI4, SPI_DMA_TRANSMIT);
    spi_dma_enable(SPI4, SPI_DMA_RECEIVE);

    spi_enable(SPI4);
}


void spi4_dma_config()
{
    rcu_periph_clock_enable(RCU_DMA0);
    rcu_periph_clock_enable(RCU_DMAMUX);

    nvic_irq_enable(DMA0_Channel2_IRQn, 0, 1);
    nvic_irq_enable(DMA0_Channel3_IRQn, 0, 0);

    dma_deinit(DMA0, DMA_CH2); //SPI1_TX
    dma_single_data_parameter_struct dma_init_struct_tx;
    dma_single_data_para_struct_init(&dma_init_struct_tx);
    dma_init_struct_tx.request = DMA_REQUEST_SPI4_TX;
    dma_init_struct_tx.direction = DMA_MEMORY_TO_PERIPH;
    dma_init_struct_tx.memory0_addr = (uint32_t)0;
    dma_init_struct_tx.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct_tx.periph_memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct_tx.number = 0;
    dma_init_struct_tx.periph_addr = (uint32_t)&SPI_TDATA(SPI4);
    dma_init_struct_tx.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct_tx.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH2, &dma_init_struct_tx);
    dma_circulation_disable(DMA0, DMA_CH2);
    dma_interrupt_enable(DMA0, DMA_CH2, DMA_INT_FTF);

    dma_deinit(DMA0, DMA_CH3); //SPI1_RX
    dma_single_data_parameter_struct dma_init_struct_rx;
    dma_single_data_para_struct_init(&dma_init_struct_rx);
    dma_init_struct_rx.request = DMA_REQUEST_SPI4_RX;
    dma_init_struct_rx.direction = DMA_PERIPH_TO_MEMORY;
    dma_init_struct_rx.memory0_addr = (uint32_t)0;
    dma_init_struct_rx.memory_inc = DMA_MEMORY_INCREASE_ENABLE;
    dma_init_struct_rx.periph_memory_width = DMA_MEMORY_WIDTH_8BIT;
    dma_init_struct_rx.number = 0;
    dma_init_struct_rx.periph_addr = (uint32_t)&SPI_RDATA(SPI4);
    dma_init_struct_rx.periph_inc = DMA_PERIPH_INCREASE_DISABLE;
    dma_init_struct_rx.priority = DMA_PRIORITY_ULTRA_HIGH;
    dma_single_data_mode_init(DMA0, DMA_CH3, &dma_init_struct_rx);
    dma_circulation_disable(DMA0, DMA_CH3); //用循环模式接收会出现问题，每次接收的第一个数据都是0x00
    dma_interrupt_enable(DMA0, DMA_CH3, DMA_INT_FTF);
}

//从机DMA发送接收
void spi_slave_transmit_receive_dma(uint8_t* tx_buff, uint8_t* rx_buff, int size)
{
    dma_memory_address_config(DMA0, DMA_CH2, DMA_MEMORY_0, tx_buff);
    dma_transfer_number_config(DMA0, DMA_CH2, size);
    dma_channel_enable(DMA0, DMA_CH2);

    dma_memory_address_config(DMA0, DMA_CH3, DMA_MEMORY_0, rx_buff);
    dma_transfer_number_config(DMA0, DMA_CH3, size);
    dma_channel_enable(DMA0, DMA_CH3);
}


//从机发送DMA callback
void DMA0_Channel2_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH2, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH2, DMA_INT_FLAG_FTF);


    }
}

//从机接收DMA callback
void DMA0_Channel3_IRQHandler()
{
    if (RESET != dma_interrupt_flag_get(DMA0, DMA_CH3, DMA_INT_FLAG_FTF)) {
        dma_interrupt_flag_clear(DMA0, DMA_CH3, DMA_INT_FLAG_FTF);


    }
}

/*!
    \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();

    spi0_dma_config();
    spi0_config();
    spi4_dma_config();
    spi4_config();


    int cnt = 0;
    while(1) {

        uint8_t master_tx_buff[4] = {0x11, 0x22, 0x33, 0x44};
        uint8_t master_rx_buff[4] = {0};

        uint8_t slave_tx_buff[4] = {0x44, 0x33, 0x22, 0x11};
        uint8_t slave_rx_buff[4] = {0};

        spi_slave_transmit_receive_dma(slave_tx_buff, slave_rx_buff, 4);
        spi_master_transmit_receive_dma(master_tx_buff, master_rx_buff, 4);
        delay_1ms(1);
        usart_transmit(master_rx_buff, 4);
        usart_transmit(slave_rx_buff, 4);
        //上位机应该收到 0x44, 0x33, 0x22, 0x11, 0x11, 0x22, 0x33, 0x44

        delay_1ms(1000);
    }
}
BusyBox0
关注
  • 15
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
GD32F405RGT6串口接收发送DMA
03-11
GD32F405RGT6串口接收发送DMA
GD32F303 串口+DMA 收发数据
10-23
工程实现了RS232 和RS485通过DMA实现收发数据 这是本人第一次在CSDN上传文件，可能还会有许多不足，希望大家可以见谅 有什么问题可以直接联系我
GD32F470VET6使用SPI+DMA操作ws2812B灯带
lucky_sunshine的博客
12-05 948
define LED_ALT_NUM GPIO_AF_5 // 复用#define CODE0 0xE0 // 0码, 发送的时间 1110 0000 根据不同的SCK适当调整#define CODE1 0xF8 // 1码, 发送的时间 1111 1000// 灯珠 RGB数量// 灯珠。
GD32E230 SPI DMA通信（读取传感器数据）
dy_ngmm的博客
11-02 6144
一场疫情让公司的生意越来越好，忙得不可开交，产品大卖特卖。结果ST的单片机开始出现交期不稳定，供货慢，价格翻倍。无奈之下只好从国产单片机下手。于是就有了我的ST-GD的代码移植。 目录一、SPI初始化二、DMA配置三、读取数据 一、SPI初始化 /************************************************ 函数名称 ： rcu_config 功 能 ： RCU时钟配置 参 数 ： 无 返 回 值 ： 无 作 者 ： Mico *************
GD32 SPI DMA收发
cftchaoxiaoshu的博客
10-08 5179
GD32 SPI DMA收发
GD32F103配置SPI+DMA收发数据
热门推荐
chenxr的博客
08-19 1万+
本文介绍如何配置GD32F103系列的SPI和DMA，并贴出相关代码。
GD32单片机串口DMA发送
weixin_53592457的博客
05-15 3012
单片机cpu将一个数据字节拷贝纸值串口发送的data寄存器中，data数据寄存器会将数据传输给移位寄存器等待数据发送完成，在此过程中需要。串口DMA 发送与接收需要定义一个缓冲区用于存放需要发送和接收未处理的数据，通常做法为给发送和接受各自定义一个。通过串口DMA可以直接通过DMA直接完成数据的搬运，搬运完成后，直接从指定地址读取接收内容即可。而常规串口接收通过中断实现，当数据量较大是，单片机频繁处于串口中断过程中，，表示数据完成发送，然而这个等待过程单片机无法处理其他数据内容，
GD32f103系列教程—(SPI DMA方式软件实现篇)
m0_37755481的博客
12-15 1923
项目中需要采用DMA方式传输数据的原因：如果仅仅采用SPI接口进行寄存器通信，那么大可不必采用DMA通信，直接让CPU利用SPI接口通信即可。但是项目中往往会出现传输大量的数据包的情况，此时直接传输和以DMA传输的时间上的差异就体现出来了，并且采用直接传输的时候由于MCU需要不停的搬运数据，因此在传输的两帧数据中间会有很大的延时，导致传输效率极低。所以，首先，配置DMA的时钟，然后配置DMA的一些功能，比如存储器的宽度，传输方向，内存的宽度等。该图为SPI采用DMA通信方式的SPI的波形图。
gd32 spi dma发送&接收例程
最新发布
weixin_43026921的博客
08-06 131
【代码】gd32 spi dma发送&接收例程。
GD32E320 SPI+DMA收发
ic2121的博客
12-26 1327
会以跟帖的形式发出来，因为我的网络不稳定，会出现断网，导致数据丢失，所以分开写降低风险。寄存器中送下一个数据，就可以实现连续发送，最主要的是可以保持时钟连续。如果需要连续发送多个数据，我们在发完上一个数据后不要拉高片选，马上向。外设就会帮我们送出去，同时我们也可以接收来自从机的返回数据。同时会对自己开发过程中遇到的问题进行说明。引脚之后，只要将数据送入发送缓冲区，复用，通过芯片数据手册可得。位数据，时钟却输出很多。的方式收发数据便已完成。的串口移植，这里加一个。设置为全双工，主模式，这样的操作是不正确的。
Stm32F407 SPI 从机 DMA全双工.zip
03-05
这是博客介绍 单片机是 Stm32F407的实现了 从机SPI +DMA收发数据 具体的可以去看我的博客 勘误 ： spi_dma_init 函数中的 这里修改一下 // DMA_InitStructure.DMA_Mode = DMA_Mode_Normal; DMA_InitStructure...
Stm32F407 SPI 从机 DMA全双工.zip - 副本.zip
06-22
4. **全双工操作**：在SPI全双工模式下，数据可以同时从主机发送到从机，同时从从机发送到主机。为了实现这一点，需要正确配置DMA通道，确保发送和接收不冲突。例如，可以设置一个优先级较高的发送通道和一个优先级...
STM32F4 串口（DMA发送接收方式）代码例程
02-24
本文将详细介绍如何在STM32F4上实现串口的DMA发送与接收功能，并提供稳定测试的代码例程。 1. **STM32F4串口介绍** STM32F4支持多个串行接口，如USART（通用同步/异步收发传输器）和UART（通用异步收发传输器），...
GD32 SPI 查询方式和DMA方式在全双模式下效率区别
浪迹天涯的博客
06-24 3227
发现SPI传输数据的过程中，SCK的时钟频率为3.703M符合我们设置的CLK频率，但是我们发现两个SPI的字节之间有一段SCK是空闲的，从逻辑分析仪上看时间高达1.95us，比SPI传输一个自字节的时间还长，在极大的影响了SPI的传输速率。其实这个空闲时间正是MCU在搬运SPI的数据。到底是不是这么回事呢，我们提升SPI的SCK速率，来继续观察。
立创梁山派GD32F470ZGT6--硬件SPI+DMA的快速刷屏
qq_51930953的博客
08-13 3392
应用于LVGL工程的SPI屏幕快速刷屏方法
GD32F4XX SPI DMA容易被中断打断导致传输异常问题
weixin_44131108的博客
08-16 1859
GD SPI DMA容易被中断打断导致异常的问题
gd32开发板I2S音频功能分析
weixin_46158019的博客
04-25 1702
开发板的基本信息：gd32f450zkt6；使用的音频D/A转换器芯片：CS4344。查看CS4344芯片的数据手册，该音频转换芯片引脚介绍如下：查看mcu的数据手册，使用I2S1接口，具体使用的引脚是PC1，PC7，PB9，PC6。引脚介绍如下：官方设计的电路原理图如下：实际的电路如下：程序设计基本流程：I2S的引脚功能配置(配置I2S外设功能）开启中断配置读取音频文件发送音频数据官方代码分...
02.立创梁山派GD32的串口发送以及使用DMA进行串口接收
lbm666666的博客
05-19 1717
本节根据嘉立创给出的入门手册进行串口的配置，并加入自己的理解和注释。串口是电脑与MUC进行通讯的重要手段，因此在工程开始之前配置好串口对后面的调试有很大的便利。串口是指外设和处理器之间通过数据信号线、地线和控制线等，按位进行传输数据的一种通讯方式。尽管传输速度比并行传输低。但串口可以在使用一根线发送数据的同时用另一根线接收数据。这种通信方式使用的数据线少，在远距离通信中可以节约通信成本。串口通信最重要的参数是波特率、数据位、停止位和奇偶校验位，这些参数在两个通信端口之间必须一致。
gd32 spi dma通信
11-01
GD32 SPI DMA通信是指在GD32系列微控制器中使用SPI接口和DMA进行数据传输的一种通信方式。 SPI（Serial Peripheral Interface）是一种同步串行通信总线，它在微控制器和外设之间传输数据。GD32系列微控制器通过SPI接口与外设（如传感器、存储器等）进行数据交互。为了提高数据传输效率，GD32系列微控制器还支持DMA（Direct Memory Access）技术。 DMA是一种无需CPU介入的数据传输方式，通过配置DMA控制器，可以实现在SPI接口和内存之间直接传输数据。在SPI DMA通信中，可以通过配置GD32的DMA控制器，实现SPI数据的输入输出。具体流程如下： 1. 配置SPI接口：包括设置SPI的工作模式（主从模式）、数据位宽、传输速度等参数。 2. 配置DMA通道：包括设置DMA通道的传输方向、传输数据的长度、传输数据的地址等参数。 3. 开启SPI和DMA：使能SPI接口和DMA通道，准备数据传输。 4. 启动DMA传输：通过触发信号（例如SPI中断）启动DMA传输，DMA控制器将根据配置的参数自动进行数据传输。 5. 数据传输完成：当DMA传输完成时，触发相应的中断或通过检测标志位完成数据传输的判断。 6. 数据处理：根据需要，对传输的数据进行处理，例如存储、计算、显示等。 7. 重复上述步骤：如果还有需要传输的数据，可以重复上述步骤进行数据传输。 通过使用SPI DMA通信，可以降低CPU的负担，提高系统的并行处理能力，并加快数据传输速度。GD32微控制器提供了相应的库函数和例程，方便开发者进行SPI DMA通信的配置和编程，实现更高效的数据交互。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值