【嵌入式】STM32F103 SPI主从收发实验

已于 2022-12-27 17:50:17 修改
阅读量1k 收藏 5
点赞数
分类专栏： 嵌入式系统 文章标签： stm32 单片机 嵌入式硬件
于 2022-12-23 14:39:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tq384998430/article/details/128419521
版权 
#include <stm32f10x_conf.h>
#include "sys.h"
#include "delay.h"
#include "usart.h"
#include "timer.h"
#include "pwm.h"
#include "gpio.h"
#include "fsmc.h"
#include "iic.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "task_com.h"
#include "task_motor.h"
#include "task_led.h"
#include "at_cmd.h"
#include "string.h"
#include "lib5500.h"
#include "flash.h"
#include "iwdg.h"
#include "ws2812_sim.h"

#define LOG_LEVEL_DISABLE      -1
#define LOG_LEVEL_ERROR        0
#define LOG_LEVEL_WARNING      1
#define LOG_LEVEL_INFO         2
#define LOG_LEVEL_DEBUG        3

#define LOG_LEVEL   LOG_LEVEL_DEBUG

#if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_DEBUG)
#define LOGD(fmt, ...)  printf("[D %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)   //%16s,%3d
#else
#define LOGD(fmt, ...)
#endif

#if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_INFO)
#define LOGI(fmt, ...)  printf("[I %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
#else
#define LOGI(fmt, ...)
#endif

#if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_WARNING)
#define LOGW(fmt, ...)  printf( "[W %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
#else
#define LOGW(fmt, ...)
#endif

#if defined(LOG_LEVEL) && (LOG_LEVEL >= LOG_LEVEL_ERROR)
#define LOGE(fmt, ...)  printf( "[E %s,%d] "fmt, __FUNCTION__, __LINE__, ##__VA_ARGS__)
#else
#define LOGE(fmt, ...)
#endif

#define MARK    LOGD("\n");

SemaphoreHandle_t SensorReadLock;
SemaphoreHandle_t UdpSendLock;
SemaphoreHandle_t slave_ready_lock;


void TaskMaster( void *pvParameters );
void TaskSlave( void *pvParameters );
static void SPI1_init(void);
static void SPI2_init(void);

void Initialization()
{
    MCU_INIT(RCC_PLLMul_9);        //?????: 12MHz * 6 = 72MHz
    Delay_Init(72);
    Uart_Init(USART1,115200,72);    //???????,PCLK1??????PCLK??RCC_HCLK_Div1???
    Uart_Init(USART2,9600,36);    //?????????,PCLK2??????PCLK??RCC_HCLK_Div1???
//     Uart_Init(USART3,115200,36);    //???????????
    printf("\r\n\r\n****************Build:%s %s****************\r\n",__DATE__,__TIME__);
//     UartSendStr(USART2,"System start\r\n");
}

int main(void)
{
    Initialization();
    
//    QStepMotorCommand = xQueueCreate( 1,sizeof(int) );
//    QHostCommand = xQueueCreate( 16,sizeof(int) );
    
    SensorReadLock = xSemaphoreCreateMutex();
    xSemaphoreGive(SensorReadLock);
    
    UdpSendLock = xSemaphoreCreateMutex();
    xSemaphoreGive(UdpSendLock);

    slave_ready_lock = xSemaphoreCreateMutex();
    xSemaphoreTake(slave_ready_lock, 0 * portTICK_PERIOD_MS);

    /* Start the tasks defined within this file/specific to this demo. */
//    xTaskCreate( TaskComm,    "task2", 2 * 256, NULL, 2, NULL );
    xTaskCreate( TaskMaster,    "task1", 4 * 256, NULL, 3, NULL );
    xTaskCreate( TaskSlave,    "task2", 4 * 256, NULL, 1, NULL );
    
    /* Start the scheduler. */
    vTaskStartScheduler();
    
    while(1);
    
}


#define USART1_RX_DMA_BUFF_SIZE        128
#define SPI2_RX_DMA_BUFF_SIZE        32
#define SPI2_TX_DMA_BUFF_SIZE        32


static void read_uart_input_buff(void);
static void USART1_RX_DMA_Init(void);
static void SPI2_RX_DMA_Init(void);
static void SPI2_TX_DMA_Init(void);
static void read_spi2_input_buff(void);
static void SPI2_frame_handler(uint8_t data);

static u32 s_frame_buff[1024];
static u8 USART1_RX_DMA_Buff[USART1_RX_DMA_BUFF_SIZE];    //????????????��????????????????????��????????????
static u8 SPI2_RX_DMA_Buff[SPI2_RX_DMA_BUFF_SIZE];
static u8 SPI2_TX_DMA_Buff[SPI2_TX_DMA_BUFF_SIZE] = {0xA0, 0x0 , 0x1 , 0x2 , 0x3 , 0x4 , 0x5 , 0x6 , 0x7 , 0x8 , 0x9 , 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x30};

void TaskMaster( void *pvParameters )
{
    LOGI("TaskMaster start...\r\n");

    // USART1_RX_DMA_Init();
    // ws2812_sim_init();
    SPI1_init();
    
    GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
    SPI_InitTypeDef SPI_InitStructure;

    //初始化片选引脚
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);    

    //chip select/reset pin init
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);


    xSemaphoreTake(slave_ready_lock, portMAX_DELAY);

    uint8_t count = 0;

    while(1)
    {
        // LOGI("test %d %d\r\n", count, DMA_GetCurrDataCounter(DMA1_Channel4));

        // read_uart_input_buff();

        static int state = 0;
        if (state == 0) {
            SPIx_ReadWriteByte(0xA5);   // preamble
            SPIx_ReadWriteByte(0x5A);
            SPIx_ReadWriteByte(0x55);
            SPIx_ReadWriteByte(0xAA);
            SPIx_ReadWriteByte(count);   // addr
            SPIx_ReadWriteByte(~count);   // cmd

            // count++;

            state = 1;
        } else if (state == 1) {
            static int timeout = 0;
            uint8_t data = SPIx_ReadWriteByte(0xFF);   // dummy byte
            // LOGI("%.2X\r\n", data);
            if (data == 0xA0) {
                for (int i = 0; i < 32; i++) {
                    uint8_t data = SPIx_ReadWriteByte(0xFF);
                    // printf("%.2X ", data);
                }
                // printf("\r\n");
                timeout = 0;
                state = 0;
                PCout(13) = ~PCout(13);
                // vTaskDelay(100);
            } else {
                if (timeout++ == 10) {
                    timeout = 0;
                    printf("timeout\r\n");
                    vTaskDelay(1000);
                    state = 0;
                }
            }
        } else if (state == 2) {
        }

        vTaskDelay(1);
    }
}

void TaskSlave( void *pvParameters )
{
    LOGI("TaskSlave start...\r\n");

    SPI2_init();
    SPI2_RX_DMA_Init();
    SPI2_TX_DMA_Init();

    xSemaphoreGive(slave_ready_lock);
    
    uint8_t count = 0;

    while(1)
    {
        read_spi2_input_buff();
        
        vTaskDelay(1);
    }
}

static void USART1_RX_DMA_Init(void)
{
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    
    DMA_DeInit(DMA1_Channel5);
    
    DMA_InitTypeDef DMA_InitStruct;
    DMA_StructInit(&DMA_InitStruct);
    DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&USART1->DR);
    DMA_InitStruct.DMA_MemoryBaseAddr = (u32)USART1_RX_DMA_Buff;
    DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStruct.DMA_BufferSize = sizeof(USART1_RX_DMA_Buff);
    DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
    
    DMA_Init(DMA1_Channel5,&DMA_InitStruct);
    
    DMA_ITConfig(DMA1_Channel5,DMA_IT_TC,DISABLE);
    DMA_ITConfig(DMA1_Channel5,DMA_IT_HT,DISABLE);
    DMA_ITConfig(DMA1_Channel5,DMA_IT_TE,DISABLE);
    
    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel5_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_Init(&NVIC_InitStruct);

    USART1->CR3 |= (1<<6);    //???DMA????
    DMA_Cmd(DMA1_Channel5,ENABLE);    //????DMA????

}

// void DMA1_Channel5_IRQHandler()
// {
//     DMA_ClearFlag(DMA1_FLAG_TC5);
//     int i;
//     for(i=0;i<sizeof(USART1_RX_DMA_Buff);i++)
//         printf("%c",USART1_RX_DMA_Buff[i]);
//     printf("\r\n");
// }

static void read_uart_input_buff(void)
{
        static int LastDataCount = 0;
        
        //????????DMA��???.????DMA_GetCurrDataCounter?????????????????????.
        int CurrDataCount = USART1_RX_DMA_BUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel5);
        
        if(LastDataCount != CurrDataCount)
        {
            int i;
            if(LastDataCount < CurrDataCount)
            {
//                 printf("1:%d %d,",LastDataCount,CurrDataCount);
                for(i = LastDataCount;i<CurrDataCount;i++) {
//                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
                     printf("%c",USART1_RX_DMA_Buff[i]);
                }
//                 printf("\r\n");
            }
            else
            {
//                 printf("2:%d %d,",LastDataCount,CurrDataCount);
                for(i = LastDataCount;i<USART1_RX_DMA_BUFF_SIZE;i++) {
//                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
                     printf("%c",USART1_RX_DMA_Buff[i]);
                }
                for(i = 0;i<CurrDataCount;i++) {
//                    MasterFrameInput(USART2_RX_DMA_Buff[i]);
                     printf("%c",USART1_RX_DMA_Buff[i]);
                }
//                 printf("\r\n");
            }
        }

        LastDataCount = CurrDataCount;
}

static void SPI1_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
    SPI_InitTypeDef SPI_InitStructure;

    //初始化片选引脚
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);    

    //chip select/reset pin init
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GPIOA, &GPIO_InitStructure);
    // SPI_CS = 1;
    // SPI_RST = 1;

    //初始化SPI引脚
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
      GPIO_Init(GPIOA, &GPIO_InitStructure);

    //初始化SPI1
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
    RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,ENABLE);//复位SPI1
    RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);//停止复位SPI1
    
      SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
      SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
      SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
      SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
      SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
      SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
      SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
      SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
      SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(SPI1,&SPI_InitStructure);

    SPI_SSOutputCmd(SPI1, ENABLE);
    // SPI_Cmd(SPI1, DISABLE);    //Enable SPI1  

    SPI_Cmd(SPI1, ENABLE);    //Enable SPI1  
    // SPIx_ReadWriteByte(0xff);    //启动传输
    // SPI_Cmd(SPI1, DISABLE);    //Enable SPI1  
}

static void SPI2_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;                    //定义一个GPIO结构体变量
    SPI_InitTypeDef SPI_InitStructure;

    //初始化片选引脚
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);    

    //chip select/reset pin init
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);
    // SPI_CS = 1;
    // SPI_RST = 1;

    //初始化SPI引脚
    GPIO_InitStructure.GPIO_Pin =   GPIO_Pin_12 |   // note that NSS pin of the SPI slave is use to select the
                                                    // device, if it is pulled up, SPI slave will not shift
                                                    // any byte to its shift register
                                    GPIO_Pin_13 | 
                                    GPIO_Pin_14 | 
                                    GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    //初始化SPI2
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,ENABLE);//复位SPI2
    RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);//停止复位SPI2

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
    SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_Init(SPI2,&SPI_InitStructure);

    SPI_SSOutputCmd(SPI2, DISABLE);
    // SPI_Cmd(SPI2, DISABLE);    //Enable SPI2  

    SPI_Cmd(SPI2, ENABLE);    //Enable SPI2  
    // SPIx_ReadWriteByte(0xff);    //启动传输
    // SPI_Cmd(SPI2, DISABLE);    //Enable SPI2
    
    // SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_RXNE, ENABLE);
    SPI_I2S_ITConfig(SPI2, SPI_I2S_IT_ERR, ENABLE);

    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = SPI2_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_Init(&NVIC_InitStruct);
    
}

void SPI2_IRQHandler()
{
    if (SPI_I2S_GetITStatus(SPI2, SPI_I2S_IT_RXNE) == SET) {
        // SPI_I2S_ClearITPendingBit(SPI2, SPI_I2S_IT_RXNE);
        LOGI("IRQ:%.2X\r\n", SPI2->DR);
    } else if (SPI_I2S_GetITStatus(SPI2, SPI_I2S_IT_ERR) == SET) {
        LOGE("SPI2 Error\r\n");
        while (1);
    } else {
        LOGE("Unknown SPI2 interrupt\r\n");
        while (1);
    }
}

static void SPI2_RX_DMA_Init(void)
{
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    
    DMA_DeInit(DMA1_Channel4);
    
    DMA_InitTypeDef DMA_InitStruct;
    DMA_StructInit(&DMA_InitStruct);
    DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
    DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_RX_DMA_Buff;
    DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC;
    DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_RX_DMA_Buff);
    DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStruct.DMA_Mode = DMA_Mode_Circular;
    DMA_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
    
    DMA_Init(DMA1_Channel4,&DMA_InitStruct);
    
    DMA_ITConfig(DMA1_Channel4,DMA_IT_TC,DISABLE);
    DMA_ITConfig(DMA1_Channel4,DMA_IT_HT,DISABLE);
    DMA_ITConfig(DMA1_Channel4,DMA_IT_TE,DISABLE);
    
    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel4_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_Init(&NVIC_InitStruct);

    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);

    DMA_Cmd(DMA1_Channel4,ENABLE);    //????DMA????


}

void DMA1_Channel4_IRQHandler()
{
    DMA_ClearFlag(DMA1_FLAG_TC4);
    int i;
    for(i=0;i<sizeof(SPI2_RX_DMA_Buff);i++)
        printf("%c",SPI2_RX_DMA_Buff[i]);
    printf("\r\n");
}

static void read_spi2_input_buff(void)
{
        static int LastDataCount = 0;
        
        int CurrDataCount = SPI2_RX_DMA_BUFF_SIZE - DMA_GetCurrDataCounter(DMA1_Channel4);
        
        if(LastDataCount != CurrDataCount)
        {
            int i;
            if(LastDataCount < CurrDataCount)
            {
//              printf("1:%d %d,",LastDataCount,CurrDataCount);
                for(i = LastDataCount;i<CurrDataCount;i++) {
                     // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
                    SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
                }
//              printf("\r\n");
            }
            else
            {
//              printf("2:%d %d,",LastDataCount,CurrDataCount);
                for(i = LastDataCount;i<SPI2_RX_DMA_BUFF_SIZE;i++) {
                    // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
                    SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
                }
                for(i = 0;i<CurrDataCount;i++) {
                    // printf("%.2X ",SPI2_RX_DMA_Buff[i]);
                    SPI2_frame_handler(SPI2_RX_DMA_Buff[i]);
                }
//              printf("\r\n");
            }
        }

        LastDataCount = CurrDataCount;
}

static void SPI2_frame_handler(uint8_t data)
{
    // printf("%.2X\r\n", data);

    static int state = 0;

    // 0xA5 5A 55 AA
    if (state == 0) {
        if (data == 0xA5) {
            state = 1;
        }
    } else if (state == 1) {
        if (data == 0x5A) {
            state = 2;
        } else if (data == 0xA5) {

        } else {
            LOGE("Frame err\r\n");
            // while (1);
            state = 0;
        }
    } else if (state == 2) {
        if (data == 0x55) {
            state = 3;
        } else if (data == 0xA5) {
            state = 1;
        } else {
            LOGE("Frame err\r\n");
            // while (1);
            state = 0;
        }
    } else if (state == 3) {
        if (data == 0xAA) {
            state = 4;
        } else if (data == 0xA5) {
            state = 1;
        } else {
            LOGE("Frame err\r\n");
            // while (1);
            state = 0;
        }
    } else if (state == 4) {
        // printf("ADDR:%.2X\r\n", data);
        state = 5;
    } else if (state == 5) {
        // printf("CMD:%.2X\r\n", data);
        // SPI2->DR = 0x33;

        DMA_Cmd(DMA1_Channel5, DISABLE);     // disable DMA before starting a new DMA transaction

        DMA_InitTypeDef DMA_InitStruct;
        DMA_StructInit(&DMA_InitStruct);
        DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
        DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_TX_DMA_Buff;
        DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
        DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_TX_DMA_Buff);
        DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
        DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
        DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
        DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
        DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
        DMA_InitStruct.DMA_Priority = DMA_Priority_High;
        DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
        
        DMA_Init(DMA1_Channel5,&DMA_InitStruct);

        DMA_Cmd(DMA1_Channel5, ENABLE);
        
        state = 0;
    } else if (state == 6) {

    } else if (state == 7) {

    } else if (state == 8) {

    } else if (state == 9) {

    } else if (state == 10) {

    } else {

    }
}

static void SPI2_TX_DMA_Init(void)
{
    RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
    
    DMA_DeInit(DMA1_Channel5);
    
    DMA_InitTypeDef DMA_InitStruct;
    DMA_StructInit(&DMA_InitStruct);
    DMA_InitStruct.DMA_PeripheralBaseAddr = (u32)(&SPI2->DR);
    DMA_InitStruct.DMA_MemoryBaseAddr = (u32)SPI2_TX_DMA_Buff;
    DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralDST;
    DMA_InitStruct.DMA_BufferSize = sizeof(SPI2_TX_DMA_Buff);
    DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
    DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable;
    DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
    DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
    DMA_InitStruct.DMA_Mode = DMA_Mode_Normal;
    DMA_InitStruct.DMA_Priority = DMA_Priority_High;
    DMA_InitStruct.DMA_M2M = DMA_M2M_Disable;
    
    DMA_Init(DMA1_Channel5,&DMA_InitStruct);
    
    DMA_ITConfig(DMA1_Channel5,DMA_IT_TC,DISABLE);
    DMA_ITConfig(DMA1_Channel5,DMA_IT_HT,DISABLE);
    DMA_ITConfig(DMA1_Channel5,DMA_IT_TE,DISABLE);
    
    NVIC_InitTypeDef NVIC_InitStruct;
    NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel5_IRQn;
    NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
    NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
    NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
    NVIC_Init(&NVIC_InitStruct);

    SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);

    DMA_Cmd(DMA1_Channel5,DISABLE);    //????DMA????

    // note: the last byte moved from RAM to SPI2->DR is seen as the end of DMA transmission
    // but the last byte still not been transferred out from the shift register which means
    // the SPI master might not received the last byte when the SPI slave finishing the DMA
    // transfer.
}

void DMA1_Channel5_IRQHandler()
{
    DMA_ClearFlag(DMA1_FLAG_TC5);
    // LOGI("Sent done\r\n");
    DMA_Cmd(DMA1_Channel5, DISABLE);
    // SPI2->DR = 0x00;     // set the shift register to 0x00 other wise SPI master will get the previous byte
    //                      // which might be 0xA0 and causes error.
                            // update: don't do it like this, due to the last byte still in the shift register
                            // and waiting to be shifted out from MISO. We can add a byte of 0x00 int the last 
                            // byte of the DMA buffer if the last byte is 0xA0.
}

Quan略略略
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STM32F103的SPI2+DMA接收数据
atoepdq039106的博客
09-12 5275
需求：STM32F103作为从设备，通过SPI接收大量数据； 方案：1.STM32的SPI通过中断接收（占用CPU资源，且长数据易丢失） 2.STM32通过SPI+DMA实现大数据接收（占用资源少） 本次采用第二种方案实现 时序图（见STM32F10XXX参考手册第471页）： 主要思路： 1. 配置SPI外设 SPI...
SPI通信之Slave 不受长度限制通信
DreamStreaking的博客
07-01 1026
最近在做两个MCU通过SPI口通信项目，以前大多数情况是使用SPI的master功能，今天在使用slave DMA传输数据时遇到一些，现将问题及关键点记录下来，为了以后避坑。MCU为两个STM32F4系列； ST官网标准库中有两个board SPI通信例子，但是它的master和slave都是固定长度的收发数据。SPI的通信由master控制传输速率、字节长度。但slave在最初并不清楚每次传输数据的长度，并且就算事先双方约定一个固定长度，每次总是按照固定长度收发数据，但存在一种可能即时钟信号如何受到干扰
基于STM32F103RCT6的SpI2的AD9833驱动
05-19
基于STM32F103RCT6的SpI2的AD9833驱动，支持三角波、方波、正弦波输出，频率连续可调。代码简单，可以直接移植使用。详情介绍见https://blog.csdn.net/weixin_43141547/article/details/106452650
STM32F103 SPI（踩坑日记）
qq_39854159的博客
01-20 1万+
STM32F103 SPI 笔记
【STM32CubeIDE】STM32F103硬件SPI驱动1.8寸TFT LCD128X160 ST7735S屏幕
perseverance51博客
03-08 3460
【STM32CubeIDE】STM32F103硬件SPI驱动1.8寸TFT LCD128X160 ST7735S屏幕
STM-32：SPI通信外设
立于皓月之边，不弱星光之势
05-03 1972
STM-32：SPI通信外设
STM32F103，SPI------FLASH
weixin_45760766的博客
09-12 2350
（4）主机接收从机数据：如果从机需要将数据发送回主机，则主机将继续产生预定数量的时钟信号，并且从机会将数据通过MISO信号线发送给主机。时钟相位(CPHA)：用来决定何时进行信号采样，0在第一个跳变沿，1在第二个跳变沿，至于是上升沿还是下降沿则由CPOL相位极性来表示。，节约了芯片的管脚，同时位PCB的布局上节省空间，提供方便，正是这种简单易用的特性，越来越多的芯片集成了这种通信协议，STM32也有SPI接口。如果CPHA=1,CPOL=1，则在SCK时钟的第二个边沿为下降沿时进行数据采样。
【嵌入式学习-STM32F103-SPI】
weixin_43251807的博客
04-05 3112
SPI学习记录，主要参考爱上半导体和江科大
STM32F103C6T6的两个SPI模块自通信实验中SPI2无法工作的问题
Alan_Walker_One的博客
05-22 2313
项目场景： 最近打算用STM32的最小系统版进行SPI通信实验，想首先验证SPI工作是否正常及观察收发数据是否正确，便进行STM32F103上SPI1和SPI2自通信。 问题描述 利用单步调试观察SPI1和SPI2寄存器的值，发现SPI1中各个寄存器的值符合预先设定，SPI2中寄存器的值都为零。 （0x40013000是SPI1的存储器映像地址，0x40003800是SPI2的存储器映像地址） 原因分析： 首先检查了SPI1和SPI2时钟及所在管脚的时钟是否开启，代码如下： /* 打开GPIOA
【正点原子STM32连载】第三十六章 SPI实验 摘自【正点原子】STM32F103 战舰开发指南V1.2
weixin_55796564的博客
06-20 1280
36.1.1 SPI介绍我们将从结构、时序和寄存器三个部分来介绍SPI。36.1.1.1 SPI框图SPI是英语 Serial Peripheral interface 缩写，顾名思义就是串行外围设备接口。SPI通信协议是 Motorola公司首先在其 MC68HCXX 系列处理器上定义的。SPI 接口是一种高速的全双工同步的通信总线，已经广泛应用在众多MCU、存储芯片、AD转换器和LCD之间。大部分STM32是有有3个SPI接口，本实验使用的是SPI2。
STM32下SPI主从机实验
06-08
基于stm32f103开发板，使用SPI1作为从机，SPI2作为主机，模拟三总线制的双核通讯。
STM32F1_SPI主从通信
01-21
SPI1作为主机发送，SPI2作为从机DMA接收
嵌入式 STM32F103系列 STM32F103中文教程及参考 学习资料
05-23
学习资料 STM32F103中文教程及参考 学习资料
嵌入式实验报告 stm32f103 跑马灯实验 GPIO口操作
07-27
熟悉编译环境，尝试独立进行工程的创建、编译、下载。通过阅读 STM32 芯片手册了解关于 GPIO 的相关内容，并且通过编程实现 LED 流水灯控制。
STM32F103C8T6的 SPI主从通讯
08-30
一份工程通过宏定义来实现主机和从机切换 主机实现串口接收SPI2发送给从机 从机SPI2接收，把接收的数据发送给串口。
串转并芯片74HC595和74HC164的区别
热门推荐
欢迎光临
12-02 2万+
串转并芯片一般用于对于速度要求不是非常严格并且IO资源有限的系统中，可以通过级联的方式轻松地扩展系统的可用输出IO口数量。同样的也可以使用并转串芯片扩展输入IO口的数量。 这里说一说串转并芯片74HC595和74HC164。 首先来看595芯片，如下图所示， 74HC595具有8位移位寄存器和一个存储器，三态输出功能。 移位寄存器和存储器有相互独立的时钟。数据在SH_
SAE J1939协议学习笔记
欢迎光临
07-21 2万+
引用百度百科： SAE J1939（以下简称J1939）是美国汽车工程协会（SAE）的推荐标准，用于为中重型道路车辆上电子部件间的通讯提供标准的体系结构。它由“卡车与大型客车电气与电子委员会”（Track & Bus Electrical & Electronics Committee）下属的“卡车与大型客车控制和通讯网络附属委员会”（Track & Bus Contro...
晶体(crystal)和晶振(oscillator)的区别
欢迎光临
12-28 2万+
参考文章：http://www.diangon.com/wenku/rd/dianzi/201502/00019711.html 晶振与晶体的区别： 1) 晶振是有源晶振的简称，又叫振荡器。英文名称是oscillator。晶体则是无源晶振的简称，也叫谐振器。英文名称是crystal，电路上简称为XTAL。 2) 无源晶振（晶体）一般是直插两个脚的无极性元件，需要借助时钟电路才能产生振荡信号。...
常用温度传感器的采集和换算方法
欢迎光临
08-16 2万+
1、前言 我觉得温度传感器应该是用量最大的传感器了，我也接触了好几种温度传感器，电阻型（50Ω，100Ω）、电流型（4~20mA）、RS485总线型、单总线型，各有各的特点。因为温度传感器使用很频繁，有必要总结一下几种最常用的温度传感器的采集方式和数据换算方法。 2、DS18B20 学习单片机的时候就很早就学过DS18B20温度传感器，测量范围为 -55 ℃ ~+ 125 ℃ ; 在 -...
嵌入式stm32f103课程设计
最新发布
02-20
嵌入式STM32F103课程设计是针对STM32F103系列单片机的课程设计项目。STM32F103是意法半导体（STMicroelectronics）公司推出的一款32位ARM Cortex-M3内核的微控制器，具有丰富的外设和强大的性能，广泛应用于嵌入式...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值