系列文章目录
文章目录
前言
框架：自己新建库文件夹 取名lib，并按顺序新建spi.c、w25q64.c(根据自己芯片型号)
使用开发板为正点原子mini板演示，开发板上芯片为W25Q64。
一、SPI.h
#ifndef _SPI_H
#define _SPI_H
#include "stm32f10x.h"
#include "system.h"
/*如果不使用SPI_DMA，屏蔽下面define*/
#define SPI1_DMA
#ifdef SPI1_DMA
extern u8 SPI_RX_BUFFER[4096];
extern u8 SPI_TX_BUFFER[4096];
#endif
void SPI1_Config(void); //初始化SPI1口
void SPI1_SetSpeed(u8 SpeedSet); //设置SPI1速度
u8 SPI1_ReadWriteByte(u8 TxData);//SPI1总线读写一个字节
void SPI1_DMA_Config(void);
void SPI_transmission(u8 *rx_buf,u8 *tx_buf,u16 NumByte);
void SPI_DMA_Read(u8 *rx_buf,u8 *tx_data,u16 NumByte);
void SPI_DMA_Write(u8 *rx_data,u8 *tx_buf,u16 NumByte);
#endif
二、SPI.c
1.SPI配置
#include "SPI.h"
#include "stdio.h"
#define Rx_BFSize (u8)20
#define Tx_BFSize (u8)20
#define SPI1_DR_Addr ( (u32)0x4001300C )
u8 Rx_Addr[Rx_BFSize];
u8 Tx_Addr[Tx_BFSize];
/*长度一定要>=数据接收发送大小*/
u8 SPI_RX_BUFFER[4096];
u8 SPI_TX_BUFFER[4096];
void SPI1_Config(void)
{
u8 count=0;
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
RCC_APB2PeriphClockCmd( RCC_APB2Periph_SPI1 , ENABLE);
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA , ENABLE);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7; //SCK,MOSI
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用推挽输出
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
//GPIO_Mode_IN_FLOATING
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6; //MISO
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; //NSS 由软件控制 设置为普通推挽输出
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA
GPIO_SetBits(GPIOA,GPIO_Pin_4|GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //设置SPI工作模式:设置为主SPI
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //设置SPI的数据大小:SPI发送接收8位帧结构
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; //串行同步时钟的空闲状态为高电平
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; //定义波特率预分频的值:波特率预分频值为256
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
SPI_InitStructure.SPI_CRCPolynomial = 7; //CRC值计算的多项式 //NSS由 软件控制
SPI_Init(SPI1, &SPI_InitStructure); //初始化SPI1
#ifdef SPI1_DMA
SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Tx,ENABLE); //使能DMA Tx通道
SPI_I2S_DMACmd(SPI1,SPI_I2S_DMAReq_Rx,ENABLE); //使能DMA Rx通道
#endif
SPI_Cmd(SPI1, ENABLE); //使能SPI
SPI_TX_BUFFER[count++]=0xFF;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
}
//SPI1速度设置函数
//SPI速度=fAPB2/分频系数
//@ref SPI_BaudRate_Prescaler:SPI_BaudRatePrescaler_2~SPI_BaudRatePrescaler_256
//fAPB2时钟一般为84Mhz：
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//判断有效性
SPI1->CR1&=0XFFC7;//位3-5清零，用来设置波特率
SPI1->CR1|=SPI_BaudRatePrescaler; //设置SPI1速度
SPI_Cmd(SPI1,ENABLE); //使能SPI1
}
2.DMA配置
#ifdef SPI1_DMA
void SPI1_DMA_Config(void)
{
DMA_InitTypeDef DMA_InitStructure;
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1,ENABLE);
/********************* DMA_Rx *********************/
DMA_DeInit(DMA1_Channel2); //DMA1 通道2 SPI1_RX
DMA_InitStructure.DMA_BufferSize=Rx_BFSize; //传输数据量的大小
DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralSRC; //DMA传输方向，SRC 外设为数据源
DMA_InitStructure.DMA_M2M=DMA_M2M_Disable; //非存储器到存储器传输模式
DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Rx_Addr; //数据缓冲区地址
DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte; //内存数据宽度 数据宽度 8位
DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable; //传输数据时候内存地址递增
DMA_InitStructure.DMA_Mode=DMA_Mode_Normal; //内存不循环采集数据
DMA_InitStructure.DMA_PeripheralBaseAddr=SPI1_DR_Addr; //SPI1 外设基地址
DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte; //外设数据宽度 数据宽度 8位
DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable; //传输地址固定不变 ENABLE时下次发送数据地址递增+1
DMA_InitStructure.DMA_Priority=DMA_Priority_Medium; //通道优先级
DMA_Init(DMA1_Channel2,&DMA_InitStructure); //DMA1 通道2 SPI1_RX
/********************* DMA_Tx *********************/
DMA_DeInit(DMA1_Channel3); //DMA1 通道3 SPI1_TX
DMA_InitStructure.DMA_BufferSize=Tx_BFSize; //传输数据量的大小
DMA_InitStructure.DMA_DIR=DMA_DIR_PeripheralDST; //DMA传输方向，DST 内存作为数据源
DMA_InitStructure.DMA_M2M=DMA_M2M_Disable; //非存储器到存储器传输模式
DMA_InitStructure.DMA_MemoryBaseAddr=(u32)Tx_Addr; //数据缓冲区地址
DMA_InitStructure.DMA_MemoryDataSize=DMA_MemoryDataSize_Byte; //内存数据宽度 数据宽度 8位
DMA_InitStructure.DMA_MemoryInc=DMA_MemoryInc_Enable; //传输数据时候内存地址递增
DMA_InitStructure.DMA_Mode=DMA_Mode_Normal; //内存不循环采集数据
DMA_InitStructure.DMA_PeripheralBaseAddr=SPI1_DR_Addr; //SPI1 外设基地址
DMA_InitStructure.DMA_PeripheralDataSize=DMA_PeripheralDataSize_Byte; //外设数据宽度 数据宽度 8位
DMA_InitStructure.DMA_PeripheralInc=DMA_PeripheralInc_Disable; //传输地址固定不变 ENABLE时下次发送数据地址递增+1
DMA_InitStructure.DMA_Priority=DMA_Priority_Medium; //通道优先级
DMA_Init(DMA1_Channel3,&DMA_InitStructure); //DMA1 通道2 SPI1_RX
}
void SPI_transmission(u8 *rx_buf,u8 *tx_buf,u16 NumByte)
{
// DMA_Cmd(DMA1_Channel2,DISABLE); //关闭DMA
// DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_SetCurrDataCounter(DMA1_Channel2,NumByte); //设定通道内存宽度
DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
DMA1_Channel2->CCR |= (1<<7); //打开地址自增
DMA1_Channel3->CCR |= (1<<7);
DMA1_Channel2->CMAR =(u32)rx_buf;
DMA1_Channel3->CMAR =(u32)tx_buf;
SPI1->DR; //清空SPI DR寄存器
while((SPI1->SR&1<<1)==0); //等待清除
DMA_Cmd(DMA1_Channel2,ENABLE); //开启DMA
DMA_Cmd(DMA1_Channel3,ENABLE);
while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET); //等待传输完成
while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
DMA_Cmd(DMA1_Channel2,DISABLE); //关闭DMA
DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_ClearFlag(DMA1_FLAG_TC3); //清空传输完成flag
DMA_ClearFlag(DMA1_FLAG_TC2);
}
void SPI_DMA_Read(u8 *rx_buf,u8 *tx_data,u16 NumByte)
{
// DMA_Cmd(DMA1_Channel2,DISABLE);
// DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_SetCurrDataCounter(DMA1_Channel2,NumByte);
DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
DMA1_Channel3->CCR &= ~(1<<7);
DMA1_Channel2->CMAR =(u32)rx_buf;
DMA1_Channel3->CMAR =(u32)tx_data;
SPI1->DR;
while((SPI1->SR&1<<1)==0);
DMA_Cmd(DMA1_Channel2,ENABLE);
DMA_Cmd(DMA1_Channel3,ENABLE);
while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);
while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
DMA_Cmd(DMA1_Channel2,DISABLE);
DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_ClearFlag(DMA1_FLAG_TC3);
DMA_ClearFlag(DMA1_FLAG_TC2);
}
void SPI_DMA_Write(u8 *rx_data,u8 *tx_buf,u16 NumByte)
{
// DMA_Cmd(DMA1_Channel2,DISABLE);
// DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_SetCurrDataCounter(DMA1_Channel2,NumByte);
DMA_SetCurrDataCounter(DMA1_Channel3,NumByte);
DMA1_Channel2->CCR &= ~(1<<7);
DMA1_Channel2->CMAR =(u32)rx_data;
DMA1_Channel3->CMAR =(u32)tx_buf;
SPI1->DR;
while((SPI1->SR&1<<1)==0);
DMA_Cmd(DMA1_Channel2,ENABLE);
DMA_Cmd(DMA1_Channel3,ENABLE);
while( DMA_GetFlagStatus(DMA1_FLAG_TC3) == RESET);
while( DMA_GetFlagStatus(DMA1_FLAG_TC2) == RESET);
DMA_Cmd(DMA1_Channel2,DISABLE);
DMA_Cmd(DMA1_Channel3,DISABLE);
DMA_ClearFlag(DMA1_FLAG_TC3);
DMA_ClearFlag(DMA1_FLAG_TC2);
}
#else
u8 SPI1_ReadWriteByte(u8 TxData)
{
while((SPI1->SR&1<<1)==0);
SPI1->DR=TxData;
while((SPI1->SR&1<<0)==0);
return SPI1->DR;
}
#endif
3.w25q64.c
#include "W25QXX.h"
void W25QXX_Config(void)
{
W25QXX_CS=1; //SPI FLASH不选中
SPI1_DMA_Config();
SPI1_Config(); //初始化SPI
SPI1_SetSpeed(SPI_BaudRatePrescaler_2); //设置为42M时钟,高速模式
#ifdef W25Q256
u8 count=0;
W25QXX_CS=0;
SPI_TX_BUFFER[count++]=W25X_Entry4ByteMode;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
W25QXX_CS=1;
#endif
}
u8 W25QXX_ReadSR(void)
{
u8 byte=0;
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ReadStatusReg;
SPI_TX_BUFFER[count++]=0xFF;
SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
return byte;
}
u8 W25QXX_ReadSR_2(void)
{
u8 byte=0;
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ReadStatusReg_2;
SPI_TX_BUFFER[count++]=0xFF;
SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
return byte;
}
u8 W25QXX_ReadSR_3(void)
{
u8 byte=0;
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ReadStatusReg_3;
SPI_TX_BUFFER[count++]=0xFF;
SPI_DMA_Write(&byte,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
return byte;
}
//写W25QXX状态寄存器
//只有SPR,TB,BP2,BP1,BP0(bit 7,5,4,3,2)可以写!!!
void W25QXX_Write_SR(u8 sr)
{
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_WriteStatusReg;
SPI_TX_BUFFER[count++]=sr;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
W25QXX_CS=1; //取消片选
}
//W25QXX写使能
//将WEL置位
void W25QXX_Write_Enable(void)
{
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_WriteEnable;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
W25QXX_CS=1; //取消片选
}
//W25QXX写禁止
//将WEL清零
void W25QXX_Write_Disable(void)
{
u8 count=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_WriteDisable;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
W25QXX_CS=1; //取消片选
}
//读取芯片ID
//返回值如下:
//0XEF13,表示芯片型号为W25Q80
//0XEF14,表示芯片型号为W25Q16
//0XEF15,表示芯片型号为W25Q32
//0XEF16,表示芯片型号为W25Q64
//0XEF17,表示芯片型号为W25Q128
u16 W25QXX_ReadID(void)
{
u8 count = 0;
u16 Temp = 0;
W25QXX_CS=0;
SPI_TX_BUFFER[count++]=W25X_ManufactDeviceID;
SPI_TX_BUFFER[count++]=0x00;
SPI_TX_BUFFER[count++]=0x00;
SPI_TX_BUFFER[count++]=0x00;
SPI_TX_BUFFER[count++]=0xFF;
SPI_TX_BUFFER[count++]=0xFF;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
Temp = SPI_RX_BUFFER[4]<<8 | SPI_RX_BUFFER[5];
W25QXX_CS=1;
return Temp;
}
//读取SPI FLASH
//在指定地址开始读取指定长度的数据
//pBuffer:数据存储区
//ReadAddr:开始读取的地址(24bit)
//NumByteToRead:要读取的字节数(最大65535)
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)
{
u8 count=0;
u8 temp=0xFF;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ReadData;
#ifdef W25Q256
SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>24);
#endif
SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>16);
SPI_TX_BUFFER[count++]=(u8)((ReadAddr)>>8);
SPI_TX_BUFFER[count++]=(u8)ReadAddr;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
SPI_DMA_Read(pBuffer,&temp,NumByteToRead);
W25QXX_CS=1;
}
//SPI在一页(0~65535)内写入少于256个字节的数据
//在指定地址开始写入最大256字节的数据
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//NumByteToWrite:要写入的字节数(最大256),该数不应该超过该页的剩余字节数!!!
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u8 count=0;
u8 temp=0;
W25QXX_Write_Enable(); //SET WEL
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_PageProgram;
#ifdef W25Q256
SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>24);
#endif
SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>16);
SPI_TX_BUFFER[count++]=(u8)((WriteAddr)>>8);
SPI_TX_BUFFER[count++]=(u8)WriteAddr;
SPI_transmission(SPI_RX_BUFFER, SPI_TX_BUFFER, count);
SPI_DMA_Write(&temp,pBuffer,NumByteToWrite);
W25QXX_CS=1; //取消片选
W25QXX_Wait_Busy(); //等待写入结束
}
//无检验写SPI FLASH
//必须确保所写的地址范围内的数据全部为0XFF,否则在非0XFF处写入的数据将失败!
//具有自动换页功能
//在指定地址开始写入指定长度的数据,但是要确保地址不越界!
//pBuffer:数据存储区
//WriteAddr:开始写入的地址(24bit)
//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:开始写入的地址(24bit)
//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;//扇区剩余空间大小
if(NumByteToWrite<=secremain)secremain=NumByteToWrite; //不大于剩余空间
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)
{
u8 count=0;
u8 temp=0;
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ChipErase;
SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
W25QXX_Wait_Busy(); //等待芯片擦除结束
}
//擦除一个扇区
//Dst_Addr:扇区地址 根据实际容量设置
//擦除一个山区的最少时间:150ms
void W25QXX_Erase_Sector(u32 Dst_Addr)
{
u8 count=0;
u8 temp=0;
Dst_Addr*=4096;
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_SectorErase;
#ifdef W25Q256
SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>24);
#endif
SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>16);
SPI_TX_BUFFER[count++]=(u8)((Dst_Addr)>>8);
SPI_TX_BUFFER[count++]=(u8)Dst_Addr;
SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
W25QXX_Wait_Busy(); //等待擦除完成
}
//等待空闲
void W25QXX_Wait_Busy(void)
{
while((W25QXX_ReadSR()&0x01)==0x01); // 等待BUSY位清空
}
//进入掉电模式
void W25QXX_PowerDown(void)
{
u8 count=0;
u8 temp=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_PowerDown;
SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
delay_us(3); //等待TPD
}
唤醒
void W25QXX_WAKEUP(void)
{
u8 count=0;
u8 temp=0;
W25QXX_CS=0; //使能器件
SPI_TX_BUFFER[count++]=W25X_ReleasePowerDown;
SPI_DMA_Write(&temp,SPI_TX_BUFFER,count);
W25QXX_CS=1; //取消片选
delay_us(3); //等待TRES1
}
4.w25q64.h
#include "system.h"
#include "SPI.h"
#include "USART.h"
#include "delay.h"
/*如果不是W25Q256，屏蔽下面define*/
//#define W25Q256
#define W25QXX_CS GAout(4)
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg 0x05
#define W25X_WriteStatusReg 0x01
#define W25X_ReadData 0x03
#define W25X_FastReadData 0x0B
#define W25X_FastReadDual 0x3B
#define W25X_PageProgram 0x02
#define W25X_BlockErase 0xD8
#define W25X_SectorErase 0x20
#define W25X_ChipErase 0xC7
#define W25X_PowerDown 0xB9
#define W25X_ReleasePowerDown 0xAB
#define W25X_DeviceID 0xAB
#define W25X_ManufactDeviceID 0x90
#define W25X_JedecDeviceID 0x9F
#define W25X_Entry4ByteMode 0xB7
#define W25X_Exit4ByteMode 0xE9
#define W25X_ReadStatusReg_2 0x35
#define W25X_WriteStatusReg_2 0x31
#define W25X_ReadStatusReg_3 0x15
#define W25X_WriteStatusReg_3 0x11
void W25QXX_Config(void);
u16 W25QXX_ReadID(void); //读取FLASH ID
u8 W25QXX_ReadSR(void); //读取状态寄存器
void W25QXX_Write_SR(u8 sr); //写状态寄存器
void W25QXX_Write_Enable(void); //写使能
void W25QXX_Write_Disable(void); //写保护
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead); //读取flash
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//写入flash
void W25QXX_Erase_Chip(void); //整片擦除
void W25QXX_Erase_Sector(u32 Dst_Addr); //扇区擦除
void W25QXX_Wait_Busy(void); //等待空闲
void W25QXX_PowerDown(void); //进入掉电模式
void W25QXX_WAKEUP(void); //唤醒
u8 W25QXX_ReadSR_2(void);
void W25QXX_Write_SR_2(u8 sr);
u8 W25QXX_ReadSR_3(void);
#endif
五.main.c
#include "main.h"
const u8 TEXT_Buffer[]={"abcdefg1234567!"};
//const u8 TEXT_Buffer[4096];
#define SIZE sizeof(TEXT_Buffer)
int main()
{
u8 datatemp[SIZE];
LED_Config();
USART1_Config(115200);
W25QXX_Config();
printf("\r\nID:%x\r\n",W25QXX_ReadID());
printf("SR1:%x\r\n",W25QXX_ReadSR());
printf("SR2:%x\r\n",W25QXX_ReadSR_2());
printf("SR3:%x\r\n",W25QXX_ReadSR_3());
W25QXX_Write((u8*)TEXT_Buffer,0,SIZE);
delay_ms(200);
W25QXX_Read(datatemp,0,SIZE);
printf("fe:%s",datatemp);
while(1)
{
}
}
六.串口打印代码
#include "USART.h"
int fputc(int ch, FILE *f)
{
while((USART1->SR&0X40)==0);//循环发送,直到发送完毕
USART1->DR = (u8) ch;
return ch;
}
void USART1_Config(u32 Baud)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1 , ENABLE);
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA , ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure); //初始化GPIOA
NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3; //子优先级3
NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE; //IRQ通道使能
NVIC_Init(&NVIC_InitStructure); //根据指定的参数初始化VIC寄存器
USART_InitStructure.USART_BaudRate = Baud;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_Init(USART1,&USART_InitStructure);
USART_ITConfig(USART1, USART_IT_RXNE, DISABLE);//开启串口接受中断
USART_Cmd(USART1,ENABLE);
}
#ifndef _USART_H
#define _USART_H
#include "stm32f10x.h"
#include "system.h"
typedef struct __FILE FILE;
int fputc(int ch, FILE *f);
void USART1_Config(u32 Baud);
#endif