67-硬件高速HS-SPI访问FLASH-串口监控，AI8051U实验箱演示程序
67-硬件高速HS-SPI访问FLASH-串口监控，AI8051U实验箱演示程序主程序main.C代码如下（汇编版本在附件中）：
/*---------------------------------------------------------------------*/
/* --- Web: www.STCAI.com ---------------------------------------------*/
/* --- BBS: www.STCAIMCU.com-----------------------------------------*/
/* 如果要在程序中使用此代码,请在程序中注明使用了STC的资料及程序 */
/*---------------------------------------------------------------------*/
/*************功能说明 **************
本例程基于AI8051U为主控芯片的实验箱进行编写测试。
使用Keil C51编译器,为了达到比较高的效率,一般建议选择"Small"模式。
当编译器出现 "error C249: 'DATA': SEGMENT TOO LARGE" 错误时，则需要手动将部分比较大的数组通过"xdata" 强制分配到 XDATA 区域(例如: char xdata buffer ;)
通过串口对SPI Flash进行读写测试。
对FLASH做扇区擦除、写入、读出的操作，命令指定地址。
串口1(P3.0 P3.1)默认波特率:115200,8,N,1.
串口命令设置: (字母不区分大小写)
E 0x001234 --> 扇区擦除，指定十六进制地址.
W 0x001234 1234567890 --> 写入操作，指定十六进制地址，后面为写入内容.
R 0x001234 10 --> 读出操作，指定十六进制地址，后面为读出字节数.
C --> 如果检测不到Flash, 发送C强制允许操作.
注意：为了通用，程序不识别地址是否有效，用户自己根据具体的型号来决定。
下载时, 选择时钟 24MHz (用户可自行修改频率).
******************************************/
#include "..\comm\AI8051U.h"
#include "stdio.h"
#include "intrins.h"
typedef unsigned char u8;
typedef unsigned int u16;
typedef unsigned long u32;
/****************************** 用户定义宏 ***********************************/
#define MAIN_Fosc 24000000L //定义主时钟
#define Baudrate 115200L
#define TM (65536 -(MAIN_Fosc/Baudrate/4))
#define EE_BUF_LENGTH 50
#define UART1_BUF_LENGTH (EE_BUF_LENGTH+9) //串口缓冲长度
/*****************************************************************************/
/*************本地常量声明 **************/
#define HSCK_MCLK 0
#define HSCK_PLL 1
#define HSCK_SEL HSCK_PLL
#define PLL_96M 0
#define PLL_144M 1
#define PLL_SEL PLL_96M
#define CKMS 0x80
#define HSIOCK 0x40
#define MCK2SEL_MSK 0x0c
#define MCK2SEL_SEL1 0x00
#define MCK2SEL_PLL 0x04
#define MCK2SEL_PLLD2 0x08
#define MCK2SEL_IRC48 0x0c
#define MCKSEL_MSK 0x03
#define MCKSEL_HIRC 0x00
#define MCKSEL_XOSC 0x01
#define MCKSEL_X32K 0x02
#define MCKSEL_IRC32K 0x03
#define ENCKM 0x80
#define PCKI_MSK 0x60
#define PCKI_D1 0x00
#define PCKI_D2 0x20
#define PCKI_D4 0x40
#define PCKI_D8 0x60
/*************本地变量声明 **************/
u8tmp;
u8sst_byte;
u32 Flash_addr;
/*************FLASH相关变量声明 **************/
sbit SPI_CE= P4^0; //PIN1
sbit SPI_SO= P4^2; //PIN2
sbit SPI_SI= P4^1; //PIN5
sbit SPI_SCK = P4^3; //PIN6
u8B_FlashOK; //Flash状态
u8PM25LV040_ID, PM25LV040_ID1, PM25LV040_ID2;
u8RX1_TimeOut;
u8TX1_Cnt; //发送计数
u8RX1_Cnt; //接收计数
bit B_TX1_Busy; //发送忙标志
u8RX1_Buffer; //接收缓冲
/*************本地函数声明 **************/
void delay_ms(u8 ms);
void RX1_Check(void);
void SPI_init(void);
void FlashCheckID(void);
u8 CheckFlashBusy(void);
void FlashWriteEnable(void);
void FlashChipErase(void);
void FlashSectorErase(u32 addr);
void SPI_Read_Nbytes( u32 addr, u8 *buffer, u16 size);
u8 SPI_Read_Compare(u32 addr, u8 *buffer, u16 size);
void SPI_Write_Nbytes(u32 addr, u8 *buffer,u8 size);
/******************** 串口打印函数 ********************/
void UartInit(void)
{
SCON = (SCON & 0x3f) | 0x40;
AUXR |= (1<<6); //定时器时钟1T模式
AUXR &= ~S1BRT; //串口1选择定时器1为波特率发生器
TL1= TM;
TH1= TM>>8;
TR1 = 1; //定时器1开始计时
REN = 1; //允许接收
ES= 1; //允许中断
//SCON = (SCON & 0x3f) | 0x40;
//T2L= TM;
//T2H= TM>>8;
//AUXR |= 0x15; //串口1选择定时器2为波特率发生器
}
void UartPutc(unsigned char dat)
{
B_TX1_Busy = 1;
SBUF = dat;
while(B_TX1_Busy);
}
char putchar(char c)
{
UartPutc(c);
return c;
}
/********************* 主函数 *************************/
void main(void)
{
WTST = 0;//设置程序指令延时参数，赋值为0可将CPU执行指令的速度设置为最快
EAXSFR(); //扩展寄存器(XFR)访问使能
CKCON = 0; //提高访问XRAM速度
P0M1 = 0x00; P0M0 = 0x00; //设置为准双向口
P1M1 = 0x00; P1M0 = 0x00; //设置为准双向口
P2M1 = 0x00; P2M0 = 0x00; //设置为准双向口
P3M1 = 0x00; P3M0 = 0x00; //设置为准双向口
P4M1 = 0x00; P4M0 = 0x00; //设置为准双向口
P5M1 = 0x00; P5M0 = 0x00; //设置为准双向口
P6M1 = 0x00; P6M0 = 0x00; //设置为准双向口
P7M1 = 0x00; P7M0 = 0x00; //设置为准双向口
P4SR = 0xf0; //电平转换速度快（提高IO口翻转速度）
UartInit();
EA = 1; //打开总中断
printf("命令设置:\r\n");
printf("E 0x001234 --> 扇区擦掉十六进制地址\r\n");
printf("W 0x001234 1234567890 --> 写入操作十六进制地址写入内容\r\n");
printf("R 0x001234 10 --> 读出操作十六进制地址读出字节内容\r\n");
printf("C --> 如果检测不到SPI Flash, 发送C强制允许操作.\r\n\r\n");
SPI_init();
FlashCheckID();
FlashCheckID();
if(!B_FlashOK)printf("未检测到PM25LV040/W25X40CL/W25Q80BV/W25Q128FV!\r\n");
else
{
if(B_FlashOK == 1)
{
printf("检测到PM25LV040!\r\n");
}
else if(B_FlashOK == 2)
{
printf("检测到W25X40CL!\r\n");
}
else if(B_FlashOK == 3)
{
printf("检测到W25Q80BV!\r\n");
}
else if(B_FlashOK == 4)
{
printf("检测到W25Q128FV!\r\n");
}
}
printf("制造商ID1 = 0x%02X",PM25LV040_ID1);
printf("\r\n ID2 = 0x%02X",PM25LV040_ID2);
printf("\r\n 设备ID = 0x%02X\r\n",PM25LV040_ID);
while(1)
{
delay_ms(1);
if(RX1_TimeOut > 0)
{
if(--RX1_TimeOut == 0)//超时,则串口接收结束
{
if(RX1_Cnt > 0)
{
RX1_Check(); //串口1处理数据
}
RX1_Cnt = 0;
}
}
}
}
//========================================================================
// 函数: void delay_ms(unsigned char ms)
// 描述: 延时函数。
// 参数: ms,要延时的ms数, 这里只支持1~255ms. 自动适应主时钟.
// 返回: none.
// 版本: VER1.0
// 日期: 2013-4-1
// 备注:
//========================================================================
void delay_ms(u8 ms)
{
u16 i;
do{
i = MAIN_Fosc / 6000;
while(--i);
}while(--ms);
}
/**************** ASCII码转BIN ****************************/
u8CheckData(u8 dat)
{
if((dat >= '0') && (dat <= '9')) return (dat-'0');
if((dat >= 'A') && (dat <= 'F')) return (dat-'A'+10);
return 0xff;
}
/**************** 获取写入地址 ****************************/
u32 GetAddress(void)
{
u32 address;
u8i,j;
address = 0;
if((RX1_Buffer == '0') && (RX1_Buffer == 'X'))
{
for(i=4; i<10; i++)
{
j = CheckData(RX1_Buffer);
if(j >= 0x10) return 0x80000000;//error
address = (address << 4) + j;
}
return (address);
}
return0x80000000; //error
}
/**************** 获取要读出数据的字节数 ****************************/
u8GetDataLength(void)
{
u8i;
u8length;
length = 0;
for(i=11; i<RX1_Cnt; i++)
{
if(CheckData(RX1_Buffer) >= 10)break;
length = length * 10 + CheckData(RX1_Buffer);
}
return (length);
}
/**************** 串口处理函数 ****************************/
void RX1_Check(void)
{
u8i,j;
if((RX1_Cnt == 1) && (RX1_Buffer == 'C')) //发送C强制允许操作
{
B_FlashOK = 1;
printf("强制允许操作FLASH!\r\n");
}
if(!B_FlashOK)
{
printf("PM25LV040/W25X40CL/W25Q80BV不存在, 不能操作FLASH!\r\n");
return;
}
F0 = 0;
if((RX1_Cnt >= 10) && (RX1_Buffer == ' ')) //最短命令为10个字节
{
for(i=0; i<10; i++)
{
if((RX1_Buffer >= 'a') && (RX1_Buffer <= 'z')) RX1_Buffer = RX1_Buffer - 'a' + 'A';//小写转大写
}
Flash_addr = GetAddress();
if(Flash_addr < 0x80000000)
{
if(RX1_Buffer == 'E') //擦除
{
FlashSectorErase(Flash_addr);
printf("已擦掉一个扇区内容!\r\n");
F0 = 1;
}
else if((RX1_Buffer == 'W') && (RX1_Cnt >= 12) && (RX1_Buffer == ' ')) //写入N个字节
{
j = RX1_Cnt - 11;
for(i=0; i<j; i++)tmp = 0xff; //检测要写入的空间是否为空
i = SPI_Read_Compare(Flash_addr,tmp,j);
if(i > 0)
{
printf("要写入的地址为非空,不能写入,请先擦掉!\r\n");
}
else
{
SPI_Write_Nbytes(Flash_addr,&RX1_Buffer,j); //写N个字节
i = SPI_Read_Compare(Flash_addr,&RX1_Buffer,j); //比较写入的数据
if(i == 0)
{
printf("已写入");
if(j >= 100) {UartPutc((u8)(j/100+'0')); j = j % 100;}
if(j >= 10) {UartPutc((u8)(j/10+'0')); j = j % 10;}
UartPutc((u8)(j%10+'0'));
printf("字节内容!\r\n");
}
else printf("写入错误!\r\n");
}
F0 = 1;
}
else if((RX1_Buffer == 'R') && (RX1_Cnt >= 12) && (RX1_Buffer == ' ')) //读出N个字节
{
j = GetDataLength();
if((j > 0) && (j < EE_BUF_LENGTH))
{
SPI_Read_Nbytes(Flash_addr,tmp,j);
printf("读出");
if(j>=100)UartPutc((u8)(j/100+'0'));
UartPutc((u8)(j%100/10+'0'));
UartPutc((u8)(j%10+'0'));
printf("个字节内容如下：\r\n");
for(i=0; i<j; i++)UartPutc(tmp);
UartPutc(0x0d);
UartPutc(0x0a);
F0 = 1;
}
}
}
}
if(!F0) printf("命令错误!\r\n");
}
//========================================================================
// 函数: void UART1_int (void) interrupt UART1_VECTOR
// 描述: UART1中断函数。
// 参数: nine.
// 返回: none.
// 版本: VER1.0
// 日期: 2014-11-28
// 备注:
//========================================================================
void UART1_int (void) interrupt 4
{
if(RI)
{
RI = 0;
RX1_Buffer = SBUF;
if(++RX1_Cnt >= UART1_BUF_LENGTH) RX1_Cnt = 0;
RX1_TimeOut = 5;
}
if(TI)
{
TI = 0;
B_TX1_Busy = 0;
}
}
/******************* FLASH相关程序 ************************/
#define SFC_WREN 0x06 //串行Flash命令集
#define SFC_WRDI 0x04
#define SFC_RDSR 0x05
#define SFC_WRSR 0x01
#define SFC_READ 0x03
#define SFC_FASTREAD 0x0B
#define SFC_RDID 0xAB
#define SFC_PAGEPROG 0x02
#define SFC_RDCR 0xA1
#define SFC_WRCR 0xF1
#define SFC_SECTORER1 0xD7 //PM25LV040 扇区擦除指令
#define SFC_SECTORER2 0x20 //W25Xxx 扇区擦除指令
#define SFC_BLOCKER 0xD8
#define SFC_CHIPER 0xC7
#define SPI_CE_High() SPI_CE= 1 // set CE high
#define SPI_CE_Low() SPI_CE= 0 // clear CE low
/************************************************************************/
void SPI_init(void)
{
//选择PLL输出时钟
#if (PLL_SEL == PLL_96M)
CLKSEL &= ~CKMS; //选择PLL的96M作为PLL的输出时钟
#elif (PLL_SEL == PLL_144M)
CLKSEL |= CKMS; //选择PLL的144M作为PLL的输出时钟
#else
CLKSEL &= ~CKMS; //默认选择PLL的96M作为PLL的输出时钟
#endif
//选择PLL输入时钟分频,保证输入时钟为12M
USBCLK &= ~PCKI_MSK;
#if (MAIN_Fosc == 12000000UL)
USBCLK |= PCKI_D1; //PLL输入时钟1分频
#elif (MAIN_Fosc == 24000000UL)
USBCLK |= PCKI_D2; //PLL输入时钟2分频
#elif (MAIN_Fosc == 48000000UL)
USBCLK |= PCKI_D4; //PLL输入时钟4分频
#elif (MAIN_Fosc == 96000000UL)
USBCLK |= PCKI_D8; //PLL输入时钟8分频
#else
USBCLK |= PCKI_D1; //默认PLL输入时钟1分频
#endif
//启动PLL
USBCLK |= ENCKM; //使能PLL倍频
delay_ms(1); //等待PLL锁频
//选择HSPWM/HSSPI时钟
#if (HSCK_SEL == HSCK_MCLK)
CLKSEL &= ~HSIOCK; //HSPWM/HSSPI选择主时钟为时钟源
#elif (HSCK_SEL == HSCK_PLL)
CLKSEL |= HSIOCK; //HSPWM/HSSPI选择PLL输出时钟为时钟源
#else
CLKSEL &= ~HSIOCK; //默认HSPWM/HSSPI选择主时钟为时钟源
#endif
HSCLKDIV = 8; //HSPWM/HSSPI时钟源4分频
SPCTL |= SSIG; //忽略 SS 引脚功能，使用 MSTR 确定器件是主机还是从机
SPCTL |= SPEN; //使能 SPI 功能
SPCTL &= ~DORD; //先发送/接收数据的高位（ MSB）
SPCTL |= MSTR; //设置主机模式
SPCTL |= CPOL; //SCLK 空闲时为高电平，SCLK 的前时钟沿为下降沿，后时钟沿为上升沿
SPCTL |= CPHA; //数据在 SCLK 前时钟沿驱动，后时钟沿采样
SPCTL = (SPCTL & ~3) | 2; //SPI 时钟频率选择, 0: 4T, 1: 8T,2: 16T,3: 2T
P_SW1 |= SPI_S1; //00: P1.4 P1.5 P1.6 P1.7, 01: P2.4 P2.5 P2.6 P2.7, 10: P4.0 P4.1 P4.2 P4.3, 11: P3.5 P3.4 P3.3 P3.2
P_SW1 &= ~SPI_S0;
SPI_SCK = 0; // set clock to low initial state
SPI_SI = 1;
SPSTAT |= SPIF; //清SPIF标志
SPSTAT |= WCOL; //清WCOL标志
HSSPI_CFG2 |= 0x20; //使能SPI高速模式
}
/************************************************************************/
void SPI_WriteByte(u8 out)
{
SPDAT = out;
while((SPSTAT & SPIF)==0);
SPSTAT |= SPIF; //清SPIF标志
SPSTAT |= WCOL; //清WCOL标志
}
/************************************************************************/
u8 SPI_ReadByte(void)
{
SPDAT = 0xff;
while((SPSTAT & SPIF)==0);
SPSTAT |= SPIF; //清SPIF标志
SPSTAT |= WCOL; //清WCOL标志
return (SPDAT);
}
/************************************************
检测Flash是否准备就绪
入口参数: 无
出口参数:
0 : 没有检测到正确的Flash
1 : Flash准备就绪
************************************************/
void FlashCheckID(void)
{
SPI_CE_Low();
SPI_WriteByte(SFC_RDID); //发送读取ID命令
SPI_WriteByte(0x00); //空读3个字节
SPI_WriteByte(0x00);
SPI_WriteByte(0x00);
PM25LV040_ID1 = SPI_ReadByte(); //读取制造商ID1
PM25LV040_ID= SPI_ReadByte(); //读取设备ID
PM25LV040_ID2 = SPI_ReadByte(); //读取制造商ID2
SPI_CE_High();
// UartPutc(PM25LV040_ID1);
// UartPutc(PM25LV040_ID);
// UartPutc(PM25LV040_ID2);
if((PM25LV040_ID1 == 0x9d) && (PM25LV040_ID2 == 0x7f))B_FlashOK = 1;//检测是否为PM25LVxx系列的Flash
else if(PM25LV040_ID == 0x12)B_FlashOK = 2; //检测是否为W25X4x系列的Flash
else if(PM25LV040_ID == 0x13)B_FlashOK = 3; //检测是否为W25X8x系列的Flash
else if(PM25LV040_ID == 0x17)B_FlashOK = 4; //检测是否为W25X128系列的Flash
else B_FlashOK = 0;
}
/************************************************
检测Flash的忙状态
入口参数: 无
出口参数:
0 : Flash处于空闲状态
1 : Flash处于忙状态
************************************************/
u8 CheckFlashBusy(void)
{
u8dat;
SPI_CE_Low();
SPI_WriteByte(SFC_RDSR); //发送读取状态命令
dat = SPI_ReadByte(); //读取状态
SPI_CE_High();
return (dat); //状态值的Bit0即为忙标志
}
/************************************************
使能Flash写命令
入口参数: 无
出口参数: 无
************************************************/
void FlashWriteEnable(void)
{
while(CheckFlashBusy() > 0); //Flash忙检测
SPI_CE_Low();
SPI_WriteByte(SFC_WREN); //发送写使能命令
SPI_CE_High();
}
/************************************************
擦除整片Flash
入口参数: 无
出口参数: 无
************************************************/
/*
void FlashChipErase(void)
{
if(B_FlashOK)
{
FlashWriteEnable(); //使能Flash写命令
SPI_CE_Low();
SPI_WriteByte(SFC_CHIPER); //发送片擦除命令
SPI_CE_High();
}
}
*/
/************************************************
擦除扇区, 一个扇区4KB
入口参数: 无
出口参数: 无
************************************************/
void FlashSectorErase(u32 addr)
{
if(B_FlashOK)
{
FlashWriteEnable(); //使能Flash写命令
SPI_CE_Low();
if(B_FlashOK == 1)
{
SPI_WriteByte(SFC_SECTORER1); //发送扇区擦除命令
}
else
{
SPI_WriteByte(SFC_SECTORER2); //发送扇区擦除命令
}
SPI_WriteByte(((u8 *)&addr)); //设置起始地址
SPI_WriteByte(((u8 *)&addr));
SPI_WriteByte(((u8 *)&addr));
SPI_CE_High();
}
}
/************************************************
从Flash中读取数据
入口参数:
addr : 地址参数
buffer : 缓冲从Flash中读取的数据
size : 数据块大小
出口参数:
无
************************************************/
void SPI_Read_Nbytes(u32 addr, u8 *buffer, u16 size)
{
if(size == 0) return;
if(!B_FlashOK)return;
while(CheckFlashBusy() > 0); //Flash忙检测
SPI_CE_Low(); //enable device
SPI_WriteByte(SFC_READ); //read command
SPI_WriteByte(((u8 *)&addr)); //设置起始地址
SPI_WriteByte(((u8 *)&addr));
SPI_WriteByte(((u8 *)&addr));
do{
*buffer = SPI_ReadByte(); //receive byte and store at buffer
buffer++;
}while(--size); //read until no_bytes is reached
SPI_CE_High(); //disable device
}
/************************************************************************
读出n个字节,跟指定的数据进行比较, 错误返回1,正确返回0
************************************************************************/
u8 SPI_Read_Compare(u32 addr, u8 *buffer, u16 size)
{
u8j;
if(size == 0) return 2;
if(!B_FlashOK)return 2;
while(CheckFlashBusy() > 0); //Flash忙检测
j = 0;
SPI_CE_Low(); //enable device
SPI_WriteByte(SFC_READ); //read command
SPI_WriteByte(((u8 *)&addr)); //设置起始地址
SPI_WriteByte(((u8 *)&addr));
SPI_WriteByte(((u8 *)&addr));
do
{
if(*buffer != SPI_ReadByte()) //receive byte and store at buffer
{
j = 1;
break;
}
buffer++;
}while(--size); //read until no_bytes is reached
SPI_CE_High(); //disable device
return j;
}
/************************************************
写数据到Flash中
入口参数:
addr : 地址参数
buffer : 缓冲需要写入Flash的数据
size : 数据块大小
出口参数: 无
************************************************/
void SPI_Write_Nbytes(u32 addr, u8 *buffer, u8 size)
{
if(size == 0) return;
if(!B_FlashOK)return;
while(CheckFlashBusy() > 0); //Flash忙检测
FlashWriteEnable(); //使能Flash写命令
SPI_CE_Low(); // enable device
SPI_WriteByte(SFC_PAGEPROG); // 发送页编程命令
SPI_WriteByte(((u8 *)&addr)); //设置起始地址
SPI_WriteByte(((u8 *)&addr));
SPI_WriteByte(((u8 *)&addr));
do{
SPI_WriteByte(*buffer++); //连续页内写
addr++;
if ((addr & 0xff) == 0) break;
}while(--size);
SPI_CE_High(); // disable device
}
页:
[1]