1. Toy模板网首页
  2. > Toy博客

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）

5月前 作者：大鱼儿Yu 分类：Toy博客 阅读(18) 违法举报

这篇具有很好参考价值的文章主要介绍了STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1、硬件电路

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

需要系统性的看一下W25Q256芯片手册 

2、设置RCC，选择高速外部时钟HSE,时钟设置为180MHz

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

3、配置SPI

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

4、生成工程配置

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

 STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

5、读写流程图

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

5、相关代码

/**
*   W25Q256JV FLASH芯片有256M bit总共32M byte存储空间
*   W25Q256JV的存储阵列被组织成131072个可编程页面，每个页面256字节。每次最多可以编程256字节
*   扇区大小为：16 * page 即 16 *256 = 4KB字节。
*   块大小为：128 * page 即 128 *256 = 32KB字节。或者是 256 * page 即 256 * 256 = 64KB 字节。
*   擦除：W25Q256JV芯片可以以4KB扇区为单位进行擦除，也可以以32KB块为单位进行擦除/64KB块为单位进行擦除，或者整个芯片为一组进行擦除。
*         W25Q256JV有8192个可擦除的扇区和512个可擦除的块。
*
*/

/**
 * 三个状态寄存器中可写的寄存器位包括：状态寄存器1中的TB、BP[3:0]；状态寄存器2中的CMP、LB[3:1]、QE、SRL；状态寄存器3中的DRV1、DRV0、WPS和ADP。
 * 所有其他状态寄存器位都是只读的，不会受到写状态寄存器指令的影响。
 * LB[3:1]是非易失性的OTP位，一旦被设置为1，就不能被清零。
*/


#define sFLASH_ID 0xef4019 // W25Q256

#define SPI_FLASH_PageSize 256
#define SPI_FLASH_PerWritePageSize 256
#define SPI_FLASH_Secsize   4096

#define W25Q256_WriteEnable         0x06    //写使能命令
#define W25Q256_WriteDisable        0x04    //写屏蔽命令
#define W25Q256_ReadStatusReg1      0x05    //读状态寄存器1命令
#define W25Q256_ReadStatusReg2      0x35    //读状态寄存器2命令
#define W25Q256_ReadStatusReg3      0x15    //读状态寄存器3命令
#define W25Q256_WriteStatusReg1     0x01    //写状态寄存器1命令
#define W25Q256_WriteStatusReg2     0x31    //写状态寄存器2命令
#define W25Q256_WriteStatusReg3     0x11    //写状态寄存器3命令
#define W25Q256_ReadData            0x13    //4字节模式读取数据命令
#define W25Q256_PageProgram         0x02    //页写入命令令（1页256字节）
#define W25Q256_PageProgram_4byte   0x12    //4字节模式页写入命令（1页256字节）
#define W25Q256_SectorErase         0x20    //扇区擦除命令（一次擦除一个扇区/4KB）
#define W25Q256_SectorErase_4byte   0x21    //4字节模式扇区擦除命令（一次擦除一个扇区/4KB）
#define W25Q256_BlockErase_32       0x52    //块擦除命令（一次擦除一个块/32KB）
#define W25Q256_BlockErase_64       0xD8    //块擦除命令（一次擦除一个块/64KB）
#define W25Q256_BlockErase_64_4byte 0xDC    //4字节模式块擦除命令（一次擦除一个块/64KB）
#define W25Q256_flashErase          0xC7    //将flash的存储全部擦除命令。可以使用C7/60
#define W25Q256_JedecDeviceID       0x9F    //读取设备ID命令
#define W25Q256_Enter4ByteMode      0xB7    //进入4字节地址模式命令

#define WIP_Flag 0x01
uint8_t flash_sec_data[4096]; // flash一个扇区的数据

/**
 * @brief   拉低片选线
 * @param   无
 * @retval  无
 */
void SPI_FLASH_NSS_LOW(void)
{
    HAL_GPIO_WritePin(SPI5_NSS_GPIO_Port, SPI5_NSS_Pin, GPIO_PIN_RESET);
}

/**
 * @brief   拉高片选线
 * @param   无
 * @retval  无
 */
void SPI_FLASH_NSS_HIGH(void)
{
    HAL_GPIO_WritePin(SPI5_NSS_GPIO_Port, SPI5_NSS_Pin, GPIO_PIN_SET);
}

/**
 * @brief   读取 FLASH ID函数
 * @param   无
 * @retval  FLASH ID
 */
uint32_t SPI_FLASH_ReadID(void)
{
    uint32_t temp = 0;
    uint8_t temp0 = 0;
    uint8_t temp1 = 0;
    uint8_t temp2 = 0;
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送获取W25Q256芯片ID指令
    SPI_FLASH_SendByte(W25Q256_JedecDeviceID);
    // 接收数据
    temp0 = SPI_FLASH_ReadByte();
    temp1 = SPI_FLASH_ReadByte();
    temp2 = SPI_FLASH_ReadByte();
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    temp = temp0 << 16 | temp1 << 8 | temp2;
    return temp;
}

/**
 * @brief   发送一个字节
 * @param   无
 * @retval  无
 */
void SPI_FLASH_SendByte(uint8_t ch)
{
    HAL_SPI_Transmit(&hspi5, &ch, 1, 500);
}

/**
 * @brief   发送n个字节
 * @param   pData：发送数据首地址
 * @param   data_number：发送数据个数（以字节为单位）
 * @retval  无
 */
void SPI_FLASH_SendnByte(uint8_t *pData, uint32_t data_number)
{
    HAL_SPI_Transmit(&hspi5, pData, data_number, 500);
}

/**
 * @brief   读取一个字节
 * @param   无
 * @retval  接收的数据
 */
uint8_t SPI_FLASH_ReadByte(void)
{
    uint8_t rxData = 0;
    HAL_SPI_Receive(&hspi5, &rxData, 1, 500);
    return rxData;
}

/**
 * @brief   接收n个字节
 * @param   pData：接收数据首地址
 * @param   data_number：接收数据个数（以字节为单位）
 * @retval  无
 */
void SPI_FLASH_ReadnByte(uint8_t *pData, uint32_t data_number)
{
    HAL_SPI_Receive(&hspi5, pData, data_number, 500);
}

/**
 * @brief   使能写命令
 * @param   无
 * @param   无
 * @retval  无
 */
void SPI_FLASH_WriteEnable(void)
{
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送写使能指令
    SPI_FLASH_SendByte(W25Q256_WriteEnable);
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    SPI_FLASH_busy_block();
}

/**
 * @brief   等待写入、擦除等操作完成
 * @param   无
 * @param   无
 * @retval  无
 */
void SPI_FLASH_WaitForWriteEnd(void)
{
    uint8_t FLASH_Status = 0;
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送写状态寄存器1指令
    SPI_FLASH_SendByte(W25Q256_ReadStatusReg1);
    do
    {
        // 获取写状态寄存器1的值并做判断。0：空闲、1：忙碌
        FLASH_Status = SPI_FLASH_ReadByte();
    } while (SET == (FLASH_Status & WIP_Flag));

    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
}

/**
 * @brief   擦除扇区函数
 * @param   SectorAddr：擦除扇区首地址
 * @retval  无
 */
void SPI_FLASH_SectorErase(uint32_t SectorAddr)
{
    //  使能写命令
    SPI_FLASH_WriteEnable();
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送擦除扇区命令
    SPI_FLASH_SendByte(W25Q256_SectorErase_4byte);
    // 发送擦除地址24 ~ 31bit
    SPI_FLASH_SendByte((SectorAddr & 0xFF000000) >> 24);
    // 发送擦除地址16 ~ 23bit
    SPI_FLASH_SendByte((SectorAddr & 0xFF0000) >> 16);
    // 发送擦除地址8 ~ 15bit
    SPI_FLASH_SendByte((SectorAddr & 0xFF00) >> 8);
    // 发送擦除地址0 ~ 7bit
    SPI_FLASH_SendByte(SectorAddr & 0xFF);
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    // 等待擦除操作结束
    SPI_FLASH_busy_block();
}

/**
 * @brief   配置4字节模式函数
 * @param   无
 * @retval  1:设置成功；
 * @retval  0:设置失败；
 */
int SPI_FLASH_FOUR_MODE(void)
{
    uint8_t temp = 0;
CODE:
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送读状态寄存器3命令
    SPI_FLASH_SendByte(W25Q256_ReadStatusReg3);
    // 读取数据
    temp = SPI_FLASH_ReadByte();
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    if (0x01 & temp)
    {
        printf("set 4byte mode success\r\n");
        return 1;
    }
    else
    {
        // 拉低片选线，开始通信
        SPI_FLASH_NSS_LOW();
        // 发送配置四字节模式指令
        SPI_FLASH_SendByte(W25Q256_Enter4ByteMode);
        // 拉高片选线，结束通信
        SPI_FLASH_NSS_HIGH();
        SPI_FLASH_busy_block();
        // 使能写命令
        SPI_FLASH_WriteEnable();
        // 拉低片选线，开始通信
        SPI_FLASH_NSS_LOW();
        // 发送写状态寄存器3命令
        SPI_FLASH_SendByte(W25Q256_WriteStatusReg3);
        // 发送要写的数据
        SPI_FLASH_SendByte(0x02); // 上电直接进入4byte地址模式
        // 拉高片选线，结束通信
        SPI_FLASH_NSS_HIGH();
        SPI_FLASH_busy_block();
        printf("reset 4 byte mode\r\n");
        goto CODE;
    }
}

/**
 * @brief   对 FLASH 按页写入数据，调用本函数写入数据前需要先擦除扇区
 * @param   pBuffer：要写入数据的指针
 * @param   WriteAddr：写入数据地址
 * @param   NumByteToWrite：写入数据长度（以字节为单位）。必须小于等于SPI_FLASH_PerWritePageSize
 * @retval  无
 */
void SPI_FLASH_PageWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    // 使能写命令
    SPI_FLASH_WriteEnable();
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送页写入指令
    SPI_FLASH_SendByte(W25Q256_PageProgram_4byte);
    // 发送写入地址[24,31]bit
    SPI_FLASH_SendByte((WriteAddr & 0xFF000000) >> 24);
    // 发送写入地址[16,23]bit
    SPI_FLASH_SendByte((WriteAddr & 0xFF0000) >> 16);
    // 发送写入地址[8,15]bit
    SPI_FLASH_SendByte((WriteAddr & 0xFF00) >> 8);
    // 发送写入地址[0,7]bit
    SPI_FLASH_SendByte(WriteAddr & 0xFF);
    for (int i = 0; i < NumByteToWrite; i++)
    {
        SPI_FLASH_SendByte(pBuffer[i]);
    }
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    SPI_FLASH_busy_block();
}

/**
 * @brief   对 FLASH 按扇区写入数据
 * @param   pBuffer：要写入数据的指针
 * @param   WriteAddr：写入数据地址
 * @param   NumByteToWrite：写入数据长度（以字节为单位）。
 * @retval  无
 */
void SPI_FLASH_SecWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint32_t page_num = 0;         // 当前要写入flash的地址属于第几扇区;
    uint32_t page_first_addr = 0;  // 当前要写入flash的地址所属扇区首地址
    uint32_t page_offset_addr = 0; // 要写入的地址相对于当前扇区首地址的偏移
    uint8_t *page_data_point = flash_sec_data;
    // 确定要写入flash的地址所属页的首地址
    page_num = WriteAddr / 4096;
    page_first_addr = 4096 * page_num;
    page_offset_addr = WriteAddr - page_first_addr;
    printf("page_num = %d\r\n",page_num);
    printf("page_first_addr = %d\r\n",page_first_addr);
    printf("page_offset_addr = %d\r\n",page_offset_addr);

    // 读出扇区数据存储到flash_sec_data数组中
    SPI_FLASH_BufferRead(page_data_point, page_first_addr, 4096);
    // 将要写入的数据赋值到page_data_point中的对应地址
    for (int i = page_offset_addr, j = 0; j < NumByteToWrite; i++, j++)
    {
        page_data_point[i] = pBuffer[j];
    }
    // 擦除要写入的扇区
    SPI_FLASH_SectorErase(page_first_addr);
    // 将整理好的数据重新写入到内部FLASH中
    for (int i = 0; i < 16; i++)
    {
        SPI_FLASH_PageWrite(page_data_point, page_first_addr, SPI_FLASH_PageSize);
        page_data_point += SPI_FLASH_PageSize;
        page_first_addr += SPI_FLASH_PageSize;
    }
}

/**
 * @brief   FALSH不定量数据写入函数，调用本函数写入数据前需要先擦除扇区
 * @param   pBuffer：要写入数据的指针
 * @param   WriteAddr：写入数据地址
 * @param   NumByteToWrite：写入数据长度。(以字节为单位)
 * @retval  无
 */
void SPI_FLASH_BufferWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint32_t NumOfSec = 0;       // 要写多少个扇区
    uint32_t NumOfSingle = 0;    // 剩下多少不满一个扇区的数据
    uint32_t Numofaddrtosec = 0; // 当前写入地址距离扇区结束地址还有多少个字节
    if (0 == WriteAddr % 4096)
    {
        Numofaddrtosec = 0;
    }
    else
    {
        Numofaddrtosec = 4096 - WriteAddr % 4096;
        if (Numofaddrtosec >= NumByteToWrite)
        {
            Numofaddrtosec = NumByteToWrite;
        }
    }
    NumOfSec = (NumByteToWrite - Numofaddrtosec) / 4096;
    NumOfSingle = (NumByteToWrite - Numofaddrtosec) % 4096;
    printf("Numofaddrtosec = %d\r\n",Numofaddrtosec);
    printf("NumOfSec = %d\r\n",NumOfSec);
    printf("NumOfSingle = %d\r\n",NumOfSingle);
//    printf("unwritten_sector_num = %d\r\n",Numofaddrtosec);
    if (0 != Numofaddrtosec)
    {
        SPI_FLASH_SecWrite(pBuffer, WriteAddr, Numofaddrtosec);
        WriteAddr += Numofaddrtosec;
        pBuffer += Numofaddrtosec;
        if (0 != NumOfSec)
        {
            for (int i = 0; i < NumOfSec; i++)
            {
                SPI_FLASH_SecWrite(pBuffer, WriteAddr, SPI_FLASH_Secsize);
                WriteAddr += SPI_FLASH_Secsize;
                pBuffer += SPI_FLASH_Secsize;
            }
        }
        if (0 != NumOfSingle)
        {
            SPI_FLASH_SecWrite(pBuffer, WriteAddr, NumOfSingle);
        }
    }
    else
    {
        if (0 != NumOfSec)
        {
            for (int i = 0; i < NumOfSec; i++)
            {
                SPI_FLASH_SecWrite(pBuffer, WriteAddr, SPI_FLASH_Secsize);
                WriteAddr += SPI_FLASH_Secsize;
                pBuffer += SPI_FLASH_Secsize;
            }
        }
        if (0 != NumOfSingle)
        {
            SPI_FLASH_SecWrite(pBuffer, WriteAddr, NumOfSingle);
        }
    }
    SPI_FLASH_busy_block();
}

/**
 * @brief   读取FLASH数据
 * @param   pBuffer：存储读出数据的指针
 * @param   WriteAddr：读取地址
 * @param   NumByteToRead：读取数据长度(以字节为单位)
 * @retval  无
 */
void SPI_FLASH_BufferRead(uint8_t *pBuffer, uint32_t ReadAddr, uint16_t NumByteToRead)
{
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送读取数据指令
    SPI_FLASH_SendByte(W25Q256_ReadData);
    // 发送读取地址[24,31]bit
    SPI_FLASH_SendByte((ReadAddr & 0xFF000000) >> 24);
    // 发送读取地址[16,23]bit
    SPI_FLASH_SendByte((ReadAddr & 0xFF0000) >> 16);
    // 发送读取地址[8,15]bit
    SPI_FLASH_SendByte((ReadAddr & 0xFF00) >> 8);
    // 发送读取地址[0,7]bit
    SPI_FLASH_SendByte(ReadAddr & 0xFF);
    // 读取数据
    for (int i = 0; i < NumByteToRead; i++)
    {
        // 读取一个字节数据
        pBuffer[i] = SPI_FLASH_ReadByte();
    }
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
    SPI_FLASH_busy_block();
}

/**
 * @brief   等待写入、擦除等操作结束
 * @param   none
 * @param   none
 * @param   none
 * @retval  none
 */
void SPI_FLASH_WaitForOperaEnd(void)
{
    uint8_t FLASH_Status = 0;
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送读状态寄存器1指令
    SPI_FLASH_SendByte(W25Q256_ReadStatusReg1);
    do
    {
        // 接收读取状态寄存器1寄存器内容
        FLASH_Status = SPI_FLASH_ReadByte();
    } while (SET == (FLASH_Status & WIP_Flag));
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
}

/**
 * @brief   忙碌阻塞函数
 * @param   none
 * @param   none
 * @param   none
 * @retval  none
 */
void SPI_FLASH_busy_block(void)
{
    uint8_t FLASH_Status = 0;
    while (1)
    {
        // 拉低片选线，开始通信
        SPI_FLASH_NSS_LOW();
        // 发送读状态寄存器1指令
        SPI_FLASH_SendByte(W25Q256_ReadStatusReg1);
        // 接收读取状态寄存器1寄存器内容
        FLASH_Status = SPI_FLASH_ReadByte();
        // 拉高片选线，结束通信
        SPI_FLASH_NSS_HIGH();
        if (0 == (1 & FLASH_Status))
        {
            break;
        }
    }
}
int main(void)
{
    /* USER CODE BEGIN 1 */

    /* USER CODE END 1 */

    /* MCU Configuration--------------------------------------------------------*/

    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    HAL_Init();

    /* USER CODE BEGIN Init */

    /* USER CODE END Init */

    /* Configure the system clock */
    SystemClock_Config();

    /* USER CODE BEGIN SysInit */

    /* USER CODE END SysInit */

    /* Initialize all configured peripherals */
    MX_GPIO_Init();
    MX_SPI5_Init();
    MX_USART1_UART_Init();
    /* USER CODE BEGIN 2 */
    // 进入4字节地址模式
    SPI_FLASH_FOUR_MODE();

    printf("READ FLASH ID test!!!\r\n");
    device_ID = SPI_FLASH_ReadID();
    printf("device_ID = 0x%x\r\n", device_ID);
    if (sFLASH_ID == device_ID)
    {
        printf("FLASH ID read success\r\n");
    }
    uint8_t ReadBuff[4096];
    uint8_t WriteBuff[4096];
    uint8_t temp_data[8];
        for(int i = 0;i<4096;i++)
    {
        WriteBuff[i] = 0x77;
    }
//    for(int i=0;i<256;i++)
//    {
//        if(0 == i%8 && i >= 8)
//        {
//            printf("\r\n");
//        }
//        printf("data1[%04d]=0x%02x\t",i,data1[i]);
//    }
    printf("\r\n");
    SPI_FLASH_BufferRead(ReadBuff, 0, 4096);
    for(int i=0;i<4096;i++)
    {
        if(0 == i%8 && i >= 8)
        {
            printf("\r\n");
        }
        printf("ReadBuff[%04d]=0x%02x\t",i,ReadBuff[i]);
    }
    printf("\r\n");
    SPI_FLASH_BufferWrite(WriteBuff, 1, 4096);
    SPI_FLASH_BufferRead(ReadBuff, 0, 4096);
    for(int i=0;i<4096;i++)
    {
        if(0 == i%8 && i >= 8)
        {
            printf("\r\n");
        }
        printf("ReadBuff[%04d]=0x%02x\t",i,ReadBuff[i]);
    }
    printf("\r\n");
    SPI_FLASH_BufferRead(temp_data, 4095, 8);
    for(int i=0;i<8;i++)
    {
        if(0 == i%8 && i >= 8)
        {
            printf("\r\n");
        }
        printf("temp_data[%04d]=0x%02x\t",i,temp_data[i]);
    }
    printf("\r\n");
    char data1[8];
    for(int i=0;i<8;i++)
    {
        data1[i] = i+1;
    }
    
    SPI_FLASH_BufferWrite((uint8_t *)data1, 4093, 8);
    SPI_FLASH_BufferRead(temp_data, 4093, 8);
    for(int i=0;i<8;i++)
    {
        if(0 == i%8 && i >= 8)
        {
            printf("\r\n");
        }
        printf("temp_data[%04d]=0x%02x\t",i,temp_data[i]);
    }
    printf("\r\n");
    int num1 = 222333;
    int num2 = 0;
    printf("num2 = %d\r\n",num2);
    SPI_FLASH_BufferWrite((uint8_t *)&num1, 8190, 4);
    SPI_FLASH_BufferRead((uint8_t *)&num2, 8190, 4);
    printf("num2 = %d\r\n",num2);
    /* USER CODE END 2 */

    /* Infinite loop */
    /* USER CODE BEGIN WHILE */
    while (1)
    {
        /* USER CODE END WHILE */
        /* USER CODE BEGIN 3 */
        LED_TIME();
    }
    /* USER CODE END 3 */
}

6、实验现象

STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）,stm32,单片机

没有问题！文章来源地址https://www.toymoban.com/news/detail-653206.html

到了这里，关于STM32F429IGT6使用CubeMX配置SPI通信（W25Q256芯片）的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • STM32F429 Discovery开发板应用：使用FreeRTOS队列+DMA双缓存实现串口数据接收

    STM32F429 Discovery开发板应用：使用FreeRTOS队列+DMA双缓存实现串口数据接收

      参考帖子：https://blog.csdn.net/freedompoi/article/details/122350866 目前想要实现STM32F4自带的DMA双缓冲区，尝试过一版，结果不能预期，就使用了RxHalfCplt和RxCplt去实现DMA双缓冲区的效果。 现在有时间了，又重新实现STM32F4自带的DMA双缓冲区，作为参考。   MCU：STM32F429ZIT6 开发环境：

    2024年02月08日
    浏览(23)
  • GD32F470 移植STM32F429工程 Keil调试笔记

    GD32F470 移植STM32F429工程 Keil调试笔记

    keil版本：5.25 安装 GigaDevice.GD32F4xx_DFP.3.0.4.pack Keil.STM32F4xx_DFP.2.15.0.pack 1、原项目为STM32F429 工程，切换到GD32F470 只需在 Options for Target\\\"“对话框的Device菜单中选中“GD32F470II”,重新编译即可，一般不会有编译错误。 2、将项目工程在切换回STM32F429，在 Options for Target”\\\"对话框的D

    2024年02月09日
    浏览(23)
  • STM32F103xx / STM32F429VET6最小系统原理图

    STM32F103xx / STM32F429VET6最小系统原理图

    STM32F429VET6核心板原理图 2023.12.09修改内容：打板后由于更换学习方向并未进行测试，所给原理图仅供参考，给出PDF下载链接，未设置积分和会员下载：https://download.csdn.net/download/m0_51294753/88611702。 一、前言 先前使用过的是STM32F1系列，只使用和绘制过STM32F103C8T6和STM32F103ZET6的板

    2023年04月24日
    浏览(18)
  • 【STM32F429】HAL库的PWM中断，精确控制脉冲数，控制步进电机

    【STM32F429】HAL库的PWM中断，精确控制脉冲数，控制步进电机

    这两天在调步进电机，希望是使得步进电机每次都达到期望的高度。在查了一天的资料，发现大部分上传的资料都是使用CubeMX生成的，可复制性很高，但未免有失可读性，故上传我的心得经验。 本来原子哥的例程里有整合度很高的，已经封装好的精确控制步进电机前进距离的

    2024年02月08日
    浏览(25)
  • RT-Thread STM32F429 armfly-v6开发板BSP说明

    RT-Thread STM32F429 armfly-v6开发板BSP说明

    本文档为 RT-Thread 开发团队为 STM32F429 armfly-v6 开发板提供的 BSP (板级支持包) 说明。 主要内容如下： 开发板资源介绍 BSP 快速上手 进阶使用方法 通过阅读快速上手章节开发者可以快速地上手该 BSP，将 RT-Thread 运行在开发板上。在进阶使用指南章节，将会介绍更多高级功能，帮

    2024年01月18日
    浏览(25)
  • STM32F1基于STM32CubeMX配置硬件SPI驱动1.8寸TFT LCD128X160 ST7735S屏幕

    STM32F1基于STM32CubeMX配置硬件SPI驱动1.8寸TFT LCD128X160 ST7735S屏幕

    📌相关篇《【STM32CubeIDE】STM32F103硬件SPI驱动1.8寸TFT LCD128X160 ST7735S屏幕》 ✨驱动效果就不做演示了，和上面的相关篇一样，主要是为了方便使用MDK Keil开发的使用。所以花了点时间从上面的工程当中做了分离，重新使用STM32CubeMX配置一个方便二次开发移植使用和配置的工程。本

    2024年02月03日
    浏览(20)
  • [STM32] - STM32F407VET6使用STM32CubeMX配置FatFs，以及挂载时返回03错误码问题的解决

    [STM32] - STM32F407VET6使用STM32CubeMX配置FatFs，以及挂载时返回03错误码问题的解决

    为测试新买的开发板TF卡读写是否正常，使用STM32CubeMX（后简称CubeMX）进行代码构建。生成代码后烧录测试，发现在挂载TF卡时无法成功，返回值为错误3（ FR_NOT_READY ）。经排查后问题已解决，遂记录配置过程供大家参考，并讲解挂载时返回错误3的解决方式。 ①为了输出TF卡（

    2024年02月22日
    浏览(25)
  • 基于STM32F103ZET6使用STM32CubeMX配置FSMC模块驱动LCD屏（基于正点原子历程）

    基于STM32F103ZET6使用STM32CubeMX配置FSMC模块驱动LCD屏（基于正点原子历程）

    在学习STM32的过程中，刚好学到了LCD屏，我使用的是STM32F103ZET6，屏幕是正点原子的。但是在我自己新建工程点亮显示LCD屏时遇到了很多问题。解决之后分享在此，希望能帮助到遇到此困惑的朋友。 想要快速驱动LCD屏请直接跳转到CubeMX配置 FSMC全名叫可变静态存储控制器（Fle

    2024年02月15日
    浏览(25)
  • STM32F103利用CubeMX配置开启定时中断

    STM32F103利用CubeMX配置开启定时中断

    1、外部晶振8MHz，下载方式SWD模式，需求配置定时器1，产生每100ms一次中断 新建工程、配置晶振、选择下载方式等略 2、查阅资料，STM32F103的时钟树分配  3、配置CubeMX的时钟树  4、配置定时器-开启定时中断  5、配置定时时间 （ 定时周期 = (Prescaler + 1) × (Period + 1) ÷ 时钟频率

    2024年02月15日
    浏览(21)
  • STM32CubeMX生成C代码及时钟树配置（基于stm32f407）

    STM32CubeMX生成C代码及时钟树配置（基于stm32f407）

    近来对于stm32单片机编程中，HAL库逐渐取代标准库成为主流的库。标准库支持的芯片型号有限，而且目前已经停止支持，而HAL库支持所有类型的芯片，可移植性也很高，再加上有神器STM32Cube可以生成工程模板，越来越多的编程开始从使用标准库转到使用HAL库。 新建工程后，在

    2024年02月15日
    浏览(30)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包