软件SPI

一、SPI通信协议

1、SPI通信

• SPI（Serial Peripheral Interface）是由Motorola公司开发的一种通用数据总线
• 四根通信线：SCK（Serial Clock）、MOSI（Master Output Slave Input）、MISO（Master Input Slave Output）、SS（Slave Select）
• 同步，全双工
• 支持总线挂载多设备（一主多从）

2、硬件电路

• 所有SPI设备的SCK、MOSI、MISO分别连在一起
• 主机另外引出多条SS控制线，分别接到各从机的SS引脚
  SPI选择从机的方式：主机的ss线为输出，从机的ss线为输入，低电平有效，需要跟哪个从机通信，只要将对应的输出线置低电平即可（默认高电平）
• 输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入
  

3、移位示意图

\quad 主机和从机中的移位寄存器有时钟输入端，spi是高位先行，每来一个时钟，移位寄存器向左移位，从机中的时钟源是由主机提供的，即波特率发生器，产生的时钟驱动主机的移位寄存器进行移位，同时，这个时钟也通过SCK引l脚进行输出，接到从机的移位寄存器里
\quad 工作原理：波特率发生器时钟的上升沿，所有移位寄存器(主机和从机)向左移动一位，移出去的位放到引脚上，波特率发生器时钟的下降沿，引脚上的位，采样输入到移位寄存器的最低位。这里的移入数据即采样数据

第一个时钟产生的现象：
\quad 假设主机有个数据10101010要发送到从机，同时，从机有个数据01010101要发送到主机，此时可以驱动时钟，产生一个上升沿，所有设备上的移位寄存器的数据都会往左移动一位，移出去的最高位数据就会在输出数据寄存器上，MOSI的数据为1，高电平，MISO的数据是0，低电平，这就是第一个时钟上升沿执行的结果，就是把主机和从机中，移位寄存器的最高位，分别放到MOSI和MISO的通信线上对数据进行输出。
\quad 下一个产生的是下降沿，主机和从机都会对数据进行采样输入，也就是把上升沿时放到MOSI和MISO上的数据分别进行采样输入到从机的最低位和主机的最低位

\quad 当执行8个时钟周期后，就实现了主机和从机一个字节的数据交换，即发送数据时同时接收
\quad 当只要发送或接收数据其中之一时，也是完成一个字节交换的基础上，读取需要的数据或接收需要的数据即可

4、SPI时序基本单元

(1)开始通信和结束通信

• 起始条件：SS从高电平切换到低电平
• 终止条件：SS从低电平切换到高电平
  在SPI 通信时，SS信号始终要保持低电平

(2)模式0—用的最多

交换一个字节（模式0）

• CPOL=0：空闲状态时，SCK为低电平
• CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

CPOL(Clock Polarity)：时钟极性
CPHA(Clock Phase)：时钟相位

\quad 模式0相比于模式1，模式0的数据移出移入的时机，提前半个时钟，也就是相位提前了，第一边沿移入数据，但是数据必须先有数据移出才能移入数据，所以在第一个边沿之前，就要提前开始移出数据，可以理解成在0个边沿移出，第一个边沿移入。
\quad 工作过程：SS下降沿时，触发MOSI和MISO输出数据，到SCK上升沿时，开始采样输入数据，下一个SCK下降沿，输出数据B6，下一个上升沿采样输入数据B6

(3)模式1

交换一个字节（模式1）

• CPOL=0：空闲状态时，SCK为低电平
• CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

\quad 工作过程（一个字节的交换）：SCK第一个边沿上升沿，主机和从机同时移出数据，主机通过MOSI移出最高位，此时MOSl的电平就表示了主机要发送数据的B7，从机通过MISO移出最高位，此时MISO表示从机要发送数据的B7，然后时钟运行，产生下降沿，此时主机和从机同时移入数据，也就是进行数据采样，这里主机移出的B7，进入从机移位寄存器的最低位，从机移出的B7，进入主机移位寄存器的最低位，如此一个时钟脉冲产生完毕，一个数据位传输完毕。
\quad 在SS的上升沿，MOSI还可以再变化一次，将MOSI置到一个默认的高电平或低电平，SPI也没有规定MOSI的默认电平，但MISO，从机必须得置回高阻态，此时如果主机的MISO为上拉输入的话，那MISO引脚的电平就是默认的高电平，如果主机MISO为浮空输入，那MISO引脚的电平不确定　。
若交换多个字节，则重复以上操作。

问题：所有从机输出同时开启输出到主机时，会造成冲突
解决办法：在SS未被选中的状态，从机的MISO引脚必须关断输出，即配置输出为高阻状态
上图：SS高电平时，MISO用一条中间的线，表示高阻态，SS下降沿之后，从机的MISO被允许开启输出，SSL上升沿之后，从机的MISO必须置回高阻态，即只有一个从机能输出数据给主机

(4)模式2

交换一个字节（模式2）

• CPOL=1：空闲状态时，SCK为高电平
• CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

(5)模式3

交换一个字节（模式3）

• CPOL=1：空闲状态时，SCK为高电平
• CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

5、SPI时序

(1)写使能

• 发送指令
• 向SS指定的设备，发送指令（0x06）

(2)指定地址写

• 指定地址写
• 向SS指定的设备，发送写指令（0x02），
• 随后在指定地址（Address[23:0]）下，写入指定数据（Data）
  

(3)指定地址读

• 指定地址读
• 向SS指定的设备，发送读指令（0x03），
• 随后在指定地址（Address[23:0]）下，读取从机数据（Data）

二、W25Q64模块介绍

１、W25Q64简介

• W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储、字库存储、固件程序存储等场景
• 存储介质：Nor Flash（闪存）
• 时钟频率：80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)

160MHz (Dual SPI):双重SPI模式等效的频率
320MHz (Quad SPI):四重SPI模式等效的频率

• 存储容量（24位地址）：
  W25Q40： 4Mbit / 512KByte
  W25Q80： 8Mbit / 1MByte
  W25Q16： 16Mbit / 2MByte
  W25Q32： 32Mbit / 4MByte
  W25Q64： 64Mbit / 8MByte
  W25Q128： 128Mbit / 16MByte
  W25Q256： 256Mbit / 32MByte

２、硬件电路

普通SPI模式：括号内的引脚忽略
双重SPI模式：DI，DO变成IO0和IO1， 数据同时收和同时发的2个数据位
四重SPI模式：DI，DO变成IO0和IO1，WP，HOLD做IO2，IO3，均作为数据收发引脚，即一个时钟，四个数据位。

３、W25Q64框图

\quad flash空间划分：block(64kb)>sector(4kb)>page(256byte):一个块=16个扇区，一个扇区=16页
\quad 存储器以字节为单位，每个字节都有唯一的地址
\quad SPI Command &Control Logic(SPI控制逻辑)：对芯片内部进行地址锁存、数据读写等操作,由控制逻辑自动完成。与SPI通信引脚连接，主控芯片通过SPI协议，把指令和数据发给控制逻辑，控制逻辑就会自动去操作内部电路，完成指定的功能。
\quad Status Register(状态寄存器)： 可以体现芯片是否处于忙状态、是否写使能、是否写保护。
\quad 地址锁存计数器：用来指定地址，通过spi，共发3个字节的地址，因为一页是256字节，所以一页内的字节地址，就取决于最低一个字节，而高位的2个字节，就对应的是页地址，所以共发的3个字节地址，前2个字节进到页地址锁存计数器里，最后一个字节，会进到这个字节地址锁存计数器里，然后，页地址，通过这个写保护和行解码(write protect and row decode)，来选择需要操作哪一页，字节地址，通过这个列解码和256字节页缓存(column decode and 256-byte page buffer)，来进行指定字节的读写操作，又因为这个地址锁存，都是有一个计数器，所以这个地址指针，在读写之后，可以自动加1.
\quad 页缓存区-256字节：256字节的RAM存储器，数据读写就是通过RAN缓存区进行的，写入的数据的会先放到缓存区，时序结束后，芯片再将缓存区的数据复制到对应的Flash里进行永久保存。因为SPI写入的频率很高，而flash的写入，需要掉电不丢失，速度较慢。所以需要将写入的数据先放在页缓存区中存储，又由于页缓存区是RAM，速度与SPI的速度同样快，因为缓存区的大小为256字节，所以写入一个时序连续写入的数据量不能超过256字节，写完后再将数据从缓存区转移到flash， 这过程需要一定的时间，所以再写入时序结束后，芯片会进入一段忙的状态，此时会将状态寄存器BUSY位置1，芯片在忙时，就不会响应新的读写时序，这就是写入的执行流程。

４、Flash操作注意事项

• 写入操作时：
  • 写入操作前，必须先进行写使能
  • 每个数据位只能由1改写为0，不能由0改写为1
  • 写入数据前必须先擦除，擦除后，所有数据位变为1
  • 擦除必须按最小擦除单元进行
  • 连续写入多字节时，最多写入一页的数据，超过页尾位置的数据，会回到页首覆盖写入
  • 写入操作结束后，芯片进入忙状态，不响应新的读写操作
• 读取操作时：
  • 直接调用读取时序，无需使能，无需额外操作，没有页的限制，读取操作结束后不会进入忙状态，但不能在忙状态时读取

软件SPI读写W25Q64代码：

SPI.c

#include "stm32f10x.h"                  // Device header
#include "myspi.h" 

//cs引脚 输出电平
void myspi_write_cs(uint8_t bit_set)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)bit_set);
}

//MOSI引脚 输出电平
void myspi_write_MOSI(uint8_t bit_set)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)bit_set);
}

//CLK引脚 输出电平
void myspi_write_CLK(uint8_t bit_set)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)bit_set);
}

// 读取MISO电平
uint8_t myspi_read_MISO(void)
{
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}

// 软件spi引脚初始化
void myspi_init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);    
    
    myspi_write_cs(1);
    myspi_write_CLK(0);  // 模式0 和 模式1 SCK极性为低电平，模式2 和 模式3 SCK极性为高电平
}

// 时序开始
void myspi_start(void)
{
    myspi_write_cs(0);
}
// 时序结束
void myspi_stop(void)
{
    myspi_write_cs(1);
}
// 交换字节---模式0  第1种方式
uint8_t myspi_swap_byte_mode_0_1(uint8_t send_byte)
{
    uint8_t i, receive_byte = 0x00;
    for(i=0;i<8;i++)
    {
        myspi_write_MOSI(send_byte & (0x80>>i)); // 主机将最高位移出到MOSI
        myspi_write_CLK(1);                // CLK 置高电平
        if(myspi_read_MISO() == 1)
        {
            receive_byte |= (0x80>>i); // 读出MISO的数据放到receive_byte的最高位
        }
        myspi_write_CLK(0);    // CLK 置低电平
    }
    return receive_byte;         // 返回从机发送给主机的数据
}
// 交换字节---模式2  第1种方式
uint8_t myspi_swap_byte_mode_2_1(uint8_t send_byte)
{
    uint8_t i, receive_byte = 0x00;
    for(i=0;i<8;i++)
    {
        myspi_write_MOSI(send_byte & (0x80>>i)); // 主机将最高位移出到MOSI
        myspi_write_CLK(0);                // CLK 置低电平
        if(myspi_read_MISO() == 1)
        {
            receive_byte |= (0x80>>i); // 读出MISO的数据放到receive_byte的最高位
        }
        myspi_write_CLK(1);    // CLK 置高电平

    }
    return receive_byte;         // 返回从机发送给主机的数据
}
// 交换字节---模式1  第1种方式
uint8_t myspi_swap_byte_mode_1_1(uint8_t send_byte)
{
    uint8_t i, receive_byte = 0x00;
    for(i=0;i<8;i++)
    {
        myspi_write_CLK(1);            // SCK上升沿     CLK 置高电平
        myspi_write_MOSI(send_byte & (0x80>>i)); // 移出数据  主机将最高位移出到MOSI
        myspi_write_CLK(0);            // SCK下降沿     CLK 置低电平
        if(myspi_read_MISO() == 1)  // 移入数据
        {
            receive_byte |= (0x80>>i); // 读出MISO的数据放到receive_byte的最高位
        }
    }
    return receive_byte;         // 返回从机发送给主机的数据
}

// 交换字节---模式3  第1种方式
uint8_t myspi_swap_byte_mode_3_1(uint8_t send_byte)
{
    uint8_t i, receive_byte = 0x00;
    for(i=0;i<8;i++)
    {
        myspi_write_CLK(0);   // CLK 置低电平
        myspi_write_MOSI(send_byte & (0x80>>i)); // 主机将最高位移出到MOSI
        myspi_write_CLK(1);    // CLK 置高电平
        if(myspi_read_MISO() == 1)
        { 
            receive_byte |= (0x80>>i); // 读出MISO的数据放到receive_byte的最高位
        }
        

    }
    return receive_byte;         // 返回从机发送给主机的数据
}
// 交换字节---模式0  第2种方式--移位模型
uint8_t myspi_swap_byte_mode_0_2(uint8_t send_byte)
{
    uint8_t i;
    for(i=0;i<8;i++)
    {
        myspi_write_MOSI(send_byte & 0x80); // 主机将最高位移出
        send_byte<<=1;          // 将次高位移到最高位
        myspi_write_CLK(1);                // CLK 置高电平
        if(myspi_read_MISO() == 1)
        {
            send_byte |= 0x01; // 接收到的数据是1时放到send_byte的最低位
        }
        myspi_write_CLK(0);    // CLK 置低电平
    }
    return send_byte;         // 最后移位完成，发送字节变量就是交换完的数据
}

SPI.h

#ifndef __MYSPI_H
#define __MYSPI_H

void myspi_init(void);
void myspi_start(void);
void myspi_stop(void);
uint8_t myspi_swap_byte_mode_0_1(uint8_t send_byte);

#endif

// w25q64.c

#include "stm32f10x.h"                  // Device header
#include "W25Q64.h" 
#include "myspi.h"
#include "w25q64_ins.h"

void w25q64_init(void)
{
    myspi_init();
}
// 读厂商ID和设备ID
void w25q64_read_ID(uint8_t *MID, uint16_t *DID)
{
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_JEDEC_ID);   // 发送指令
    *MID = myspi_swap_byte_mode_0_1(W25Q64_DUMMY_BYTE);// 接收厂商ID
    *DID = myspi_swap_byte_mode_0_1(W25Q64_DUMMY_BYTE);// 接收设备ID高8位
    
    *DID <<= 8;
    *DID |= myspi_swap_byte_mode_0_1(W25Q64_DUMMY_BYTE);// 接收设备ID低8位
    myspi_stop();
}
// 写使能
void w25q64_write_enable(void)
{
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_WRITE_ENABLE);
    myspi_stop();
}
// 读取状态寄存器忙等待
void w25q64_read_status_busy(void)
{
    uint32_t timeout = 100000;  //超时等待，防止程序一直在循环
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_READ_STATUS_REGISTER_1);
    while(myspi_swap_byte_mode_0_1(W25Q64_DUMMY_BYTE) & 0x01 == 0x01)
    {
        timeout--;
        if(timeout==0)
            break;
    }
    myspi_stop();
}

// 页编程
void w25q64_page_program(uint32_t address, uint8_t *data_buf, uint16_t count)
{
    uint16_t i;
    
    w25q64_write_enable(); // 写使能
    
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_PAGE_PROGRAM);
    myspi_swap_byte_mode_0_1(address>>16);// 输出第一个字节地址(最高位)，地址高位先行
    myspi_swap_byte_mode_0_1(address>>8); // 输出第二个字节地址(次高位)：在一个24位地址右移8位时，第二字节的数据被移动到最低位时，因为只能发8位数据，所以第一个字节的数据被舍弃
    myspi_swap_byte_mode_0_1(address);    // 输出第三个字节地址(最低位)，直接输出最低位地址，最高位和最低位舍弃
    for(i=0; i<count; i++)       // 将count 大小的数据写入flash
        myspi_swap_byte_mode_0_1(data_buf[i]);
    
    myspi_stop();
    
    w25q64_read_status_busy();  // 忙等待---确保下次可直接写入
}

// 扇区擦除
void w25q64_sector_erase(uint32_t address)
{
    w25q64_write_enable(); // 写使能
    
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_SECTOR_ERASE_4KB);
    myspi_swap_byte_mode_0_1(address>>16);// 输出第一个字节地址(最高位)，地址高位先行
    myspi_swap_byte_mode_0_1(address>>8); // 输出第二个字节地址(次高位)：在一个24位地址右移8位时，第二字节的数据被移动到最低位时，因为只能发8位数据，所以第一个字节的数据被舍弃
    myspi_swap_byte_mode_0_1(address);    // 输出第三个字节地址(最低位)，直接输出最低位地址，最高位和最低位舍弃

    myspi_stop();
    
    w25q64_read_status_busy();  // 忙等待---确保下次可直接写入
}

// 读flash数据
void w25q64_read_data(uint32_t address, uint8_t *data_buf, uint16_t count)
{
    uint16_t i;
    myspi_start();
    myspi_swap_byte_mode_0_1(W25Q64_READ_DATA);
    myspi_swap_byte_mode_0_1(address>>16);// 输出第一个字节地址(最高位)，地址高位先行
    myspi_swap_byte_mode_0_1(address>>8); // 输出第二个字节地址(次高位)：在一个24位地址右移8位时，第二字节的数据被移动到最低位时，因为只能发8位数据，所以第一个字节的数据被舍弃
    myspi_swap_byte_mode_0_1(address);    // 输出第三个字节地址(最低位)，直接输出最低位地址，最高位和最低位舍弃
    for(i=0; i<count; i++)       // 将count 大小的数据写入flash
        data_buf[i] = myspi_swap_byte_mode_0_1(W25Q64_DUMMY_BYTE);
    myspi_stop();
}

// w25q64.h

#ifndef __W25Q64_H
#define __W25Q64_H

void w25q64_init(void);

void w25q64_read_ID(uint8_t *MID, uint16_t *DID);
// 页编程
void w25q64_page_program(uint32_t address, uint8_t *data_buf, uint16_t count);

// 扇区擦除
void w25q64_sector_erase(uint32_t address);

// 读flash数据
void w25q64_read_data(uint32_t address, uint8_t *data_buf, uint16_t count);
#endif

//w25q64_Ins.h

#ifndef __W25Q64_INS_H
#define __W25Q64_INS_H

#define W25Q64_WRITE_ENABLE                            0x06
#define W25Q64_WRITE_DISABLE                        0x04
#define W25Q64_READ_STATUS_REGISTER_1                0x05
#define W25Q64_READ_STATUS_REGISTER_2                0x35
#define W25Q64_WRITE_STATUS_REGISTER                0x01
#define W25Q64_PAGE_PROGRAM                            0x02
#define W25Q64_QUAD_PAGE_PROGRAM                    0x32
#define W25Q64_BLOCK_ERASE_64KB                        0xD8
#define W25Q64_BLOCK_ERASE_32KB                        0x52
#define W25Q64_SECTOR_ERASE_4KB                        0x20
#define W25Q64_CHIP_ERASE                            0xC7
#define W25Q64_ERASE_SUSPEND                        0x75
#define W25Q64_ERASE_RESUME                            0x7A
#define W25Q64_POWER_DOWN                            0xB9
#define W25Q64_HIGH_PERFORMANCE_MODE                0xA3
#define W25Q64_CONTINUOUS_READ_MODE_RESET            0xFF
#define W25Q64_RELEASE_POWER_DOWN_HPM_DEVICE_ID        0xAB
#define W25Q64_MANUFACTURER_DEVICE_ID                0x90
#define W25Q64_READ_UNIQUE_ID                        0x4B
#define W25Q64_JEDEC_ID                                0x9F
#define W25Q64_READ_DATA                            0x03
#define W25Q64_FAST_READ                            0x0B
#define W25Q64_FAST_READ_DUAL_OUTPUT                0x3B
#define W25Q64_FAST_READ_DUAL_IO                    0xBB
#define W25Q64_FAST_READ_QUAD_OUTPUT                0x6B
#define W25Q64_FAST_READ_QUAD_IO                    0xEB
#define W25Q64_OCTAL_WORD_READ_QUAD_IO                0xE3

#define W25Q64_DUMMY_BYTE                            0xFF

#endif

// main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h" 


uint8_t MID;
uint16_t DID;
uint8_t write_buf[] = {0x01, 0x02, 0x03, 0x04};
uint8_t read_buf[4] = {0}; 

int main(void)
{
    OLED_Init();
    w25q64_init();

    OLED_ShowString(1, 1, "MID:");
    OLED_ShowString(1, 8, "DID:");
    OLED_ShowString(2, 1, "W:");
    OLED_ShowString(3, 1, "R:");    

    w25q64_read_ID(&MID, &DID);
    OLED_ShowHexNum(1, 5, MID, 2);
    OLED_ShowHexNum(1, 12, DID, 4);
    
    w25q64_sector_erase(0x000000);
    w25q64_page_program(0x000000, write_buf, 4);
    w25q64_read_data(0x000000, read_buf, 4);
    
    OLED_ShowHexNum(2, 3, write_buf[0], 2);
    OLED_ShowHexNum(2, 6, write_buf[1], 2);
    OLED_ShowHexNum(2, 9, write_buf[2], 2);
    OLED_ShowHexNum(2, 12, write_buf[3], 2);
    
    OLED_ShowHexNum(3, 3,  read_buf[0], 2);
    OLED_ShowHexNum(3, 6,  read_buf[1], 2);
    OLED_ShowHexNum(3, 9,  read_buf[2], 2);
    OLED_ShowHexNum(3, 12, read_buf[3], 2);
    while (1)
    {
        
    }
}

硬件SPI

一、SPI外设简介

• STM32内部集成了硬件SPI收发电路，可以由硬件自动执行时钟生成、数据收发等功能，减轻CPU的负担
• 可配置8位/16位数据帧、高位先行/低位先行
• 时钟频率： f(PCLK) / (2, 4, 8, 16, 32, 64, 128, 256)
• 支持多主机模型、主或从操作
• 可精简为半双工/单工通信
• 支持DMA
• 兼容I2S协议
• STM32F103C8T6 硬件SPI资源：SPI1、SPI2

SPI1挂载到APB2(PCLK=72MHZ)，SPI2挂载到APB1(PCLK=36MHZ)

1、SPI框图

接收缓冲区即接收数据寄存器RDR、发送缓冲区即发送数据寄存器TDR

2、SPI基本结构

3、主模式全双工连续传输(少用)

\quad 示例使用SPI模式3，SCK 默认高电平，在第一个下降沿，MOSI和MISO移出数据，之后，上升沿移入数据，依次进行（对应图中第六行）；第二行是MOSI和MISO输出的波形，跟随SCK时钟变换，数据位依次出现，从前到后，依次出现的是60、b1，一直到b7，所以示例演示的是低位先行的模式（实际SPI高位先行用的多），第三行是TXE，发送寄存器空标志位，第四行是发送缓冲器，括号，写入SPI_DR(实际是发送数据寄存器TDR)，第五行BSY，BUSY，是由硬件自动设置和清除的，有数据传输时，BSY位置1，以上部分演示的是输出的流程和现象。
\quad 输入的流程和现象：第一个是MISO/MOSI的输入类据，之后是，RXNE，接收数据寄存器非空标志位，最后是接收缓冲器，读出SPI_DR。

4、非连续传输(常用)

复用开漏输出/ 复用推挽输出：可以理解为GPIO口被用作第二功能时的配置情况（即并非作为通用IO口使用）

硬件SPI读写W25Q64代码：

硬件SPI读写W25Q64，相比于软件SPI，修改了引脚配置和交换数据方式，其余与软件SPI一致，四行代码即可完成

SPI.c

#include "stm32f10x.h"                  // Device header

void MySPI_W_SS(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_4, (BitAction)BitValue);
}

void MySPI_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    // PA4 通用推挽输出 SS引脚  --使用的是软件模拟，
    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    SPI_InitTypeDef SPI_InitStructure;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;          // 选择SPI模式--主机
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;// 配置SPI裁剪引脚--双线全全工 
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;     // 配置8位或16位数据帧--8位数据帧
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;    // 配置高位先行还是低位先行--高位先行
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;// 配置SCK时钟频率(SCK时钟频率=PCLK/分频系数) --128分频 72MHZ/128=562.5KHZ
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;          // 时钟极性--选择模式0，空闲时CPOL=0
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;        // 时钟相位--选择模式0，空闲时CPHA=0
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;             // NSS引脚--软件NSS
    SPI_InitStructure.SPI_CRCPolynomial = 7;            //CRC校验的多项式
    SPI_Init(SPI1, &SPI_InitStructure);
    
    SPI_Cmd(SPI1, ENABLE); //开启SPI　
    
    MySPI_W_SS(1);// 默认不选中从机 
}

void MySPI_Start(void)
{
    MySPI_W_SS(0);
}

void MySPI_Stop(void)
{
    MySPI_W_SS(1);
}

uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
    //  等待TXE为1，发送寄存器为空
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) != SET);
    // 软件写入数据至SPI_DR  ByteSend:要写入到TDR的数据 
    SPI_I2S_SendData(SPI1, ByteSend);
    // 等待RXNE为1，即收到一个字节
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) != SET);
    // 读取DR--读取RDR寄存器中的数据
    return SPI_I2S_ReceiveData(SPI1);
}