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

1、硬件电路

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

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

3、配置SPI

4、生成工程配置

5、相关代码

#define sFLASH_ID 0XEF4019 // W25Q256

#define SPI_FLASH_PageSize 256
#define SPI_FLASH_PerWritePageSize 256

#define W25Q256_WriteEnable 0x06    // 写使能指令
#define W25Q256_WriteDisable 0x04   // 写屏蔽指令
#define W25Q256_ReadStatusReg 0x05  // 读取状态寄存器1
#define W25Q256_WriteStatusReg 0x01 // 写入状态寄存器1
//#define W25Q256_ReadData 0x03       // 3字节模式读取数据指令
#define W25Q256_ReadData 0x13       // 4字节模式读取数据指令
#define W25Q256_FastReadData 0x0B   //
#define W25Q256_FastReadDual 0x3B
#define W25Q256_PageProgram 0x02 // 页写入指令
#define W25Q256_BlockErase 0xD8
#define W25Q256_SectorErase 0x20
#define W25Q256_ChipErase 0xC7
#define W25Q256_PowerDown 0xB9
#define W25Q256_ReleasePowerDown 0xAB
#define W25Q256_DeviceID 0xAB
#define W25Q256_ManufactDeviceID 0x90
#define W25Q256_JedecDeviceID 0x9F
#define W25Q256_Enter4ByteMode 0xB7 // 4字节地址模式指令
#define W25Q256_ReadStatusRegister3 0x15
#define W25Q256_WriteStatusRegister3 0x11   //写状态寄存器3指令
#define WIP_Flag 0x01
#define Dummy_Byte 0xFF

#define FLASH_WriteAddress 0x00000
#define FLASH_ReadAddress FLASH_WriteAddress
#define FLASH_SectorToErase FLASH_WriteAddress

/* 获取缓冲区的长度 */
#define TxBufferSize1 (countof(TxBuffer1) - 1)
#define RxBufferSize1 (countof(TxBuffer1) - 1)
#define countof(a) (sizeof(a) / sizeof(*(a)))
#define BufferSize (countof(Tx_Buffer) - 1)

#define FLASH_WriteAddress 0x00000
#define FLASH_ReadAddress FLASH_WriteAddress
#define FLASH_SectorToErase FLASH_WriteAddress

/* 发送缓冲区初始化 */
extern uint8_t ReadBuff[4096];
extern uint8_t WriteBuff[4096];

/**
 * @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;
    uint32_t temp0 = 0;
    uint32_t temp1 = 0;
    uint32_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();
}

/**
 * @brief   等待写入、擦除等操作完成
 * @param   无
 * @param   无
 * @retval  无
 */
void SPI_FLASH_WaitForWriteEnd(void)
{
    uint8_t FLASH_Status = 0;
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送写状态寄存器1指令
    SPI_FLASH_SendByte(W25Q256_ReadStatusReg);
    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)
{
    // uint8_t ADDR[4] = {0x00,0x00,0x00,0x00};
    //  使能写命令
    SPI_FLASH_WriteEnable();
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送擦除扇区命令
    SPI_FLASH_SendByte(W25Q256_SectorErase);
    // 发送擦除地址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();
    // HAL_Delay(3000);
    // 等待擦除操作结束
    SPI_FLASH_WaitForOperaEnd();
}

/**
 * @brief   配置4字节模式
 * @param   无
 * @retval  无
 */
void SPI_FLASH_FOUR_MODE(void)
{
    uint8_t temp = 0;
    // 使能写命令
    SPI_FLASH_WriteEnable();
    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送写状态寄存器3命令
    SPI_FLASH_SendByte(W25Q256_WriteStatusRegister3);
    // 发送要写的数据
    SPI_FLASH_SendByte(0x02);

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

    // 拉低片选线，开始通信
    SPI_FLASH_NSS_LOW();
    // 发送读状态寄存器3命令
    SPI_FLASH_SendByte(W25Q256_ReadStatusRegister3);
    // 读取数据
    temp = SPI_FLASH_ReadByte();
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();

    if (1 == (0x02 & temp))
    {
        // 拉低片选线，开始通信
        SPI_FLASH_NSS_LOW();
        // 发送配置四字节模式指令
        SPI_FLASH_SendByte(W25Q256_Enter4ByteMode);
        // 拉高片选线，结束通信
        SPI_FLASH_NSS_HIGH();
    }
    SPI_FLASH_WaitForOperaEnd();
}

/**
 * @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);
    // 发送写入地址[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);
    if (NumByteToWrite > SPI_FLASH_PerWritePageSize)
    {
        NumByteToWrite = SPI_FLASH_PerWritePageSize;
        printf("256\r\n");
    }
    for (int i = 0; i < NumByteToWrite; i++)
    {
        SPI_FLASH_SendByte(pBuffer[i]);
    }
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
}

/**
 * @brief   FALSH不定量数据写入函数，调用本函数写入数据前需要先擦除扇区
 * @param   pBuffer：要写入数据的指针
 * @param   WriteAddr：写入数据地址
 * @param   NumByteToWrite：写入数据长度
 * @retval  无
 */
void SPI_FLASH_BufferWrite(uint8_t *pBuffer, uint32_t WriteAddr, uint16_t NumByteToWrite)
{
    uint8_t NumOfPage = 0;
    uint8_t NumOfSingle = 0;
    uint8_t Addr = 0;
    uint8_t count = 0;
    uint8_t temp = 0;
    /*mod 运算求余，若 writeAddr 是 SPI_FLASH_PageSize 整数倍，运算结果 Addr 值为0*/
    Addr = WriteAddr % SPI_FLASH_PageSize;
    /* 差 count 个数据值，刚好可以对齐到页地址 */
    count = SPI_FLASH_PageSize - Addr;
    /* 计算出要写多少整数页 */
    NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
    /*mod 运算求余，计算出剩余不满一页的字节数 */
    NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
    /* Addr=0, 则 WriteAddr 刚好按页对齐 aligned */
    if (0 == Addr)
    {
        /*NumByteToWrite < SPI_FLASH_PageSize*/
        if (0 == NumOfPage)
        {
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
            SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
        }
        else
        {
            /* 先把整数页都写了 */
            for (int i = 0; i < NumOfPage; i++)
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
                WriteAddr += SPI_FLASH_PageSize;
                pBuffer += SPI_FLASH_PageSize;
            }
            /* 若有多余的不满一页的数据，把它写完 */
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
            SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
        }
    }
    else /* 若地址与 SPI_FLASH_PageSize 不对齐 */
    {
        /*NumByteToWrite < SPI_FLASH_PageSize*/
        if (0 == NumOfPage)
        {
            /* 当前页剩余的 count 个位置比 NumOfSingle 小，写不完 */
            if (NumOfSingle > count)
            {
                temp = NumOfSingle - count;
                /* 先写满当前页 */
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
                WriteAddr += count;
                pBuffer += count;
                /* 再写剩余的数据 */
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, temp);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
            }
            else /* 当前页剩余的 count 个位置能写完 NumOfSingle 个数据 */
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumByteToWrite);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
            }
        }
        else /*NumByteToWrite > SPI_FLASH_PageSize*/
        {
            /*先把距离页地址的count个数据减去，计算需要写的页数和NumOfSingle，然后写数据时先把原来减去的count个数据写入，写满当前页*/
            /*再写剩余数据，即计算好的NumOfPage和NumOfSingle*/
            NumByteToWrite -= count;
            NumOfPage = NumByteToWrite / SPI_FLASH_PageSize;
            NumOfSingle = NumByteToWrite % SPI_FLASH_PageSize;
            SPI_FLASH_PageWrite(pBuffer, WriteAddr, count);
            SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
            WriteAddr += count;
            pBuffer += count;
            /* 把整数页都写了 */
            for (int i = 0; i < NumOfPage; i++)
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, SPI_FLASH_PageSize);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
                WriteAddr += SPI_FLASH_PageSize;
                pBuffer += SPI_FLASH_PageSize;
            }
            if (0 != NumOfSingle)
            {
                SPI_FLASH_PageWrite(pBuffer, WriteAddr, NumOfSingle);
                SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
            }
        }
    }
}

/**
 * @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_WaitForOperaEnd(); // 等待操作完成
}

/**
 * @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_ReadStatusReg);
    do
    {
        // 接收读取状态寄存器1寄存器内容
        FLASH_Status = SPI_FLASH_ReadByte();
    } while (SET == (FLASH_Status & WIP_Flag));
    // 拉高片选线，结束通信
    SPI_FLASH_NSS_HIGH();
}

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("W25Q256 SPI readwrite test!!!\r\n");
    device_ID = SPI_FLASH_ReadID();
    printf("device_ID = 0x%x\r\n", device_ID);
    SPI_FLASH_SectorErase(0x00); // 擦除扇区数据
    // 读取擦除后的数据
    SPI_FLASH_BufferRead(ReadBuff, 0x00, 4096);
    printf("*****************读取擦出后的数据*****************\r\n");
    for (int i = 0; i < 4096; i++)
    {
        printf("ReadBuff[%d] = 0x%02x\t", i, ReadBuff[i]);
        if (0 == (i + 1) % 8 && (i + 1) >= 8)
        {
            printf("\r\n");
        }
    }
    for (int i = 0; i < 256; i++)
    {
        WriteBuff[i] = i;
    }
    SPI_FLASH_BufferWrite(WriteBuff, 0xFF, 256);
    SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
    // 读数据
    SPI_FLASH_BufferRead(ReadBuff, 0xFF, 256);
    SPI_FLASH_WaitForOperaEnd(); // 等待操作完成
    printf("*****************读取写入后的数据*****************\r\n");
    for (int i = 0; i < 256; i++)
    {
        printf("ReadBuff[%d] = 0x%02x\t", i, ReadBuff[i]);
        if (0 == (i + 1) % 8 && (i + 1) >= 8)
        {
            printf("\r\n");
        }
    }
    /* 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、实验现象