GD32单片机SPI数据传输发生错位

问题：使用两个GD32E103进行SPI数据传输，主机和从机接收的数组都会移位且不能按照数组顺序接收。

我作为从机，想要实现：主机发送7F 00 00 00 00 00 00 7F，从机传回7F 05 05 05 05 05 05 7F。如果不能实现数组形式传输，也可以一个数一个数的方式传输。

主机代码：

#include "gd32e10x.h"
#include "gd32e10x_eval.h"

//#define SPI_CRC_ENABLE           1
#define ARRAYSIZE                10

#define SET_SPI0_NSS_HIGH          gpio_bit_set(GPIOA,GPIO_PIN_4);
#define SET_SPI0_NSS_LOW           gpio_bit_reset(GPIOA,GPIO_PIN_4);

uint8_t spi0_send_array[ARRAYSIZE] = {0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA};
uint8_t spi2_send_array[ARRAYSIZE] = {0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA};
uint8_t spi0_receive_array[ARRAYSIZE] = {0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA};
uint8_t spi2_receive_array[ARRAYSIZE];
uint32_t send_n = 0, receive_n = 0;
uint32_t crc_value1 = 0, crc_value2 = 0;

void rcu_config(void);
void gpio_config(void);
void spi_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* initialize the LEDs */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    /* enable peripheral clock */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    
    SET_SPI0_NSS_LOW
    /* configure SPI */
    spi_config();
    /* enable SPI */
    spi_enable(SPI0);
    
#if SPI_CRC_ENABLE
    /* wait for transmit completed */
    while(send_n < ARRAYSIZE) {
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
        }
        spi2_receive_array[receive_n] = spi_i2s_data_receive(SPI2);
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
        }
        spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
    }

    /* send the last data */
    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE)) {
    }
    spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);

    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
    }
    spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);

    /* send the CRC value */
    spi_crc_next(SPI2);
    spi_crc_next(SPI0);

    /* receive the last data */
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
    }
    spi0_receive_array[receive_n] = spi_i2s_data_receive(SPI0);

    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
    }
    spi2_receive_array[receive_n++] = spi_i2s_data_receive(SPI2);

    /* receive the CRC value */
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
    }
    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
    }
    crc_value1 = spi_i2s_data_receive(SPI0);
    crc_value2 = spi_i2s_data_receive(SPI2);

    /* check the CRC error status  */
    if(SET != spi_i2s_flag_get(SPI0, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

    if(SET != spi_i2s_flag_get(SPI2, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#else
    /* wait for transmit completed */
    while(send_n < ARRAYSIZE) {
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);

        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
        }
        spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi0_receive_array, spi0_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

#endif /* enable CRC function */

    while(1) {
    }
}

/*!
    \brief      configure different peripheral clocks
    \param[in]  none
    \param[out] none
    \retval     none
*/
void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_AF);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
}

/*!
    \brief      configure the GPIO peripheral
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    /* configure SPI0 GPIO: SCK/PA5, MISO/PA6, MOSI/PA7 */
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_6);
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_4);

}

/*!
    \brief      configure the SPI peripheral
    \param[in]  none
    \param[out] none
    \retval     none
*/
void spi_config(void)
{
    spi_parameter_struct spi_init_struct;
    /* deinitilize SPI and the parameters */
    spi_i2s_deinit(SPI0);
    spi_i2s_deinit(SPI2);
    spi_struct_para_init(&spi_init_struct);

    /* configure SPI0 parameter */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_MASTER;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
    spi_init_struct.nss                  = SPI_NSS_SOFT;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

#if SPI_CRC_ENABLE
    /* configure SPI CRC function */
    spi_crc_polynomial_set(SPI0, 7);
    spi_crc_polynomial_set(SPI2, 7);
    spi_crc_on(SPI0);
    spi_crc_on(SPI2);
#endif /* enable CRC function */
}

/*!
    \brief      memory compare function
    \param[in]  src: source data pointer
    \param[in]  dst: destination data pointer
    \param[in]  length: the compare data length
    \param[out] none
    \retval     ErrStatus: ERROR or SUCCESS
*/
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length)
{
    while(length--) {
        if(*src++ != *dst++) {
            return ERROR;
        }
    }
    return SUCCESS;
}

从机代码：

#include "gd32e10x.h"
#include "gd32e10x_eval.h"

//#define SPI_CRC_ENABLE           1
#define ARRAYSIZE                10

uint8_t spi0_send_array[ARRAYSIZE] = {0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 0xA9, 0xAA};
uint8_t spi2_send_array[ARRAYSIZE] = {0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA};
uint8_t spi0_receive_array[ARRAYSIZE];
uint8_t spi2_receive_array[ARRAYSIZE];
uint32_t send_n = 0, receive_n = 0;
uint32_t crc_value1 = 0, crc_value2 = 0;

void rcu_config(void);
void gpio_config(void);
void spi_config(void);
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length);

/*!
    \brief      main function
    \param[in]  none
    \param[out] none
    \retval     none
*/
int main(void)
{
    /* initialize the LEDs */
    gd_eval_led_init(LED2);
    gd_eval_led_init(LED3);
    /* enable peripheral clock */
    rcu_config();
    /* configure GPIO */
    gpio_config();
    /* configure SPI */
    spi_config();
    /* enable SPI */
    spi_enable(SPI2);
    spi_enable(SPI0);

#if SPI_CRC_ENABLE
    /* wait for transmit completed */
    while(send_n < ARRAYSIZE) {
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);
        while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
        }
        spi2_receive_array[receive_n] = spi_i2s_data_receive(SPI2);
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
        }
        spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
    }

    /* send the last data */
    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_TBE)) {
    }
    spi_i2s_data_transmit(SPI2, spi2_send_array[send_n]);

    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
    }
    spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);

    /* send the CRC value */
    spi_crc_next(SPI2);
    spi_crc_next(SPI0);

    /* receive the last data */
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
    }
    spi0_receive_array[receive_n] = spi_i2s_data_receive(SPI0);

    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
    }
    spi2_receive_array[receive_n++] = spi_i2s_data_receive(SPI2);

    /* receive the CRC value */
    while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
    }
    while(RESET == spi_i2s_flag_get(SPI2, SPI_FLAG_RBNE)) {
    }
    crc_value1 = spi_i2s_data_receive(SPI0);
    crc_value2 = spi_i2s_data_receive(SPI2);

    /* check the CRC error status  */
    if(SET != spi_i2s_flag_get(SPI0, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }

    if(SET != spi_i2s_flag_get(SPI2, SPI_FLAG_CRCERR)) {
        gd_eval_led_on(LED3);
    } else {
        gd_eval_led_off(LED3);
    }
#else
    /* wait for transmit completed */
    while(receive_n < ARRAYSIZE) {
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_TBE)) {
        }
        spi_i2s_data_transmit(SPI0, spi0_send_array[send_n++]);
        while(RESET == spi_i2s_flag_get(SPI0, SPI_FLAG_RBNE)) {
        }
        spi0_receive_array[receive_n++] = spi_i2s_data_receive(SPI0);
        
        
    }

    /* compare receive data with send data */
    if(ERROR != memory_compare(spi0_receive_array, spi0_send_array, ARRAYSIZE)) {
        gd_eval_led_on(LED2);
    } else {
        gd_eval_led_off(LED2);
    }
    

#endif /* enable CRC function */

    while(1) {
    }
}

/*!
    \brief      configure different peripheral clocks
    \param[in]  none
    \param[out] none
    \retval     none
*/
void rcu_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOC);
    rcu_periph_clock_enable(RCU_AF);
    rcu_periph_clock_enable(RCU_SPI0);
    rcu_periph_clock_enable(RCU_SPI2);
}

/*!
    \brief      configure the GPIO peripheral
    \param[in]  none
    \param[out] none
    \retval     none
*/
void gpio_config(void)
{
    /* configure SPI0 GPIO: SCK/PA5, MISO/PA6, MOSI/PA7 */
     /* set GPIO PA4 as SPI0 NSS input */

    
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_5 | GPIO_PIN_7);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_4);
    gpio_init(GPIOA, GPIO_MODE_AF_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_6);

}

/*!
    \brief      configure the SPI peripheral
    \param[in]  none
    \param[out] none
    \retval     none
*/
void spi_config(void)
{
    spi_parameter_struct spi_init_struct;
    /* deinitilize SPI and the parameters */
    spi_i2s_deinit(SPI0);
    spi_struct_para_init(&spi_init_struct);

    /* configure SPI0 parameter */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;
    spi_init_struct.device_mode          = SPI_SLAVE;
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT;
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;
    spi_init_struct.nss                  = SPI_NSS_HARD;
    spi_init_struct.prescale             = SPI_PSC_256;
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(SPI0, &spi_init_struct);

#if SPI_CRC_ENABLE
    /* configure SPI CRC function */
    spi_crc_polynomial_set(SPI0, 7);
    spi_crc_polynomial_set(SPI2, 7);
    spi_crc_on(SPI0);
    spi_crc_on(SPI2);
#endif /* enable CRC function */
}

/*!
    \brief      memory compare function
    \param[in]  src: source data pointer
    \param[in]  dst: destination data pointer
    \param[in]  length: the compare data length
    \param[out] none
    \retval     ErrStatus: ERROR or SUCCESS
*/
ErrStatus memory_compare(uint8_t *src, uint8_t *dst, uint8_t length)
{
    while(length--) {
        if(*src++ != *dst++) {
            return ERROR;
        }
    }
    return SUCCESS;
}

传输0x05，更改传输速度8分频，时钟极性1，第二个边沿采样得到如下结果：

传输0x05，更改传输速度64分频，时钟极性1，第二个边沿采样得到如下结果：

得到结果会移位，也就是
14
0001 0100

A0
1010 0000

0A
0000 1010

更改256分频，时钟极性0，第一个边沿采样得到如下结果：

数据正确，但是顺序不是按照发送顺序。
还尝试过中断和DMA处理，都是相同情况。
有没有工程师知道怎么解决的。

写回答
好问题 0 提建议
关注问题
分享
邀请回答
编辑收藏删除结题
收藏举报

2条回答默认最新

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
强国豪，林中霖 2023-07-23 09:34
关注
检查SPI时钟频率是否正确，确保时钟频率在设备允许的范围内；

检查SPI数据传输模式是否正确，确保数据传输模式与设备要求的模式一致；

检查SPI数据位宽是否正确，确保数据位宽与设备要求的位宽一致；

检查SPI片选信号是否正确，确保片选信号与设备要求的信号一致；

检查SPI数据传输顺序是否正确，确保数据传输顺序与设备要求的顺序一致；

检查SPI数据传输时序是否正确，确保数据传输时序与设备要求的时序一致；

检查SPI数据传输方向是否正确，确保数据传输方向与设备要求的方向一致；

检查SPI数据传输格式是否正确，确保数据传输格式与设备要求的格式一致；

检查SPI数据传输时的中断是否正确，确保数据传输时的中断与设备要求的中断一致；

检查SPI数据传输时的延时是否正确，确保数据传输时的延时与设备要求的延时一致。
解决无用
评论打赏
分享
举报

评论

按下Enter换行，Ctrl+Enter发表内容

报告相同问题？

关注问题

STM32 DMA SPI 自发自收数据错位问题
2024-07-22 14:04

imico12的博客把HAL_SPI_Receive_DMA(&hspi1, spi1_rxdata, 8);屏蔽后，SPI2接收正常。数据错位问题，SP1发送 {0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88};...没有深入分析原因，有知道的大神可以告知一下哈~SPI2接收总是发生错位。
STM32 从机SPI全双工DMA错位问题及解决
2025-01-14 17:06

qq_16963231的博客 STM32的作从机SPI，接收错位、异常等问题是经常能碰到的。比如在debug时程序断点会随机打乱DMA本身传输数据的顺序；或是由于中断嵌套未处理好而导致从机SPI不能及时完成全双工通信；或者是由于外部电磁环境干扰了CLK...
Stm32 SPI+DMA连续发送出现丢字节/时序错乱的可能原因
2025-10-12 19:12

nnzll1826的博客 up在驱动LCD时，使用了SPI+DMA进行。将全屏填充函数做了硬件SPI和SIP+DMA两个版本。我发现在仅使用SPI模式时，连续发送数据依旧正常。...抓取波形，发现第二次传输时的地址被打乱了，出现数据错乱。
STM32F103C8T6的SPI收发数据错误的问题
2022-05-22 14:46

Alan_Walker_One的博客本人最近在做一个STM32F103C8T6的两个SPI模块自通信实验，旨在验证SPI收发数据的正确性。即事先设定好两个SPI模块发送的值，通过ST-LINK单步调试观察单片机内部寄存器的值。待发送的数据如下：同时定义两个SPI的...
stm32HAL库 G4 SPI 从机DMA可变长度接受数据乱码问题
2023-09-02 18:39

紫枫洛天的博客如果实际主机只发了小于20字节时候, 下一个帧就会错乱;去老外找了之后,需要复位SPi RCC时钟才能复位掉SPI。使用一个引脚当作SPI CS, 边沿触发;在电平位0时候接受SPI数据20个字节。
---GD32 MCU---SPI硬件CRC校验失败
2020-02-28 17:57

笙歌君独忧的博客使用SPI的CRC校验始终失败，发送的SPI0发送和读取回来的数据错位了两个字节，导致CRC校验不对。原因： SPI0使用16位格式发送数据，但是客户在使能发送的数据之前，使用了SPI0按照8位格式发送了两个字节，SPI0进行...
多个单片机之间的SPI主从通讯
2024-05-20 15:15

菜长江的博客 1.因为工作是从事PCBA测试软件开发的(上位机),之前做过的很多项目都是一个单片机完成所有功能，做了有段时间了无非就是那些东西的操控,继电器,电压,电流,PWM,串口,外部IO信号采集,无非是通道的多少,可能这次项目需要...
GD32F427 SDIO DMA写入后读取数据错误问题
2025-01-08 16:41

屛楼听雨的博客上述问题通过指针偏移地址后不为字节对齐地址，传输过程中DMA强制进行对齐访问则将无效地址数据传输存储，所以导致写入数据和读取数据不符，解决办法为一重新分配字节对齐地址后在配置给DMA传输，二修改DMA对齐方式...
RT-Thread开发GD32F450 添加串口外设，以及一种串口接收数据处理的方法
2023-03-27 19:11

嵌入式学习和实践的博客开发板使用的是gd32f450zk，env工具使用的版本是1.3.5，rtthread版本是5.0.0。添加串口外设的方法，串口2是打印口，串口0是数据收发口。串口2的引脚是PB10和PD9，串口0的引脚是PA9和PA10.使用env工具，menuconfig...
GD32F303调试小记(五)之ADC+DMA+硬件过采样
2022-02-05 19:55

欢喜6666的博客 单片机的大多数的功能都是基于数字信号去控制的。然而许多的场合下，我们也需要有模拟信号的参与，因为许多变量的控制是需要连续的而非阶跃式的。常见的若想得到电压值、温度值、电流值等等都需要用到A/D转换(如果...
GD32读取GT30L32S4W字模芯片输出数据出错的总结
2022-09-01 08:59

kyh_to_future的博客高通字模芯片读数据错误的一种解决办法
STM32-使用软件NSS时，第一个字节的时序错误问题
2025-05-07 18:21

Blade-Ace的博客如图所示，在传输第一个字节时，CLK才会被设置为空闲状态（电平变高）。这样会导致，部分使用者，在使用SPI，读取第一个字节时，出现错误。
关于stm32作i2c从机时发送第一个字节错误的经验总结
2023-06-19 21:38

国企摸鱼程序猿的博客图中TXIS表示前一个字节，实际上，在主机发送和从机地址之前，从机就向TXDR写入了一个字节data1，但是软件中并没有将数据准备好，就将ISR寄存器bit0的值（TXE)置1了，于是立刻刷新可TXDR，导致多了一个字节，而第1帧...
阮工的单片机编程经验集：如何做稳定单片机程序与上位机程序防卡顿,js等经验；阮丁远于20251110
2019-12-08 00:52

阮丁远的博客阮工的单片机编程经验集V2.0：如何做稳定单片机程序，阮丁远于20220614： ================================================================================================ 20191207 : 5V等电源输入时...
使用GD32E230，ADC+DMA，在FLASH编程时出现adc数据错位的解决办法
2023-04-23 16:33

qq_24655853的博客下面把代码贴出，根据GD32E230固件库写的，我用的是GD32E230G8。获取ADC值，每次获取时触发一次转换，我这个是在定时器中断中调用的。根据大佬介绍改完代码，运行完美！
为什么越来越多 DIY 爱好者选择 STM32F407VET6？真实案例分享
2025-12-09 16:54

milk5的博客本文深入分析STM32F407VET6在DIY爱好者中流行的原因，涵盖其高性能Cortex-M4内核、丰富外设接口、强大开发生态及成熟中文社区支持。通过真实智能家居网关案例，展示其多任务处理、网络通信与图形显示能力，揭示其...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 6月30日

GD32单片机SPI数据传输发生错位

2条回答 默认 最新

问题事件

2条回答默认最新