This commit is contained in:
Qiea
2024-12-19 14:06:05 +08:00
parent 1c0f3b676f
commit dcd484c1bd
58 changed files with 14859 additions and 863 deletions

416
HARDWARE/EC800/EC800M.c Normal file
View File

@@ -0,0 +1,416 @@
#include "EC800M.h"
#include "usart.h"
#include "delay.h"
#include "sdram.h"
#include "stm32f4xx.h"
#include <stdio.h>
#include <string.h>
#include <stdint.h>
#include <stdlib.h>
#include "cnn.h"
unsigned char Flag_topic;
extern UART_BUF buf_uart2; //NBIOT
extern UART_BUF buf_uart1; //TTL
char *strx,*extstrx;
CSTX_4G CSTX_4G_Status; //模块的状态信息
int errcount=0; //发送命令失败次数 防止死循环
int errCountData=0;
char ATSTR[BUFLEN]; //组建AT命令的函数
char IMEINUMBER[BUFLEN];//+CGSN: "869523052178994"
#define DESTINATION_SIZE 256
char *strx,*extstrx;
char destination[DESTINATION_SIZE];
/*云端下发的时间*/
int month_def = 1;
int date_def = 0;
int hour_def = 0;
int min_def = 0;
int sec_def= 0;
////////////////////////只要修改三要素/////////////////////////////////
#define PRODUCEKEY "k16dsL76w8K" //修改产品秘钥
#define DEVICENAME "device_1" //修改设备名称
#define DEVICESECRET "b36d0f9e35c7fede452a85c59473a411" //设备的API
void Clear_Buffer(uint16_t *USARTx_RX_STA, uint8_t *USARTx_RX_BUF) {
delay_ms(300);
memset(USARTx_RX_BUF, 0, USART_REC_LEN);
*USARTx_RX_STA = 0;
}
void extract_IMSI(uint8_t *input_str, char *output_str) {
char *start_ptr = strstr((char *)input_str, "460");
if (start_ptr != NULL) {
strncpy(output_str, start_ptr, 15);
output_str[15] = '\0'; // 添加字符串结束符
} else {
output_str[0] = '\0';
}
}
/*****************************************************
初始化模块 和单片机连接,获取卡号和信号质量
*****************************************************/
uint8_t CSTX_4G_Init(void)
{
//打印初始化信息
printf("start init EC800X\r\n");
//发第一个命令ATE1
Uart2_SendStr("ATE1\r\n");
delay_ms(200);
strx = strstr((char*)USART2_RX_BUF, "OK");
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
while(strx==NULL)
{
printf("单片机正在连接模块......\r\n");
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("\n\rATE1\r\nATE1");
delay_ms(300);
strx = strstr((char*)USART2_RX_BUF, "OK");
// if(errcount++ > 10) {
// printf("\r\n未连接到模块\r\n");
// return 0;
// }
}
printf("****单片机和模块连接成功*****\r\n");
Uart2_SendStr("ATI\r\n");//获取模块的版本
delay_ms(30);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+CIMI\r\n");//获取卡号,类似是否存在卡的意思,比较重要。
delay_ms(30);
strx = strstr((char*)USART2_RX_BUF, "460");
while(strx==NULL)
{
printf("****获取卡号*****\r\n");
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+CIMI\r\n");//获取卡号,类似是否存在卡的意思,比较重要。
delay_ms(30);
strx = strstr((char*)USART2_RX_BUF, "460");
printf("%s",USART2_RX_BUF);
}
char output_str[16];
extract_IMSI(USART2_RX_BUF, output_str);
printf("我的卡号是 : %s \r\n",output_str);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+CGATT?\r\n");//查询激活状态
delay_ms(30);
strx = strstr((char*)USART2_RX_BUF, "+CGATT: 1");
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
while(strx==NULL)
{
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+CGATT?\r\n");//获取激活状态
delay_ms(30);
strx = strstr((char*)USART2_RX_BUF, "+CGATT: 1");
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+CSQ\r\n");//查看获取CSQ值
delay_ms(30);
strx = strstr((char*)USART2_RX_BUF, "+CSQ:");
if(strx)printf("信号质量是:%s 注意信号最大值是31 \r\n",USART2_RX_BUF);
return 1;
}
/*****************************************************
收到服务器下发的数据就直接打印 +QMTRECV: 0,0,"$creq/a19d2d64-3ee3-5070-8078-ad43e10a52f0","LED11"
*****************************************************/
unsigned char CSTX_4G_RECData(void)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"+QMTRECV");//返回+QMTRECV:,表明接收到服务器发回的数据
if(strx)
{
delay_ms(300); // 必须延时
strncpy(destination, (char *)USART2_RX_BUF, DESTINATION_SIZE - 1);
destination[DESTINATION_SIZE - 1] = '\0';
TimeInfo TimeInfo = parseTimeInfo(destination);
month_def =TimeInfo.month;
date_def =TimeInfo.day;
hour_def =TimeInfo.hour;
min_def =TimeInfo.minute;
sec_def =TimeInfo.second;
printf(" Month: %d, Day: %d, Hour: %d, Minute: %d, Second: %d\r\n",
TimeInfo.month, TimeInfo.day, TimeInfo.hour, TimeInfo.minute, TimeInfo.second);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
return 1;
}
return 0;
}
/*****************************************************
注册到ONENET topic = 0 -> 自定义topic 用于准备接收下发的时间 topic = 1 -> 物模型topic 用于上传数据
*****************************************************/
void CSTX_4G_RegALiYunIOT(unsigned char topic)//平台注册
{
int errcount = 0;
static unsigned char flag=0;
if(flag == 0){
printf("****初始化完成*****\r\n\r\n");
Uart2_SendStr("AT+QMTDISC=0\r\n");//Disconnect a client from MQTT server
delay_ms(30);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+QMTCLOSE=0\r\n");//删除句柄
delay_ms(30);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
delay_ms(30);
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+QMTCFG=\"version\",0,4\r\n");//切换下版本
delay_ms(30); //等待300ms反馈OK
strx = strstr((char*)USART2_RX_BUF, "OK");
while(strx==NULL)
{
strx = strstr((char*)USART2_RX_BUF, "OK");
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTCFG=\"ALIAUTH\",0,\"%s\",\"%s\",\"%s\"\r\n",PRODUCEKEY,DEVICENAME,DEVICESECRET); //+QMTCONN: 0,0,0
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTOPEN: 0,0 +QMTOPEN: 0,0
while(strx==NULL)
{
errcount++;
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返回OK
if(errcount>10000) //防止死循环
{
NVIC_SystemReset(); //没有创建TCP SOCKET就重启系统等到服务器就绪
}
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+QMTOPEN=0,\"iot-as-mqtt.cn-shanghai.aliyuncs.com\",1883\r\n");//切换下版本
delay_ms(30); //等待300ms反馈OK
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返OK
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返OK
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Uart2_SendStr("AT+QMTCONN=0,\"-test-\"\r\n");//切换下版本
delay_ms(30); //等待300ms反馈OK
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返OK
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返OK
printf("连接中……\r\n");
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
}
flag = 1;
if(topic == 0){
if(Flag_topic == 1){
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTUNS=0,100,\"/%s/%s/user/Set_time\"\r\n",PRODUCEKEY,DEVICENAME); //+QMTCONN: 0,0,0
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);//发送链接到阿里云
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
}
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTSUB=0,1,\"/%s/%s/user/Set_time\",0\r\n",PRODUCEKEY,DEVICENAME); //+QMTCONN: 0,0,0
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);//发送链接到阿里云
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Flag_topic = 0;
}
else if(topic == 1){
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTUNS=0,100,\"/%s/%s/user/Set_time\"\r\n",PRODUCEKEY,DEVICENAME); //+QMTCONN: 0,0,0
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);//发送链接到阿里云
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTSUB=0,1,\"/%s/%s/thing/event/property/set\",0\r\n",PRODUCEKEY,DEVICENAME); //+QMTCONN: 0,0,0
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);//发送链接到阿里云
delay_ms(30);
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
while(strx==NULL)
{
strx=strstr((const char*)USART2_RX_BUF,(const char*)"OK");//返+QMTCONN: 0,0,0
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
Flag_topic = 1;
}
}
uint16_t MakeALiYunPayload_s(char *Str,char *Data, const char* identifier)
{
// Onenet有效载荷固定格式的模板
const char PayloadTemplate[60] = "{\"id\":\"123\",\"version\":\"1.0\",\"params\":{\"%s\":{\"value\":\"%s\"}}}";
char JsonBuf[BUFLEN]; // 临时数据缓存
unsigned int StrLen; // 有效载荷数据长度
// 使用snprintf将Data和identifier插入到PayloadTemplate中
snprintf(JsonBuf,sizeof(JsonBuf),PayloadTemplate,identifier,Data);
// 计算有效载荷的数据长度
StrLen = strlen((const char*)JsonBuf); // strlen返回的是字节数无需再除以sizeof(char)
// 拷贝有效载荷数据到Str
memcpy(Str, JsonBuf, StrLen);
// 返回长度
return StrLen;
}
void convert_to_string(uint8_t *Send_Json, char *output_str, size_t length)
{
// 将 uint8_t 数组转换为字符串
memcpy(output_str, Send_Json, length);
output_str[length] = '\0'; // 添加字符串结束符
}
void CSTX_4G_ALiYunIOTSenddata_string(char *Data,const char* identifier)//上发数据,上发的数据跟对应的插件有关系,用户需要注意插件然后对应数据即可
{
static char Send_buff[BUFLEN];//AT命令临时缓存
u16 JsonLen; // Json包数据长度
memset((char *)Send_buff, 0, BUFLEN); // 开辟数据缓存 //开辟数据缓存 sprintf((char*)Json,"{\"Temp\":%d,\"Humi\":%d}",Temperature,Humidity);//拷贝数据 装订联网三要素 Temperature,Humidity
memset(ATSTR,0,BUFLEN);
JsonLen = MakeALiYunPayload_s(Send_buff,Data, identifier); //得到json
memset(ATSTR,0,BUFLEN);
sprintf(ATSTR,"AT+QMTPUBEX=0,0,0,0,\"/sys/%s/%s/thing/event/property/post\",%d\r\n",PRODUCEKEY,DEVICENAME,JsonLen);
printf("ATSTR = %s \r\n",ATSTR);
Uart2_SendStr(ATSTR);//mqtt订阅
strx=strstr((const char*)USART2_RX_BUF,(const char*)">");//准备发送数据
errcount=0;
while(strx==NULL)
{
errcount++;
strx=strstr((const char*)USART2_RX_BUF,(const char*)">");//准备发送数据 模块的反馈
delay_ms(10);
if(errcount>100) //超时退出
{
errcount = 0;
break;
}
}
printf("Data数据为:%s\r\n",Send_buff);
delay_ms(50);
Uart2_SendStr(Send_buff);
// 发送JSON数据
delay_ms(50);
// 等待发送完成响应
errcount = 0;
strx = strstr((const char*)USART2_RX_BUF, (const char*)"+QMTPUBEX: 0,0,0"); // 返SEND OK +QMTPUB: 0,0,0
while (strx == NULL)
{
errcount++;
strx = strstr((const char*)USART2_RX_BUF, (const char*)"+QMTPUBEX: 0,0,0"); // 返SEND OK
delay_ms(100);
if (errcount > 10) // 超时退出
{
printf("发送数据超时!\n");
errcount = 0;
break;
}
}
Clear_Buffer(&USART2_RX_STA, USART2_RX_BUF);
}
// 解析函数实现
TimeInfo parseTimeInfo(const char *jsonString) {
TimeInfo TimeInfo = {0}; // 初始化结构体为0
// 查找JSON字符串中"params"部分的起始位置
const char *paramsStart = strstr(jsonString, "\"params\"");
if (paramsStart != NULL) {
// 创建一个临时缓冲区来复制JSON的"params"部分(注意,这里为了简化处理,直接使用了静态缓冲区)
char TempBuffer[256];
strncpy(TempBuffer, paramsStart, sizeof(TempBuffer) - 1);
TempBuffer[sizeof(TempBuffer) - 1] = '\0';
// 使用简单的字符串解析来提取时间信息(注意,这种方法很脆弱,仅适用于格式固定的字符串)
char *token;
token = strtok(TempBuffer, ",\"{}:");
while (token != NULL) {
if (strcmp(token, "date") == 0) {
token = strtok(NULL, ",\"{}:");
TimeInfo.day = atoi(token); // JSON中"date"实际上是日这里暂存到day字段
} else if (strcmp(token, "month") == 0) {
token = strtok(NULL, ",\"{}:");
TimeInfo.month = atoi(token);
} else if (strcmp(token, "year") == 0) {
// JSON中没有直接的"year"字段,但我们可以从其他信息中推断,或者假设一个默认的年份(这里不处理)
// 或者如果"date"和"month"存在,且你有某种方式知道是哪一年(比如当前年份),你可以在这里设置它
} else if (strcmp(token, "hour") == 0) {
token = strtok(NULL, ",\"{}:");
TimeInfo.hour = atoi(token);
} else if (strcmp(token, "minute") == 0) {
token = strtok(NULL, ",\"{}:");
TimeInfo.minute = atoi(token);
} else if (strcmp(token, "second") == 0) {
token = strtok(NULL, ",\"{}:");
TimeInfo.second = atoi(token);
}
token = strtok(NULL, ",\"{}:");
}
// 注意:上面的代码没有处理"year"字段因为你的示例JSON中没有提供。
// 你需要根据实际情况来处理这个字段,比如使用当前年份,或者从其他来源获取年份信息。
// 这里为了示例我们假设年份是固定的比如2024年你可以在实际代码中修改这个值。
TimeInfo.year = 2024; // 假设的年份,根据实际情况修改
}
return TimeInfo;
}
///重定向c库函数scanf到串口重写向后可使用scanf、getchar等函数
int fgetc(FILE *f)
{ RX1_len=USART_RX_STA&0x3fff;//得到此次接收到的数据长度
/* 等待串口输入数据 */
while (__HAL_UART_GET_FLAG(&UART1_Handler, UART_FLAG_RXNE) == RESET);
//while (USART_GetFlagStatus(USART1, USART_FLAG_RXNE) == RESET);
return (int)HAL_UART_Receive(&UART1_Handler,(uint8_t*)USART_RX_BUF,RX1_len,1000);
//return (int)USART_ReceiveData(USART1);
}

44
HARDWARE/EC800/EC800M.h Normal file
View File

@@ -0,0 +1,44 @@
#ifndef __EC800M_H
#define __EC800M_H
#include "stm32f4xx.h"
#include "string.h"
#include "sys.h"
#include "string.h"
#include "stdio.h"
#include "usart.h"
extern unsigned char Flag_topic;
typedef struct
{
uint8_t CSQ;
uint8_t Socketnum; //编号
uint8_t reclen; //获取到数据的长度
uint8_t res;
uint8_t recdatalen[10];
uint8_t recdata[100];
uint8_t netstatus;//网络指示灯
} CSTX_4G;
typedef struct {
int year;
int month;
int day;
int hour;
int minute;
int second;
}TimeInfo;
void Clear_Buffer(uint16_t *USARTx_RX_STA, uint8_t *USARTx_RX_BUF);
uint8_t CSTX_4G_Init(void);
void CSTX_4G_CreateTCPSokcet(void);
void CSTX_4G_Senddata(int len,uint8_t *data);
void CSTX_4G_RegALiYunIOT(unsigned char topic);//平台注册
uint16_t MakeALiYunPayload_s(char *Str,char *Data, const char* identifier);//上发数据,上发的数据跟对应的插件有关系,用户需要注意插件然后对应数据即可
char* Get_4GIMEI_NUM(void); //获取IMEI号
unsigned char CSTX_4G_RECData(void);
void extract_IMSI(uint8_t *input_str, char *output_str);
void CSTX_4G_ALiYunIOTSenddata_string(char *Data,const char* identifier);
TimeInfo parseTimeInfo(const char *jsonString);
#endif

234
HARDWARE/FATFS/diskio.c Normal file
View File

@@ -0,0 +1,234 @@
/*-----------------------------------------------------------------------*/
/* Low level disk I/O module skeleton for FatFs (C)ChaN, 2014 */
/*-----------------------------------------------------------------------*/
/* If a working storage control module is available, it should be */
/* attached to the FatFs via a glue function rather than modifying it. */
/* This is an example of glue functions to attach various exsisting */
/* storage control modules to the FatFs module with a defined API. */
/*-----------------------------------------------------------------------*/
#include "diskio.h"
#include "sdio.h"
#include "malloc.h"
#define SD_CARD 0 // SD<53><44>,<2C><><EFBFBD><EFBFBD>Ϊ0
#define EX_FLASH 1 // <20>ⲿspi flash,<2C><><EFBFBD><EFBFBD>Ϊ1
#define USB_DISK 3 // U<><55>,<2C><><EFBFBD><EFBFBD>Ϊ3
// <20><><EFBFBD><EFBFBD>W25Q128
// ǰ8M<38>ֽڸ<D6BD>fatfs<66><73>,8M<38>ֽں<D6BD>,<2C><><EFBFBD>ڴ<EFBFBD><DAB4><EFBFBD><EFBFBD>ֿ<EFBFBD>,<2C>ֿ<EFBFBD>ռ<EFBFBD><D5BC>6.01M.ʣ<>ಿ<EFBFBD><E0B2BF>1.99M,<2C><><EFBFBD>ͻ<EFBFBD><CDBB>Լ<EFBFBD><D4BC><EFBFBD>
#define FLASH_SECTOR_SIZE 512
#define FLASH_SECTOR_COUNT 1024*8*2 // W25Q128,ǰ8M<38>ֽڸ<D6BD>FATFSռ<53><D5BC>
#define FLASH_BLOCK_SIZE 8 // ÿ<><C3BF>BLOCK<43><4B>8<EFBFBD><38><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FATFS fatfs_sd; // SD<53><44><EFBFBD>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
FATFS fatfs_flash; // FLASH<53>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
FATFS fatfs_usb; // USB<53>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
FIL file_sd; // SD<53><44><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
FIL file_flash; // FLASH<53>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
FIL file_usb; // USB<53>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// DWORD get_fattime (void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>û<EFBFBD><C3BB><EFBFBD><EFBFBD><EFBFBD><E5BAAF><EFBFBD><EFBFBD>Ϊfatfsģ<73><C4A3>ͣ<EFBFBD><CDA3><EFBFBD><EFBFBD>ǰʱ<C7B0><CAB1>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DWORD get_fattime (void)
{
return 0;
}
//-----------------------------------------------------------------
// DSTATUS disk_status (BYTE pdrv)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD>ô<EFBFBD><C3B4><EFBFBD>״̬
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: BYTE pdrv<72><76><EFBFBD><EFBFBD><EFBFBD>ڱ<EFBFBD>ʶ<EFBFBD><CAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DSTATUS disk_status(BYTE pdrv)
{
return RES_OK;
}
//-----------------------------------------------------------------
// DSTATUS disk_status (BYTE pdrv)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: BYTE pdrv<72><76><EFBFBD><EFBFBD><EFBFBD>ڱ<EFBFBD>ʶ<EFBFBD><CAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DSTATUS disk_initialize(BYTE pdrv)
{
u8 res=0;
switch(pdrv)
{
case SD_CARD: // SD<53><44>
res=SD_Init(); // SD<53><44><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>
break;
case USB_DISK: // U<><55>
break;
default:
res=1;
}
if(res)
return STA_NOINIT;
else
return 0; // <20><>ʼ<EFBFBD><CABC><EFBFBD>ɹ<EFBFBD>
}
//-----------------------------------------------------------------
// DRESULT disk_read (BYTE pdrv,BYTE *buff,DWORD sector,UINT count)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: BYTE pdrv<72><76><EFBFBD><EFBFBD><EFBFBD>̱<EFBFBD><CCB1><EFBFBD>0~9
// BYTE *buff<66><66><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD><DDBD>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD>׵<EFBFBD>ַ
// DWORD sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// UINT count<6E><74><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DRESULT disk_read (BYTE pdrv,BYTE *buff,DWORD sector,UINT count)
{
u8 res=0;
if (!count)
return RES_PARERR;// count<6E><74><EFBFBD>ܵ<EFBFBD><DCB5><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD>򷵻ز<F2B7B5BB><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
switch(pdrv)
{
case SD_CARD: // SD<53><44>
res=SD_ReadDisk(buff,sector,count);
while(res) // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SD_Init(); // <20><><EFBFBD>³<EFBFBD>ʼ<EFBFBD><CABC>SD<53><44>
res=SD_ReadDisk(buff,sector,count);
}
break;
case USB_DISK: // U<><55>
break;
default:
res=1;
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>SPI_SD_driver.c<>ķ<EFBFBD><C4B7><EFBFBD>ֵת<D6B5><D7AA>ff.c<>ķ<EFBFBD><C4B7><EFBFBD>ֵ
if(res==0x00)
return RES_OK;
else
return RES_ERROR;
}
//-----------------------------------------------------------------
// DRESULT disk_write (BYTE pdrv,const BYTE *buff,DWORD sector,UINT count)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: д<><D0B4><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: BYTE pdrv<72><76><EFBFBD><EFBFBD><EFBFBD>̱<EFBFBD><CCB1><EFBFBD>0~9
// BYTE *buff<66><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>׵<EFBFBD>ַ
// DWORD sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// UINT count<6E><74><EFBFBD><EFBFBD>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DRESULT disk_write (BYTE pdrv,const BYTE *buff,DWORD sector,UINT count)
{
u8 res=0;
if (!count)
return RES_PARERR;// count<6E><74><EFBFBD>ܵ<EFBFBD><DCB5><EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD>򷵻ز<F2B7B5BB><D8B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
switch(pdrv)
{
case SD_CARD: // SD<53><44>
res=SD_WriteDisk((u8*)buff,sector,count);
while(res) // д<><D0B4><EFBFBD><EFBFBD>
{
SD_Init(); //<2F><><EFBFBD>³<EFBFBD>ʼ<EFBFBD><CABC>SD<53><44>
res=SD_WriteDisk((u8*)buff,sector,count);
//printf("sd wr error:%d\r\n",res);
}
break;
case USB_DISK: // U<><55>
break;
default:
res=1;
}
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>SPI_SD_driver.c<>ķ<EFBFBD><C4B7><EFBFBD>ֵת<D6B5><D7AA>ff.c<>ķ<EFBFBD><C4B7><EFBFBD>ֵ
if(res == 0x00)
return RES_OK;
else
return RES_ERROR;
}
//-----------------------------------------------------------------
// DRESULT disk_ioctl (BYTE pdrv,BYTE cmd,void *buff)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ļ<EFBFBD><C4BB><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: BYTE pdrv<72><76><EFBFBD><EFBFBD><EFBFBD>̱<EFBFBD><CCB1><EFBFBD>0~9
// BYTE cmd<6D><64><EFBFBD><EFBFBD><EFBFBD>ƴ<EFBFBD><C6B4><EFBFBD>
// void *buff<66><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD>ջ<EFBFBD><D5BB><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
DRESULT disk_ioctl (BYTE pdrv,BYTE cmd,void *buff)
{
DRESULT res;
if(pdrv==SD_CARD)// SD<53><44>
{
switch(cmd)
{
case CTRL_SYNC:
res = RES_OK;
break;
case GET_SECTOR_SIZE:
*(DWORD*)buff = 512;
res = RES_OK;
break;
case GET_BLOCK_SIZE:
*(WORD*)buff = SDCardInfo.CardBlockSize;
res = RES_OK;
break;
case GET_SECTOR_COUNT:
*(DWORD*)buff = SDCardInfo.CardCapacity/512;
res = RES_OK;
break;
default:
res = RES_PARERR;
break;
}
}
else if(pdrv==USB_DISK) // U<><55>
{
}
else
res=RES_ERROR;// <20><><EFBFBD><EFBFBD><EFBFBD>IJ<EFBFBD>֧<EFBFBD><D6A7>
return res;
}
void *ff_memalloc (UINT size)
{
return (void*)mymalloc(SRAMEX,size);
}
//<2F>ͷ<EFBFBD><CDB7>ڴ<EFBFBD>
void ff_memfree (void* mf)
{
myfree(SRAMEX,mf);
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

90
HARDWARE/FATFS/diskio.h Normal file
View File

@@ -0,0 +1,90 @@
/*-----------------------------------------------------------------------/
/ Low level disk interface modlue include file (C)ChaN, 2014 /
/-----------------------------------------------------------------------*/
#ifndef _DISKIO_DEFINED
#define _DISKIO_DEFINED
#ifdef __cplusplus
extern "C" {
#endif
#define _USE_WRITE 1 /* 1: Enable disk_write function */
#define _USE_IOCTL 1 /* 1: Enable disk_ioctl fucntion */
#include "integer.h"
#include "ff.h"
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
typedef BYTE DSTATUS; // <20><><EFBFBD>̹<EFBFBD><CCB9>ܵ<EFBFBD>״̬
// <20><><EFBFBD>̹<EFBFBD><CCB9>ܵĽ<DCB5><C4BD><EFBFBD>
typedef enum {
RES_OK = 0, // 0<><30><EFBFBD>ɹ<EFBFBD>
RES_ERROR, // 1<><31><EFBFBD><EFBFBD>дʧ<D0B4><CAA7>
RES_WRPRT, // 2<><32>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
RES_NOTRDY, // 3<><33>û׼<C3BB><D7BC><EFBFBD><EFBFBD>
RES_PARERR // 4<><34><EFBFBD><EFBFBD>Ч<EFBFBD>IJ<EFBFBD><C4B2><EFBFBD>
} DRESULT;
extern FATFS fatfs_sd; // SD<53><44><EFBFBD>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
extern FATFS fatfs_flash; // FLASH<53>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
extern FATFS fatfs_usb; // USB<53>߼<EFBFBD><DFBC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĺ<EFBFBD><C4B9><EFBFBD><EFBFBD><EFBFBD>
extern FIL file_sd; // SD<53><44><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
extern FIL file_flash; // FLASH<53>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
extern FIL file_usb; // USB<53>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// <20><EFBFBD><EAB6A8>
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD>״̬λ
#define STA_NOINIT 0x01 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>δ<EFBFBD><CEB4>ʼ<EFBFBD><CABC>
#define STA_NODISK 0x02 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>û<EFBFBD>д<EFBFBD><D0B4><EFBFBD>
#define STA_PROTECT 0x04 // д<><D0B4><EFBFBD><EFBFBD>
// disk_ioctrl<72><6C><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ͨ<><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(Used by FatFs)
#define CTRL_SYNC 0 // <20><><EFBFBD>ɹ<EFBFBD><C9B9><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(needed at _FS_READONLY == 0)
#define GET_SECTOR_COUNT 1 // <20><>ȡ<EFBFBD><C8A1><EFBFBD>̴<EFBFBD>С(needed at _USE_MKFS == 1)
#define GET_SECTOR_SIZE 2 // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С(needed at _MAX_SS != _MIN_SS)
#define GET_BLOCK_SIZE 3 // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С (needed at _USE_MKFS == 1)
#define CTRL_TRIM 4 // ֪ͨ<CDA8><EFBFBD><E8B1B8><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ϵ<EFBFBD><CFB5><EFBFBD><EFBFBD><EFBFBD>(needed at _USE_TRIM == 1)
// ͨ<><CDA8><EFBFBD><EFBFBD><EFBFBD><EFBFBD> (Not used by FatFs)
#define CTRL_POWER 5 // <20><>ȡ/<2F><><EFBFBD>õ<EFBFBD>Դ״̬
#define CTRL_LOCK 6 // <20><><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƴ<EFBFBD>
#define CTRL_EJECT 7 // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define CTRL_FORMAT 8 // <20><>ý<EFBFBD><C3BD><EFBFBD>ϴ<EFBFBD><CFB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽ
// MMC/SDC<44>ض<EFBFBD><D8B6><EFBFBD>ioctl<74><6C><EFBFBD><EFBFBD>
#define MMC_GET_TYPE 10 // <20><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define MMC_GET_CSD 11 // <20><>ȡCSD
#define MMC_GET_CID 12 // <20><>ȡCID
#define MMC_GET_OCR 13 // <20><>ȡOCR
#define MMC_GET_SDSTAT 14 // <20><>ȡSD״̬
#define ISDIO_READ 55 // <20><>SD iSDIO<49>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
#define ISDIO_WRITE 56 // <20><>SD iSDIO<49>Ĵ<EFBFBD><C4B4><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
#define ISDIO_MRITE 57 // <20><><EFBFBD><EFBFBD>д<EFBFBD><D0B4>SD iSDIO<49>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ATA/CF<43>ض<EFBFBD><D8B6><EFBFBD>ioctl<74><6C><EFBFBD><EFBFBD>
#define ATA_GET_REV 20 // <20><>ȡF/W revision
#define ATA_GET_MODEL 21 // <20><>ȡ<EFBFBD>ͺ<EFBFBD><CDBA><EFBFBD><EFBFBD><EFBFBD>
#define ATA_GET_SN 22 // <20><>ȡ<EFBFBD><C8A1><EFBFBD>к<EFBFBD>
#ifdef __cplusplus
}
#endif
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern DSTATUS disk_initialize (BYTE pdrv);
extern DSTATUS disk_status (BYTE pdrv);
extern DRESULT disk_read (BYTE pdrv, BYTE* buff, DWORD sector, UINT count);
extern DRESULT disk_write (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count);
extern DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

4677
HARDWARE/FATFS/ff.c Normal file

File diff suppressed because it is too large Load Diff

350
HARDWARE/FATFS/ff.h Normal file
View File

@@ -0,0 +1,350 @@
/*---------------------------------------------------------------------------/
/ FatFs - FAT file system module include R0.11a (C)ChaN, 2015
/----------------------------------------------------------------------------/
/ FatFs module is a free software that opened under license policy of
/ following conditions.
/
/ Copyright (C) 2015, ChaN, all right reserved.
/
/ 1. Redistributions of source code must retain the above copyright notice,
/ this condition and the following disclaimer.
/
/ This software is provided by the copyright holder and contributors "AS IS"
/ and any warranties related to this software are DISCLAIMED.
/ The copyright owner or contributors be NOT LIABLE for any damages caused
/ by use of this software.
/---------------------------------------------------------------------------*/
#ifndef _FATFS
#define _FATFS 64180 /* Revision ID */
#ifdef __cplusplus
extern "C" {
#endif
#include "integer.h" /* Basic integer types */
#include "ffconf.h" /* FatFs configuration options */
#if _FATFS != _FFCONF
#error Wrong configuration file (ffconf.h).
#endif
/* Definitions of volume management */
#if _MULTI_PARTITION /* Multiple partition configuration */
typedef struct {
BYTE pd; /* Physical drive number */
BYTE pt; /* Partition: 0:Auto detect, 1-4:Forced partition) */
} PARTITION;
extern PARTITION VolToPart[]; /* Volume - Partition resolution table */
#define LD2PD(vol) (VolToPart[vol].pd) /* Get physical drive number */
#define LD2PT(vol) (VolToPart[vol].pt) /* Get partition index */
#else /* Single partition configuration */
#define LD2PD(vol) (BYTE)(vol) /* Each logical drive is bound to the same physical drive number */
#define LD2PT(vol) 0 /* Find first valid partition or in SFD */
#endif
/* Type of path name strings on FatFs API */
#if _LFN_UNICODE /* Unicode string */
#if !_USE_LFN
#error _LFN_UNICODE must be 0 at non-LFN cfg.
#endif
#ifndef _INC_TCHAR
typedef WCHAR TCHAR;
#define _T(x) L ## x
#define _TEXT(x) L ## x
#endif
#else /* ANSI/OEM string */
#ifndef _INC_TCHAR
typedef char TCHAR;
#define _T(x) x
#define _TEXT(x) x
#endif
#endif
/* File system object structure (FATFS) */
typedef struct {
BYTE fs_type; /* FAT sub-type (0:Not mounted) */
BYTE drv; /* Physical drive number */
BYTE csize; /* Sectors per cluster (1,2,4...128) */
BYTE n_fats; /* Number of FAT copies (1 or 2) */
BYTE wflag; /* win[] flag (b0:dirty) */
BYTE fsi_flag; /* FSINFO flags (b7:disabled, b0:dirty) */
WORD id; /* File system mount ID */
WORD n_rootdir; /* Number of root directory entries (FAT12/16) */
#if _MAX_SS != _MIN_SS
WORD ssize; /* Bytes per sector (512, 1024, 2048 or 4096) */
#endif
#if _FS_REENTRANT
_SYNC_t sobj; /* Identifier of sync object */
#endif
#if !_FS_READONLY
DWORD last_clust; /* Last allocated cluster */
DWORD free_clust; /* Number of free clusters */
#endif
#if _FS_RPATH
DWORD cdir; /* Current directory start cluster (0:root) */
#endif
DWORD n_fatent; /* Number of FAT entries, = number of clusters + 2 */
DWORD fsize; /* Sectors per FAT */
DWORD volbase; /* Volume start sector */
DWORD fatbase; /* FAT start sector */
DWORD dirbase; /* Root directory start sector (FAT32:Cluster#) */
DWORD database; /* Data start sector */
DWORD winsect; /* Current sector appearing in the win[] */
BYTE win[_MAX_SS]; /* Disk access window for Directory, FAT (and file data at tiny cfg) */
} FATFS;
/* File object structure (FIL) */
typedef struct {
FATFS* fs; /* Pointer to the related file system object (**do not change order**) */
WORD id; /* Owner file system mount ID (**do not change order**) */
BYTE flag; /* Status flags */
BYTE err; /* Abort flag (error code) */
DWORD fptr; /* File read/write pointer (Zeroed on file open) */
DWORD fsize; /* File size */
DWORD sclust; /* File start cluster (0:no cluster chain, always 0 when fsize is 0) */
DWORD clust; /* Current cluster of fpter (not valid when fprt is 0) */
DWORD dsect; /* Sector number appearing in buf[] (0:invalid) */
#if !_FS_READONLY
DWORD dir_sect; /* Sector number containing the directory entry */
BYTE* dir_ptr; /* Pointer to the directory entry in the win[] */
#endif
#if _USE_FASTSEEK
DWORD* cltbl; /* Pointer to the cluster link map table (Nulled on file open) */
#endif
#if _FS_LOCK
UINT lockid; /* File lock ID origin from 1 (index of file semaphore table Files[]) */
#endif
#if !_FS_TINY
BYTE buf[_MAX_SS]; /* File private data read/write window */
#endif
} FIL;
/* Directory object structure (DIR) */
typedef struct {
FATFS* fs; /* Pointer to the owner file system object (**do not change order**) */
WORD id; /* Owner file system mount ID (**do not change order**) */
WORD index; /* Current read/write index number */
DWORD sclust; /* Table start cluster (0:Root dir) */
DWORD clust; /* Current cluster */
DWORD sect; /* Current sector */
BYTE* dir; /* Pointer to the current SFN entry in the win[] */
BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
#if _FS_LOCK
UINT lockid; /* File lock ID (index of file semaphore table Files[]) */
#endif
#if _USE_LFN
WCHAR* lfn; /* Pointer to the LFN working buffer */
WORD lfn_idx; /* Last matched LFN index number (0xFFFF:No LFN) */
#endif
#if _USE_FIND
const TCHAR* pat; /* Pointer to the name matching pattern */
#endif
} DIR;
/* File information structure (FILINFO) */
typedef struct {
DWORD fsize; /* File size */
WORD fdate; /* Last modified date */
WORD ftime; /* Last modified time */
BYTE fattrib; /* Attribute */
TCHAR fname[13]; /* Short file name (8.3 format) */
#if _USE_LFN
TCHAR* lfname; /* Pointer to the LFN buffer */
UINT lfsize; /* Size of LFN buffer in TCHAR */
#endif
} FILINFO;
/* File function return code (FRESULT) */
typedef enum {
FR_OK = 0, /* (0) Succeeded */
FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
FR_INT_ERR, /* (2) Assertion failed */
FR_NOT_READY, /* (3) The physical drive cannot work */
FR_NO_FILE, /* (4) Could not find the file */
FR_NO_PATH, /* (5) Could not find the path */
FR_INVALID_NAME, /* (6) The path name format is invalid */
FR_DENIED, /* (7) Access denied due to prohibited access or directory full */
FR_EXIST, /* (8) Access denied due to prohibited access */
FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
FR_NOT_ENABLED, /* (12) The volume has no work area */
FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
FR_TIMEOUT, /* (15) Could not get a grant to access the volume within defined period */
FR_LOCKED, /* (16) The operation is rejected according to the file sharing policy */
FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_LOCK */
FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
} FRESULT;
/*--------------------------------------------------------------*/
/* FatFs module application interface */
FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode); /* Open or create a file */
FRESULT f_close (FIL* fp); /* Close an open file object */
FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from a file */
FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to a file */
FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */
FRESULT f_lseek (FIL* fp, DWORD ofs); /* Move file pointer of a file object */
FRESULT f_truncate (FIL* fp); /* Truncate file */
FRESULT f_sync (FIL* fp); /* Flush cached data of a writing file */
FRESULT f_opendir (DIR* dp, const TCHAR* path); /* Open a directory */
FRESULT f_closedir (DIR* dp); /* Close an open directory */
FRESULT f_readdir (DIR* dp, FILINFO* fno); /* Read a directory item */
FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern); /* Find first file */
FRESULT f_findnext (DIR* dp, FILINFO* fno); /* Find next file */
FRESULT f_mkdir (const TCHAR* path); /* Create a sub directory */
FRESULT f_unlink (const TCHAR* path); /* Delete an existing file or directory */
FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new); /* Rename/Move a file or directory */
FRESULT f_stat (const TCHAR* path, FILINFO* fno); /* Get file status */
FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask); /* Change attribute of the file/dir */
FRESULT f_utime (const TCHAR* path, const FILINFO* fno); /* Change times-tamp of the file/dir */
FRESULT f_chdir (const TCHAR* path); /* Change current directory */
FRESULT f_chdrive (const TCHAR* path); /* Change current drive */
FRESULT f_getcwd (TCHAR* buff, UINT len); /* Get current directory */
FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */
FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn); /* Get volume label */
FRESULT f_setlabel (const TCHAR* label); /* Set volume label */
FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt); /* Mount/Unmount a logical drive */
FRESULT f_mkfs (const TCHAR* path, BYTE sfd, UINT au); /* Create a file system on the volume */
FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work); /* Divide a physical drive into some partitions */
int f_putc (TCHAR c, FIL* fp); /* Put a character to the file */
int f_puts (const TCHAR* str, FIL* cp); /* Put a string to the file */
int f_printf (FIL* fp, const TCHAR* str, ...); /* Put a formatted string to the file */
TCHAR* f_gets (TCHAR* buff, int len, FIL* fp); /* Get a string from the file */
#define f_eof(fp) ((int)((fp)->fptr == (fp)->fsize))
#define f_error(fp) ((fp)->err)
#define f_tell(fp) ((fp)->fptr)
#define f_size(fp) ((fp)->fsize)
#define f_rewind(fp) f_lseek((fp), 0)
#define f_rewinddir(dp) f_readdir((dp), 0)
#ifndef EOF
#define EOF (-1)
#endif
/*--------------------------------------------------------------*/
/* Additional user defined functions */
/* RTC function */
#if !_FS_READONLY && !_FS_NORTC
DWORD get_fattime (void);
#endif
/* Unicode support functions */
#if _USE_LFN /* Unicode - OEM code conversion */
WCHAR ff_convert (WCHAR chr, UINT dir); /* OEM-Unicode bidirectional conversion */
WCHAR ff_wtoupper (WCHAR chr); /* Unicode upper-case conversion */
#if _USE_LFN == 3 /* Memory functions */
void* ff_memalloc (UINT msize); /* Allocate memory block */
void ff_memfree (void* mblock); /* Free memory block */
#endif
#endif
/* Sync functions */
#if _FS_REENTRANT
int ff_cre_syncobj (BYTE vol, _SYNC_t* sobj); /* Create a sync object */
int ff_req_grant (_SYNC_t sobj); /* Lock sync object */
void ff_rel_grant (_SYNC_t sobj); /* Unlock sync object */
int ff_del_syncobj (_SYNC_t sobj); /* Delete a sync object */
#endif
/*--------------------------------------------------------------*/
/* Flags and offset address */
/* File access control and file status flags (FIL.flag) */
#define FA_READ 0x01
#define FA_OPEN_EXISTING 0x00
#if !_FS_READONLY
#define FA_WRITE 0x02
#define FA_CREATE_NEW 0x04
#define FA_CREATE_ALWAYS 0x08
#define FA_OPEN_ALWAYS 0x10
#define FA__WRITTEN 0x20
#define FA__DIRTY 0x40
#endif
/* FAT sub type (FATFS.fs_type) */
#define FS_FAT12 1
#define FS_FAT16 2
#define FS_FAT32 3
/* File attribute bits for directory entry */
#define AM_RDO 0x01 /* Read only */
#define AM_HID 0x02 /* Hidden */
#define AM_SYS 0x04 /* System */
#define AM_VOL 0x08 /* Volume label */
#define AM_LFN 0x0F /* LFN entry */
#define AM_DIR 0x10 /* Directory */
#define AM_ARC 0x20 /* Archive */
#define AM_MASK 0x3F /* Mask of defined bits */
/* Fast seek feature */
#define CREATE_LINKMAP 0xFFFFFFFF
/*--------------------------------*/
/* Multi-byte word access macros */
#if _WORD_ACCESS == 1 /* Enable word access to the FAT structure */
#define LD_WORD(ptr) (WORD)(*(WORD*)(BYTE*)(ptr))
#define LD_DWORD(ptr) (DWORD)(*(DWORD*)(BYTE*)(ptr))
#define ST_WORD(ptr,val) *(WORD*)(BYTE*)(ptr)=(WORD)(val)
#define ST_DWORD(ptr,val) *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
#else /* Use byte-by-byte access to the FAT structure */
#define LD_WORD(ptr) (WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
#define LD_DWORD(ptr) (DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))
#define ST_WORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)
#define ST_DWORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)
#endif
#ifdef __cplusplus
}
#endif
#endif /* _FATFS */

276
HARDWARE/FATFS/ffconf.h Normal file
View File

@@ -0,0 +1,276 @@
/*---------------------------------------------------------------------------/
/ FatFs - FAT file system module configuration file R0.11a (C)ChaN, 2015
/---------------------------------------------------------------------------*/
#define _FFCONF 64180 /* Revision ID */
/*---------------------------------------------------------------------------/
/ Function Configurations
/---------------------------------------------------------------------------*/
#define _FS_READONLY 0
/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
/ Read-only configuration removes writing API functions, f_write(), f_sync(),
/ f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
/ and optional writing functions as well. */
#define _FS_MINIMIZE 0
/* This option defines minimization level to remove some basic API functions.
/
/ 0: All basic functions are enabled.
/ 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_chmod(), f_utime(),
/ f_truncate() and f_rename() function are removed.
/ 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
/ 3: f_lseek() function is removed in addition to 2. */
#define _USE_STRFUNC 0
/* This option switches string functions, f_gets(), f_putc(), f_puts() and
/ f_printf().
/
/ 0: Disable string functions.
/ 1: Enable without LF-CRLF conversion.
/ 2: Enable with LF-CRLF conversion. */
#define _USE_FIND 0
/* This option switches filtered directory read feature and related functions,
/ f_findfirst() and f_findnext(). (0:Disable or 1:Enable) */
#define _USE_MKFS 0
/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
#define _USE_FASTSEEK 0
/* This option switches fast seek feature. (0:Disable or 1:Enable) */
#define _USE_LABEL 0
/* This option switches volume label functions, f_getlabel() and f_setlabel().
/ (0:Disable or 1:Enable) */
#define _USE_FORWARD 0
/* This option switches f_forward() function. (0:Disable or 1:Enable)
/ To enable it, also _FS_TINY need to be set to 1. */
/*---------------------------------------------------------------------------/
/ Locale and Namespace Configurations
/---------------------------------------------------------------------------*/
#define _CODE_PAGE 936
/* This option specifies the OEM code page to be used on the target system.
/ Incorrect setting of the code page can cause a file open failure.
/
/ 1 - ASCII (No extended character. Non-LFN cfg. only)
/ 437 - U.S.
/ 720 - Arabic
/ 737 - Greek
/ 771 - KBL
/ 775 - Baltic
/ 850 - Latin 1
/ 852 - Latin 2
/ 855 - Cyrillic
/ 857 - Turkish
/ 860 - Portuguese
/ 861 - Icelandic
/ 862 - Hebrew
/ 863 - Canadian French
/ 864 - Arabic
/ 865 - Nordic
/ 866 - Russian
/ 869 - Greek 2
/ 932 - Japanese (DBCS)
/ 936 - Simplified Chinese (DBCS)
/ 949 - Korean (DBCS)
/ 950 - Traditional Chinese (DBCS)
*/
#define _USE_LFN 3
#define _MAX_LFN 255
/* The _USE_LFN option switches the LFN feature.
/
/ 0: Disable LFN feature. _MAX_LFN has no effect.
/ 1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
/ 2: Enable LFN with dynamic working buffer on the STACK.
/ 3: Enable LFN with dynamic working buffer on the HEAP.
/
/ When enable the LFN feature, Unicode handling functions (option/unicode.c) must
/ be added to the project. The LFN working buffer occupies (_MAX_LFN + 1) * 2 bytes.
/ When use stack for the working buffer, take care on stack overflow. When use heap
/ memory for the working buffer, memory management functions, ff_memalloc() and
/ ff_memfree(), must be added to the project. */
#define _LFN_UNICODE 0
/* This option switches character encoding on the API. (0:ANSI/OEM or 1:Unicode)
/ To use Unicode string for the path name, enable LFN feature and set _LFN_UNICODE
/ to 1. This option also affects behavior of string I/O functions. */
#define _STRF_ENCODE 3
/* When _LFN_UNICODE is 1, this option selects the character encoding on the file to
/ be read/written via string I/O functions, f_gets(), f_putc(), f_puts and f_printf().
/
/ 0: ANSI/OEM
/ 1: UTF-16LE
/ 2: UTF-16BE
/ 3: UTF-8
/
/ When _LFN_UNICODE is 0, this option has no effect. */
#define _FS_RPATH 0
/* This option configures relative path feature.
/
/ 0: Disable relative path feature and remove related functions.
/ 1: Enable relative path feature. f_chdir() and f_chdrive() are available.
/ 2: f_getcwd() function is available in addition to 1.
/
/ Note that directory items read via f_readdir() are affected by this option. */
/*---------------------------------------------------------------------------/
/ Drive/Volume Configurations
/---------------------------------------------------------------------------*/
#define _VOLUMES 4
/* Number of volumes (logical drives) to be used. */
#define _STR_VOLUME_ID 0
#define _VOLUME_STRS "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
/* _STR_VOLUME_ID option switches string volume ID feature.
/ When _STR_VOLUME_ID is set to 1, also pre-defined strings can be used as drive
/ number in the path name. _VOLUME_STRS defines the drive ID strings for each
/ logical drives. Number of items must be equal to _VOLUMES. Valid characters for
/ the drive ID strings are: A-Z and 0-9. */
#define _MULTI_PARTITION 0
/* This option switches multi-partition feature. By default (0), each logical drive
/ number is bound to the same physical drive number and only an FAT volume found on
/ the physical drive will be mounted. When multi-partition feature is enabled (1),
/ each logical drive number is bound to arbitrary physical drive and partition
/ listed in the VolToPart[]. Also f_fdisk() funciton will be available. */
#define _MIN_SS 512
#define _MAX_SS 512
/* These options configure the range of sector size to be supported. (512, 1024,
/ 2048 or 4096) Always set both 512 for most systems, all type of memory cards and
/ harddisk. But a larger value may be required for on-board flash memory and some
/ type of optical media. When _MAX_SS is larger than _MIN_SS, FatFs is configured
/ to variable sector size and GET_SECTOR_SIZE command must be implemented to the
/ disk_ioctl() function. */
#define _USE_TRIM 0
/* This option switches ATA-TRIM feature. (0:Disable or 1:Enable)
/ To enable Trim feature, also CTRL_TRIM command should be implemented to the
/ disk_ioctl() function. */
#define _FS_NOFSINFO 0
/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
/ option, and f_getfree() function at first time after volume mount will force
/ a full FAT scan. Bit 1 controls the use of last allocated cluster number.
/
/ bit0=0: Use free cluster count in the FSINFO if available.
/ bit0=1: Do not trust free cluster count in the FSINFO.
/ bit1=0: Use last allocated cluster number in the FSINFO if available.
/ bit1=1: Do not trust last allocated cluster number in the FSINFO.
*/
/*---------------------------------------------------------------------------/
/ System Configurations
/---------------------------------------------------------------------------*/
#define _FS_TINY 0
/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
/ At the tiny configuration, size of the file object (FIL) is reduced _MAX_SS
/ bytes. Instead of private sector buffer eliminated from the file object,
/ common sector buffer in the file system object (FATFS) is used for the file
/ data transfer. */
#define _FS_NORTC 0
#define _NORTC_MON 1
#define _NORTC_MDAY 1
#define _NORTC_YEAR 2015
/* The _FS_NORTC option switches timestamp feature. If the system does not have
/ an RTC function or valid timestamp is not needed, set _FS_NORTC to 1 to disable
/ the timestamp feature. All objects modified by FatFs will have a fixed timestamp
/ defined by _NORTC_MON, _NORTC_MDAY and _NORTC_YEAR.
/ When timestamp feature is enabled (_FS_NORTC == 0), get_fattime() function need
/ to be added to the project to read current time form RTC. _NORTC_MON,
/ _NORTC_MDAY and _NORTC_YEAR have no effect.
/ These options have no effect at read-only configuration (_FS_READONLY == 1). */
#define _FS_LOCK 0
/* The _FS_LOCK option switches file lock feature to control duplicated file open
/ and illegal operation to open objects. This option must be 0 when _FS_READONLY
/ is 1.
/
/ 0: Disable file lock feature. To avoid volume corruption, application program
/ should avoid illegal open, remove and rename to the open objects.
/ >0: Enable file lock feature. The value defines how many files/sub-directories
/ can be opened simultaneously under file lock control. Note that the file
/ lock feature is independent of re-entrancy. */
#define _FS_REENTRANT 0
#define _FS_TIMEOUT 1000
#define _SYNC_t HANDLE
/* The _FS_REENTRANT option switches the re-entrancy (thread safe) of the FatFs
/ module itself. Note that regardless of this option, file access to different
/ volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
/ and f_fdisk() function, are always not re-entrant. Only file/directory access
/ to the same volume is under control of this feature.
/
/ 0: Disable re-entrancy. _FS_TIMEOUT and _SYNC_t have no effect.
/ 1: Enable re-entrancy. Also user provided synchronization handlers,
/ ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
/ function, must be added to the project. Samples are available in
/ option/syscall.c.
/
/ The _FS_TIMEOUT defines timeout period in unit of time tick.
/ The _SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
/ SemaphoreHandle_t and etc.. A header file for O/S definitions needs to be
/ included somewhere in the scope of ff.c. */
#define _WORD_ACCESS 0
/* The _WORD_ACCESS option is an only platform dependent option. It defines
/ which access method is used to the word data on the FAT volume.
/
/ 0: Byte-by-byte access. Always compatible with all platforms.
/ 1: Word access. Do not choose this unless under both the following conditions.
/
/ * Address misaligned memory access is always allowed to ALL instructions.
/ * Byte order on the memory is little-endian.
/
/ If it is the case, _WORD_ACCESS can also be set to 1 to reduce code size.
/ Following table shows allowable settings of some type of processors.
/
/ ARM7TDMI 0 *2 ColdFire 0 *1 V850E 0 *2
/ Cortex-M3 0 *3 Z80 0/1 V850ES 0/1
/ Cortex-M0 0 *2 x86 0/1 TLCS-870 0/1
/ AVR 0/1 RX600(LE) 0/1 TLCS-900 0/1
/ AVR32 0 *1 RL78 0 *2 R32C 0 *2
/ PIC18 0/1 SH-2 0 *1 M16C 0/1
/ PIC24 0 *2 H8S 0 *1 MSP430 0 *2
/ PIC32 0 *1 H8/300H 0 *1 8051 0/1
/
/ *1:Big-endian.
/ *2:Unaligned memory access is not supported.
/ *3:Some compilers generate LDM/STM for mem_cpy function.
*/

33
HARDWARE/FATFS/integer.h Normal file
View File

@@ -0,0 +1,33 @@
/*-------------------------------------------*/
/* Integer type definitions for FatFs module */
/*-------------------------------------------*/
#ifndef _FF_INTEGER
#define _FF_INTEGER
#ifdef _WIN32 /* Development platform */
#include <windows.h>
#include <tchar.h>
#else /* Embedded platform */
/* This type MUST be 8-bit */
typedef unsigned char BYTE;
/* These types MUST be 16-bit */
typedef short SHORT;
typedef unsigned short WORD;
typedef unsigned short WCHAR;
/* These types MUST be 16-bit or 32-bit */
typedef int INT;
typedef unsigned int UINT;
/* These types MUST be 32-bit */
typedef long LONG;
typedef unsigned long DWORD;
#endif
#endif

119
HARDWARE/GPS/gps.c Normal file
View File

@@ -0,0 +1,119 @@
#include "gps.h"
#include "stdio.h"
#include "string.h"
#include "math.h"
uint32_t UTC;
char SetTimeZone[25] = {0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xf1, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c};
u8 NMEA_Comma_Pos(u8 *buf, u8 cx)
{
u8 *p = buf;
while (cx)
{
if (*buf == '*' || *buf < ' ' || *buf > 'z')
return 0XFF; // <20><><EFBFBD><EFBFBD>'*'<27><><EFBFBD>߷Ƿ<DFB7><C7B7>ַ<EFBFBD>,<2C>򲻴<EFBFBD><F2B2BBB4>ڵ<EFBFBD>cx<63><78><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (*buf == ',')
cx--;
buf++;
}
return buf - p;
}
u32 NMEA_Pow(u8 m, u8 n)
{
u32 result = 1;
while (n--)
result *= m;
return result;
}
int NMEA_Str2num(u8 *buf, u8 *dx)
{
u8 *p = buf;
u32 ires = 0, fres = 0;
u8 ilen = 0, flen = 0, i;
u8 mask = 0;
int res;
while (1) // <20>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD>ij<EFBFBD><C4B3><EFBFBD>
{
if (*p == '-')
{
mask |= 0X02;
p++;
} // <20>Ǹ<EFBFBD><C7B8><EFBFBD>
if (*p == ',' || (*p == '*'))
break; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if (*p == '.')
{
mask |= 0X01;
p++;
} // <20><><EFBFBD><EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else if (*p > '9' || (*p < '0')) // <20>зǷ<D0B7><C7B7>ַ<EFBFBD>
{
ilen = 0;
flen = 0;
break;
}
if (mask & 0X01)
flen++;
else
ilen++;
p++;
}
if (mask & 0X02)
buf++; // ȥ<><C8A5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for (i = 0; i < ilen; i++) // <20>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
ires += NMEA_Pow(10, ilen - 1 - i) * (buf[i] - '0');
}
if (flen > 5)
flen = 5; // <20><><EFBFBD><EFBFBD>ȡ5λС<CEBB><D0A1>
*dx = flen; // С<><D0A1><EFBFBD><EFBFBD>λ<EFBFBD><CEBB>
for (i = 0; i < flen; i++) // <20>õ<EFBFBD>С<EFBFBD><D0A1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
fres += NMEA_Pow(10, flen - 1 - i) * (buf[ilen + 1 + i] - '0');
}
res = ires * NMEA_Pow(10, flen) + fres;
if (mask & 0X02)
res = -res;
return res;
}
// <20><><EFBFBD><EFBFBD>GPRMC<4D><43>Ϣ
// gpsx: nmea<65><61>Ϣ<EFBFBD><EFBFBD><E1B9B9>
// buf: <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD>GPS<50><53><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>׵<EFBFBD>ַ
void NMEA_GPRMC_Analysis(nmea_msg *gpsx, u8 *buf)
{
u8 *p1, dx;
u8 posx;
u32 temp;
p1 = (u8 *)strstr((const char *)buf, "RMC"); // "$GPRMC", <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>&<26><>GPRMC<4D>ֿ<EFBFBD><D6BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>, <20><>ֻ<EFBFBD>ж<EFBFBD>GPRMC.
posx = NMEA_Comma_Pos(p1, 1); // <20>õ<EFBFBD>UTCʱ<43><CAB1>
if (posx != 0XFF)
{
UTC = NMEA_Str2num(p1 + posx, &dx) / NMEA_Pow(10, dx);
temp = (NMEA_Str2num(p1 + posx, &dx) / NMEA_Pow(10, dx)); // <20>õ<EFBFBD>UTCʱ<43><CAB1>, ȥ<><C8A5>ms
gpsx->utc.hour = temp / 10000 + 8; // UTCʱ<43><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
gpsx->utc.min = (temp / 100) % 100;
gpsx->utc.sec = temp % 100;
}
posx = NMEA_Comma_Pos(p1, 9); // <20>õ<EFBFBD>UTC<54><43><EFBFBD><EFBFBD>
if (posx != 0XFF)
{
temp = NMEA_Str2num(p1 + posx, &dx); // <20>õ<EFBFBD>UTC<54><43><EFBFBD><EFBFBD>
gpsx->utc.date = temp / 10000;
gpsx->utc.month = (temp / 100) % 100;
gpsx->utc.year = 2000 + temp % 100;
}
}
// <20><>ȡNMEA-0183<38><33>Ϣ
// gpsx: nmea<65><61>Ϣ<EFBFBD><EFBFBD><E1B9B9>
// buf: <20><><EFBFBD>յ<EFBFBD><D5B5><EFBFBD>GPS<50><53><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>׵<EFBFBD>ַ
void GPS_Analysis(nmea_msg *gpsx, u8 *buf)
{
NMEA_GPRMC_Analysis(gpsx, buf); // GPRMC<4D><43><EFBFBD><EFBFBD>
}

30
HARDWARE/GPS/gps.h Normal file
View File

@@ -0,0 +1,30 @@
#ifndef __GPS_H
#define __GPS_H
#include "sys.h"
// UTCʱ<43><CAB1><EFBFBD><EFBFBD>Ϣ
__packed typedef struct
{
u16 year; //<2F><><EFBFBD><EFBFBD>
u8 month; //<2F>·<EFBFBD>
u8 date; //<2F><><EFBFBD><EFBFBD>
u8 hour; //Сʱ
u8 min; //<2F><><EFBFBD><EFBFBD>
u8 sec; //<2F><><EFBFBD><EFBFBD>
}nmea_utc_time;
// NMEA 0183 Э<><D0AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD><DDB4>Žṹ<C5BD><E1B9B9>
__packed typedef struct
{
nmea_utc_time utc; // UTCʱ<43><CAB1>
}nmea_msg;
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
int NMEA_Str2num(u8 *buf,u8*dx);
void NMEA_GPRMC_Analysis(nmea_msg *gpsx, u8 *buf);
void GPS_Analysis(nmea_msg *gpsx, u8 *buf);
#endif

82
HARDWARE/KEY/key.c Normal file
View File

@@ -0,0 +1,82 @@
#include "key.h"
#include "delay.h"
//-----------------------------------------------------------------
GPIO_TypeDef* BUTTON_PORT[BUTTONn] = {BUTTON_KEY1_GPIO_PORT,BUTTON_KEY2_GPIO_PORT,BUTTON_KEY3_GPIO_PORT,BUTTON_KEY4_GPIO_PORT};
const uint16_t BUTTON_PIN[BUTTONn] = {BUTTON_KEY1_PIN,BUTTON_KEY2_PIN,BUTTON_KEY3_PIN,BUTTON_KEY4_PIN};
//-----------------------------------------------------------------
// void KEY_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̶˿<CCB6>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void KEY_Init(void)
{
BSP_KEY_Init(BUTTON_KEY1); // KEY1<59><31><EFBFBD><EFBFBD>PD6
BSP_KEY_Init(BUTTON_KEY2); // KEY2<59><32><EFBFBD><EFBFBD>PB4
BSP_KEY_Init(BUTTON_KEY3); // KEY3<59><33><EFBFBD><EFBFBD>PB6
BSP_KEY_Init(BUTTON_KEY4); // KEY4<59><34><EFBFBD><EFBFBD>PB9
}
//-----------------------------------------------------------------
// void BSP_KEY_Init(Button_TypeDef button)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>İ<EFBFBD><C4B0><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: button<6F><6E><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD>İ<EFBFBD><C4B0><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5>BUTTON_KEY1<59><31>BUTTON_KEY2<59><32>BUTTON_KEY3<59><33>BUTTON_KEY4<59><34>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void BSP_KEY_Init(Button_TypeDef button)
{
GPIO_InitTypeDef GPIO_InitStruct;
BUTTONx_GPIO_CLK_ENABLE(button); // <20><><EFBFBD><EFBFBD>KEYʱ<59><CAB1>
GPIO_InitStruct.Pin = BUTTON_PIN[button]; // <20><><EFBFBD><EFBFBD>KEY
GPIO_InitStruct.Mode = GPIO_MODE_INPUT; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_InitStruct.Pull = GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
HAL_GPIO_Init(BUTTON_PORT[button], &GPIO_InitStruct); // <20><>ʼ<EFBFBD><CABC>KEY
}
//-----------------------------------------------------------------
// u8 KEY_Scan(u8 mode)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɨ<EFBFBD><C9A8>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 mode<64><65>0<EFBFBD><30>֧<EFBFBD><D6A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><31><D6A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><><EFBFBD><EFBFBD>ֵ
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>˺<EFBFBD><CBBA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD><D3A6><EFBFBD>ȼ<EFBFBD>,KEY1>KEY2>KEY3>KEY4!!
//
//-----------------------------------------------------------------
u8 KEY_Scan(u8 mode)
{
static u8 key_up=1; // <20><><EFBFBD><EFBFBD><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD>־
if(mode==1) // ֧<><D6A7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
key_up=1;
if(key_up&&(KEY1==0||KEY2==0||KEY3==0||KEY4==0)) // <20>а<EFBFBD><D0B0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
delay_ms(10); // <20><>ʱ10ms
key_up=0; // <20><><EFBFBD><EFBFBD><EFBFBD>ɿ<EFBFBD><C9BF><EFBFBD>־<EFBFBD><D6BE><EFBFBD><EFBFBD>
if(KEY1==0) // <20><><EFBFBD><EFBFBD>K1<4B><31><EFBFBD><EFBFBD>
return KEY1_PRES;
else if(KEY2==0) // <20><><EFBFBD><EFBFBD>K2<4B><32><EFBFBD><EFBFBD>
return KEY2_PRES;
else if(KEY3==0) // <20><><EFBFBD><EFBFBD>K3<4B><33><EFBFBD><EFBFBD>
return KEY3_PRES;
else if(KEY4==0) // <20><><EFBFBD><EFBFBD>K4<4B><34><EFBFBD><EFBFBD>
return KEY4_PRES;
}
else if(KEY1==1&&KEY2==1&&KEY3==1&&KEY4==01) // <20>ް<EFBFBD><DEB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
key_up=1;
return 0; // <20>ް<EFBFBD><DEB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

71
HARDWARE/KEY/key.h Normal file
View File

@@ -0,0 +1,71 @@
#ifndef _KEY_H
#define _KEY_H
#include "stm32f429_winner.h"
//-----------------------------------------------------------------
// BUTTON<4F><4E><EFBFBD>Ŷ<EFBFBD><C5B6><EFBFBD>
//-----------------------------------------------------------------
typedef enum
{
BUTTON_KEY1 = 0,
BUTTON_KEY2 = 1,
BUTTON_KEY3 = 2,
BUTTON_KEY4 = 3
}Button_TypeDef;
#define BUTTONn 4
#define BUTTON_KEY1_PIN GPIO_PIN_6
#define BUTTON_KEY1_GPIO_PORT GPIOD
#define BUTTON_KEY1_GPIO_CLK_ENABLE() __HAL_RCC_GPIOD_CLK_ENABLE()
#define BUTTON_KEY1_GPIO_CLK_DISABLE() __HAL_RCC_GPIOD_CLK_DISABLE()
#define BUTTON_KEY2_PIN GPIO_PIN_4
#define BUTTON_KEY2_GPIO_PORT GPIOB
#define BUTTON_KEY2_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define BUTTON_KEY2_GPIO_CLK_DISABLE() __HAL_RCC_GPIOB_CLK_DISABLE()
#define BUTTON_KEY2_EXTI_IRQn EXTI4_IRQn
#define BUTTON_KEY3_PIN GPIO_PIN_6
#define BUTTON_KEY3_GPIO_PORT GPIOB
#define BUTTON_KEY3_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define BUTTON_KEY3_GPIO_CLK_DISABLE() __HAL_RCC_GPIOB_CLK_DISABLE()
#define BUTTON_KEY3_EXTI_IRQn EXTI9_5_IRQn
#define BUTTON_KEY4_PIN GPIO_PIN_9
#define BUTTON_KEY4_GPIO_PORT GPIOB
#define BUTTON_KEY4_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define BUTTON_KEY4_GPIO_CLK_DISABLE() __HAL_RCC_GPIOB_CLK_DISABLE()
#define BUTTON_KEY4_EXTI_IRQn EXTI9_5_IRQn
#define BUTTONx_GPIO_CLK_ENABLE(__INDEX__) do{if((__INDEX__) == 0) BUTTON_KEY1_GPIO_CLK_ENABLE(); else \
if((__INDEX__) == 1) BUTTON_KEY2_GPIO_CLK_ENABLE(); else \
if((__INDEX__) == 1) BUTTON_KEY3_GPIO_CLK_ENABLE(); else \
if((__INDEX__) == 2) BUTTON_KEY4_GPIO_CLK_ENABLE(); \
}while(0)
#define BUTTONx_GPIO_CLK_DISABLE(__INDEX__) do{if((__INDEX__) == 0) BUTTON_KEY1_GPIO_CLK_DISABLE(); else \
if((__INDEX__) == 1) BUTTON_KEY2_GPIO_CLK_DISABLE(); else \
if((__INDEX__) == 1) BUTTON_KEY3_GPIO_CLK_DISABLE(); else \
if((__INDEX__) == 2) BUTTON_KEY4_GPIO_CLK_DISABLE(); \
}while(0)
#define KEY1 HAL_GPIO_ReadPin(BUTTON_KEY1_GPIO_PORT,BUTTON_KEY1_PIN) // KEY1<59><31><EFBFBD><EFBFBD>PD6
#define KEY2 HAL_GPIO_ReadPin(BUTTON_KEY2_GPIO_PORT,BUTTON_KEY2_PIN) // KEY2<59><32><EFBFBD><EFBFBD>PB4
#define KEY3 HAL_GPIO_ReadPin(BUTTON_KEY3_GPIO_PORT,BUTTON_KEY3_PIN) // KEY3<59><33><EFBFBD><EFBFBD>PB6
#define KEY4 HAL_GPIO_ReadPin(BUTTON_KEY4_GPIO_PORT,BUTTON_KEY4_PIN) // KEY4<59><34><EFBFBD><EFBFBD>PB9
#define KEY1_PRES 1 // K1<4B><31>ֵ
#define KEY2_PRES 2 // K2<4B><32>ֵ
#define KEY3_PRES 3 // K3<4B><33>ֵ
#define KEY4_PRES 4 // K4<4B><34>ֵ
//-----------------------------------------------------------------
// <20>ⲿ<EFBFBD><E2B2BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern void KEY_Init(void);
extern void BSP_KEY_Init(Button_TypeDef button);
extern u8 KEY_Scan(u8 mode);
//-----------------------------------------------------------------
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,30 +1,47 @@
#include "led.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//LED<45><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><EFBFBD>@ALIENTEK
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/5
//<EFBFBD><EFBFBD><EFBFBD>V1.0
//<EFBFBD><EFBFBD>Ȩ<EFBFBD><EFBFBD><EFBFBD>У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><EFBFBD><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
//<2F><>ʼ<EFBFBD><CABC>PB1Ϊ<31><CEAA><EFBFBD><EFBFBD>.<2E><>ʹ<EFBFBD><CAB9>ʱ<EFBFBD><CAB1>
//LED IO<49><4F>ʼ<EFBFBD><CABC>
//-----------------------------------------------------------------
GPIO_TypeDef* GPIO_PORT[LEDn] = {LEDB_GPIO_PORT,LEDG_GPIO_PORT,LEDR_GPIO_PORT};
const uint16_t GPIO_PIN[LEDn] = {LEDB_PIN,LEDG_PIN,LEDR_PIN};
//-----------------------------------------------------------------
// void LED_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: LED GPIO<49><4F><EFBFBD><EFBFBD>
// <EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><EFBFBD><EFBFBD>: <EFBFBD><EFBFBD>
// <20><> <EFBFBD><EFBFBD> ֵ: <EFBFBD><EFBFBD>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void LED_Init(void)
{
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_GPIOB_CLK_ENABLE(); //<2F><><EFBFBD><EFBFBD>GPIOBʱ<42><CAB1>
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_1; //PB1,0
GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; //<2F><><EFBFBD><EFBFBD>
HAL_GPIO_Init(GPIOB,&GPIO_Initure);
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET); //PB0<42><30>1
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_1,GPIO_PIN_SET); //PB1<42><31>1
BSP_LED_Init(LEDB); // LED_B(<28><><EFBFBD><EFBFBD>)<29><>PB14
BSP_LED_Init(LEDG); // LED_G(<28>̵<EFBFBD>)<29><>PF7
BSP_LED_Init(LEDR); // LED_R(<28><><EFBFBD><EFBFBD>)<29><>PI3
}
//-----------------------------------------------------------------
// void BSP_LED_Init(Led_TypeDef Led)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>LED
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: Led<65><64>ָ<EFBFBD><D6B8>Ҫ<EFBFBD><D2AA><EFBFBD>õ<EFBFBD>LED<45><44>ֵ<EFBFBD><D6B5>LEDB<44><42>LEDG<44><47>LEDR<44><52>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void BSP_LED_Init(Led_TypeDef Led)
{
GPIO_InitTypeDef GPIO_InitStruct;
LEDx_GPIO_CLK_ENABLE(Led); // <20><><EFBFBD><EFBFBD>Ledʱ<64><CAB1>
GPIO_InitStruct.Pin = GPIO_PIN[Led]; // <20><><EFBFBD><EFBFBD>Led
GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_InitStruct.Pull = GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_InitStruct.Speed = GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
HAL_GPIO_Init(GPIO_PORT[Led], &GPIO_InitStruct); // <20><>ʼ<EFBFBD><CABC>Led
HAL_GPIO_WritePin(GPIO_PORT[Led], GPIO_PIN[Led], GPIO_PIN_SET); // LED<45>ø<EFBFBD>
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,21 +1,53 @@
#ifndef _LED_H
#define _LED_H
#include "sys.h"
//////////////////////////////////////////////////////////////////////////////////
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD>ѧϰʹ<EFBFBD>ã<EFBFBD>δ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><EFBFBD><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//LED<45><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/1
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
#include "stm32f429_winner.h"
//-----------------------------------------------------------------
// LED<EFBFBD><EFBFBD><EFBFBD>Ŷ<EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
typedef enum
{
LEDB = 0,
LEDG = 1,
LEDR = 2
}Led_TypeDef;
#define LED0 PBout(1) //LED0
#define LED1 PBout(0) //LED1
#define LEDn 3
void LED_Init(void);
#define LEDB_PIN GPIO_PIN_14
#define LEDB_GPIO_PORT GPIOB
#define LEDB_GPIO_CLK_ENABLE() __HAL_RCC_GPIOB_CLK_ENABLE()
#define LEDB_GPIO_CLK_DISABLE() __HAL_RCC_GPIOB_CLK_DISABLE()
#define LED_B PBout(14) // LED_B(<28><><EFBFBD><EFBFBD>) PB14
#define LEDG_PIN GPIO_PIN_7
#define LEDG_GPIO_PORT GPIOF
#define LEDG_GPIO_CLK_ENABLE() __HAL_RCC_GPIOF_CLK_ENABLE()
#define LEDG_GPIO_CLK_DISABLE() __HAL_RCC_GPIOF_CLK_DISABLE()
#define LED_G PFout(7) // LED_G(<28>̵<EFBFBD>) PF7
#define LEDR_PIN GPIO_PIN_3
#define LEDR_GPIO_PORT GPIOI
#define LEDR_GPIO_CLK_ENABLE() __HAL_RCC_GPIOI_CLK_ENABLE()
#define LEDR_GPIO_CLK_DISABLE() __HAL_RCC_GPIOI_CLK_DISABLE()
#define LED_R PIout(3) // LED_R(<28><><EFBFBD><EFBFBD>) PI3
#define LEDx_GPIO_CLK_ENABLE(__INDEX__) do{if((__INDEX__) == 0) LEDB_GPIO_CLK_ENABLE(); else \
if((__INDEX__) == 1) LEDG_GPIO_CLK_ENABLE(); else \
if((__INDEX__) == 2) LEDR_GPIO_CLK_ENABLE(); \
}while(0)
#define LEDx_GPIO_CLK_DISABLE(__INDEX__) do{if((__INDEX__) == 0) LEDB_GPIO_CLK_DISABLE(); else \
if((__INDEX__) == 1) LEDG_GPIO_CLK_DISABLE(); else \
if((__INDEX__) == 2) LEDR_GPIO_CLK_DISABLE(); \
}while(0)
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// <20>ⲿ<EFBFBD><E2B2BF><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern void LED_Init(void);
extern void BSP_LED_Init(Led_TypeDef Led);
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

398
HARDWARE/SDIO/sdio.c Normal file
View File

@@ -0,0 +1,398 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SD<53><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04) SD<53><44><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>Ͷ<EFBFBD>д
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// ͷ<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#include "sdio.h"
#include "string.h"
//-----------------------------------------------------------------
SD_HandleTypeDef SDCARD_Handler; // SD<53><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HAL_SD_CardInfoTypedef SDCardInfo; // SD<53><44><EFBFBD><EFBFBD>Ϣ<EFBFBD><EFBFBD><E1B9B9>
DMA_HandleTypeDef SDTxDMAHandler,SDRxDMAHandler; // SD<53><44>DMA<4D><41><EFBFBD>ͺͽ<CDBA><CDBD>վ<EFBFBD><D5BE><EFBFBD>
// SD_ReadDisk/SD_WriteDisk<73><6B><EFBFBD><EFBFBD>ר<EFBFBD><D7A8>buf,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7><EFBFBD><EFBFBD>4<EFBFBD>ֽڶ<D6BD><DAB6><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>,
// <20><>Ҫ<EFBFBD>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><><C8B7><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>4<EFBFBD>ֽڶ<D6BD><DAB6><EFBFBD><EFBFBD><EFBFBD>.
__align(4) u8 SDIO_DATA_BUFFER[512];
//-----------------------------------------------------------------
// u8 SD_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SD<53><44><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: 0 <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><D6B5><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_Init(void)
{
u8 SD_Error;
// <20><>ʼ<EFBFBD><CABC>ʱ<EFBFBD><CAB1>ʱ<EFBFBD>Ӳ<EFBFBD><D3B2>ܴ<EFBFBD><DCB4><EFBFBD>400KHZ
SDCARD_Handler.Instance=SDIO;
SDCARD_Handler.Init.ClockEdge=SDIO_CLOCK_EDGE_RISING; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDCARD_Handler.Init.ClockBypass=SDIO_CLOCK_BYPASS_DISABLE; // <20><>ʹ<EFBFBD><CAB9>bypassģʽ<C4A3><CABD>ֱ<EFBFBD><D6B1><EFBFBD><EFBFBD>HCLK<4C><4B><EFBFBD>з<EFBFBD>Ƶ<EFBFBD>õ<EFBFBD>SDIO_CK
SDCARD_Handler.Init.ClockPowerSave=SDIO_CLOCK_POWER_SAVE_DISABLE; // <20><><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>ر<EFBFBD>ʱ<EFBFBD>ӵ<EFBFBD>Դ
SDCARD_Handler.Init.BusWide=SDIO_BUS_WIDE_1B; // 1λ<31><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDCARD_Handler.Init.HardwareFlowControl=SDIO_HARDWARE_FLOW_CONTROL_DISABLE; // <20>ر<EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDCARD_Handler.Init.ClockDiv=SDIO_TRANSFER_CLK_DIV; // SD<53><44><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD>25MHZ
SD_Error=HAL_SD_Init(&SDCARD_Handler,&SDCardInfo);
if(SD_Error!=SD_OK)
return 1;
SD_Error=HAL_SD_WideBusOperation_Config(&SDCARD_Handler,SDIO_BUS_WIDE_4B); // ʹ<>ܿ<EFBFBD><DCBF><EFBFBD><EFBFBD><EFBFBD>ģʽ
if(SD_Error!=SD_OK)
return 2;
return 0;
}
//-----------------------------------------------------------------
// void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SDMMC<4D>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>ʹ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>DMA<4D><41><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: SD_HandleTypeDef *hsd<73><64>SD<53><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>ᱻHAL_SD_Init()<29><><EFBFBD><EFBFBD>
//
//-----------------------------------------------------------------
void HAL_SD_MspInit(SD_HandleTypeDef *hsd)
{
DMA_HandleTypeDef TxDMAHandler,RxDMAHandler;
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_SDIO_CLK_ENABLE(); // ʹ<><CAB9>SDIOʱ<4F><CAB1>
__HAL_RCC_DMA2_CLK_ENABLE(); // ʹ<><CAB9>DMA2ʱ<32><CAB1>
__HAL_RCC_GPIOC_CLK_ENABLE(); // ʹ<><CAB9>GPIOCʱ<43><CAB1>
__HAL_RCC_GPIOD_CLK_ENABLE(); // ʹ<><CAB9>GPIODʱ<44><CAB1>
// PC8->SDIO_D0, PC9->SDIO_D1, PC10->SDIO_D2, PC11->SDIO_D3, PC12->SDIO_CK
GPIO_Initure.Pin=GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
GPIO_Initure.Mode=GPIO_MODE_AF_PP; // <20><><EFBFBD><EFBFBD><ECB8B4>
GPIO_Initure.Pull=GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=GPIO_AF12_SDIO; // <20><><EFBFBD><EFBFBD>ΪSDIO
HAL_GPIO_Init(GPIOC,&GPIO_Initure); // <20><>ʼ<EFBFBD><CABC>
GPIO_Initure.Pin=GPIO_PIN_2; // PD2->SDIO_CMD
HAL_GPIO_Init(GPIOD,&GPIO_Initure); // <20><>ʼ<EFBFBD><CABC>
#if (SD_DMA_MODE==1) // ʹ<><CAB9>DMAģʽ
HAL_NVIC_SetPriority(SDMMC1_IRQn,2,0); // <20><><EFBFBD><EFBFBD>SDMMC1<43>жϣ<D0B6><CFA3><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD>ȼ<EFBFBD>2<EFBFBD><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȼ<EFBFBD>0
HAL_NVIC_EnableIRQ(SDMMC1_IRQn); // ʹ<><CAB9>SDMMC1<43>ж<EFBFBD>
// <20><><EFBFBD>÷<EFBFBD><C3B7><EFBFBD>DMA
SDRxDMAHandler.Instance=DMA2_Stream3;
SDRxDMAHandler.Init.Channel=DMA_CHANNEL_4;
SDRxDMAHandler.Init.Direction=DMA_PERIPH_TO_MEMORY;
SDRxDMAHandler.Init.PeriphInc=DMA_PINC_DISABLE;
SDRxDMAHandler.Init.MemInc=DMA_MINC_ENABLE;
SDRxDMAHandler.Init.PeriphDataAlignment=DMA_PDATAALIGN_WORD;
SDRxDMAHandler.Init.MemDataAlignment=DMA_MDATAALIGN_WORD;
SDRxDMAHandler.Init.Mode=DMA_PFCTRL;
SDRxDMAHandler.Init.Priority=DMA_PRIORITY_VERY_HIGH;
SDRxDMAHandler.Init.FIFOMode=DMA_FIFOMODE_ENABLE;
SDRxDMAHandler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;
SDRxDMAHandler.Init.MemBurst=DMA_MBURST_INC4;
SDRxDMAHandler.Init.PeriphBurst=DMA_PBURST_INC4;
__HAL_LINKDMA(hsd, hdmarx, SDRxDMAHandler); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>DMA<4D><41>SD<53><44><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD>DMA<4D><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HAL_DMA_DeInit(&SDRxDMAHandler);
HAL_DMA_Init(&SDRxDMAHandler); // <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>DMA
// <20><><EFBFBD>ý<EFBFBD><C3BD><EFBFBD>DMA
SDTxDMAHandler.Instance=DMA2_Stream6;
SDTxDMAHandler.Init.Channel=DMA_CHANNEL_4;
SDTxDMAHandler.Init.Direction=DMA_MEMORY_TO_PERIPH;
SDTxDMAHandler.Init.PeriphInc=DMA_PINC_DISABLE;
SDTxDMAHandler.Init.MemInc=DMA_MINC_ENABLE;
SDTxDMAHandler.Init.PeriphDataAlignment=DMA_PDATAALIGN_WORD;
SDTxDMAHandler.Init.MemDataAlignment=DMA_MDATAALIGN_WORD;
SDTxDMAHandler.Init.Mode=DMA_PFCTRL;
SDTxDMAHandler.Init.Priority=DMA_PRIORITY_VERY_HIGH;
SDTxDMAHandler.Init.FIFOMode=DMA_FIFOMODE_ENABLE;
SDTxDMAHandler.Init.FIFOThreshold=DMA_FIFO_THRESHOLD_FULL;
SDTxDMAHandler.Init.MemBurst=DMA_MBURST_INC4;
SDTxDMAHandler.Init.PeriphBurst=DMA_PBURST_INC4;
__HAL_LINKDMA(hsd, hdmatx, SDTxDMAHandler);// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>DMA<4D><41>SD<53><44><EFBFBD>ķ<EFBFBD><C4B7><EFBFBD>DMA<4D><41><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HAL_DMA_DeInit(&SDTxDMAHandler);
HAL_DMA_Init(&SDTxDMAHandler); // <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>DMA
HAL_NVIC_SetPriority(DMA2_Stream3_IRQn, 3, 0); // <20><><EFBFBD><EFBFBD>DMA<4D>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ȼ<EFBFBD>
HAL_NVIC_EnableIRQ(DMA2_Stream3_IRQn);
HAL_NVIC_SetPriority(DMA2_Stream6_IRQn, 3, 0); // <20><><EFBFBD><EFBFBD>DMA<4D>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ȼ<EFBFBD>
HAL_NVIC_EnableIRQ(DMA2_Stream6_IRQn);
#endif
}
//-----------------------------------------------------------------
// u8 SD_GetCardInfo(HAL_SD_CardInfoTypedef *cardinfo)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD>Ϣ
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: HAL_SD_CardInfoTypedef *cardinfo<66><6F><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϣ<EFBFBD><EFBFBD><E6B4A2>
// <20><> <20><> ֵ: <20><><EFBFBD><EFBFBD>״̬
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_GetCardInfo(HAL_SD_CardInfoTypedef *cardinfo)
{
u8 sta;
sta=HAL_SD_Get_CardInfo(&SDCARD_Handler,cardinfo);
return sta;
}
#if (SD_DMA_MODE==1) // DMAģʽ
//-----------------------------------------------------------------
// u8 SD_ReadBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: ͨ<><CDA8>DMA<4D><41>ȡSD<53><44>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: uint32_t *buf<75><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// uint64_t sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// uint32_t blocksize<7A><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С(һ<><EFBFBD><E3B6BC>512<31>ֽ<EFBFBD>)
// uint32_t cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><><EFBFBD><EFBFBD>״̬;0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_ReadBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt)
{
u8 err=0;
err=HAL_SD_ReadBlocks_DMA(&SDCARD_Handler,buf,sector,blocksize,cnt); // ͨ<><CDA8>DMA<4D><41>ȡSD<53><44>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(err==0)// <20><>ȡ<EFBFBD>ɹ<EFBFBD>
err=HAL_SD_CheckReadOperation(&SDCARD_Handler,(uint32_t)SD_TIMEOUT);// <20>ȴ<EFBFBD><C8B4><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
return err;
}
//-----------------------------------------------------------------
// u8 SD_ReadBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: дSD<53><44>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: uint32_t *buf<75><66>д<EFBFBD><D0B4><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// uint64_t sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// uint32_t blocksize<7A><65><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>С(һ<><EFBFBD><E3B6BC>512<31>ֽ<EFBFBD>)
// uint32_t cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><><EFBFBD><EFBFBD>״̬;0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_WriteBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt)
{
u8 err=0;
err=HAL_SD_WriteBlocks_DMA(&SDCARD_Handler,buf,sector,blocksize,cnt); // ͨ<><CDA8>DMAдSD<53><44>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(err==0)// д<>ɹ<EFBFBD>
err=HAL_SD_CheckWriteOperation(&SDCARD_Handler,(uint32_t)SD_TIMEOUT); // <20>ȴ<EFBFBD><C8B4><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>/
return err;
}
//-----------------------------------------------------------------
// u8 SD_ReadDisk(u8* buf,u32 sector,u32 cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>SD<53><44>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* buf<75><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// u32 sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// uu32 cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><><EFBFBD><EFBFBD>״̬;0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_ReadDisk(u8* buf,u32 sector,u32 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
if(SDCardInfo.CardType!=STD_CAPACITY_SD_CARD_V1_1)
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
sta=SD_ReadBlocks_DMA((uint32_t*)SDIO_DATA_BUFFER,lsector+512*n,512,1);
memcpy(buf,SDIO_DATA_BUFFER,512);
buf+=512;
}
}
else
{
sta=SD_ReadBlocks_DMA((uint32_t*)buf,lsector, 512,cnt);
}
return sta;
}
//-----------------------------------------------------------------
// u8 SD_WriteDisk(u8 *buf,u32 sector,u32 cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: дSD<53><44>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* buf<75><66>д<EFBFBD><D0B4><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// u32 sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// uu32 cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><><EFBFBD><EFBFBD>״̬;0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_WriteDisk(u8 *buf,u32 sector,u32 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
if(SDCardInfo.CardType!=STD_CAPACITY_SD_CARD_V1_1)
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
memcpy(SDIO_DATA_BUFFER,buf,512);
sta=SD_WriteBlocks_DMA((uint32_t*)SDIO_DATA_BUFFER,lsector+512*n,512,1);// <20><><EFBFBD><EFBFBD>sector<6F><72>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
buf+=512;
}
}
else
{
sta=SD_WriteBlocks_DMA((uint32_t*)buf,lsector,512,cnt);// <20><><EFBFBD><EFBFBD>sector<6F><72>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
}
return sta;
}
//-----------------------------------------------------------------
// void SDMMC1_IRQHandler(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SDMMC1<43>жϷ<D0B6><CFB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void SDMMC1_IRQHandler(void)
{
HAL_SD_IRQHandler(&SDCARD_Handler);
}
//-----------------------------------------------------------------
// void DMA2_Stream6_IRQHandler(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: DMA2<41><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD>6<EFBFBD>жϷ<D0B6><CFB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void DMA2_Stream6_IRQHandler(void)
{
HAL_DMA_IRQHandler(SDCARD_Handler.hdmatx);
}
//-----------------------------------------------------------------
// void DMA2_Stream3_IRQHandler(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: DMA2<41><32><EFBFBD><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD>жϷ<D0B6><CFB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void DMA2_Stream3_IRQHandler(void)
{
HAL_DMA_IRQHandler(SDCARD_Handler.hdmarx);
}
#else // <20><>ѵģʽ
//-----------------------------------------------------------------
// u8 SD_ReadDisk(u8* buf,u32 sector,u32 cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>SD<53><44>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* buf<75><66><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// u32 sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// u32 cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: 0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_ReadDisk(u8* buf,u32 sector,u32 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
lsector<<=9;
__disable_irq();// <20>ر<EFBFBD><D8B1><EFBFBD><EFBFBD>ж<EFBFBD>(POLLINGģʽ,<2C>Ͻ<EFBFBD><CFBD>жϴ<D0B6><CFB4><EFBFBD>SDIO<49><4F>д<EFBFBD><D0B4><EFBFBD><EFBFBD>!!!)
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
sta=HAL_SD_ReadBlocks(&SDCARD_Handler,(uint32_t*)SDIO_DATA_BUFFER,lsector+512*n,512,1);// <20><><EFBFBD><EFBFBD>sector<6F>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>
memcpy(buf,SDIO_DATA_BUFFER,512);
buf+=512;
}
}
else
{
sta=HAL_SD_ReadBlocks(&SDCARD_Handler,(uint32_t*)buf,lsector,512,cnt);// <20><><EFBFBD><EFBFBD>sector<6F>Ķ<EFBFBD><C4B6><EFBFBD><EFBFBD><EFBFBD>
}
__enable_irq();// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>
return sta;
}
//-----------------------------------------------------------------
// u8 SD_WriteDisk(u8 *buf,u32 sector,u32 cnt)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: дSD<53><44>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* buf<75><66>д<EFBFBD><D0B4><EFBFBD>ݻ<EFBFBD><DDBB><EFBFBD><EFBFBD><EFBFBD>
// u32 sector<6F><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
// u32 cnt<6E><74><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: 0,<2C><><EFBFBD><EFBFBD>;<3B><><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>;
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SD_WriteDisk(u8 *buf,u32 sector,u32 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
lsector<<=9;
__disable_irq();// <20>ر<EFBFBD><D8B1><EFBFBD><EFBFBD>ж<EFBFBD>(POLLINGģʽ,<2C>Ͻ<EFBFBD><CFBD>жϴ<D0B6><CFB4><EFBFBD>SDIO<49><4F>д<EFBFBD><D0B4><EFBFBD><EFBFBD>!!!)
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
memcpy(SDIO_DATA_BUFFER,buf,512);
sta=HAL_SD_WriteBlocks(&SDCARD_Handler,(uint32_t*)SDIO_DATA_BUFFER,lsector+512*n,512,1);// <20><><EFBFBD><EFBFBD>sector<6F><72>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
buf+=512;
}
}
else
{
sta=HAL_SD_WriteBlocks(&SDCARD_Handler,(uint32_t*)buf,lsector,512,cnt);// <20><><EFBFBD><EFBFBD>sector<6F><72>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
}
__enable_irq();// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD>
return sta;
}
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

49
HARDWARE/SDIO/sdio.h Normal file
View File

@@ -0,0 +1,49 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SD<53><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ļ<EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04) SD<53><44><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD>Ͷ<EFBFBD>д
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// ͷ<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#ifndef _SDIO_H
#define _SDIO_H
#include "stm32f429_winner.h"
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// <20><EFBFBD><EAB6A8>
//-----------------------------------------------------------------
#define SD_TIMEOUT ((uint32_t)100000000) // <20><>ʱʱ<CAB1><CAB1>
#define SD_DMA_MODE 0 // 1<><31>DMAģʽ<C4A3><CABD>0<EFBFBD><30><EFBFBD><EFBFBD>ѯģʽ
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern SD_HandleTypeDef SDCARD_Handler; // SD<53><44><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
extern HAL_SD_CardInfoTypedef SDCardInfo; // SD<53><44><EFBFBD><EFBFBD>Ϣ<EFBFBD><EFBFBD><E1B9B9>
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern u8 SD_Init(void);
extern u8 SD_GetCardInfo(HAL_SD_CardInfoTypedef *cardinfo);
extern u8 SD_ReadDisk(u8* buf,u32 sector,u32 cnt);
extern u8 SD_WriteDisk(u8 *buf,u32 sector,u32 cnt);
extern u8 SD_ReadBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt);
extern u8 SD_WriteBlocks_DMA(uint32_t *buf,uint64_t sector,uint32_t blocksize,uint32_t cnt);
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,116 +1,177 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)SDRAM<41><4D>ʼ<EFBFBD><CABC>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+Cyclone IV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// ͷ<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#include "sdram.h"
#include "delay.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/6
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------
SDRAM_HandleTypeDef SDRAM_Handler; //SDRAM<41><4D><EFBFBD><EFBFBD>
//SDRAM<EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void SDRAM_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SDRAM<41><4D>ʼ<EFBFBD><CABC>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void SDRAM_Init(void)
{
FMC_SDRAM_TimingTypeDef SDRAM_Timing;
SDRAM_Handler.Instance=FMC_SDRAM_DEVICE; //SDRAM<EFBFBD><EFBFBD>BANK5,6
SDRAM_Handler.Init.SDBank=FMC_SDRAM_BANK1; //SDRAM<41><4D><EFBFBD><EFBFBD>BANK5<EFBFBD><EFBFBD>
SDRAM_Handler.Init.ColumnBitsNumber=FMC_SDRAM_COLUMN_BITS_NUM_9; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Handler.Init.RowBitsNumber=FMC_SDRAM_ROW_BITS_NUM_13; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Handler.Init.MemoryDataWidth=FMC_SDRAM_MEM_BUS_WIDTH_16; //<2F><><EFBFBD>ݿ<EFBFBD><DDBF><EFBFBD>Ϊ16λ
SDRAM_Handler.Init.InternalBankNumber=FMC_SDRAM_INTERN_BANKS_NUM_4; //һ<><D2BB>4<EFBFBD><34>BANK
SDRAM_Handler.Init.CASLatency=FMC_SDRAM_CAS_LATENCY_3; //CASΪ3
SDRAM_Handler.Init.WriteProtection=FMC_SDRAM_WRITE_PROTECTION_DISABLE;//ʧ<><CAA7>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
SDRAM_Handler.Init.SDClockPeriod=FMC_SDRAM_CLOCK_PERIOD_2; //SDRAMʱ<4D><CAB1>ΪHCLK/2=180M/2=90M=11.1ns
SDRAM_Handler.Init.ReadBurst=FMC_SDRAM_RBURST_ENABLE; //ʹ<EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD>
SDRAM_Handler.Init.ReadPipeDelay=FMC_SDRAM_RPIPE_DELAY_1; //<2F><>ͨ<EFBFBD><CDA8><EFBFBD><EFBFBD>ʱ
SDRAM_Timing.LoadToActiveDelay=2; //<2F><><EFBFBD><EFBFBD>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.ExitSelfRefreshDelay=8; //<2F>˳<EFBFBD><EFBFBD><EFBFBD>ˢ<EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ8<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.SelfRefreshTime=6; //<2F><>ˢ<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD>Ϊ6<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RowCycleDelay=6; //<2F><>ѭ<EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ6<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.WriteRecoveryTime=2; //<2F>ָ<EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RPDelay=2; //<EFBFBD><EFBFBD>Ԥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RCDDelay=2; //<2F>е<EFBFBD><D0B5><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<CEAA><32>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HAL_SDRAM_Init(&SDRAM_Handler,&SDRAM_Timing);
SDRAM_Initialization_Sequence(&SDRAM_Handler);//<2F><><EFBFBD><EFBFBD>SDRAM<41><4D>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
FMC_SDRAM_TimingTypeDef SDRAM_Timing;
SDRAM_Handler.Instance=FMC_SDRAM_DEVICE; // SDRAM<41>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
SDRAM_Handler.Init.SDBank=FMC_SDRAM_BANK1; // <20><>һ<EFBFBD><D2BB>SDRAM BANK
SDRAM_Handler.Init.ColumnBitsNumber=FMC_SDRAM_COLUMN_BITS_NUM_10; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Handler.Init.RowBitsNumber=FMC_SDRAM_ROW_BITS_NUM_13; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Handler.Init.MemoryDataWidth=FMC_SDRAM_MEM_BUS_WIDTH_16; // <EFBFBD><EFBFBD><EFBFBD>ݿ<EFBFBD><EFBFBD><EFBFBD>Ϊ16λ
SDRAM_Handler.Init.InternalBankNumber=FMC_SDRAM_INTERN_BANKS_NUM_4; // һ<><D2BB>4<EFBFBD><34>BANK
SDRAM_Handler.Init.CASLatency=FMC_SDRAM_CAS_LATENCY_3; // CASΪ3
SDRAM_Handler.Init.WriteProtection=FMC_SDRAM_WRITE_PROTECTION_DISABLE;// ʧ<><CAA7>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
SDRAM_Handler.Init.SDClockPeriod=FMC_SDRAM_CLOCK_PERIOD_2; // SDRAMʱ<4D><CAB1>ΪHCLK/2=180M/2=90M=11.1ns
SDRAM_Handler.Init.ReadBurst=FMC_SDRAM_RBURST_ENABLE; // ʹ<><CAB9>ͻ<EFBFBD><CDBB>
SDRAM_Handler.Init.ReadPipeDelay=FMC_SDRAM_RPIPE_DELAY_1; // <20><>ͨ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ
SDRAM_Timing.LoadToActiveDelay=2; // <20><><EFBFBD><EFBFBD>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<CEAA><32>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.ExitSelfRefreshDelay=8; // <20>˳<EFBFBD><CBB3><EFBFBD>ˢ<EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ8<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.SelfRefreshTime=6; // <EFBFBD><EFBFBD>ˢ<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD>Ϊ6<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RowCycleDelay=6; // <EFBFBD><EFBFBD>ѭ<EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ6<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.WriteRecoveryTime=2; // <20>ָ<EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RPDelay=2; // <20><>Ԥ<EFBFBD><D4A4><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Timing.RCDDelay=2; // <20>е<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӳ<EFBFBD>Ϊ2<EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
HAL_SDRAM_Init(&SDRAM_Handler,&SDRAM_Timing);
SDRAM_Initialization_Sequence(&SDRAM_Handler);// <20><><EFBFBD><EFBFBD>SDRAM<41><4D>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// ˢ<><CBA2>Ƶ<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD>(<28><>SDCLKƵ<4B>ʼ<EFBFBD><CABC><EFBFBD>),<2C><><EFBFBD><EFBFBD><E3B7BD>:
// COUNT=SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD>-20=SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(us)*SDCLKƵ<4B><C6B5>(Mhz)/<2F><><EFBFBD><EFBFBD>
// <20><><EFBFBD><EFBFBD>ʹ<EFBFBD>õ<EFBFBD>SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ64ms,SDCLK=180/2=90Mhz,<2C><><EFBFBD><EFBFBD>Ϊ8192(2^13).
// <20><><EFBFBD><EFBFBD>,COUNT=64*1000*90/8192-20=683
HAL_SDRAM_ProgramRefreshRate(&SDRAM_Handler,683);// <20><><EFBFBD><EFBFBD>ˢ<EFBFBD><CBA2>Ƶ<EFBFBD><C6B5>
}
//<2F><><EFBFBD><EFBFBD>SDRAM<41><4D>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>SDRAM<41><4D>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: SDRAM_HandleTypeDef *hsdram<61><6D>SDRAM<41><4D><EFBFBD><EFBFBD>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram)
{
u32 temp=0;
//SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ժ<EFBFBD><D4BA><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD><CBB3><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>SDRAM
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_CLK_ENABLE,1,0); //ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>
delay_us(500); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ200us
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_PALL,1,0); //<2F><><EFBFBD><EFBFBD><EFBFBD>д洢<D0B4><E6B4A2>Ԥ<EFBFBD><D4A4><EFBFBD><EFBFBD>
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_AUTOREFRESH_MODE,8,0);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˢ<EFBFBD>´<EFBFBD><C2B4><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD>,SDRAM<41><4D>bit0~bit2Ϊָ<CEAA><D6B8>ͻ<EFBFBD><CDBB><EFBFBD><EFBFBD><EFBFBD>ʵij<CAB5><C4B3>ȣ<EFBFBD>
//bit3Ϊָ<CEAA><D6B8>ͻ<EFBFBD><CDBB><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD>ͣ<EFBFBD>bit4~bit6ΪCASֵ<53><D6B5>bit7<74><37>bit8Ϊ<38><CEAA><EFBFBD><EFBFBD>ģʽ
//bit9Ϊָ<CEAA><D6B8><EFBFBD><EFBFBD>дͻ<D0B4><CDBB>ģʽ<C4A3><CABD>bit10<31><30>bit11λ<31><CEBB><EFBFBD><EFBFBD>λ
temp=(u32)SDRAM_MODEREG_BURST_LENGTH_1 | //<2F><><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:1(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1/2/4/8)
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL | //<2F><><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:<3A><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD>)
SDRAM_MODEREG_CAS_LATENCY_3 | //<2F><><EFBFBD><EFBFBD>CASֵ:3(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2/3)
SDRAM_MODEREG_OPERATING_MODE_STANDARD | //<2F><><EFBFBD>ò<EFBFBD><C3B2><EFBFBD>ģʽ:0,<2C><>׼ģʽ
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE; //<2F><><EFBFBD><EFBFBD>ͻ<EFBFBD><CDBB>дģʽ:1,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_LOAD_MODE,1,temp); //<2F><><EFBFBD><EFBFBD>SDRAM<41><4D>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD>
//ˢ<><CBA2>Ƶ<EFBFBD>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD>(<28><>SDCLKƵ<4B>ʼ<EFBFBD><CABC><EFBFBD>),<2C><><EFBFBD><EFBFBD><E3B7BD>:
//COUNT=SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD>-20=SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>(us)*SDCLKƵ<4B><C6B5>(Mhz)/<2F><><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ʹ<EFBFBD>õ<EFBFBD>SDRAMˢ<4D><CBA2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ64ms,SDCLK=180/2=90Mhz,<2C><><EFBFBD><EFBFBD>Ϊ8192(2^13).
//<2F><><EFBFBD><EFBFBD>,COUNT=64*1000*90/8192-20=683
HAL_SDRAM_ProgramRefreshRate(&SDRAM_Handler,683);
u32 temp=0;
// SDRAM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ժ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ҫ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˳<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>SDRAM
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_CLK_ENABLE,1,0); // ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><EFBFBD>
delay_us(500); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ200us
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_PALL,1,0); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д洢<EFBFBD><EFBFBD>Ԥ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_AUTOREFRESH_MODE,8,0);// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ˢ<EFBFBD>´<EFBFBD><EFBFBD><EFBFBD>
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>,SDRAM<41><4D>bit0~bit2Ϊָ<CEAA><D6B8>ͻ<EFBFBD><CDBB><EFBFBD><EFBFBD><EFBFBD>ʵij<CAB5><C4B3>ȣ<EFBFBD>
// bit3Ϊָ<EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͣ<EFBFBD>bit4~bit6ΪCASֵ<53><D6B5>bit7<74><37>bit8Ϊ<38><CEAA><EFBFBD><EFBFBD>ģʽ
// bit9Ϊָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>дͻ<EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD>bit10<EFBFBD><EFBFBD>bit11λ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ
temp=(u32)SDRAM_MODEREG_BURST_LENGTH_1 | // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:1(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>1/2/4/8)
SDRAM_MODEREG_BURST_TYPE_SEQUENTIAL | // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:<3A><><EFBFBD><EFBFBD>(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>/<2F><><EFBFBD><EFBFBD>)
SDRAM_MODEREG_CAS_LATENCY_3 | // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>CASֵ:3(<28><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>2/3)
SDRAM_MODEREG_OPERATING_MODE_STANDARD | // <EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><EFBFBD><EFBFBD>ģʽ:0,<2C><>׼ģʽ
SDRAM_MODEREG_WRITEBURST_MODE_SINGLE; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͻ<EFBFBD><EFBFBD>дģʽ:1,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SDRAM_Send_Cmd(0,FMC_SDRAM_CMD_LOAD_MODE,1,temp); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>SDRAM<EFBFBD><EFBFBD>ģʽ<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>
}
//SDRAM<41>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>ʱ<EFBFBD><CAB1>ʹ<EFBFBD><CAB9>
//<2F>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>ᱻHAL_SDRAM_Init()<29><><EFBFBD><EFBFBD>
//hsdram:SDRAM<41><4D><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SDRAM<41>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ã<EFBFBD>ʱ<EFBFBD><CAB1>ʹ<EFBFBD><CAB9>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: SDRAM_HandleTypeDef *hsdram<61><6D>SDRAM<41><4D><EFBFBD><EFBFBD>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>ᱻHAL_SDRAM_Init()<29><><EFBFBD><EFBFBD>
// SDS_D0 -> PD14 SDS_A0 -> PF0
// SDS_D1 -> PD15 SDS_A1 -> PF1
// SDS_D2 -> PD0 SDS_A2 -> PF2
// SDS_D3 -> PD1 SDS_A3 -> PF3
// SDS_D4 -> PE7 SDS_A4 -> PF4
// SDS_D5 -> PE8 SDS_A5 -> PF5
// SDS_D6 -> PE9 SDS_A6 -> PF12
// SDS_D7 -> PE10 SDS_A7 -> PF13
// SDS_D8 -> PE11 SDS_A8 -> PF14
// SDS_D9 -> PE12 SDS_A9 -> PF15
// SDS_D10 -> PE13 SDS_A10 -> PG0
// SDS_D11 -> PE14 SDS_A11 -> PG1
// SDS_D12 -> PE15 SDS_A12 -> PG2
// SDS_D13 -> PD8
// SDS_D14 -> PD9
// SDS_D15 -> PD10
//
// SDS_SDNWE -> PH5 SDS_BA0 -> PG4
// SDS_SDNCAS -> PG15 SDS_BA1 -> PG5
// SDS_SDNRAS -> PF11 SDS_NBL0 -> PE0
// SDS_SDNE0 -> PH3 SDS_NBL1 -> PE1
// SDS_SDCKE0 -> PH2 SDS_SDCLK -> PG8
//
//-----------------------------------------------------------------
void HAL_SDRAM_MspInit(SDRAM_HandleTypeDef *hsdram)
{
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_FMC_CLK_ENABLE(); //ʹ<><CAB9>FMCʱ<43><CAB1>
__HAL_RCC_GPIOC_CLK_ENABLE(); //ʹ<><CAB9>GPIOCʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOD_CLK_ENABLE(); //ʹ<><CAB9>GPIODʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOE_CLK_ENABLE(); //ʹ<><CAB9>GPIOEʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOF_CLK_ENABLE(); //ʹ<><CAB9>GPIOFʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOG_CLK_ENABLE(); //ʹ<><CAB9>GPIOGʱ<EFBFBD><EFBFBD>
__HAL_RCC_FMC_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>FMCʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOD_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>GPIODʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOE_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>GPIOEʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOF_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>GPIOFʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOG_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>GPIOGʱ<EFBFBD><EFBFBD>
__HAL_RCC_GPIOH_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>GPIOHʱ<EFBFBD><EFBFBD>
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_2|GPIO_PIN_3;
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //<2F><><EFBFBD><EFBFBD><ECB8B4>
GPIO_Initure.Pull=GPIO_PULLUP; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=GPIO_AF12_FMC; //<2F><><EFBFBD><EFBFBD>ΪFMC
HAL_GPIO_Init(GPIOC,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>PC0,2,3
GPIO_Initure.Pin=GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_5;
GPIO_Initure.Mode=GPIO_MODE_AF_PP; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=GPIO_AF12_FMC; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ΪFMC
HAL_GPIO_Init(GPIOH,&GPIO_Initure); // <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>PH2,3,5
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_14|GPIO_PIN_15;
HAL_GPIO_Init(GPIOD,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>PD0,1,8,9,10,14,15
HAL_GPIO_Init(GPIOD,&GPIO_Initure); // <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>PD0,1,8,9,10,14,15
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10| GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
HAL_GPIO_Init(GPIOE,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>PE0,1,7,8,9,10,11,12,13,14,15
HAL_GPIO_Init(GPIOE,&GPIO_Initure); // <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>PE0,1,7,8,9,10,11,12,13,14,15
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_3|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15;
HAL_GPIO_Init(GPIOF,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>PF0,1,2,3,4,5,11,12,13,14,15
HAL_GPIO_Init(GPIOF,&GPIO_Initure); // <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>PF0,1,2,3,4,5,11,12,13,14,15
GPIO_Initure.Pin=GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2|GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_8|GPIO_PIN_15;
HAL_GPIO_Init(GPIOG,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>PG0,1,2,4,5,8,15
HAL_GPIO_Init(GPIOG,&GPIO_Initure); // <EFBFBD><EFBFBD>ʼ<EFBFBD><EFBFBD>PG0,1,2,4,5,8,15
}
//<EFBFBD><EFBFBD>SDRAM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//bankx:0,<2C><>BANK5<4B><35><EFBFBD><EFBFBD><EFBFBD><EFBFBD>SDRAM<41><4D><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
// 1,<2C><>BANK6<4B><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>SDRAM<41><4D><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
//cmd:ָ<><D6B8>(0,<2C><><EFBFBD><EFBFBD>ģʽ/1,ʱ<><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>/2,Ԥ<><D4A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д洢<D0B4><E6B4A2>/3,<2C>Զ<EFBFBD>ˢ<EFBFBD><CBA2>/4,<2C><><EFBFBD><EFBFBD>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD>/5,<2C><>ˢ<EFBFBD><CBA2>/6,<2C><><EFBFBD><EFBFBD>)
//refresh:<3A><>ˢ<EFBFBD>´<EFBFBD><EFBFBD><EFBFBD>
//regval:ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD>Ķ<EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ֵ:0,<2C><><EFBFBD><EFBFBD>;1,ʧ<EFBFBD><EFBFBD>.
//-----------------------------------------------------------------
// u8 SDRAM_Send_Cmd(u8 bankx,u8 cmd,u8 refresh,u16 regval)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 bankx<6B><78>0,<2C><>BANK5<4B><35><EFBFBD><EFBFBD><EFBFBD><EFBFBD>SDRAM<41><4D><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8> 1,<2C><>BANK6<4B><36><EFBFBD><EFBFBD><EFBFBD><EFBFBD>SDRAM<41><4D><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD>
// u8 cmd<EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD>(0,<2C><><EFBFBD><EFBFBD>ģʽ/1,ʱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><EFBFBD>/2,Ԥ<><D4A4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д洢<D0B4><E6B4A2>/3,<2C>Զ<EFBFBD>ˢ<EFBFBD><CBA2>/4,<2C><><EFBFBD><EFBFBD>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD>/5,<2C><>ˢ<EFBFBD><CBA2>/6,<2C><><EFBFBD><EFBFBD>)
// u8 refresh<73><68><EFBFBD><EFBFBD>ˢ<EFBFBD>´<EFBFBD><C2B4><EFBFBD>
// u16 regval<61><6C>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD>Ķ<EFBFBD><C4B6><EFBFBD>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: 0,<2C><><EFBFBD><EFBFBD>;1,ʧ<><CAA7>.
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
u8 SDRAM_Send_Cmd(u8 bankx,u8 cmd,u8 refresh,u16 regval)
{
u32 target_bank=0;
@@ -118,21 +179,29 @@ u8 SDRAM_Send_Cmd(u8 bankx,u8 cmd,u8 refresh,u16 regval)
if(bankx==0) target_bank=FMC_SDRAM_CMD_TARGET_BANK1;
else if(bankx==1) target_bank=FMC_SDRAM_CMD_TARGET_BANK2;
Command.CommandMode=cmd; //<2F><><EFBFBD><EFBFBD>
Command.CommandTarget=target_bank; //Ŀ<><C4BF>SDRAM<41><EFBFBD><E6B4A2><EFBFBD><EFBFBD>
Command.AutoRefreshNumber=refresh; //<2F><>ˢ<EFBFBD>´<EFBFBD><C2B4><EFBFBD>
Command.ModeRegisterDefinition=regval; //Ҫд<D2AA><D0B4>ģʽ<C4A3>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>ֵ
if(HAL_SDRAM_SendCommand(&SDRAM_Handler,&Command,0X1000)==HAL_OK) //<2F><>SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Command.CommandMode=cmd; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Command.CommandTarget=target_bank; // Ŀ<EFBFBD><EFBFBD>SDRAM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
Command.AutoRefreshNumber=refresh; // <EFBFBD><EFBFBD>ˢ<EFBFBD>´<EFBFBD><EFBFBD><EFBFBD>
Command.ModeRegisterDefinition=regval; // Ҫд<EFBFBD><EFBFBD>ģʽ<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
if(HAL_SDRAM_SendCommand(&SDRAM_Handler,&Command,0X1000)==HAL_OK) // <EFBFBD><EFBFBD>SDRAM<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
return 0;
}
else return 1;
}
//<EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ(WriteAddr+Bank5_SDRAM_ADDR)<29><>ʼ,<2C><><EFBFBD><EFBFBD>д<EFBFBD><D0B4>n<EFBFBD><6E><EFBFBD>ֽ<EFBFBD>.
//pBuffer:<3A>ֽ<EFBFBD>ָ<EFBFBD><D6B8>
//WriteAddr:Ҫд<D2AA><D0B4><EFBFBD>ĵ<EFBFBD>ַ
//n:Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
//-----------------------------------------------------------------
// void FMC_SDRAM_WriteBuffer(u8 *pBuffer,u32 WriteAddr,u32 n)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ(WriteAddr+Bank5_SDRAM_ADDR)<29><>ʼ,<2C><><EFBFBD><EFBFBD>д<EFBFBD><D0B4>n<EFBFBD><6E><EFBFBD>ֽ<EFBFBD>.
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 *pBuffer<65><72><EFBFBD>ֽ<EFBFBD>ָ<EFBFBD><D6B8>
// u32 WriteAddr<64><72>Ҫд<D2AA><D0B4><EFBFBD>ĵ<EFBFBD>ַ
// u32 n<><6E>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: 0,<2C><><EFBFBD><EFBFBD>;1,ʧ<><CAA7>.
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void FMC_SDRAM_WriteBuffer(u8 *pBuffer,u32 WriteAddr,u32 n)
{
for(;n!=0;n--)
@@ -143,10 +212,18 @@ void FMC_SDRAM_WriteBuffer(u8 *pBuffer,u32 WriteAddr,u32 n)
}
}
//<EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ((WriteAddr+Bank5_SDRAM_ADDR))<29><>ʼ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>n<EFBFBD><6E><EFBFBD>ֽ<EFBFBD>.
//pBuffer:<3A>ֽ<EFBFBD>ָ<EFBFBD><D6B8>
//ReadAddr:Ҫ<><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>ַ
//n:Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
//-----------------------------------------------------------------
// void FMC_SDRAM_ReadBuffer(u8 *pBuffer,u32 ReadAddr,u32 n)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ(ReadAddr+Bank5_SDRAM_ADDR)<29><>ʼ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>n<EFBFBD><6E><EFBFBD>ֽ<EFBFBD>.
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 *pBuffer<65><72><EFBFBD>ֽ<EFBFBD>ָ<EFBFBD><D6B8>
// u32 ReadAddr<64><72>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʼ<EFBFBD><CABC>ַ
// u32 n<><6E>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
// <20><><EFBFBD>ز<EFBFBD><D8B2><EFBFBD>: 0,<2C><><EFBFBD><EFBFBD>;1,ʧ<><CAA7>.
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void FMC_SDRAM_ReadBuffer(u8 *pBuffer,u32 ReadAddr,u32 n)
{
for(;n!=0;n--)
@@ -155,3 +232,7 @@ void FMC_SDRAM_ReadBuffer(u8 *pBuffer,u32 ReadAddr,u32 n)
ReadAddr++;
}
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,22 +1,30 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ļ<EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)SDRAM<41><4D>ʼ<EFBFBD><CABC>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+Cyclone IV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
#ifndef _SDRAM_H
#define _SDRAM_H
#include "sys.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD>ѧϰʹ<EFBFBD>ã<EFBFBD>δ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><EFBFBD><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//SDRAM<41><4D><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ԭ<EFBFBD><EFBFBD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/6
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
extern SDRAM_HandleTypeDef SDRAM_Handler;//SDRAM<41><4D><EFBFBD><EFBFBD>
#define Bank5_SDRAM_ADDR ((u32)(0XC0000000)) //SDRAM<41><4D>ʼ<EFBFBD><CABC>ַ
#include "stm32f429_winner.h"
//-----------------------------------------------------------------
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern SDRAM_HandleTypeDef SDRAM_Handler;// SDRAM<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// <20><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#define Bank5_SDRAM_ADDR ((u32)(0XC0000000)) // SDRAM<41><4D>ʼ<EFBFBD><CABC>ַ
//SDRAM<41><4D><EFBFBD>ò<EFBFBD><C3B2><EFBFBD>
// SDRAM<EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><EFBFBD><EFBFBD>
#define SDRAM_MODEREG_BURST_LENGTH_1 ((u16)0x0000)
#define SDRAM_MODEREG_BURST_LENGTH_2 ((u16)0x0001)
#define SDRAM_MODEREG_BURST_LENGTH_4 ((u16)0x0002)
@@ -29,10 +37,16 @@ extern SDRAM_HandleTypeDef SDRAM_Handler;//SDRAM
#define SDRAM_MODEREG_WRITEBURST_MODE_PROGRAMMED ((u16)0x0000)
#define SDRAM_MODEREG_WRITEBURST_MODE_SINGLE ((u16)0x0200)
void SDRAM_Init(void);
void SDRAM_MPU_Config(void);
u8 SDRAM_Send_Cmd(u8 bankx,u8 cmd,u8 refresh,u16 regval);
void FMC_SDRAM_WriteBuffer(u8 *pBuffer,u32 WriteAddr,u32 n);
void FMC_SDRAM_ReadBuffer(u8 *pBuffer,u32 ReadAddr,u32 n);
void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram);
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern void SDRAM_Init(void);
extern void SDRAM_MPU_Config(void);
extern u8 SDRAM_Send_Cmd(u8 bankx,u8 cmd,u8 refresh,u16 regval);
extern void FMC_SDRAM_WriteBuffer(u8 *pBuffer,u32 WriteAddr,u32 n);
extern void FMC_SDRAM_ReadBuffer(u8 *pBuffer,u32 ReadAddr,u32 n);
extern void SDRAM_Initialization_Sequence(SDRAM_HandleTypeDef *hsdram);
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,81 +1,164 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SPI<50><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)LED IO <20><><EFBFBD><EFBFBD>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// ͷ<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#include "spi.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//SPI<50><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/16/16
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------
SPI_HandleTypeDef SPI5_Handler; //SPI<50><49><EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>SPIģ<EFBFBD><EFBFBD><EFBFBD>ij<EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ
//SPI<EFBFBD>ڳ<EFBFBD>ʼ<EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƕ<EFBFBD>SPI5<EFBFBD>ij<EFBFBD>ʼ<EFBFBD><EFBFBD>
void SPI5_Init(void)
SPI_HandleTypeDef SPI_Handler; // SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi);
//-----------------------------------------------------------------
// void SPI_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SPI<50><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD>ģʽ
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void SPI_Init(void)
{
SPI5_Handler.Instance=SPI5; //SP5
SPI5_Handler.Init.Mode=SPI_MODE_MASTER; //<2F><><EFBFBD><EFBFBD>SPI<50><49><EFBFBD><EFBFBD>ģʽ<C4A3><CABD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><CEAA>ģʽ
SPI5_Handler.Init.Direction=SPI_DIRECTION_2LINES; //<2F><><EFBFBD><EFBFBD>SPI<50><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˫<EFBFBD><CBAB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ:SPI<50><49><EFBFBD><EFBFBD>Ϊ˫<CEAA><CBAB>ģʽ
SPI5_Handler.Init.DataSize=SPI_DATASIZE_8BIT; //<2F><><EFBFBD><EFBFBD>SPI<50><49><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD>С:SPI<50><49><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD>8λ֡<EFBFBD>
SPI5_Handler.Init.CLKPolarity=SPI_POLARITY_HIGH; //<2F><><EFBFBD><EFBFBD>ͬ<EFBFBD><CDAC>ʱ<EFBFBD>ӵĿ<D3B5><C4BF><EFBFBD>״̬Ϊ<CCAC>ߵ<EFBFBD>ƽ
SPI5_Handler.Init.CLKPhase=SPI_PHASE_2EDGE; //<2F><><EFBFBD><EFBFBD>ͬ<EFBFBD><CDAC>ʱ<EFBFBD>ӵĵڶ<C4B5><DAB6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD><D8A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>½<EFBFBD><C2BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݱ<EFBFBD><DDB1><EFBFBD><EFBFBD><EFBFBD>
SPI5_Handler.Init.NSS=SPI_NSS_SOFT; //NSS<53>ź<EFBFBD><C5BA><EFBFBD>Ӳ<EFBFBD><D3B2><EFBFBD><EFBFBD>NSS<53>ܽţ<DCBD><C5A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><CAB9>SSIλ<49><CEBB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:<3A>ڲ<EFBFBD>NSS<53>ź<EFBFBD><C5BA><EFBFBD>SSIλ<49><CEBB><EFBFBD><EFBFBD>
SPI5_Handler.Init.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_256;//<2F><><EFBFBD><EFBFBD><E5B2A8><EFBFBD><EFBFBD>Ԥ<EFBFBD><D4A4>Ƶ<EFBFBD><C6B5>ֵ:<3A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԥ<EFBFBD><D4A4>ƵֵΪ256
SPI5_Handler.Init.FirstBit=SPI_FIRSTBIT_MSB; //ָ<><D6B8><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD><DDB4><EFBFBD><EFBFBD><EFBFBD>MSBλ<42><CEBB><EFBFBD><EFBFBD>LSBλ<42><CEBB>ʼ:<3A><><EFBFBD>ݴ<EFBFBD><DDB4><EFBFBD><EFBFBD><EFBFBD>MSBλ<42><CEBB>ʼ
SPI5_Handler.Init.TIMode=SPI_TIMODE_DISABLE; //<2F>ر<EFBFBD>TIģʽ
SPI5_Handler.Init.CRCCalculation=SPI_CRCCALCULATION_DISABLE;//<2F>ر<EFBFBD>Ӳ<EFBFBD><D3B2>CRCУ<43><D0A3>
SPI5_Handler.Init.CRCPolynomial=7; //CRCֵ<43><D6B5><EFBFBD><EFBFBD><EFBFBD>Ķ<EFBFBD><C4B6><EFBFBD>ʽ
HAL_SPI_Init(&SPI5_Handler);
__HAL_SPI_ENABLE(&SPI5_Handler); //ʹ<><CAB9>SPI5
SPI5_ReadWriteByte(0Xff); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI_Handler.Instance=SPIx; // SP4
SPI_Handler.Init.Mode=SPI_MODE_MASTER; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ<EFBFBD><EFBFBD>ģʽ
SPI_Handler.Init.Direction=SPI_DIRECTION_2LINES; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˫<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ:SPI<50><49><EFBFBD><EFBFBD>Ϊ˫<CEAA><CBAB>ģʽ
SPI_Handler.Init.DataSize=SPI_DATASIZE_8BIT; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD>С:SPI<50><49><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD>16λ֡<EFBFBD>
SPI_Handler.Init.CLKPolarity=SPI_POLARITY_HIGH; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬ<EFBFBD><EFBFBD>ʱ<EFBFBD>ӵĿ<EFBFBD><EFBFBD><EFBFBD>״̬Ϊ<EFBFBD>ߵ<EFBFBD>ƽ
SPI_Handler.Init.CLKPhase=SPI_PHASE_2EDGE; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͬ<EFBFBD><EFBFBD>ʱ<EFBFBD>ӵĵڶ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>أ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>½<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݱ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI_Handler.Init.NSS=SPI_NSS_SOFT; // NSS<EFBFBD>ź<EFBFBD><EFBFBD><EFBFBD>Ӳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>NSS<EFBFBD>ܽţ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʹ<EFBFBD><EFBFBD>SSIλ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:<3A>ڲ<EFBFBD>NSS<53>ź<EFBFBD><C5BA><EFBFBD>SSIλ<49><CEBB><EFBFBD><EFBFBD>
SPI_Handler.Init.BaudRatePrescaler=SPI_BAUDRATEPRESCALER_4;//<2F><><EFBFBD><EFBFBD><E5B2A8><EFBFBD><EFBFBD>Ԥ<EFBFBD><D4A4>Ƶ<EFBFBD><C6B5>ֵ:<3A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ԥ<EFBFBD><D4A4>ƵֵΪ2,<2C><><EFBFBD><EFBFBD>Ϊ45Mʱ<4D><CAB1>,<2C><><EFBFBD><EFBFBD>ģʽ
SPI_Handler.Init.FirstBit=SPI_FIRSTBIT_MSB; // ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>MSBλ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>LSBλ<EFBFBD><EFBFBD>ʼ:<3A><><EFBFBD>ݴ<EFBFBD><DDB4><EFBFBD><EFBFBD><EFBFBD>MSBλ<42><CEBB>ʼ
SPI_Handler.Init.TIMode=SPI_TIMODE_DISABLE; // <EFBFBD>ر<EFBFBD>TIģʽ
SPI_Handler.Init.CRCCalculation=SPI_CRCCALCULATION_DISABLE;// <EFBFBD>ر<EFBFBD>Ӳ<EFBFBD><EFBFBD>CRCУ<EFBFBD><EFBFBD>
SPI_Handler.Init.CRCPolynomial=7; // CRCֵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ķ<EFBFBD><EFBFBD><EFBFBD>ʽ
if (HAL_SPI_Init(&SPI_Handler) != HAL_OK) //<2F><>ʼ<EFBFBD><CABC>
{
Error_Handler();
}
__HAL_SPI_ENABLE(&SPI_Handler); // ʹ<><CAB9>SPI4
}
//SPI5<EFBFBD>ײ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD>ʹ<EFBFBD>ܣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<EFBFBD>˺<EFBFBD><EFBFBD><EFBFBD><EFBFBD>HAL_SPI_Init()<29><><EFBFBD><EFBFBD>
//hspi:SPI<50><49><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SPI<50>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>ʹ<EFBFBD>ܣ<EFBFBD><DCA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: SPI_HandleTypeDef *hspi<70><69>SPI<50><49><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>ᱻHAL_SPI_Init()<29><><EFBFBD><EFBFBD>
//
//-----------------------------------------------------------------
void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_GPIOF_CLK_ENABLE(); //ʹ<><CAB9>GPIOFʱ<EFBFBD><EFBFBD>
__HAL_RCC_SPI5_CLK_ENABLE(); //ʹ<><CAB9>SPI5ʱ<EFBFBD><EFBFBD>
//PF7,8,9
GPIO_Initure.Pin=GPIO_PIN_7|GPIO_PIN_8|GPIO_PIN_9;
GPIO_Initure.Mode=GPIO_MODE_AF_PP; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_FAST; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=GPIO_AF5_SPI5; //<2F><><EFBFBD><EFBFBD>ΪSPI5
HAL_GPIO_Init(GPIOF,&GPIO_Initure);
GPIO_InitTypeDef GPIO_Initure;
SPI_MISO_GPIO_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>SPI_MISO<EFBFBD><EFBFBD>GPIOʱ<EFBFBD><EFBFBD>
SPI_MOSI_GPIO_CLK_ENABLE(); // ʹ<EFBFBD><EFBFBD>SPI_MOSI<EFBFBD><EFBFBD>GPIOʱ<EFBFBD><EFBFBD>
SPI_CLK_GPIO_CLK_ENABLE(); // ʹ<><CAB9>SPI_CLK<4C><4B>GPIOʱ<4F><CAB1>
SPI_CS_GPIO_CLK_ENABLE(); // ʹ<><CAB9>SPI_CS<43><53>GPIOʱ<4F><CAB1>
__HAL_RCC_GPIOD_CLK_ENABLE(); // ʹ<><CAB9>PD11
SPI_CLK_ENABLE(); // ʹ<><CAB9>SPI4ʱ<EFBFBD><EFBFBD>
GPIO_Initure.Pin = SPI_CS_PIN; //PE4 -> SPI4_CS
GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull = GPIO_NOPULL; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH; //<2F><><EFBFBD><EFBFBD>ģʽ
HAL_GPIO_Init(SPI_CS_GPIO_PORT, &GPIO_Initure);
GPIO_Initure.Pin = GPIO_PIN_11; //PD11 -> SPIʹ<49><CAB9><EFBFBD>źţ<C5BA><C5A3><EFBFBD>fpga<67>˵<EFBFBD>Լ<EFBFBD><D4BC><EFBFBD><EFBFBD>
GPIO_Initure.Mode = GPIO_MODE_OUTPUT_PP; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull = GPIO_PULLUP; //<2F><><EFBFBD><EFBFBD>ģʽ
GPIO_Initure.Speed = GPIO_SPEED_FREQ_HIGH; //<2F><><EFBFBD><EFBFBD>ģʽ
HAL_GPIO_Init(GPIOD, &GPIO_Initure);
GPIO_Initure.Pin=SPI_MISO_PIN; // PE5 -> SPI4_MISO
GPIO_Initure.Mode=GPIO_MODE_AF_PP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=SPI_MISO_AF; // <20><><EFBFBD><EFBFBD>ΪSPI4
HAL_GPIO_Init(SPI_MISO_GPIO_PORT,&GPIO_Initure);
GPIO_Initure.Pin=SPI_MOSI_PIN; // PE6 -> SPI4_MOSI
GPIO_Initure.Mode=GPIO_MODE_AF_PP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=SPI_MOSI_AF; // <20><><EFBFBD><EFBFBD>ΪSPI4
HAL_GPIO_Init(SPI_MOSI_GPIO_PORT,&GPIO_Initure);
GPIO_Initure.Pin=SPI_CLK_PIN; // PE2 -> SPI4_SCK
GPIO_Initure.Mode=GPIO_MODE_AF_PP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_HIGH; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Alternate=SPI_CLK_AF; // <20><><EFBFBD><EFBFBD>ΪSPI4
HAL_GPIO_Init(SPI_CLK_GPIO_PORT,&GPIO_Initure);
//<2F><>ʼ<EFBFBD>ߵ<EFBFBD>ƽ
HAL_GPIO_WritePin(SPI_CS_GPIO_PORT, SPI_CS_PIN, GPIO_PIN_SET);
}
//SPI<EFBFBD>ٶ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ú<EFBFBD><EFBFBD><EFBFBD>
//SPI<EFBFBD>ٶ<EFBFBD>=fAPB1/<2F><>Ƶϵ<C6B5><CFB5>
//@ref SPI_BaudRate_Prescaler:SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_2 256
//fAPB1ʱ<EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD>Ϊ45Mhz<EFBFBD><EFBFBD>
void SPI5_SetSpeed(u8 SPI_BaudRatePrescaler)
//-----------------------------------------------------------------
// void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SPI<50>ٶ<EFBFBD><D9B6><EFBFBD><EFBFBD>ú<EFBFBD><C3BA><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 SPI_BaudRatePrescaler<65><72>SPI_BAUDRATEPRESCALER_2~SPI_BAUDRATEPRESCALER_2 256
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SPI<50>ٶ<EFBFBD>=fAPB1/<2F><>Ƶϵ<C6B5><CFB5><EFBFBD><EFBFBD>fAPB1ʱ<31><CAB1>һ<EFBFBD><D2BB>Ϊ45Mhz
//
//-----------------------------------------------------------------
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));//<2F>ж<EFBFBD><D0B6><EFBFBD>Ч<EFBFBD><D0A7>
__HAL_SPI_DISABLE(&SPI5_Handler); //<2F>ر<EFBFBD>SPI
SPI5_Handler.Instance->CR1&=0XFFC7; //λ3-5<><35><EFBFBD><EFBFBD><E3A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
SPI5_Handler.Instance->CR1|=SPI_BaudRatePrescaler;//<2F><><EFBFBD><EFBFBD>SPI<50>ٶ<EFBFBD>
__HAL_SPI_ENABLE(&SPI5_Handler); //ʹ<><CAB9>SPI
assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler)); // <EFBFBD>ж<EFBFBD><EFBFBD><EFBFBD>Ч<EFBFBD><EFBFBD>
__HAL_SPI_DISABLE(&SPI_Handler); // <EFBFBD>ر<EFBFBD>SPI
SPI_Handler.Instance->CR1&=0XFFC7; // λ3-5<><35><EFBFBD><EFBFBD><E3A3AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ò<EFBFBD><C3B2><EFBFBD><EFBFBD><EFBFBD>
SPI_Handler.Instance->CR1|=SPI_BaudRatePrescaler; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>SPI<EFBFBD>ٶ<EFBFBD>
__HAL_SPI_ENABLE(&SPI_Handler); // ʹ<EFBFBD><EFBFBD>SPI
}
//SPI5 <20><>дһ<D0B4><D2BB><EFBFBD>ֽ<EFBFBD>
//TxData:Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ:<3A><>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
u8 SPI5_ReadWriteByte(u8 TxData)
//-----------------------------------------------------------------
// u8 SPI1_ReadWriteByte(u8 TxData)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: SPI1<49><31>дһ<D0B4><D2BB><EFBFBD>ֽ<EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 TxData<74><61> Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
// <20><> <20><> ֵ: u8 Rxdata<74><61><EFBFBD><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
uint16_t SPI1_ReadWriteByte(uint16_t TxData)
{
u8 Rxdata;
HAL_SPI_TransmitReceive(&SPI5_Handler,&TxData,&Rxdata,1, 1000);
return Rxdata; //<2F><><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
u8 rx_data[2];
u8 tx_data[2];
u16 Rxdata;
tx_data[0] = (TxData >> 8) & 0xFF;
tx_data[1] = TxData & 0xFF;
HAL_SPI_TransmitReceive(&SPI_Handler,tx_data,rx_data,2, 1000);
Rxdata = (rx_data[0] << 8) | rx_data[1];
return Rxdata; // <20><><EFBFBD><EFBFBD><EFBFBD>յ<EFBFBD><D5B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,22 +1,67 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// SPI<50><49><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ļ<EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)LED IO <20><><EFBFBD><EFBFBD>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
#ifndef __SPI_H
#define __SPI_H
#include "sys.h"
//////////////////////////////////////////////////////////////////////////////////
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD>ѧϰʹ<EFBFBD>ã<EFBFBD>δ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><EFBFBD><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><EFBFBD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/16/16
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
#include "stm32f429_winner.h"
#include "main.h"
//-----------------------------------------------------------------
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern SPI_HandleTypeDef SPI_Handler; // SPI<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
extern SPI_HandleTypeDef SPI5_Handler; //SPI<50><49><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// SPI<50><49><EFBFBD>Ŷ<EFBFBD><C5B6><EFBFBD>
//-----------------------------------------------------------------
#define SPIx SPI4
#define SPI_CLK_ENABLE() __HAL_RCC_SPI4_CLK_ENABLE()
#define SPI_CS_PIN GPIO_PIN_4
#define SPI_CS_GPIO_PORT GPIOE
#define SPI_CS_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
#define SPI_CS_GPIO_CLK_DISABLE() __HAL_RCC_GPIOE_CLK_DISABLE()
#define SPI_MISO_PIN GPIO_PIN_5
#define SPI_MISO_GPIO_PORT GPIOE
#define SPI_MISO_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
#define SPI_MISO_GPIO_CLK_DISABLE() __HAL_RCC_GPIOE_CLK_DISABLE()
#define SPI_MISO_AF GPIO_AF5_SPI4
#define SPI_MOSI_PIN GPIO_PIN_6
#define SPI_MOSI_GPIO_PORT GPIOE
#define SPI_MOSI_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
#define SPI_MOSI_GPIO_CLK_DISABLE() __HAL_RCC_GPIOE_CLK_DISABLE()
#define SPI_MOSI_AF GPIO_AF5_SPI4
#define SPI_CLK_PIN GPIO_PIN_2
#define SPI_CLK_GPIO_PORT GPIOE
#define SPI_CLK_GPIO_CLK_ENABLE() __HAL_RCC_GPIOE_CLK_ENABLE()
#define SPI_CLK_GPIO_CLK_DISABLE() __HAL_RCC_GPIOE_CLK_DISABLE()
#define SPI_CLK_AF GPIO_AF5_SPI4
#define SPI_FPGA_CS_LOW() HAL_GPIO_WritePin(SPI_CS_GPIO_PORT, SPI_CS_PIN, GPIO_PIN_RESET);
#define SPI_FPGA_CS_HIGH() HAL_GPIO_WritePin(SPI_CS_GPIO_PORT, SPI_CS_PIN, GPIO_PIN_SET);
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern void SPI_Init(void);
extern void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler);
extern u16 SPI1_ReadWriteByte(u16 TxData);
void SPI5_Init(void);
void SPI5_SetSpeed(u8 SPI_BaudRatePrescaler);
u8 SPI5_ReadWriteByte(u8 TxData);
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

68
HARDWARE/TIMER/timer.c Normal file
View File

@@ -0,0 +1,68 @@
#include "timer.h"
#include "led.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><>ʱ<EFBFBD><CAB1><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/6
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
extern vu16 USART3_RX_STA;
TIM_HandleTypeDef TIM4_Handler; //<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//ͨ<>ö<EFBFBD>ʱ<EFBFBD><CAB1>4<EFBFBD>жϳ<D0B6>ʼ<EFBFBD><CABC>
//arr<72><72><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>װֵ<D7B0><D6B5>
//psc<73><63>ʱ<EFBFBD><CAB1>Ԥ<EFBFBD><D4A4>Ƶ<EFBFBD><C6B5>
//<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><E3B7BD>:Tout=((arr+1)*(psc+1))/Ft us.
//Ft=<3D><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƶ<EFBFBD><C6B5>,<2C><>λ:Mhz
//<2F><><EFBFBD><EFBFBD>ʹ<EFBFBD>õ<EFBFBD><C3B5>Ƕ<EFBFBD>ʱ<EFBFBD><CAB1>4!(<28><>ʱ<EFBFBD><CAB1>4<EFBFBD><34><EFBFBD><EFBFBD>APB1<42>ϣ<EFBFBD>ʱ<EFBFBD><CAB1>ΪHCLK/2)
void TIM4_Init(u16 arr,u16 psc)
{
TIM4_Handler.Instance=TIM4; //ͨ<>ö<EFBFBD>ʱ<EFBFBD><CAB1>4
TIM4_Handler.Init.Prescaler=psc; //<2F><>Ƶϵ<C6B5><CFB5>
TIM4_Handler.Init.CounterMode=TIM_COUNTERMODE_UP; //<2F><><EFBFBD>ϼ<EFBFBD><CFBC><EFBFBD><EFBFBD><EFBFBD>
TIM4_Handler.Init.Period=arr; //<2F>Զ<EFBFBD>װ<EFBFBD><D7B0>ֵ
TIM4_Handler.Init.ClockDivision=TIM_CLOCKDIVISION_DIV1;//ʱ<>ӷ<EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD><EFBFBD>
HAL_TIM_Base_Init(&TIM4_Handler);
HAL_TIM_Base_Start_IT(&TIM4_Handler); //ʹ<>ܶ<EFBFBD>ʱ<EFBFBD><CAB1>4<EFBFBD>Ͷ<EFBFBD>ʱ<EFBFBD><CAB1>4<EFBFBD><34><EFBFBD><EFBFBD><EFBFBD>жϣ<D0B6>TIM_IT_UPDATE
}
//<2F><>ʱ<EFBFBD><CAB1><EFBFBD>ײ<EFBFBD><D7B2><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD>ӣ<EFBFBD><D3A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ȼ<EFBFBD>
//<2F>˺<EFBFBD><CBBA><EFBFBD><EFBFBD>ᱻHAL_TIM_Base_Init()<29><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance==TIM4)
{
__HAL_RCC_TIM4_CLK_ENABLE(); //ʹ<><CAB9>TIM4ʱ<34><CAB1>
HAL_NVIC_SetPriority(TIM4_IRQn,0,2); //<2F><><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><D0B6><EFBFBD><EFBFBD>ȼ<EFBFBD><C8BC><EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD>ȼ<EFBFBD>0<EFBFBD><30><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȼ<EFBFBD>2
HAL_NVIC_EnableIRQ(TIM4_IRQn); //<2F><><EFBFBD><EFBFBD>ITM4<4D>ж<EFBFBD>
}
}
//<2F><>ʱ<EFBFBD><CAB1>4<EFBFBD>жϷ<D0B6><CFB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&TIM4_Handler);
}
//<2F>ص<EFBFBD><D8B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>жϷ<D0B6><CFB7><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim==(&TIM4_Handler))
{
USART3_RX_STA|=1<<15; //<2F><><EFBFBD>ǽ<EFBFBD><C7BD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
__HAL_TIM_CLEAR_IT(&TIM4_Handler, TIM_IT_UPDATE); // <20><><EFBFBD><EFBFBD>TIM4<4D>ĸ<EFBFBD><C4B8><EFBFBD><EFBFBD>жϱ<D0B6>־
HAL_TIM_Base_Stop(&TIM4_Handler); //<2F>ر<EFBFBD>TIM4
}
}

20
HARDWARE/TIMER/timer.h Normal file
View File

@@ -0,0 +1,20 @@
#ifndef _TIMER_H
#define _TIMER_H
#include "sys.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/6
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
extern TIM_HandleTypeDef TIM4_Handler; //<2F><>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void TIM4_Init(u16 arr,u16 psc);
#endif

View File

@@ -1,242 +1,325 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// W25QXX<58><58><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)W25QXX<58><58>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
//-----------------------------------------------------------------
// ͷ<>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
#include "w25qxx.h"
#include "spi.h"
#include "delay.h"
#include "usart.h"
#include "stm32f4xx_hal_gpio.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><D6BB>ѧϰʹ<CFB0>ã<EFBFBD>δ<EFBFBD><CEB4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><C9A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><CEBA><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//W25QXX<58><58><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/16
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------
u16 W25QXX_TYPE=W25Q256; //Ĭ<><C4AC><EFBFBD><EFBFBD>W25Q256
//4KbytesΪһ<EFBFBD><EFBFBD>Sector
//16<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ1<EFBFBD><EFBFBD>Block
//W25Q256
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ϊ32M<EFBFBD>ֽ<EFBFBD>,<2C><><EFBFBD><EFBFBD>512<31><32>Block,8192<39><32>Sector
//<2F><>ʼ<EFBFBD><EFBFBD>SPI FLASH<53><48>IO<EFBFBD><EFBFBD>
u16 W25QXX_TYPE=W25Q128; // Ĭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q128
//-----------------------------------------------------------------
// void W25QXX_Init(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ʼ<EFBFBD><CABC>SPI FLASH<53><48>IO<49><4F>
// <EFBFBD><EFBFBD><EFBFBD>ڲ<EFBFBD><EFBFBD><EFBFBD>: <EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Init(void)
{
u8 temp;
GPIO_InitTypeDef GPIO_Initure;
u8 temp;
GPIO_InitTypeDef GPIO_Initure;
__HAL_RCC_GPIOG_CLK_ENABLE(); // ʹ<><CAB9>GPIOGʱ<47><CAB1>
GPIO_Initure.Pin=GPIO_PIN_3; // PG3 -> FLASH_CS
GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; // <20><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_FAST; // <20><><EFBFBD><EFBFBD>
HAL_GPIO_Init(GPIOG,&GPIO_Initure); // <20><>ʼ<EFBFBD><CABC>
__HAL_RCC_GPIOF_CLK_ENABLE(); //ʹ<><CAB9>GPIOFʱ<46><CAB1>
//PF6
GPIO_Initure.Pin=GPIO_PIN_6; //PF6
GPIO_Initure.Mode=GPIO_MODE_OUTPUT_PP; //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
GPIO_Initure.Pull=GPIO_PULLUP; //<2F><><EFBFBD><EFBFBD>
GPIO_Initure.Speed=GPIO_SPEED_FAST; //<2F><><EFBFBD><EFBFBD>
HAL_GPIO_Init(GPIOF,&GPIO_Initure); //<2F><>ʼ<EFBFBD><CABC>
W25QXX_CS=1; //SPI FLASH<53><48>ѡ<EFBFBD><D1A1>
SPI5_Init(); //<2F><>ʼ<EFBFBD><CABC>SPI
SPI5_SetSpeed(SPI_BAUDRATEPRESCALER_2); //<2F><><EFBFBD><EFBFBD>Ϊ45Mʱ<4D><CAB1>,<2C><><EFBFBD><EFBFBD>ģʽ
W25QXX_TYPE=W25QXX_ReadID(); //<2F><>ȡFLASH ID.
if(W25QXX_TYPE==W25Q256) //SPI FLASHΪW25Q256
{
temp=W25QXX_ReadSR(3); //<2F><>ȡ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>3<EFBFBD><33><EFBFBD>жϵ<D0B6>ַģʽ
if((temp&0X01)==0) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<D6BD>ַģʽ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<D6BD>ַģʽ
W25QXX_CS=1; // ȡ<><C8A1>Ƭѡ
SPI_Init(); // <20><>ʼ<EFBFBD><CABC>SPI
W25QXX_TYPE=W25QXX_ReadID(); // <20><>ȡFLASH ID.
if(W25QXX_TYPE==W25Q256) // <20><>SPI FLASHΪW25Q256
{
temp=W25QXX_ReadSR(3); // <20><>ȡ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>3<EFBFBD><33><EFBFBD>жϵ<D0B6>ַģʽ
if((temp&0X01)==0) // <20><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<EFBFBD>ַģʽ,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<D6BD>ַģʽ
{
W25QXX_CS=0; //ѡ<><D1A1>
SPI5_ReadWriteByte(W25X_Enable4ByteAddr);//<2F><><EFBFBD>ͽ<EFBFBD><CDBD><EFBFBD>4<EFBFBD>ֽڵ<D6BD>ַģʽָ<CABD><D6B8>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_CS=0; // ѡ<EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_Enable4ByteAddr);// <EFBFBD><EFBFBD><EFBFBD>ͽ<EFBFBD><EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<EFBFBD>ַģʽָ<EFBFBD><EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
}
}
}
}
//<EFBFBD><EFBFBD>ȡW25QXX<EFBFBD><EFBFBD>״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25QXXһ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>3<EFBFBD><EFBFBD>״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>
//״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>1<EFBFBD><EFBFBD>
//BIT7 6 5 4 3 2 1 0
//SPR RV TB BP2 BP1 BP0 WEL BUSY
//SPR:Ĭ<><C4AC>0,״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ,<2C><><EFBFBD><EFBFBD>WPʹ<EFBFBD><EFBFBD>
//TB,BP2,BP1,BP0:FLASH<53><48><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//WEL:дʹ<D0B4><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//BUSY:æ<><C3A6><EFBFBD><EFBFBD>λ(1,æ;0,<2C><><EFBFBD><EFBFBD>)
//Ĭ<EFBFBD><EFBFBD>:0x00
//״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>2<EFBFBD><EFBFBD>
//BIT7 6 5 4 3 2 1 0
//SUS CMP LB3 LB2 LB1 (R) QE SRP1
//״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>3<EFBFBD><EFBFBD>
//BIT7 6 5 4 3 2 1 0
//HOLD/RST DRV1 DRV0 (R) (R) WPS ADP ADS
//regno:״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ţ<EFBFBD><EFBFBD><EFBFBD>:1~3
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ:״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>ֵ
//-----------------------------------------------------------------
// u8 W25QXX_ReadSR(u8 regno)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ȡW25QXX<58><58>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD>W25QXXһ<58><D2BB><EFBFBD><EFBFBD>3<EFBFBD><33>״̬<D7B4>Ĵ<EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 regno<6E><6F>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD>ţ<EFBFBD><C5A3><EFBFBD>Χ:1~3
// <20><> <20><> ֵ: u8 byte<74><65>״̬<D7B4>Ĵ<EFBFBD><EFBFBD><EFBFBD>ֵ
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>1<EFBFBD><31>
// BIT7 6 5 4 3 2 1 0
// SPR RV TB BP2 BP1 BP0 WEL BUSY
// SPR:Ĭ<><C4AC>0,״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>λ,<2C><><EFBFBD><EFBFBD>WPʹ<50><CAB9>
// TB,BP2,BP1,BP0:FLASH<53><48><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// WEL:дʹ<D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// BUSY:æ<><C3A6><EFBFBD><EFBFBD>λ(1,æ;0,<2C><><EFBFBD><EFBFBD>)
// Ĭ<><C4AC>:0x00
// ״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>2<EFBFBD><EFBFBD>
// BIT7 6 5 4 3 2 1 0
// SUS CMP LB3 LB2 LB1 (R) QE SRP1
// ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>3<EFBFBD><33>
// BIT7 6 5 4 3 2 1 0
// HOLD/RST DRV1 DRV0 (R) (R) WPS ADP ADS
//
//-----------------------------------------------------------------
u8 W25QXX_ReadSR(u8 regno)
{
u8 byte=0,command=0;
switch(regno)
{
case 1:
command=W25X_ReadStatusReg1; //<2F><>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><31><D6B8>
break;
case 2:
command=W25X_ReadStatusReg2; //<2F><>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><32><D6B8>
break;
case 3:
command=W25X_ReadStatusReg3; //<2F><>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><33><D6B8>
break;
default:
command=W25X_ReadStatusReg1;
break;
}
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(command); //<2F><><EFBFBD>Ͷ<EFBFBD>ȡ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
byte=SPI5_ReadWriteByte(0Xff); //<2F><>ȡһ<C8A1><D2BB><EFBFBD>ֽ<EFBFBD>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
switch(regno)
{
case 1:
command=W25X_ReadStatusReg1; // <EFBFBD><EFBFBD>״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
case 2:
command=W25X_ReadStatusReg2; // <EFBFBD><EFBFBD>״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
case 3:
command=W25X_ReadStatusReg3; // <EFBFBD><EFBFBD>״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
default:
command=W25X_ReadStatusReg1;
break;
}
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(command); // <EFBFBD><EFBFBD><EFBFBD>Ͷ<EFBFBD>ȡ״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
byte=SPI1_ReadWriteByte(0Xff); // <EFBFBD><EFBFBD>ȡһ<EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
return byte;
}
//дW25QXX״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>
//-----------------------------------------------------------------
// void W25QXX_Write_SR(u8 regno,u8 sr)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: дW25QXX״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8 regno<6E><6F>״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD>ţ<EFBFBD><C5A3><EFBFBD>Χ:1~3
// u8 sr<73><72>д<EFBFBD><D0B4>һ<EFBFBD><D2BB><EFBFBD>ֽ<EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Write_SR(u8 regno,u8 sr)
{
u8 command=0;
switch(regno)
{
case 1:
command=W25X_WriteStatusReg1; //д״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><31><D6B8>
break;
case 2:
command=W25X_WriteStatusReg2; //д״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><32><D6B8>
break;
case 3:
command=W25X_WriteStatusReg3; //д״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><33><D6B8>
break;
default:
command=W25X_WriteStatusReg1;
break;
}
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(command); //<2F><><EFBFBD><EFBFBD>дȡ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(sr); //д<><D0B4>һ<EFBFBD><D2BB><EFBFBD>ֽ<EFBFBD>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
u8 command=0;
switch(regno)
{
case 1:
command=W25X_WriteStatusReg1; // д״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
case 2:
command=W25X_WriteStatusReg2; // д״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
case 3:
command=W25X_WriteStatusReg3; // д״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
break;
default:
command=W25X_WriteStatusReg1;
break;
}
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(command); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>дȡ״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(sr); // д<EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
}
//W25QXXдʹ<D0B4><CAB9>
//<2F><>WEL<45><4C>λ
//-----------------------------------------------------------------
// void W25QXX_Write_Enable(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: W25QXXдʹ<D0B4><CAB9>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Write_Enable(void)
{
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_WriteEnable); //<2F><><EFBFBD><EFBFBD>дʹ<D0B4><CAB9>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_WriteEnable); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>дʹ<EFBFBD><EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
}
//W25QXXд<58><D0B4>ֹ
//<2F><>WEL<45><4C><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void W25QXX_Write_Disable(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: WW25QXXд<58><D0B4>ֹ
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Write_Disable(void)
{
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_WriteDisable); //<2F><><EFBFBD><EFBFBD>д<EFBFBD><D0B4>ָֹ<D6B9><D6B8>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_WriteDisable); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><EFBFBD>ָֹ<EFBFBD><EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
}
//<EFBFBD><EFBFBD>ȡоƬID
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
//0XEF13,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q80
//0XEF14,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q16
//0XEF15,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q32
//0XEF16,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q64
//0XEF17,<EFBFBD><EFBFBD>ʾоƬ<EFBFBD>ͺ<EFBFBD>ΪW25Q128
//0XEF18,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q256
//-----------------------------------------------------------------
// u16 W25QXX_ReadID(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ȡоƬID
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: u16 Temp<EFBFBD><EFBFBD>оƬ<EFBFBD>ͺ<EFBFBD>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 0XEF13,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q80
// 0XEF14,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q16
// 0XEF15,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q32
// 0XEF16,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q64
// 0XEF17,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q128
// 0XEF18,<2C><>ʾоƬ<D0BE>ͺ<EFBFBD>ΪW25Q256
//
//-----------------------------------------------------------------
u16 W25QXX_ReadID(void)
{
u16 Temp = 0;
W25QXX_CS=0;
SPI5_ReadWriteByte(0x90);//<2F><><EFBFBD>Ͷ<EFBFBD>ȡID<49><44><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(0x00);
SPI5_ReadWriteByte(0x00);
SPI5_ReadWriteByte(0x00);
Temp|=SPI5_ReadWriteByte(0xFF)<<8;
Temp|=SPI5_ReadWriteByte(0xFF);
SPI1_ReadWriteByte(0x90);// <EFBFBD><EFBFBD><EFBFBD>Ͷ<EFBFBD>ȡID<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(0x00);
SPI1_ReadWriteByte(0x00);
SPI1_ReadWriteByte(0x00);
Temp|=SPI1_ReadWriteByte(0xFF)<<8;
Temp|=SPI1_ReadWriteByte(0xFF);
W25QXX_CS=1;
return Temp;
}
//<2F><>ȡSPI FLASH
//<2F><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼ<EFBFBD><CABC>ȡָ<C8A1><D6B8><EFBFBD><EFBFBD><EFBFBD>ȵ<EFBFBD><C8B5><EFBFBD><EFBFBD><EFBFBD>
//pBuffer:<3A><><EFBFBD>ݴ洢<DDB4><E6B4A2>
//ReadAddr:<3A><>ʼ<EFBFBD><CABC>ȡ<EFBFBD>ĵ<EFBFBD>ַ(24bit)
//NumByteToRead:Ҫ<><D2AA>ȡ<EFBFBD><C8A1><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>65535)
//-----------------------------------------------------------------
// void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>ȡSPI FLASH<53><48><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼ<EFBFBD><CABC>ȡָ<C8A1><D6B8><EFBFBD><EFBFBD><EFBFBD>ȵ<EFBFBD><C8B5><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* pBuffer<65><72><EFBFBD><EFBFBD><EFBFBD>ݴ洢<DDB4><E6B4A2>
// u32 ReadAddr:<3A><>ʼ<EFBFBD><CABC>ȡ<EFBFBD>ĵ<EFBFBD>ַ(24bit)
// u16 NumByteToRead:<3A><><EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>65535)
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead)
{
u16 i;
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_ReadData); //<2F><><EFBFBD>Ͷ<EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD><EFBFBD>
if(W25QXX_TYPE==W25Q256) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<35>Ļ<EFBFBD><C4BB><EFBFBD>ַΪ4<CEAA>ֽڵģ<DAB5>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI5_ReadWriteByte((u8)((ReadAddr)>>24));
}
SPI5_ReadWriteByte((u8)((ReadAddr)>>16)); //<2F><><EFBFBD><EFBFBD>24bit<69><74>ַ
SPI5_ReadWriteByte((u8)((ReadAddr)>>8));
SPI5_ReadWriteByte((u8)ReadAddr);
for(i=0;i<NumByteToRead;i++)
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_ReadData); // <EFBFBD><EFBFBD><EFBFBD>Ͷ<EFBFBD>ȡ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(W25QXX_TYPE==W25Q256) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<EFBFBD>Ļ<EFBFBD><EFBFBD><EFBFBD>ַΪ4<EFBFBD>ֽڵģ<EFBFBD>Ҫ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI1_ReadWriteByte((u8)((ReadAddr)>>24));
}
SPI1_ReadWriteByte((u8)((ReadAddr)>>16)); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>24bit<EFBFBD><EFBFBD>ַ
SPI1_ReadWriteByte((u8)((ReadAddr)>>8));
SPI1_ReadWriteByte((u8)ReadAddr);
for(i=0;i<NumByteToRead;i++)
{
pBuffer[i]=SPI5_ReadWriteByte(0XFF); //ѭ<><D1AD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
pBuffer[i]=SPI1_ReadWriteByte(0XFF); // ѭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
W25QXX_CS=1;
}
//SPI<50><49>һҳ(0~65535)<29><>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35><36><EFBFBD>ֽڵ<D6BD><DAB5><EFBFBD><EFBFBD><EFBFBD>
//<2F><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼд<CABC><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35>ֽڵ<D6BD><DAB5><EFBFBD><EFBFBD><EFBFBD>
//pBuffer:<3A><><EFBFBD>ݴ洢<DDB4><E6B4A2>
//WriteAddr:<3A><>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
//NumByteToWrite:Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>256),<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD>ҳ<EFBFBD><D2B3>ʣ<EFBFBD><CAA3><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>!!!
//-----------------------------------------------------------------
// void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: PI<50><49>һҳ(0~65535)<29><>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35><36><EFBFBD>ֽڵ<D6BD><DAB5><EFBFBD><EFBFBD>ݣ<EFBFBD><DDA3><EFBFBD>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼд<CABC><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35>ֽڵ<D6BD><DAB5><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* pBuffer<65><72><EFBFBD><EFBFBD><EFBFBD>ݴ洢<DDB4><E6B4A2>
// u32 WriteAddr<64><72><EFBFBD><EFBFBD>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
// u16 NumByteToWrite<74><65>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>256),<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ӧ<EFBFBD>ó<EFBFBD><C3B3><EFBFBD><EFBFBD><EFBFBD>ҳ<EFBFBD><D2B3>ʣ<EFBFBD><CAA3><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>!!!
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Write_Page(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u16 i;
W25QXX_Write_Enable(); //SET WEL
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_PageProgram); //<2F><><EFBFBD><EFBFBD>дҳ<D0B4><D2B3><EFBFBD><EFBFBD>
if(W25QXX_TYPE==W25Q256) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<35>Ļ<EFBFBD><C4BB><EFBFBD>ַΪ4<CEAA>ֽڵģ<DAB5>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI5_ReadWriteByte((u8)((WriteAddr)>>24));
}
SPI5_ReadWriteByte((u8)((WriteAddr)>>16)); //<2F><><EFBFBD><EFBFBD>24bit<69><74>ַ
SPI5_ReadWriteByte((u8)((WriteAddr)>>8));
SPI5_ReadWriteByte((u8)WriteAddr);
for(i=0;i<NumByteToWrite;i++)SPI5_ReadWriteByte(pBuffer[i]);//ѭ<><D1AD>д<EFBFBD><D0B4>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_Wait_Busy(); //<2F>ȴ<EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_Write_Enable(); // SET WEL
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_PageProgram); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>дҳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(W25QXX_TYPE==W25Q256) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<EFBFBD>Ļ<EFBFBD><EFBFBD><EFBFBD>ַΪ4<EFBFBD>ֽڵģ<EFBFBD>Ҫ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI1_ReadWriteByte((u8)((WriteAddr)>>24));
}
SPI1_ReadWriteByte((u8)((WriteAddr)>>16)); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>24bit<EFBFBD><EFBFBD>ַ
SPI1_ReadWriteByte((u8)((WriteAddr)>>8));
SPI1_ReadWriteByte((u8)WriteAddr);
for(i=0;i<NumByteToWrite;i++)
SPI1_ReadWriteByte(pBuffer[i]); // ѭ<><D1AD>д<EFBFBD><D0B4>
W25QXX_CS=1; // ȡ<><C8A1>Ƭѡ
W25QXX_Wait_Busy(); // <20>ȴ<EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
//<2F>޼<EFBFBD><DEBC><EFBFBD>дSPI FLASH
//<2F><><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD>д<EFBFBD>ĵ<EFBFBD>ַ<EFBFBD><D6B7>Χ<EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB>Ϊ0XFF,<2C><><EFBFBD><EFBFBD><EFBFBD>ڷ<EFBFBD>0XFF<46><46>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD>ʧ<EFBFBD><CAA7>!
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><EFBFBD><EFBFBD>ҳ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><EFBFBD>ʼд<EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ȵ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>Ҫȷ<D2AA><C8B7><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>Խ<EFBFBD><D4BD>!
//pBuffer:<3A><><EFBFBD>ݴ洢<DDB4><E6B4A2>
//WriteAddr:<3A><>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
//NumByteToWrite:Ҫд<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD>(<EFBFBD><EFBFBD><EFBFBD><EFBFBD>65535)
//CHECK OK
//-----------------------------------------------------------------
// void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>޼<EFBFBD><DEBC><EFBFBD>дSPI FLASH
// <20><EFBFBD><EFBFBD>ڲ<EFBFBD><EFBFBD><EFBFBD>: u8* pBuffer<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݴ洢<EFBFBD><EFBFBD>
// u32 WriteAddr<64><72><EFBFBD><EFBFBD>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
// u16 NumByteToWrite<74><65>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>65535)
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>ȷ<EFBFBD><C8B7><EFBFBD><EFBFBD>д<EFBFBD>ĵ<EFBFBD>ַ<EFBFBD><D6B7>Χ<EFBFBD>ڵ<EFBFBD><DAB5><EFBFBD><EFBFBD><EFBFBD>ȫ<EFBFBD><C8AB>Ϊ0XFF,<2C><><EFBFBD><EFBFBD><EFBFBD>ڷ<EFBFBD>0XFF<46><46>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݽ<EFBFBD>ʧ<EFBFBD><CAA7>!
// <20><><EFBFBD><EFBFBD><EFBFBD>Զ<EFBFBD><D4B6><EFBFBD>ҳ<EFBFBD><D2B3><EFBFBD><EFBFBD>!
// <20><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼд<CABC><D0B4>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>ȵ<EFBFBD><C8B5><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD>Ҫȷ<D2AA><C8B7><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>Խ<EFBFBD><D4BD>!
//
//-----------------------------------------------------------------
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u16 pageremain;
pageremain=256-WriteAddr%256; //<2F><>ҳʣ<D2B3><CAA3><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
if(NumByteToWrite<=pageremain)pageremain=NumByteToWrite;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35><36><EFBFBD>ֽ<EFBFBD>
pageremain=256-WriteAddr%256; // <EFBFBD><EFBFBD>ҳʣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD>
if(NumByteToWrite<=pageremain)
pageremain=NumByteToWrite; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>256<35><36><EFBFBD>ֽ<EFBFBD>
while(1)
{
W25QXX_Write_Page(pBuffer,WriteAddr,pageremain);
if(NumByteToWrite==pageremain)break;//д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else //NumByteToWrite>pageremain
if(NumByteToWrite==pageremain)
break; // д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else // NumByteToWrite>pageremain
{
pBuffer+=pageremain;
WriteAddr+=pageremain;
NumByteToWrite-=pageremain; //<2F><>ȥ<EFBFBD>Ѿ<EFBFBD>д<EFBFBD><D0B4><EFBFBD>˵<EFBFBD><CBB5>ֽ<EFBFBD><D6BD><EFBFBD>
if(NumByteToWrite>256)pageremain=256; //һ<>ο<EFBFBD><CEBF><EFBFBD>д<EFBFBD><D0B4>256<35><36><EFBFBD>ֽ<EFBFBD>
else pageremain=NumByteToWrite; //<2F><><EFBFBD><EFBFBD>256<EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD>
NumByteToWrite-=pageremain; // <EFBFBD><EFBFBD>ȥ<EFBFBD>Ѿ<EFBFBD>д<EFBFBD><EFBFBD><EFBFBD>˵<EFBFBD><EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD>
if(NumByteToWrite>256)
pageremain=256; // һ<>ο<EFBFBD><CEBF><EFBFBD>д<EFBFBD><EFBFBD>256<EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>
else
pageremain=NumByteToWrite; // <20><><EFBFBD><EFBFBD>256<35><36><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>
}
};
}
}
//дSPI FLASH
//<2F><>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>ʼд<CABC><D0B4>ָ<EFBFBD><D6B8><EFBFBD><EFBFBD><EFBFBD>ȵ<EFBFBD><C8B5><EFBFBD><EFBFBD><EFBFBD>
//<2F>ú<EFBFBD><C3BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>!
//pBuffer:<3A><><EFBFBD>ݴ洢<DDB4><E6B4A2>
//WriteAddr:<3A><>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
//NumByteToWrite:Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>65535)
u8 W25QXX_BUFFER[4096];
u8 W25QXX_BUFFER[4096];
//-----------------------------------------------------------------
// void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: дSPI FLASH
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u8* pBuffer<65><72><EFBFBD><EFBFBD><EFBFBD>ݴ洢<DDB4><E6B4A2>
// u32 WriteAddr<64><72><EFBFBD><EFBFBD>ʼд<CABC><D0B4><EFBFBD>ĵ<EFBFBD>ַ(24bit)
// u16 NumByteToWrite<74><65>Ҫд<D2AA><D0B4><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD><D6BD><EFBFBD>(<28><><EFBFBD><EFBFBD>65535)
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>ú<EFBFBD><C3BA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>!
//
//-----------------------------------------------------------------
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
{
u32 secpos;
@@ -244,94 +327,149 @@ void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite)
u16 secremain;
u16 i;
u8 * W25QXX_BUF;
W25QXX_BUF=W25QXX_BUFFER;
secpos=WriteAddr/4096;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
secoff=WriteAddr%4096;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>ƫ<EFBFBD><C6AB>
secremain=4096-secoff;//<2F><><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD>ռ<EFBFBD><D5BC><EFBFBD>С
//printf("ad:%X,nb:%X\r\n",WriteAddr,NumByteToWrite);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
if(NumByteToWrite<=secremain)secremain=NumByteToWrite;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4096<39><36><EFBFBD>ֽ<EFBFBD>
W25QXX_BUF=W25QXX_BUFFER;
secpos=WriteAddr/4096; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ
secoff=WriteAddr%4096; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ڵ<EFBFBD>ƫ<EFBFBD><EFBFBD>
secremain=4096-secoff; // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><EFBFBD><EFBFBD>ռ<EFBFBD><EFBFBD><EFBFBD>С
if(NumByteToWrite<=secremain)
secremain=NumByteToWrite;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>4096<39><36><EFBFBD>ֽ<EFBFBD>
while(1)
{
W25QXX_Read(W25QXX_BUF,secpos*4096,4096);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(i=0;i<secremain;i++)//У<><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_Read(W25QXX_BUF,secpos*4096,4096); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(i=0;i<secremain;i++) // У<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
if(W25QXX_BUF[secoff+i]!=0XFF)break;//<2F><>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>
if(W25QXX_BUF[secoff+i]!=0XFF)
break;// <20><>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>
}
if(i<secremain)//<2F><>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD>
if(i<secremain)// <EFBFBD><EFBFBD>Ҫ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
W25QXX_Erase_Sector(secpos);//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(i=0;i<secremain;i++) //<2F><><EFBFBD><EFBFBD>
W25QXX_Erase_Sector(secpos); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
for(i=0;i<secremain;i++) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
W25QXX_BUF[i+secoff]=pBuffer[i];
}
W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);//д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_Write_NoCheck(W25QXX_BUF,secpos*4096,4096);// д<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}else W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);//д<>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˵<EFBFBD><><D6B1>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if(NumByteToWrite==secremain)break;//д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else//д<><EFBFBD>δ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
else
W25QXX_Write_NoCheck(pBuffer,WriteAddr,secremain);// д<EFBFBD>Ѿ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>˵<EFBFBD><><D6B1>д<EFBFBD><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʣ<EFBFBD><CAA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.
if(NumByteToWrite==secremain)
break; // д<><D0B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else // д<><D0B4>δ<EFBFBD><CEB4><EFBFBD><EFBFBD>
{
secpos++;//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><D6B7>1
secoff=0;//ƫ<><C6AB>λ<EFBFBD><CEBB>Ϊ0
secpos++;// <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ<EFBFBD><EFBFBD>1
secoff=0;// ƫ<EFBFBD><EFBFBD>λ<EFBFBD><EFBFBD>Ϊ0
pBuffer+=secremain; //ָ<><D6B8>ƫ<EFBFBD><C6AB>
WriteAddr+=secremain;//д<><D0B4>ַƫ<D6B7><C6AB>
NumByteToWrite-=secremain; //<2F>ֽ<EFBFBD><D6BD><EFBFBD><EFBFBD>ݼ<EFBFBD>
if(NumByteToWrite>4096)secremain=4096; //<2F><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
else secremain=NumByteToWrite; //<2F><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
pBuffer+=secremain; // ָ<EFBFBD><EFBFBD>ƫ<EFBFBD><EFBFBD>
WriteAddr+=secremain; // д<EFBFBD><EFBFBD>ַƫ<EFBFBD><EFBFBD>
NumByteToWrite-=secremain; // <EFBFBD>ֽ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݼ<EFBFBD>
if(NumByteToWrite>4096)
secremain=4096; // <EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
else
secremain=NumByteToWrite; // <20><>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>д<EFBFBD><D0B4><EFBFBD><EFBFBD>
}
};
}
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>оƬ
//<2F>ȴ<EFBFBD>ʱ<EFBFBD><EFBFBD><E4B3AC>...
//-----------------------------------------------------------------
// void W25QXX_Erase_Chip(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>оƬ
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Erase_Chip(void)
{
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_ChipErase); //<2F><><EFBFBD><EFBFBD>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_Wait_Busy(); //<2F>ȴ<EFBFBD>оƬ<D0BE><C6AC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_Write_Enable(); // SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_ChipErase); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ƭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
W25QXX_Wait_Busy(); // <EFBFBD>ȴ<EFBFBD>оƬ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
//<2F><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//Dst_Addr:<3A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ <20><><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><EFBFBD>:150ms
//-----------------------------------------------------------------
// void W25QXX_Erase_Sector(u32 Dst_Addr)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: u32 Dst_Addr<64><72><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ַ <20><><EFBFBD><EFBFBD>ʵ<EFBFBD><CAB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1>:150ms
//
//-----------------------------------------------------------------
void W25QXX_Erase_Sector(u32 Dst_Addr)
{
//<2F><><EFBFBD><EFBFBD>falsh<73><68><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//printf("fe:%x\r\n",Dst_Addr);
{
Dst_Addr*=4096;
W25QXX_Write_Enable(); //SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_SectorErase); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><D6B8>
if(W25QXX_TYPE==W25Q256) //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<35>Ļ<EFBFBD><C4BB><EFBFBD>ַΪ4<CEAA>ֽڵģ<DAB5>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI5_ReadWriteByte((u8)((Dst_Addr)>>24));
}
SPI5_ReadWriteByte((u8)((Dst_Addr)>>16)); //<2F><><EFBFBD><EFBFBD>24bit<69><74>ַ
SPI5_ReadWriteByte((u8)((Dst_Addr)>>8));
SPI5_ReadWriteByte((u8)Dst_Addr);
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
W25QXX_Wait_Busy(); //<2F>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_Write_Enable(); // SET WEL
W25QXX_Wait_Busy();
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_SectorErase); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ָ<EFBFBD><EFBFBD>
if(W25QXX_TYPE==W25Q256) // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25Q256<EFBFBD>Ļ<EFBFBD><EFBFBD><EFBFBD>ַΪ4<EFBFBD>ֽڵģ<EFBFBD>Ҫ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
{
SPI1_ReadWriteByte((u8)((Dst_Addr)>>24));
}
SPI1_ReadWriteByte((u8)((Dst_Addr)>>16)); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD>24bit<EFBFBD><EFBFBD>ַ
SPI1_ReadWriteByte((u8)((Dst_Addr)>>8));
SPI1_ReadWriteByte((u8)Dst_Addr);
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
W25QXX_Wait_Busy(); // <EFBFBD>ȴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
}
//<2F>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void W25QXX_Wait_Busy(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20>ȴ<EFBFBD><C8B4><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_Wait_Busy(void)
{
while((W25QXX_ReadSR(1)&0x01)==0x01); // <20>ȴ<EFBFBD>BUSYλ<59><CEBB><EFBFBD><EFBFBD>
}
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ
//-----------------------------------------------------------------
// void W25QXX_PowerDown(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_PowerDown(void)
{
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_PowerDown); //<2F><><EFBFBD>͵<EFBFBD><CDB5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
delay_us(3); //<2F>ȴ<EFBFBD>TPD
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_PowerDown); // <EFBFBD><EFBFBD><EFBFBD>͵<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
delay_us(3); // <EFBFBD>ȴ<EFBFBD>TPD
}
//<2F><><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// void W25QXX_WAKEUP(void)
//-----------------------------------------------------------------
//
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><><EFBFBD><EFBFBD>
// <20><><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD>: <20><>
// <20><> <20><> ֵ: <20><>
// ע<><D7A2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: <20><>
//
//-----------------------------------------------------------------
void W25QXX_WAKEUP(void)
{
W25QXX_CS=0; //ʹ<><CAB9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI5_ReadWriteByte(W25X_ReleasePowerDown); // send W25X_PowerDown command 0xAB
W25QXX_CS=1; //ȡ<><C8A1>Ƭѡ
delay_us(3); //<2F>ȴ<EFBFBD>TRES1
W25QXX_CS=0; // ʹ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
SPI1_ReadWriteByte(W25X_ReleasePowerDown); // send W25X_PowerDown command 0xAB
W25QXX_CS=1; // ȡ<EFBFBD><EFBFBD>Ƭѡ
delay_us(3); // <EFBFBD>ȴ<EFBFBD>TRES1
}
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------

View File

@@ -1,26 +1,29 @@
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:
// W25QXX<58><58><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ͷ<EFBFBD>ļ<EFBFBD>
// <20><> <20><>: <20><><EFBFBD>ǵ<EFBFBD><C7B5><EFBFBD>
// <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD>: 2018-08-04
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>: 2018-08-04
// <20>޸<EFBFBD><DEB8><EFBFBD><EFBFBD><EFBFBD>:
// <20><>ǰ<EFBFBD>汾: V1.0
// <20><>ʷ<EFBFBD>汾:
// - V1.0: (2018-08-04)W25QXX<58><58>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
// <20><><EFBFBD>Թ<EFBFBD><D4B9><EFBFBD>: <20><><EFBFBD><EFBFBD>STM32F429+CycloneIV<49><56><EFBFBD><EFBFBD>ϵͳ<CFB5><CDB3><EFBFBD>ƿ<EFBFBD><C6BF><EFBFBD><EFBFBD>塢LZE_ST_LINK2
// ˵ <20><>:
//
//-----------------------------------------------------------------
#ifndef __W25QXX_H
#define __W25QXX_H
#include "sys.h"
//////////////////////////////////////////////////////////////////////////////////
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֻ<EFBFBD><EFBFBD>ѧϰʹ<EFBFBD>ã<EFBFBD>δ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɣ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>κ<EFBFBD><EFBFBD><EFBFBD>;
//ALIENTEK STM32F429<32><39><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//W25QXX<58><58><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//<2F><><EFBFBD><EFBFBD>ԭ<EFBFBD><D4AD>@ALIENTEK
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̳:www.openedv.com
//<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:2016/1/16
//<2F><EFBFBD><E6B1BE>V1.0
//<2F><>Ȩ<EFBFBD><C8A8><EFBFBD>У<EFBFBD><D0A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ؾ<EFBFBD><D8BE><EFBFBD>
//Copyright(C) <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ӿƼ<D3BF><C6BC><EFBFBD><EFBFBD>޹<EFBFBD>˾ 2014-2024
//All rights reserved
//////////////////////////////////////////////////////////////////////////////////
#include "stm32f429_winner.h"
//-----------------------------------------------------------------
// <EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern u16 W25QXX_TYPE; // <20><><EFBFBD><EFBFBD>W25QXXоƬ<D0BE>ͺ<EFBFBD>
//W25Xϵ<EFBFBD><EFBFBD>/Qϵ<51><CFB5>оƬ<D0BE>б<EFBFBD>
//W25Q80 ID 0XEF13
//W25Q16 ID 0XEF14
//W25Q32 ID 0XEF15
//W25Q64 ID 0XEF16
//W25Q128 ID 0XEF17
//W25Q256 ID 0XEF18
//-----------------------------------------------------------------
// <20><EFBFBD><EAB6A8>
//-----------------------------------------------------------------
// W25<EFBFBD><EFBFBD>/Qϵ<51><CFB5>оƬ<D0BE>б<EFBFBD>
#define W25Q80 0XEF13
#define W25Q16 0XEF14
#define W25Q32 0XEF15
@@ -28,49 +31,50 @@
#define W25Q128 0XEF17
#define W25Q256 0XEF18
extern u16 W25QXX_TYPE; //<EFBFBD><EFBFBD><EFBFBD><EFBFBD>W25QXXоƬ<EFBFBD>ͺ<EFBFBD>
#define W25QXX_CS PGout(3) // W25QXX<EFBFBD><EFBFBD>Ƭѡ<EFBFBD>ź<EFBFBD>
#define W25QXX_CS PFout(6) //W25QXX<58><58>Ƭѡ<C6AC>ź<EFBFBD>
//////////////////////////////////////////////////////////////////////////////////
//ָ<><D6B8><EFBFBD><EFBFBD>
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg1 0x05
#define W25X_ReadStatusReg2 0x35
#define W25X_ReadStatusReg3 0x15
#define W25X_WriteEnable 0x06
#define W25X_WriteDisable 0x04
#define W25X_ReadStatusReg1 0x05
#define W25X_ReadStatusReg2 0x35
#define W25X_ReadStatusReg3 0x15
#define W25X_WriteStatusReg1 0x01
#define W25X_WriteStatusReg2 0x31
#define W25X_WriteStatusReg3 0x11
#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_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_Enable4ByteAddr 0xB7
#define W25X_Exit4ByteAddr 0xE9
void W25QXX_Init(void);
u16 W25QXX_ReadID(void); //<2F><>ȡFLASH ID
u8 W25QXX_ReadSR(u8 regno); //<2F><>ȡ״̬<D7B4>Ĵ<EFBFBD><C4B4><EFBFBD>
void W25QXX_4ByteAddr_Enable(void); //ʹ<EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<EFBFBD>ַģʽ
void W25QXX_Write_SR(u8 regno,u8 sr); //д״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>
void W25QXX_Write_Enable(void); //дʹ<EFBFBD><EFBFBD>
void W25QXX_Write_Disable(void); //д<><EFBFBD><EFBFBD><EFBFBD>
void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead); //<2F><>ȡflash
void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);//д<><D0B4>flash
void W25QXX_Erase_Chip(void); //<2F><>Ƭ<EFBFBD><C6AC><EFBFBD><EFBFBD>
void W25QXX_Erase_Sector(u32 Dst_Addr); //<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void W25QXX_Wait_Busy(void); //<EFBFBD>ȴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
void W25QXX_PowerDown(void); //<2F><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ
void W25QXX_WAKEUP(void); //<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
//-----------------------------------------------------------------
extern void W25QXX_Init(void);
extern u16 W25QXX_ReadID(void); // <EFBFBD><EFBFBD>ȡFLASH ID
extern u8 W25QXX_ReadSR(u8 regno); // <20><>ȡ״̬<EFBFBD>Ĵ<EFBFBD><EFBFBD><EFBFBD>
extern void W25QXX_4ByteAddr_Enable(void); // ʹ<EFBFBD><EFBFBD>4<EFBFBD>ֽڵ<EFBFBD>ַģʽ
extern void W25QXX_Write_SR(u8 regno,u8 sr); // д״̬<D7B4>Ĵ<EFBFBD><EFBFBD><EFBFBD>
extern void W25QXX_Write_Enable(void); // дʹ<D0B4><CAB9>
extern void W25QXX_Write_Disable(void); // д<><D0B4><EFBFBD><EFBFBD>
extern void W25QXX_Write_NoCheck(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);
extern void W25QXX_Read(u8* pBuffer,u32 ReadAddr,u16 NumByteToRead); // <20><>ȡflash
extern void W25QXX_Write(u8* pBuffer,u32 WriteAddr,u16 NumByteToWrite);// д<><D0B4>flash
extern void W25QXX_Erase_Chip(void); // <20><>Ƭ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>
extern void W25QXX_Erase_Sector(u32 Dst_Addr); // <EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
extern void W25QXX_Wait_Busy(void); // <20>ȴ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
extern void W25QXX_PowerDown(void); // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ģʽ
extern void W25QXX_WAKEUP(void); // <20><><EFBFBD><EFBFBD>
#endif
//-----------------------------------------------------------------
// End Of File
//-----------------------------------------------------------------