gd32h7 spi全双工极限速度测试

于 2024-08-06 18:05:30 发布
阅读量253 收藏
点赞数 1
分类专栏： gd32 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43026921/article/details/140962548
版权

同一块H7开发板上开2个spi互相传输数据，经过测试在此频率下运行最稳定
最高运行频率 300MHz / 16 = 18.75MHz
最高传输速度 2117kb/s

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 SPI_BUFF_SIZE 1024

uint32_t master_send_bytes = 0;
uint32_t master_send_error_bytes = 0;
uint32_t master_recv_error_bytes = 0;

__attribute__ ((aligned(32))) uint8_t master_tx_buff[SPI_BUFF_SIZE] = {0};
__attribute__ ((aligned(32))) uint8_t master_rx_buff[SPI_BUFF_SIZE] = {0};
__attribute__ ((aligned(32))) uint8_t slave_tx_buff[SPI_BUFF_SIZE] = {0};
__attribute__ ((aligned(32))) uint8_t slave_rx_buff[SPI_BUFF_SIZE] = {0};



void spi_master_transmit_receive_dma(uint8_t* tx_buff, uint8_t* rx_buff, int size);
void spi_slave_transmit_receive_dma(uint8_t* tx_buff, uint8_t* rx_buff, int size);


/*!
    \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_16;
    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, 0);
    nvic_irq_enable(DMA0_Channel1_IRQn, 1, 1);


    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);


        //验证数据是否正确
        if (memcmp(slave_tx_buff, master_rx_buff, SPI_BUFF_SIZE) != 0) {
            master_recv_error_bytes += SPI_BUFF_SIZE;
        }


        //接收完继续发送
        spi_slave_transmit_receive_dma(slave_tx_buff, slave_rx_buff, SPI_BUFF_SIZE);
        spi_master_transmit_receive_dma(master_tx_buff, master_rx_buff, SPI_BUFF_SIZE);
    }
}



/*
 * 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_16;
    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);

        master_send_bytes += SPI_BUFF_SIZE;


        //验证数据是否正确
        if (memcmp(master_tx_buff, slave_rx_buff, SPI_BUFF_SIZE) != 0) {
            master_send_error_bytes += SPI_BUFF_SIZE;
        }

    }
}



void timer_config()
{
    nvic_irq_enable(TIMER1_IRQn, 0,0);

    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER1);

    //1Hz
    timer_deinit(TIMER1);
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler         = 30000 - 1;
    timer_initpara.alignedmode       = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection  = TIMER_COUNTER_UP;
    timer_initpara.period            = (uint64_t)(10000 - 1);
    timer_initpara.clockdivision     = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER1, &timer_initpara);

    timer_interrupt_flag_clear(TIMER1, TIMER_INT_FLAG_UP);
    timer_interrupt_enable(TIMER1, TIMER_INT_UP);
    timer_enable(TIMER1);
}

void TIMER1_IRQHandler(void)
{
    if(SET == timer_interrupt_flag_get(TIMER1, TIMER_INT_FLAG_UP)){
        timer_interrupt_flag_clear(TIMER1, TIMER_INT_FLAG_UP);


        char buff[128];
        snprintf(buff, 128, "speed: %.2fkb/s send_error:%d recv_error:%d\r\n", (float)master_send_bytes / 1024.0,
                 master_send_error_bytes, master_recv_error_bytes);
        usart_transmit(buff, strlen(buff));

        master_send_bytes = 0;
        master_send_error_bytes = 0;
        master_recv_error_bytes = 0;

        gpio_bit_toggle(GPIOJ, GPIO_PIN_8);
    }
}


void init_tx_buff(uint8_t* buff, int size, uint32_t seed)
{
    for (int i = 0; i < size; ++i) {
        seed ^= (13 + i);
        buff[i] = seed;
    }
}

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


    timer_config();


    init_tx_buff(master_tx_buff, SPI_BUFF_SIZE, 1314);
    init_tx_buff(slave_tx_buff, SPI_BUFF_SIZE, 512);

    spi_slave_transmit_receive_dma(slave_tx_buff, slave_rx_buff, SPI_BUFF_SIZE);
    spi_master_transmit_receive_dma(master_tx_buff, master_rx_buff, SPI_BUFF_SIZE);


    int cnt = 0;
    while(1) {


        delay_1ms(1000);
    }
}
BusyBox0
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单次事件触发DMA读取多字节SPI数据
weixin_38106263的博客
12-12 4769
有人想使用定时器事件触发DMA读取SPI数据，希望每一次更新事件仅触发一轮DMA传输，借助DMA实现N字节的SPI数据收发。要完成这个功能，这里推荐两种做法供参考。第一种，先做好SPI的D...
STM32-H7开发环境搭建
qq_16175499的博客
07-24 1286
前言： 使用的是stm32 Nucleo-H7A3ZI-Q开发板，由于网上资料较少，自己折腾一遍后写一些东西用来记录，不然过段时间忘了再重新准备又要很久。 1.下载安装配置STM32CubeMx环境 提取码：1234 1.1安装CubeMx软件 1.2安装H7包 2.下载安装配置MDK ARM环境 提取码：1234 这个要安装比较新的版本，不然无法适配H7上自带的V3版本stlink。 2.1安装MDK 2.2安装H7库 3.MDK的具体设置 3.1勾选Use MicroLIB，用于后面重映射pri
GD32303C_SPI_QSPI_DMA.rar_GD32 DMA spi_GD32 文件_gd32 spi dma_spi
07-15
GD32通过SPI和QSPI模式读取GD的NOR Flash，支持DMA模式，和文件系统。
同旺科技 USB TO SPI / I2C 专业版 极限测试 ---- 读取数据
weixin_69665239的博客
04-10 352
设置如下，读取65500个字节，单条指令，速率20Mhz;备注：带EXCEL调试的只适用于专业版；
GD32H7xx_ADC模拟配置问题
frank_1a的博客
09-26 779
GD MCU H7 GPIO ADC TIMER
GD32H7系列学习笔记（1）
叮当猫的博客
03-15 655
片上SRAM的使用建议
兆易创新推出最强GD32H7，STM32可以在VS Code中新建、调试软件
strongerHuang
03-22 1173
兆易创新推出最强GD32H7，STM32可以在VS Code中新建、调试软件（点击链接，阅读原文）更多视频，请到我视频号查看：点击“阅读原文”查看更多分享。
基于GD32F103采用硬件SPI驱动0.96寸OLED显示图片汉字字符串多级菜单等
12-15
GD32F103是一款基于ARM Cortex-M3内核的高性能微控制器，具有丰富的外设接口，其中包括SPI（串行外围接口），它可以高效地驱动OLED显示器。 首先，我们要理解SPI是一种同步串行通信协议，它允许主设备（在这里是GD...
SPI_Master_Slaver_303.rar_SPI_SLAVE GD32_gd32 spi_master_slave_s
07-14
这个名为"SPI_Master_Slaver_303.rar"的压缩包文件可能包含了一个关于如何在GD32微控制器上设置和操作SPI主从通信的实例或教程。 标题中的"SPI_SLAVE GD32"表明这个资源主要关注的是GD32微控制器上的SPI从机模式。...
RT-thread+GD32F450+spi+GD25Q32.zip
04-07
《RT-thread+GD32F450+SPI+GD25Q32：嵌入式系统中的SPI闪存操作》 RT-thread是一款强大的、开源的实时操作系统，它广泛应用于各种嵌入式设备中，提供了丰富的功能和服务。在本项目中，RT-thread与GD32F450系列微...
应用笔记LAT1398+STM32H7+SPI+NSS功能的灵活应用案例
最新发布
04-15
### 应用笔记LAT1398+STM32H7+SPI+NSS功能的灵活应用案例 #### 1. 引言 本应用笔记针对某客户开发的一款高精度工业测量仪器，旨在解决使用STM32H7微控制器与外置高精度ADC采样芯片进行通信的问题。该客户在开发...
【兆易创新GD32H759I-EVAL开发板】图像处理加速器（IPA）的应用
qq50031185的专栏
03-15 1769
参数(在结构体中)意义：为整个前景图像设置统一的alpha透明度值。作用：用于在混合操作中调整前景图像的透明度，实现透明效果或图像覆盖。概念：Alpha值用于定义像素的透明度。前景预定义的alpha值是在图像融合或者alpha混合操作中，前景图像像素的默认透明度值。这个值会根据设置的alpha计算模式与前景像素的实际alpha值（如果存在）一起决定最终的像素透明度。概念：前景预定义的红、绿、蓝色值允许用户为整个前景图像设置一个统一的颜色调整或色彩偏移。
H7-TOOL脱机烧录器支持1拖4，支持新唐，GD32，MM32，AT32，APM32，CX32，STM32，STM8，i.MX RT，W7500，外置Flash等2020-10-27
Simon223的博客
05-30 6515
大家在使用中，有什么建议，欢迎反馈。脱机烧录视频效果展示：http://v.qq.com/x/page/p30628h2ou7.html多款STM8+STM32产品混合烧录展示：http://v.qq.com/x/page/o0932ppnuwx.html1拖4脱机烧录效果展示：https://v.qq.com/x/page/s0954t133ti.htmlV1.20版APP程序：h7_tool_app(V1.20).zip (480.91KB)H7-TOOL_STM32H7_App-master(V1.2
【兆易创新GD32H759I-EVAL开发板】Keil平台快速搭建Free RTOS 系统
qq50031185的专栏
03-15 669
去掉 SVC_Handler(void),PendSV_Handler(void),SysTick_Handler(void)三个函数。// 延时500ms。// 延时500ms。// LED点灯任务函数。
《痞子衡嵌入式半月刊》 第 74 期
痞子衡嵌入式
03-20 296
痞子衡嵌入式半月刊： 第 74 期 这里分享嵌入式领域有用有趣的项目/工具以及一些热点新闻，农历年分二十四节气，希望在每个交节之日准时发布一期。 本期刊是开源项目(GitHub: JayHeng/pzh-mcu-bi-weekly)，欢迎提交 issue，投稿或推荐你知道的嵌入式那些事儿。 上期回顾 ：《痞子衡嵌入式半月刊： 第 73 期》 唠两句 历史上的今天：1990年3月20日，中国自行...
【兆易创新GD32H759I-EVAL开发板】USB设备 介绍1
qq50031185的专栏
03-24 1370
微控制器核心：GD32H759I-EVAL搭载了GD32H7系列的微控制器，采用ARM Cortex-M7内核，最高主频可达600MHz，配备了高速浮点单元（FPU）和内存保护单元（MPU），为计算密集型应用提供了强力支撑。内存配置：内置了多种规模的Flash和SRAM，提供足够的程序存储空间和运行缓存，以适应不同的应用需求。丰富的外设和通信接口：包括多路ADC、DAC、定时器、PWM控制器、I2C、SPI、USART以及USB OTG等，可满足各类外设连接和数据交换需求。USB接口特性。
替代STM32的GD32，替代KEIL的Eclipse配置---连载4
weixin_45426095的博客
09-02 1224
Eclipse的H750程序改写
STM32 SPI读写速度评估
qq_23313467的博客
01-20 5360
对STM32H7 SPI 读写速度进行评估
STM32H7使用QSPI外扩flash（linux下使用openocd操作）
m0_64213554的博客
10-27 3294
在linux环境下没有keil5 IDE的情况下，如何使用clion+openocd实现 1、将大体积代码下载到外置flash并执行 2、对外置flash执行的代码进行仿真
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值