学习笔记——软件SPI驱动W25Q64

因为是软件模拟SPI时序，做不到通信线之间同时响应，只能按因果关系来写时序 

 底层SPI接口：

#include "stm32f10x.h"
#include "spi.h"
//虽然是软件模拟SPI的时序，但还是采用硬件SPI的引脚，这样切换起来方便 
//PA7-DI PA6-DO PA5-SCK PA4-/SS

void MYSPI_WR_SS(uint8_t BitValue) //写SS电平
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_4,(BitAction)BitValue);
}

void MYSPI_WR_SCK(uint8_t BitValue) //写SCK电平
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_5,(BitAction)BitValue);
}

void MYSPI_WR_MOSI(uint8_t BitValue) //主机写数据到MOSI通信线上
{
	GPIO_WriteBit(GPIOA,GPIO_Pin_6,(BitAction)BitValue);
}

uint8_t MYSPI_RD_MISO(void) //读从机发出到MOSI通信线上的数据
{
	return GPIO_ReadInputDataBit(GPIOA,GPIO_Pin_6);
}

void MYSPI_Init()
{
	GPIO_InitTypeDef gpio_structInit;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
	
	gpio_structInit.GPIO_Mode  = GPIO_Mode_Out_PP;
	gpio_structInit.GPIO_Pin   = GPIO_Pin_7 | GPIO_Pin_5 | GPIO_Pin_4; //输出、时钟、片选引脚都用推挽 
	gpio_structInit.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOA,&gpio_structInit);
	
	//输入配置为上拉
	gpio_structInit.GPIO_Mode  = GPIO_Mode_IPU;
	gpio_structInit.GPIO_Pin   = GPIO_Pin_6; 
	gpio_structInit.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOA,&gpio_structInit);
	
	//初始化时，SS先拉高，选择模式0，时钟线空闲状态为低电平
	MYSPI_WR_SS(1);
	MYSPI_WR_SCK(0);
	
}

void MYSPI_Start(void)
{
	MYSPI_WR_SS(0);
}

void MYSPI_Stop(void)
{
	MYSPI_WR_SS(1);
}

/*	
	交换字节，即主机发送一个字节数据给从机，然后读出从机传来的数据，发送的字节当然已知，所以关心读到的数据
	采用模式0
	起始时序SS被拉低->主机MOSI移出->SCK拉高->从机MISO移入->SCK拉低   
*/
uint8_t MYSPI_SwapByte1(uint8_t ByteSend) 
{
	uint8_t i,ByteReceive = 0x00; 
	
	for(i=0;i<8;i++)
	{
		MYSPI_WR_MOSI(ByteSend & (0x80>>i)); //不改变发送的数据，只通过掩码和循环操作依次提取原始数据的每一位
		MYSPI_WR_SCK(1);
		if(MYSPI_RD_MISO() == 1){ ByteReceive |= (0x80>>i);} //这里通过读通信线上数据是否为1，相应置位
		MYSPI_WR_SCK(0);
	}
	
	return ByteReceive;
}

uint8_t MYSPI_SwapByte2(uint8_t ByteSend)//另一种方式 
{
	uint8_t i; 
	
	for(i=0;i<8;i++)
	{
		MYSPI_WR_MOSI(ByteSend & 0x80); //最高位相与结果是1就移出1，是0移出0
		ByteSend <<= 1; //最高位b7不要了，次高位递补最高位，同时末位补0
		MYSPI_WR_SCK(1);
		if(MYSPI_RD_MISO() == 1){ ByteSend |= 0x01;} //如果读到1 ByteSend末位置1 不是的话反正前面左移操作补了0
		MYSPI_WR_SCK(0);
	}
	
	return ByteSend;
}

驱动层W25Q64接口：

#include "stm32f10x.h"
#include "w25q64.h"
#include "spi.h"
#include "w25q64_ins.h" //根据手册定义的指令宏 

void W25Q64_Init(void) //调用底层SPI初始化
{	
	MYSPI_Init();
}

void W25Q64_ReadID(uint8_t * MID,uint16_t* DID) //获取厂商ID、设备ID
{
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_JEDEC_ID); 		    //这里只是发送指令，不关心读到的数据，相当于抛砖引玉 下一次交换 就能得到"玉"了
	*MID = MYSPI_SwapByte1(W25Q64_DUMMY_BYTE);  //这里只为了读取到ID，"获得玉"
	*DID = MYSPI_SwapByte1(W25Q64_DUMMY_BYTE);  //得到高八位，此时还在数据的低八位
	*DID <<= 8;       			                //左移八位
	*DID |= MYSPI_SwapByte1(W25Q64_DUMMY_BYTE); //得到低八位
	MYSPI_Stop();
}

void W25Q64_WriteEnable(void) //写使能
{
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_WRITE_ENABLE);
	MYSPI_Stop();
}

/*关于等待，因为有事前等待事后等待之分，两种有所区别：
	事后等待，即每次写操作结束后都调用一次等待忙函数（这也是符合Flash操作注意事项的），函数退出后肯定不可能存在忙状态，也就不会影响下次读写操作   这样方便、保险，但效率不高
	事前等待，即每次读写操作前都调用等待忙函数，这样效率会高很多，因为读写完不会影响其他操作

*/
void W25Q64_WaitBusy(void) //等待状态寄存器1BUSY位置0 
{
	uint32_t TIMEOUT = 100000;
	
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_READ_STATUS_REGISTER_1); //读状态寄存器1指令
	while((MYSPI_SwapByte1(W25Q64_DUMMY_BYTE) & 0x01) == 0x01 ) //交换字节得到状态寄存器1的S7~S0,这里只关注最低位是否为1 为1说明忙 那就循环等待    
	{
		TIMEOUT --;
		if(TIMEOUT == 0) //超时退出
		{
			break;
		}
	}
	MYSPI_Stop();	
}


void W25Q64_WriteData(uint32_t Address, uint8_t *DataArray, uint16_t CountOfWrite) //利用数组来传递多个字节数据（反复传递一个字节数据也麻烦）
{
	uint16_t i;
	
	W25Q64_WriteEnable();
	
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_PAGE_PROGRAM); //发送写指令
	MYSPI_SwapByte1(Address >> 16); 	  //发送地址高八位
	MYSPI_SwapByte1(Address >> 8);        //发送地址中间八位
	MYSPI_SwapByte1(Address);	          //发送地址低八位
	for(i=0;i<CountOfWrite;i++)       //连续写入DataCountPerByte个字节
	{
		MYSPI_SwapByte1(DataArray[i]);
	}	
	MYSPI_Stop();
	
	W25Q64_WaitBusy(); 
}

void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t CountOfRead) //读数据，因为数量不受限，类型给最大的32位
{
	uint32_t i;
	
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_READ_DATA);    //发送读指令
	MYSPI_SwapByte1(Address >> 16); 	  //发送地址高八位
	MYSPI_SwapByte1(Address >> 8);        //发送地址中间八位
	MYSPI_SwapByte1(Address);	          //发送地址低八位
	for(i=0;i<CountOfRead;i++)           //连续读出数据放入指定数组中 发送无用数据即可，这时候只关心读到的
	{
		DataArray[i] = MYSPI_SwapByte1(W25Q64_DUMMY_BYTE);
	}
	
	MYSPI_Stop();  
}

void W25Q64_SectorErase(uint32_t Address) //从指定地址开始按扇区大小擦除
{
	W25Q64_WriteEnable();
	
	MYSPI_Start();
	MYSPI_SwapByte1(W25Q64_SECTOR_ERASE_4KB); //发送擦除指令
	MYSPI_SwapByte1(Address >> 16); 	      //发送地址高八位
	MYSPI_SwapByte1(Address >> 8);            //发送地址中间八位
	MYSPI_SwapByte1(Address);	              //发送地址低八位
	MYSPI_Stop();
	
	W25Q64_WaitBusy();
}

指令宏：

#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