SPI/QSPI通信协议详解和应用

SPi是高速全双工的串行总线，通常应用在通讯速率较高的场合。

 

 SS：从设备选择信号线，也称片选信号线

每个从设备都有一个独立的SS信号线，信号线独占主机的一个引脚，及有多少个从设备就有多少个片选信号线，

I2c是通过设备地址来寻址，选中总线上的某个设备并与其进行通讯。

（SPi以SS线置低电平为开始信号，以ss线被拉高作为结束信号）摩托摩拉的标准

MOSI，主设备输出、从设备输入

MISO，主设备输入，从设备输出

 

 

 

 

 1，QSPI初始化步骤

1）开启QSPI接口和相关IO的时钟，设置IO口的复用功能。
要使用QSPI，肯定要先开启其时钟（由AHB3ENR控制），然后根据我们使用的QSPI IO口，开启对应IO口的时钟，并初始化相关IO口的复用功能（选择QSPI复用功能）。
QSPI时钟使能方法为：
__HAL_RCC_QSPI_CLK_ENABLE();        //使能QSPI时钟
这里大家要注意，和其他外设处理方法一样，HAL库提供了QSPI的初始化回调函数HAL_QSPI_MspInit，一般用来编写与MCU相关的初始化操作。时钟使能和IO口初始化一般在回调函数中编写。

2）设置QSPI相关参数。
此部分需要设置两个寄存器：QUADSPI_CR和QUADSPI_DCR，控制QSPI的时钟、片选参数、FLASH容量和时钟模式等参数，设定SPI FLASH的工作条件。最后，使能QSPI，完成对QSPI的初始化。HAL库中设置QSPI相关参数函数为HAL_QSPI_Init，该函数声明为：
HAL_StatusTypeDef HAL_QSPI_Init(QSPI_HandleTypeDef *hqspi);

2，QSPI发送命令步骤
1）等待QSPI空闲
在QSPI发送命令前，必须先等待QSPI空闲，通过判断QUADSPI_SR寄存器的BUSY位为0，来确定。
2）设置命令参数。
此部分主要是通过通信配置寄存器（QUADSPI_CCR）设置，将QSPI配置为：每次都发送指令、间接写模式，根据具体需要设置：指令、地址、空周期和数据等的传输位宽等信息。如果需要发送地址，则配置地址寄存器（QUADSPI_AR）。
在配置完成以后，即可启动发送。如果不需要传输数据，则需要等待命令发送完成（等待QUADSPI_SR寄存器的TCF位为1）。

3，QSPI读数据步骤
1）设置数据传输长度
通过设置数据长度寄存器（QUADSPI_DLR），配置需要传输的字节数。2）设置QSPI工作模式并设置地址
因为要读取数据，所以，设置QUADSPI_CCR寄存器的FMODE[1:0]位为01，工作在间接读取模式。然后，通过地址寄存器（QUADSPI_AR），设置我们将要读取的数据的首地址。
3）读取数据
在发送完地址以后，就可以读取数据了，不过要等待数据准备好，通过判断QUADSPI_SR寄存器的FTF和TCF位，当这两个位任意一个位为1的时候，我们就可以读取QUADSPI_DR寄存器来获取从FLASH读到的数据。
最后，在所有数据接收完成以后，终止传输（ABORT），清除传输完成标志位（TCF）。

4，QSPI写数据步骤
1）设置数据传输长度
通过设置数据长度寄存器（QUADSPI_DLR），配置需要传输的字节数。2）设置QSPI工作模式并设置地址
因为要读取数据，所以，设置QUADSPI_CCR寄存器的FMODE[1:0]位为00，工作在间接写入模式。然后，通过地址寄存器（QUADSPI_AR），设置我们将要写入的数据的首地址。
3）写入数据
在发送完地址以后，就可以写入数据了，不过要等待FIFO不满，通过判断QUADSPI_SR寄存器的FTF位，当这个位为1的时候，表示FIFO可以写入数据，此时往QUADSPI_DR写入需要发送的数据，就可以实现写入数据到FLASH。
最后，在所有数据写入完成以后，终止传输（ABORT），清除传输完成标志位（TCF）。在HAL库中，QSPI发送数据是通过函数HAL_QSPI_Transmit来实现的，

 

最后，我们看看W25Q256的初始化流程（QPI模式）：
1）使能QPI模式。
因为我们是通过QSPI访问W25Q256的，所以先设置W25Q256工作在QPI模式下。通过W25X_EnterQPIMode指令控制。注意：在该指令发送之前，必须先使能W25Q256的QE位。
2）设置4字节地址模式。
W25Q256上电后，一般默认是3字节地址模式，我们需要通W25X_Enable4ByteAddr指令，设置其为四字节地址模式，否则只能访问16MB的地址空间。
3）设置读参数。
这一步，我们通过W25X_SetReadParam指令，将P[5:4]设置为11，以支持最高速度访问W25Q256（8个dummy，104M时钟频率）。至此，W25Q256的初始化流程就完成了，接下来便可以通过QSPI读写数据了。

这是正点原子的代码，后续自己深入再更新过.

这里要注意，该函数可以在W25Q256的任意地址开始写入任意长度（必须不超过W25Q256的容量）的数据，先获得所在扇区的首地址先获得首地址（WriteAddr）所在的扇区，并计算在扇区内的偏移，然后判断要写入的数据长度是否超过本扇区所剩下的长度，如果不超过，再先看看是否要擦除，如果不要，则直接写入数据即可，如果要则读出整个扇区，在偏移处开始写入指定长度的数据，然后擦除这个扇区，再一次性写入。当所需要写入的数据长度超过一个扇区的长度的时候，我们先按照前面的步骤把扇区剩余部分写完，再在新扇区内执行同样的操作，如此循环，直到写入结束。这里我们还定义了一个W25QXX_BUFFER的全局变量，用于擦除时缓存扇区内的数据。

u16 W25QXX_TYPE=W25Q256;    //默认是W25Q256
u8 W25QXX_QPI_MODE=0;        //QSPI模式标志:0,SPI模式;1,QPI模式.

//4Kbytes为一个Sector
//16个扇区为1个Block
//W25Q256
//容量为32M字节,共有512个Block,8192个Sector 
                                                     
//初始化SPI FLASH的IO口
void W25QXX_Init(void)
{ 
    u8 temp;    
    QSPI_Init();                    //初始化QSPI
     W25QXX_Qspi_Enable();            //使能QSPI模式
    W25QXX_TYPE=W25QXX_ReadID();    //读取FLASH ID.
    //printf("ID:%x\r\n",W25QXX_TYPE);
    if(W25QXX_TYPE==W25Q256)        //SPI FLASH为W25Q256
    {
        temp=W25QXX_ReadSR(3);      //读取状态寄存器3，判断地址模式
        if((temp&0X01)==0)            //如果不是4字节地址模式,则进入4字节地址模式
        { 
            W25QXX_Write_Enable();    //写使能
            QSPI_Send_CMD(W25X_Enable4ByteAddr,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);//QPI,使能4字节地址指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据 
        }
        W25QXX_Write_Enable();        //写使能
        QSPI_Send_CMD(W25X_SetReadParam,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_4_LINES);         //QPI,设置读参数指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
        temp=3<<4;                    //设置P4&P5=11,8个dummy clocks,104M
        QSPI_Transmit(&temp,1);        //发送1个字节       
    }
}  
//W25QXX进入QSPI模式 
void W25QXX_Qspi_Enable(void)
{
    u8 stareg2;
    stareg2=W25QXX_ReadSR(2);        //先读出状态寄存器2的原始值
    if((stareg2&0X02)==0)            //QE位未使能
    {
        W25QXX_Write_Enable();        //写使能 
        stareg2|=1<<1;                //使能QE位        
        W25QXX_Write_SR(2,stareg2);    //写状态寄存器2
    }
    QSPI_Send_CMD(W25X_EnterQPIMode,0,0,QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);//写command指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据
    W25QXX_QPI_MODE=1;                //标记QSPI模式
}

//W25QXX退出QSPI模式 
void W25QXX_Qspi_Disable(void)
{ 
    QSPI_Send_CMD(W25X_ExitQPIMode,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);//写command指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
    W25QXX_QPI_MODE=0;                //标记SPI模式
}

//读取W25QXX的状态寄存器，W25QXX一共有3个状态寄存器
//状态寄存器1：
//BIT7  6   5   4   3   2   1   0
//SPR   RV  TB BP2 BP1 BP0 WEL BUSY
//SPR:默认0,状态寄存器保护位,配合WP使用
//TB,BP2,BP1,BP0:FLASH区域写保护设置
//WEL:写使能锁定
//BUSY:忙标记位(1,忙;0,空闲)
//默认:0x00
//状态寄存器2：
//BIT7  6   5   4   3   2   1   0
//SUS   CMP LB3 LB2 LB1 (R) QE  SRP1
//状态寄存器3：
//BIT7      6    5    4   3   2   1   0
//HOLD/RST  DRV1 DRV0 (R) (R) WPS ADP ADS
//regno:状态寄存器号，范:1~3
//返回值:状态寄存器值
u8 W25QXX_ReadSR(u8 regno)   
{  
    u8 byte=0,command=0; 
    switch(regno)
    {
        case 1:
            command=W25X_ReadStatusReg1;    //读状态寄存器1指令
            break;
        case 2:
            command=W25X_ReadStatusReg2;    //读状态寄存器2指令
            break;
        case 3:
            command=W25X_ReadStatusReg3;    //读状态寄存器3指令
            break;
        default:
            command=W25X_ReadStatusReg1;    
            break;
    }   
    if(W25QXX_QPI_MODE)QSPI_Send_CMD(command,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_4_LINES);    //QPI,写command指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
    else QSPI_Send_CMD(command,0,0,QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_1_LINE);                //SPI,写command指令,地址为0,单线传数据_8位地址_无地址_单线传输指令,无空周期,1个字节数据
    QSPI_Receive(&byte,1);            
    return byte;   
}   

//写W25QXX状态寄存器
void W25QXX_Write_SR(u8 regno,u8 sr)   
{   
    u8 command=0;
    switch(regno)
    {
        case 1:
            command=W25X_WriteStatusReg1;    //写状态寄存器1指令
            break;
        case 2:
            command=W25X_WriteStatusReg2;    //写状态寄存器2指令
            break;
        case 3:
            command=W25X_WriteStatusReg3;    //写状态寄存器3指令
            break;
        default:
            command=W25X_WriteStatusReg1;    
            break;
    }   
    if(W25QXX_QPI_MODE)QSPI_Send_CMD(command,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_4_LINES);    //QPI,写command指令,地址为0,4线传数据_8位地址_无地址_4线传输指令,无空周期,1个字节数据
    else QSPI_Send_CMD(command,0,0, QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_1_LINE);                //SPI,写command指令,地址为0,单线传数据_8位地址_无地址_单线传输指令,无空周期,1个字节数据
    QSPI_Transmit(&sr,1);                       
}  

//W25QXX写使能    
//将S1寄存器的WEL置位   
void W25QXX_Write_Enable(void)   
{
    if(W25QXX_QPI_MODE)QSPI_Send_CMD(W25X_WriteEnable,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);    //QPI,写使能指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
    else QSPI_Send_CMD(W25X_WriteEnable,0,0,QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);                //SPI,写使能指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据
} 

//W25QXX写禁止    
//将WEL清零  
void W25QXX_Write_Disable(void)   
{  
    if(W25QXX_QPI_MODE)QSPI_Send_CMD(W25X_WriteDisable,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);//QPI,写禁止指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
    else QSPI_Send_CMD(W25X_WriteDisable,0,0,QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);                //SPI,写禁止指令,地址为0,无数据_8位地址_无地址_单线传输指令,无空周期,0个字节数据 
} 

//返回值如下:                   
//0XEF13,表示芯片型号为W25Q80  
//0XEF14,表示芯片型号为W25Q16    
//0XEF15,表示芯片型号为W25Q32  
//0XEF16,表示芯片型号为W25Q64 
//0XEF17,表示芯片型号为W25Q128       
//0XEF18,表示芯片型号为W25Q256
u16 W25QXX_ReadID(void)
{
    u8 temp[2];
    u16 deviceid;
    if(W25QXX_QPI_MODE)QSPI_Send_CMD(W25X_ManufactDeviceID,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_4_LINES,QSPI_ADDRESS_24_BITS,QSPI_DATA_4_LINES);//QPI,读id,地址为0,4线传输数据_24位地址_4线传输地址_4线传输指令,无空周期,2个字节数据
    else QSPI_Send_CMD(W25X_ManufactDeviceID,0,0,QSPI_INSTRUCTION_1_LINE,QSPI_ADDRESS_1_LINE,QSPI_ADDRESS_24_BITS,QSPI_DATA_1_LINE);            //SPI,读id,地址为0,单线传输数据_24位地址_单线传输地址_单线传输指令,无空周期,2个字节数据
    QSPI_Receive(temp,2);
    deviceid=(temp[0]<<8)|temp[1];
    return deviceid;
}    

//读取SPI FLASH,仅支持QPI模式  
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(最大32bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)   
{ 
    QSPI_Send_CMD(W25X_FastReadData,ReadAddr,8,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_4_LINES,QSPI_ADDRESS_32_BITS,QSPI_DATA_4_LINES);    //QPI,快速读数据,地址为ReadAddr,4线传输数据_32位地址_4线传输地址_4线传输指令,8空周期,NumByteToRead个数据
    QSPI_Receive(pBuffer,NumByteToRead); 
}  

//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(最大32bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!     
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
    W25QXX_Write_Enable();                    //写使能
    QSPI_Send_CMD(W25X_PageProgram,WriteAddr,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_4_LINES,QSPI_ADDRESS_32_BITS,QSPI_DATA_4_LINES);    //QPI,页写指令,地址为WriteAddr,4线传输数据_32位地址_4线传输地址_4线传输指令,无空周期,NumByteToWrite个数据
    QSPI_Transmit(pBuffer,NumByteToWrite);                       
    W25QXX_Wait_Busy();                       //等待写入结束
} 

//无检验写SPI FLASH 
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能 
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(最大32bit)
//NumByteToWrite:要写入的字节数(最大65535)
//CHECK OK
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{                       
    u16 pageremain;       
    pageremain=256-WriteAddr%256; //单页剩余的字节数                 
    if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//不大于256个字节
    while(1)
    {       
        W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
        if(NumByteToWrite==pageremain)break;//写入结束了
         else //NumByteToWrite>pageremain
        {
            pBuffer+=pageremain;
            WriteAddr+=pageremain;    

            NumByteToWrite-=pageremain;              //减去已经写入了的字节数
            if(NumByteToWrite>256)pageremain=256; //一次可以写入256个字节
            else pageremain=NumByteToWrite;       //不够256个字节了
        }
    }   
} 

//写SPI FLASH  
//在指定地址开始写入指定长度的数据
//该函数带擦除操作!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(最大32bit)                        
//NumByteToWrite:要写入的字节数(最大65535)   
u8 W25QXX_BUFFER[4096];         
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)   
{ 
    u32 secpos;
    u16 secoff;
    u16 secremain;       
     u16 i;    
    u8 * W25QXX_BUF;      
       W25QXX_BUF=W25QXX_BUFFER;         
     secpos=WriteAddr/4096;//扇区地址  
    secoff=WriteAddr%4096;//在扇区内的偏移
    secremain=4096-secoff;//扇区剩余空间大小   
     //printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//测试用
     if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//不大于4096个字节
    while(1) 
    {    
        W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//读出整个扇区的内容
        for(i=0;i<secremain;i++)//校验数据
        {
            if(W25QXX_BUF[secoff+i]!=0XFF)break;//需要擦除        
        }
        if(i<secremain)//需要擦除
        {
            W25QXX_Erase_Sector(secpos);//擦除这个扇区
            for(i=0;i<secremain;i++)       //复制
            {
                W25QXX_BUF[i+secoff]=pBuffer[i];      
            }
            W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//写入整个扇区  

        }else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//写已经擦除了的,直接写入扇区剩余区间.                    
        if(NumByteToWrite==secremain)break;//写入结束了
        else//写入未结束
        {
            secpos++;//扇区地址增1
            secoff=0;//偏移位置为0      

               pBuffer+=secremain;  //指针偏移
            WriteAddr+=secremain;//写地址偏移       
               NumByteToWrite-=secremain;                //字节数递减
            if(NumByteToWrite>4096)secremain=4096;    //下一个扇区还是写不完
            else secremain=NumByteToWrite;            //下一个扇区可以写完了
        }     
    };     
}

//擦除整个芯片          
//等待时间超长...
void W25QXX_Erase_Chip(void)   
{                                   
    W25QXX_Write_Enable();                    //SET WEL 
    W25QXX_Wait_Busy();   
    QSPI_Send_CMD(W25X_ChipErase,0,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_NONE,QSPI_ADDRESS_8_BITS,QSPI_DATA_NONE);//QPI,写全片擦除指令,地址为0,无数据_8位地址_无地址_4线传输指令,无空周期,0个字节数据
    W25QXX_Wait_Busy();                        //等待芯片擦除结束
} 

//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个扇区的最少时间:150ms
void W25QXX_Erase_Sector(u32 Dst_Addr)   
{  
     
     //printf("fe:%x\r\n",Dst_Addr);            //监视falsh擦除情况,测试用        
     Dst_Addr*=4096;
    W25QXX_Write_Enable();                  //SET WEL      
    W25QXX_Wait_Busy();  
    QSPI_Send_CMD(W25X_SectorErase,Dst_Addr,0,QSPI_INSTRUCTION_4_LINES,QSPI_ADDRESS_4_LINES,QSPI_ADDRESS_32_BITS,QSPI_DATA_NONE);//QPI,写扇区擦除指令,地址为0,无数据_32位地址_4线传输地址_4线传输指令,无空周期,0个字节数据
    W25QXX_Wait_Busy();                       //等待擦除完成
}

//等待空闲
void W25QXX_Wait_Busy(void)   
{   
    while((W25QXX_ReadSR(1)&0x01)==0x01);   // 等待BUSY位清空
}