SPI

SPI通信简介

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

硬件电路

• 所有SPI设备的SCK、MOSI、MISO分别连在一起
• 主机另外引出多条SS控制线，分别接到各从机的SS引脚
• 输出引脚配置为推挽输出，输入引脚配置为浮空或上拉输入

移位示意图

• 高位先行，高电平移出数据，低电平移入

SPI时基单元

• **起始条件：**SS从高电平切换到低电平
• **终止条件：**SS从低电平切换到高电平

SPI交换字节有多种模式可以选择，主要取决于CPOL(时钟极性)和CPHA(时钟相位)，一个四种组合方式。

• 交换一个字节**（模式0）**
• CPOL=0：空闲状态时，SCK为低电平
• CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

• 交换一个字节**（模式1）**
• CPOL=0：空闲状态时，SCK为低电平
• CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

• 交换一个字节**（模式2）**
• CPOL=1：空闲状态时，SCK为高电平
• CPHA=0：SCK第一个边沿移入数据，第二个边沿移出数据

• 交换一个字节**（模式3）**
• CPOL=1：空闲状态时，SCK为高电平
• CPHA=1：SCK第一个边沿移出数据，第二个边沿移入数据

SPI时序

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

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

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

与上图类似，将最后一步指令发送数据改为接收数据即可

W25Q64简介

• W25Qxx系列是一种低成本、小型化、使用简单的非易失性存储器，常应用于数据存储、字库存储、固件程序存储等场景

• 存储介质：Nor Flash（闪存）

• 时钟频率：80MHz / 160MHz (Dual SPI) / 320MHz (Quad SPI)

• 存储容量（24位地址）：

W25Q40： 4Mbit / 512KByte

W25Q80： 8Mbit / 1MByte

W25Q16： 16Mbit / 2MByte

W25Q32： 32Mbit / 4MByte

W25Q64： 64Mbit / 8MByte

W25Q128： 128Mbit / 16MByte

W25Q256： 256Mbit / 32MByte

硬件电路

引脚	功能
VCC、GND	电源（2.7~3.6V）
CS（SS）	SPI片选
CLK（SCK）	SPI时钟
DI（MOSI）	SPI主机输出从机输入
DO（MISO）	SPI主机输入从机输出
WP	写保护
HOLD	数据保持

W25Q64框图

Flash读写注意事项

写入操作时：

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

读取操作时：

• 直接调用读取时序，无需使能，无需额外操作，没有页的限制，读取操作结束后不会进入忙状态，但不能在忙状态时读取

软件模拟SPI(标准库)

SPI文件

创建MySPI.c文件，编写SPI基本时序单元

#include "stm32f10x.h"                  // Device header

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

void MySPI_W_MOSI(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

void MySPI_W_CLK(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)
{
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}


//主机输出引脚：SCK、MOSI、SS(复用推挽输出模式);主机输入引脚：MISO(上拉输入模式)
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);

    //初始化引脚电压(SPI0模式)
    MySPI_W_SS(1);
    MySPI_W_CLK(0);
}

void MySPI_Start(void)
{
    MySPI_W_SS(0);              //拉低SS，开始时序
}
void MySPI_Stop(void)
{
    MySPI_W_SS(1);              //拉高SS，终止时序
}

//
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
    uint8_t i,ByteReceive=0x00;
    for(i=0;i<8;i++)
    {
        //移出数据
        MySPI_W_MOSI(ByteSend & (0x80>>i));
        MySPI_W_CLK(1);
        //移入数据
        //当MISO为1时，置变量指定位为1，当MISO为0时，不做处理，指定位为默认的初值0
        if(MySPI_R_MISO()==1){ByteReceive |= (0x80>>i);}
        MySPI_W_CLK(0);
    }
    return ByteReceive;
}   

W25Q64文件

创建W25Q64.c文件，编写W25Q64操作函数

#include "stm32f10x.h"                  // Device header
#include "MySPI.h"
#include "W25Q64.h"

void W25Q64_Init(void)
{
    MySPI_Init();
}

void W25Q64_GetID(uint8_t *MID, uint16_t *DID)
{
    MySPI_Start();
    MySPI_SwapByte(W25Q64_JEDEC_ID);
    *MID = MySPI_SwapByte(0xFF);
    *DID = MySPI_SwapByte(0xFF);
    //左移8位,后续获取底八位
    *DID<<=8;
    //取或“|”
    *DID |= MySPI_SwapByte(0xFF);
    MySPI_Stop();
}

/**
  * @brief  W25Q64写使能
  * @param  无
  * @retval 无
  */
void W25Q64_WriteEnable(void)
{
    MySPI_Start();
    MySPI_SwapByte(W25Q64_WRITE_ENABLE);
    MySPI_Stop();
}

/**
  * @brief  W25Q64等待“忙”状态
  * @param  无
  * @retval 无
  */
void W25Q64_WaitBusy(void)
{
    uint32_t Timeout;
    MySPI_Start();
    //读状态寄存器1的最后一位（1为忙）
    MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
    while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01)==1);

    Timeout = 100000;                           //给定超时计数时间
    while ((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)  //循环等待忙标志位
    {
        Timeout --;                             //等待时，计数值自减
        if (Timeout == 0)                       //自减到0后，等待超时
        {
            /*超时的错误处理代码，可以添加到此处*/
            break;                              //跳出等待，不等了
        }
    }

    MySPI_Stop();
}
/**
  * 函    数：W25Q64页编程
  * 参    数：Address 页编程的起始地址，范围：0x000000~0x7FFFFF
  * 参    数：DataArray    用于写入数据的数组
  * 参    数：Count 要写入数据的数量，范围：0~256
  * 返 回 值：无
  * 注意事项：写入的地址范围不能跨页
  */
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint8_t Count)
{
    uint32_t i;
    W25Q64_WriteEnable();
    MySPI_Start();
    MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
    MySPI_SwapByte(Address>>16);
    MySPI_SwapByte(Address>>8);
    MySPI_SwapByte(Address);
    for(i=0; i<Count; i++)
    {
        MySPI_SwapByte(DataArray[i]);
    }

    MySPI_Stop();
    W25Q64_WaitBusy();
}

/**
  * 函    数：W25Q64扇区擦除（4KB）
  * 参    数：Address 指定扇区的地址，范围：0x000000~0x7FFFFF
  * 返 回 值：无
  */
void W25Q64_SectorErase(uint32_t Address)
{   
    W25Q64_WriteEnable();
    MySPI_Start();

    MySPI_SwapByte(W25Q64_SECTOR_ERASE_4KB);
    MySPI_SwapByte(Address>>16);
    MySPI_SwapByte(Address>>8);
    MySPI_SwapByte(Address);

    MySPI_Stop();
    W25Q64_WaitBusy();
}

/**
  * 函    数：W25Q64读取数据
  * 参    数：Address 读取数据的起始地址，范围：0x000000~0x7FFFFF
  * 参    数：DataArray 用于接收读取数据的数组，通过输出参数返回
  * 参    数：Count 要读取数据的数量，范围：0~0x800000
  * 返 回 值：无
  */
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint8_t Count)
{
    uint32_t i;
    MySPI_Start();
    MySPI_SwapByte(W25Q64_READ_DATA);
    MySPI_SwapByte(Address>>16);
    MySPI_SwapByte(Address>>8);
    MySPI_SwapByte(Address);
    for(i=0; i<Count; i++)
    {
        DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
    }

    MySPI_Stop();
}

在W25Q64.h文件，记录W25Q64寄存器地址

#ifndef __W25Q64_H__
#define __W25Q64_H__

#include "stm32f10x.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


void W25Q64_Init(void);
void W25Q64_GetID(uint8_t *MID, uint16_t *DID);
void W25Q64_SectorErase(uint32_t Address);
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint8_t Count);
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint8_t Count);

#endif

SPI硬件外设

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

SPI框图

SPI基本结构

主模式全双工连续传输

非连续传输

硬件SPI(标准库)

修改MySPI.c文件

#include "stm32f10x.h"                  // Device header

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

void MySPI_W_MOSI(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_7, (BitAction)BitValue);
}

void MySPI_W_CLK(uint8_t BitValue)
{
    GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}

uint8_t MySPI_R_MISO(void)
{
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}


//主机输出引脚：SCK、MOSI、SS(复用推挽输出模式);主机输入引脚：MISO(上拉输入模式)
void MySPI_Init(void)
{
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

    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_IPU;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
    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);

//  //初始化引脚电压(SPI0模式)
//  MySPI_W_SS(1);
//  MySPI_W_CLK(0);
    SPI_InitTypeDef SPI_InitStructure;
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;  //主机模式
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;  //分频系数
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //CPHA=0
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;  //CPOL=0,SPI模式0
    SPI_InitStructure.SPI_CRCPolynomial = 7;
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //8位数据帧
    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //全双工
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //高位先行
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //软件模拟SS引脚

    SPI_Init(SPI1, &SPI_InitStructure);
    SPI_Cmd(SPI1, ENABLE);
    MySPI_W_SS(1); //SS默认高电平

}

void MySPI_Start(void)
{
    MySPI_W_SS(0);              //拉低SS，开始时序
}
void MySPI_Stop(void)
{
    MySPI_W_SS(1);              //拉高SS，终止时序
}

//
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
//  uint8_t i,ByteReceive=0x00;
//  for(i=0;i<8;i++)
//  {
//      //移出数据
//      MySPI_W_MOSI(ByteSend & (0x80>>i));
//      MySPI_W_CLK(1);
//      //移入数据
//      //当MISO为1时，置变量指定位为1，当MISO为0时，不做处理，指定位为默认的初值0
//      if(MySPI_R_MISO()==1){ByteReceive |= (0x80>>i);}
//      MySPI_W_CLK(0);
//  }
//  return ByteReceive;

    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
    SPI_I2S_SendData(SPI1, ByteSend);

    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

    return SPI_I2S_ReceiveData(SPI1);
}