STM32 软件SPI读写W25Q64

程序整体框架

首先建立一个MySPI模块，在该模块当中包含通信引脚封装、初始化，SPI通信的起始、终止和交换一个字节。

之后基于SPI层再建立一个W25Q64的模块，再该模块当中调用底层SPI的拼图，来拼接各种指令和功能的完整时序。

最后在主函数内调用W25Q64驱动层的函数来实现功能。

SPI模块

MySPI_Init(void)

        在初始化函数当中要分清谁是输入脚谁是输出脚，对于主机来说，CS片选，SCK时钟和DI都是输出脚，之后DI引脚是输入。输出引脚配置为推挽输出，输入引脚配置为浮空或者上拉输入。 

控制三个输出引脚的高低电平

MySPI_W_SS(uint8_t BitValue)

 MySPI_W_MOSI(uint8_t BitValue)

MySPI_W_SCK(uint8_t BitValue)

控制输出引脚

MySPI_R_MISO(void)

起始信号

SPI软件模拟的起始信号只需要让片选为1即可，表示从机未被选中。

终止信号

SPI软件模拟的终止信号相对于起始信号，只需要将我们的片选改为0即可。

交换一个字节(0模式)

我们可以使用掩码的方式来进行，也可以通过，模拟硬件寄存器的方式来进行实现

#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_SCK(uint8_t BitValue)
{
	GPIO_WriteBit(GPIOA, GPIO_Pin_5, (BitAction)BitValue);
}
//读取输入引脚的高低电平
uint8_t MySPI_R_MISO(void)
{
	return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_6);
}
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;	//对于主机来说CS、SCK、DI是输出脚
	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;	//对于主机来说DI输入脚
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
	//置一下初始化之后引脚的默认电平
	MySPI_W_SS(1);	//不选中从机
	MySPI_W_SCK(0);	//时钟SPI模式零
}
//起始信号
void MySPI_Start(void)
{
	MySPI_W_SS(0);
}
//终止信号
void MySPI_Stop(void)
{
	MySPI_W_SS(1);
}
//交换一个字节（模式0）先下降沿，然后再进行数据的移出，先上升沿，然后再移入数据
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t ByteReceive = 0x00;
	uint8_t i;
	for(i = 0; i < 8; i ++)
	{
		MySPI_W_MOSI(ByteSend & (0x80 >> i));	//通过掩码挑出每一位进行操作
		MySPI_W_SCK(1);
		if(MySPI_R_MISO() == 1){ByteReceive |= (0x80 >> i);}
		MySPI_W_SCK(0);
	}
	return ByteReceive;
}
/*
  模拟硬件的啊移位寄存器的移位操作，可见掩码操作可以被该模拟的移位寄存器进行替代
好处就是效率更高，坏处就是我们的移位的过程中我们的ByteSend的数值变了。
uint8_t MySPI_SwapByte(uint8_t ByteSend)
{
	uint8_t i;
	for(i = 0; i < 8; i ++)
	{
		MySPI_W_MOSI(ByteSend & 0x80);	//通过掩码挑出每一位进行操作
		ByteSend <<= 1;
		MySPI_W_SCK(1);
		if(MySPI_R_MISO() == 1){ByteSend |= 0x01;}
		MySPI_W_SCK(0);
	}
	return ByteSend;
}
*/

My25Q64模块

void W25Q64_Init(void)

void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)

void W25Q64_WriteEnable(void)

void W25Q64_WaitBusy(void)

void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)

void W25Q64_SectorErase(uint32_t Address)

void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)

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

void W25Q64_Init(void)
{
	MySPI_Init();
}
//接收ID号，发送指令之后就可以连续的交换三个字节，第一个字节是厂商的ID，第二个字节是存储器类型，最后一个字节表示存储器的容量
void W25Q64_ReadID(uint8_t *MID, uint16_t *DID)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_JEDEC_ID);
	*MID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);	//0xFF的意义就是置换数据
	//*DID = (MySPI_SwapByte(0xFF) << 8) | MySPI_SwapByte(0xFF);
	*DID = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	*DID <<= 8;
	*DID |= MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	MySPI_Stop();
}
//写使能函数
void W25Q64_WriteEnable(void)
{
	MySPI_Start();
	MySPI_SwapByte(W25Q64_WRITE_ENABLE);
	MySPI_Stop();
}
//读状态寄存器1等待状态寄存器Busy位为0（状态寄存器可以被连续的读出）
void W25Q64_WaitBusy(void)
{
	uint32_t TimeOut;
	uint8_t Busy;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_STATUS_REGISTER_1);
	TimeOut = 100000;
	while((MySPI_SwapByte(W25Q64_DUMMY_BYTE) & 0x01) == 0x01)	//等待Busy为0
	{
		TimeOut --;
		if(TimeOut == 0){break;}
	}
	MySPI_Stop();
}
//页编程函数(指定地址写一个函数)
void W25Q64_PageProgram(uint32_t Address, uint8_t *DataArray, uint16_t Count)	//最后这一个Count表示传递多少个，因为页编程是从0~256所以我们的Count应该定义为16位的，如果定义为8位的，那么就只可以存储0~255
{
	uint16_t i;
	
	W25Q64_WriteEnable();			//写使能
	
	MySPI_Start();
	MySPI_SwapByte(W25Q64_PAGE_PROGRAM);
	MySPI_SwapByte(Address >> 16);	//最高的8个bit
	MySPI_SwapByte(Address >> 8);	//中间的8个bit
	MySPI_SwapByte(Address);		//最低的8个bit
	for(i = 0; i < Count; i ++)
	{
		MySPI_SwapByte(DataArray[i]);
	}
	MySPI_Stop();
	
	W25Q64_WaitBusy(); 				//等待芯片不忙的状态(等待可以是事前(写入前)等待，也可以是事后(写入后)等待，事前等待的话效率会高一些，但是读的操作之前也就需要调用等待的函数，如果是事后等待的话我们只需要在写入之后进行等待就可以了)
}
//扇区擦除功能函数(指定地址的整个扇区会被删除)
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(); 
}
//读取，读取没有256字节限制可以一直无限读
void W25Q64_ReadData(uint32_t Address, uint8_t *DataArray, uint32_t Count)	//count可以给的很大
{
	uint32_t i;
	MySPI_Start();
	MySPI_SwapByte(W25Q64_READ_DATA);
	MySPI_SwapByte(Address >> 16);	//最高的8个bit
	MySPI_SwapByte(Address >> 8);	//中间的8个bit
	MySPI_SwapByte(Address);		//最低的8个bit
	for(i = 0; i < Count; i++)
	{
		DataArray[i] = MySPI_SwapByte(W25Q64_DUMMY_BYTE);
	}
	MySPI_Stop();
}

主函数

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "W25Q64.h"
uint8_t MID;
uint16_t DID;
uint8_t ArrayWrite[] = {0x55, 0x66, 0x77, 0x88};
uint8_t ArrayRead[4];
int main()
{
	OLED_Init();
	W25Q64_Init();
	
	OLED_ShowString(1, 1, "MID:   DID:");
	OLED_ShowString(2, 1, "W:");
	OLED_ShowString(3, 1, "R:");
	
	W25Q64_ReadID(&MID, &DID);
	OLED_ShowHexNum(1, 5, MID, 2);
	OLED_ShowHexNum(1, 12, DID, 4);
	
	W25Q64_SectorErase(0x000000);		//Ö¸¶¨ÉÈÇøÆðʼµØÀ´½øÐвÁ³ý£¬Èç¹û²»½øÐвÁ³ý£¬ÄÇô¾ÍÊÇ ¶Á³öµÄÊý¾Ý = ԭʼÊý¾Ý & дÈëµÄÊý¾Ý
	W25Q64_PageProgram(0x000000, ArrayWrite, 4);
	
	W25Q64_ReadData(0x000000, ArrayRead, 4);
	
	OLED_ShowHexNum(2, 3, ArrayWrite[0], 2);
	OLED_ShowHexNum(2, 6, ArrayWrite[1], 2);
	OLED_ShowHexNum(2, 9, ArrayWrite[2], 2);
	OLED_ShowHexNum(2, 12, ArrayWrite[3], 2);
	
	OLED_ShowHexNum(3, 3, ArrayRead[0], 2);
	OLED_ShowHexNum(3, 6, ArrayRead[1], 2);
	OLED_ShowHexNum(3, 9, ArrayRead[2], 2);
	OLED_ShowHexNum(3, 12, ArrayRead[3], 2);
	while(1)
	{
		
		
	}
}