1494
一、前言
在STM32項目開發(fā)中，經(jīng)常會用到存儲芯片存儲數(shù)據(jù)。 比如：關機時保存機器運行過程中的狀態(tài)數(shù)據(jù)，上電再從存儲芯片里讀取數(shù)據(jù)恢復；在存儲芯片里也會存放很多資源文件。比如，開機音樂，界面上的菜單圖標，字庫文件，方便設備開機加載。
為了讓單片機更加方便的讀寫這些資源文件，通常都會加文件系統(tǒng)，如果沒有文件系統(tǒng)，直接讀取寫扇區(qū)的方式，對數(shù)據(jù)不好管理。 這篇文章就手把手教大家，在STM32上完成FATFS文件系統(tǒng)的移植；主控芯片采用STM32F103ZET6， 存儲芯片我這里采用（雷龍） CS創(chuàng)世 SD NAND 。 SD NAND 簡單來說就是貼片式SD卡，使用起來與普通的SD卡一樣，簡單的區(qū)別就是：比TF卡穩(wěn)定，比eMMC便宜。 下面章節(jié)里會詳細介紹下 CS創(chuàng)世 SD NAND。
下面是CS創(chuàng)世 SD NAND 與STM32開發(fā)的板的接線實物圖：
這是讀寫扇區(qū)測試的結果：
二、SD NAND 介紹
我當前使用的SD NAND型號是，CSNP32GCR01-AOW，容量是4GB。
下面是通過編寫STM32代碼讀取的存儲信息：
Card Type:SDHC V2.0
Card ManufacturerID:102
Card RCA:5000
Card Capacity:3696 MB
Card BlockSize:512
芯片的詳細參數(shù)如下：
【1】不用寫驅(qū)動程序自帶壞塊管理
【2】尺寸小巧，簡單易用，兼容性強，穩(wěn)定可靠，固件可定制，LGA-8封裝
【3】標準SDIO接口，兼容SPI，兼容拔插式TF卡/SD卡，可替代普通TF卡/SD卡
【4】尺寸6.2x8mm，直接貼片，不占空間
【5】內(nèi)置平均讀寫算法，通過1萬次隨機掉電測試
【6】耐高低溫，機貼手貼都非常方便
【7】速度級別Class10（讀取速度23.5MB/S寫入速度12.3MB/S）
【8】支持標準的SD 2.0協(xié)議，用戶可以直接移植標準驅(qū)動代碼，省去了驅(qū)動代碼編程環(huán)節(jié)。支持TF卡啟動的SOC都可以用SD NAND
【9】比TF卡穩(wěn)定，比eMMC便宜
**下面是芯片的實物圖： ** 這是官網(wǎng)申請的樣品，焊接了轉(zhuǎn)接板，可以直接插在SD卡卡槽上測試。 最終選型之后，設計PCB板時，設計接口，直接貼片上去使用，非常穩(wěn)定，抖動也不會導致，外置卡TF卡這種容易松動的問題。
這是雷龍的官網(wǎng)： http://www.longsto.com/product/35.html
三、編寫SD NAND驅(qū)動代碼
SD NAND 的驅(qū)動代碼與正常的SD卡協(xié)議是一樣的，支持標準的SD 2.0協(xié)議，下面我就直接貼出寫好的驅(qū)動代碼。
包括了模擬SPI，硬件SPI，SDIO等3種方式，完成對SD NAND 的讀寫。我當前使用的主控板子是STM32F103ZET6，如果你使用的板子不是這一款，可能還是其他的CPU也沒關系；我這里直接貼出了SPI模擬時序的驅(qū)動代碼，可以直接移植到任何單片機上使用，代碼拷貝過去也只需要修改GPIO口即可，非常方便。
3.1 SPI模擬時序驅(qū)動方式
（1）整體工程代碼
這是當前工程的截圖: 代碼采用寄存器風格編寫，非常簡潔。
當前工程完成SD NAND卡初始化，扇區(qū)的讀寫，測試芯片基本的使用情況。
（2） sd.c
#include "sdcard.h"
static u8 SD_Type=0; //存放SD卡的類型
/*
函數(shù)功能：SD卡底層接口,通過SPI時序向SD卡讀寫一個字節(jié)
函數(shù)參數(shù)：data是要寫入的數(shù)據(jù)
返 回 值：讀到的數(shù)據(jù)
*/
u8 SDCardReadWriteOneByte(u8 DataTx)
{
u8 i;
u8 data=0;
for(i=0;i<8;i++)
{
SDCARD_SCK=0;
if(DataTx&0x80)SDCARD_MOSI=1;
else SDCARD_MOSI=0;
SDCARD_SCK=1;
DataTx<<=1;
data<<=1;
if(SDCARD_MISO)data|=0x01;
}
return data;
}
//4種: 邊沿兩種、電平是兩種
/*
函數(shù)功能：底層SD卡接口初始化
本程序SPI接口如下：
PC11 片選 SDCardCS
PC12 時鐘 SDCardSCLK
PD2 輸出 SPI_MOSI--主機輸出從機輸入
PC8 輸入 SPI_MISO--主機輸入從機輸出
*/
void SDCardSpiInit(void)
{
/*1. 開啟時鐘*/
RCC->APB2ENR|=1<<5; //使能PORTD時鐘
RCC->APB2ENR|=1<<4; //使能PORTC時鐘
/*2. 配置GPIO口模式*/
GPIOC->CRH&=0xFFF00FF0;
GPIOC->CRH|=0x00033008;
GPIOD->CRL&=0xFFFFF0FF;
GPIOD->CRL|=0x00000300;
/*3. 上拉*/
GPIOC->ODR|=1<<8;
GPIOC->ODR|=1<<11;
GPIOC->ODR|=1<<12;
GPIOD->ODR|=1<<2;
}
/*
函數(shù)功能：取消選擇,釋放SPI總線
*/
void SDCardCancelCS(void)
{
SDCARD_CS=1;
SDCardReadWriteOneByte(0xff);//提供額外的8個時鐘
}
/*
函數(shù) 功 能：選擇sd卡,并且等待卡準備OK
函數(shù)返回值：0,成功;1,失敗;
*/
void SDCardSelectCS(void)
{
SDCARD_CS=0;
SDCardWaitBusy();//等待成功
}
/*
函數(shù) 功 能：等待卡準備好
函數(shù)返回值：0,準備好了;其他,錯誤代碼
*/
void SDCardWaitBusy(void)
{
while(SDCardReadWriteOneByte(0XFF)!=0XFF){}
}
/*
函數(shù)功能：等待SD卡回應
函數(shù)參數(shù)：
Response:要得到的回應值
返 回 值：
0,成功得到了該回應值
其他,得到回應值失敗
*/
u8 SDCardGetAck(u8 Response)
{
u16 Count=0xFFFF;//等待次數(shù)
while((SDCardReadWriteOneByte(0XFF)!=Response)&&Count)Count--;//等待得到準確的回應
if(Count==0)return SDCard_RESPONSE_FAILURE;//得到回應失敗
else return SDCard_RESPONSE_NO_ERROR;//正確回應
}
/*
函數(shù)功能：從sd卡讀取一個數(shù)據(jù)包的內(nèi)容
函數(shù)參數(shù)：
buf:數(shù)據(jù)緩存區(qū)
len:要讀取的數(shù)據(jù)長度.
返回值：
0,成功;其他,失敗;
*/
u8 SDCardRecvData(u8*buf,u16 len)
{
if(SDCardGetAck(0xFE))return 1;//等待SD卡發(fā)回數(shù)據(jù)起始令牌0xFE
while(len--)//開始接收數(shù)據(jù)
{
*buf=SDCardReadWriteOneByte(0xFF);
buf++;
}
//下面是2個偽CRC（dummy CRC）
SDCardReadWriteOneByte(0xFF);
SDCardReadWriteOneByte(0xFF);
return 0;//讀取成功
}
/*
函數(shù)功能：向sd卡寫入一個數(shù)據(jù)包的內(nèi)容 512字節(jié)
函數(shù)參數(shù)：
buf 數(shù)據(jù)緩存區(qū)
cmd 指令
返 回 值：0表示成功;其他值表示失敗;
*/
u8 SDCardSendData(u8*buf,u8 cmd)
{
u16 t;
SDCardWaitBusy(); //等待忙狀態(tài)
SDCardReadWriteOneByte(cmd);
if(cmd!=0XFD)//不是結束指令
{
for(t=0;t<512;t++)SDCardReadWriteOneByte(buf[t]);//提高速度,減少函數(shù)傳參時間
SDCardReadWriteOneByte(0xFF); //忽略crc
SDCardReadWriteOneByte(0xFF);
t=SDCardReadWriteOneByte(0xFF); //接收響應
if((t&0x1F)!=0x05)return 2; //響應錯誤
}
return 0;//寫入成功
}
/*
函數(shù)功能：向SD卡發(fā)送一個命令
函數(shù)參數(shù)：
u8 cmd 命令
u32 arg 命令參數(shù)
u8 crc crc校驗值
返回值:SD卡返回的響應
*/
u8 SendSDCardCmd(u8 cmd, u32 arg, u8 crc)
{
u8 r1;
SDCardCancelCS(); //取消上次片選
SDCardSelectCS(); //選中SD卡
//發(fā)送數(shù)據(jù)
SDCardReadWriteOneByte(cmd | 0x40);//分別寫入命令
SDCardReadWriteOneByte(arg >> 24);
SDCardReadWriteOneByte(arg >> 16);
SDCardReadWriteOneByte(arg >> 8);
SDCardReadWriteOneByte(arg);
SDCardReadWriteOneByte(crc);
if(cmd==SDCard_CMD12)SDCardReadWriteOneByte(0xff);//Skip a stuff byte when stop reading
do
{
r1=SDCardReadWriteOneByte(0xFF);
}while(r1&0x80); //等待響應，或超時退出
return r1; //返回狀態(tài)值
}
/*
函數(shù)功能：獲取SD卡的CID信息，包括制造商信息
函數(shù)參數(shù)：u8 *cid_data(存放CID的內(nèi)存，至少16Byte）
返 回 值：
0：成功，1：錯誤
*/
u8 GetSDCardCISDCardOutnfo(u8 *cid_data)
{
u8 r1;
//發(fā)SDCard_CMD10命令，讀CID
r1=SendSDCardCmd(SDCard_CMD10,0,0x01);
if(r1==0x00)
{
r1=SDCardRecvData(cid_data,16);//接收16個字節(jié)的數(shù)據(jù)
}
SDCardCancelCS();//取消片選
if(r1)return 1;
else return 0;
}
/*
函數(shù)說明：
獲取SD卡的CSD信息，包括容量和速度信息
函數(shù)參數(shù)：
u8 *cid_data(存放CID的內(nèi)存，至少16Byte）
返 回 值：
0：成功，1：錯誤
*/
u8 GetSDCardCSSDCardOutnfo(u8 *csd_data)
{
u8 r1;
r1=SendSDCardCmd(SDCard_CMD9,0,0x01); //發(fā)SDCard_CMD9命令，讀CSD
if(r1==0)
{
r1=SDCardRecvData(csd_data, 16);//接收16個字節(jié)的數(shù)據(jù)
}
SDCardCancelCS();//取消片選
if(r1)return 1;
else return 0;
}
/*
函數(shù)功能：獲取SD卡的總扇區(qū)數(shù)（扇區(qū)數(shù)）
返 回 值：
0表示容量檢測出錯，其他值表示SD卡的容量(扇區(qū)數(shù)/512字節(jié))
說 明：
每扇區(qū)的字節(jié)數(shù)必為512字節(jié)，如果不是512字節(jié)，則初始化不能通過.
*/
u32 GetSDCardSectorCount(void)
{
u8 csd[16];
u32 Capacity;
u16 csize;
if(GetSDCardCSSDCardOutnfo(csd)!=0) return 0; //取CSD信息，如果期間出錯，返回0
if((csd[0]&0xC0)==0x40) //SDHC卡，按照下面方式計算
{
csize = csd[9] + ((u16)csd[8] << 8) + 1;
Capacity = (u32)csize << 10;//得到扇區(qū)數(shù)
}
return Capacity;
}
/*
函數(shù)功能： 初始化SD卡
返 回 值： 非0表示初始化失敗!
*/
u8 SDCardDeviceInit(void)
{
u8 r1; // 存放SD卡的返回值
u8 buf[4];
u16 i;
SDCardSpiInit();//初始化底層IO口
for(i=0;i<10;i++)SDCardReadWriteOneByte(0xFF); //發(fā)送最少74個脈沖
do
{
r1=SendSDCardCmd(SDCard_CMD0,0,0x95);//進入IDLE狀態(tài) 閑置
}while(r1!=0X01);
SD_Type=0; //默認無卡
if(r1==0X01)
{
if(SendSDCardCmd(SDCard_CMD8,0x1AA,0x87)==1) //SD V2.0
{
for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);
if(buf[2]==0X01&&buf[3]==0XAA) //卡是否支持2.7~3.6V
{
do
{
SendSDCardCmd(SDCard_CMD55,0,0X01); //發(fā)送SDCard_CMD55
r1=SendSDCardCmd(SDCard_CMD41,0x40000000,0X01);//發(fā)送SDCard_CMD41
}while(r1);
if(SendSDCardCmd(SDCard_CMD58,0,0X01)==0)//鑒別SD2.0卡版本開始
{
for(i=0;i<4;i++)buf[i]=SDCardReadWriteOneByte(0XFF);//得到OCR值
if(buf[0]&0x40)SD_Type=SDCard_TYPE_V2HC; //檢查CCS
else SD_Type=SDCard_TYPE_V2;
}
}
}
}
printf("SD_Type=0x%Xrn",SD_Type);
SDCardCancelCS(); //取消片選
if(SD_Type)return 0; //初始化成功返回0
else if(r1)return r1; //返回值錯誤值
return 0xaa; //其他錯誤
}
/*
函數(shù)功能：讀SD卡
函數(shù)參數(shù)：
buf:數(shù)據(jù)緩存區(qū)
sector:扇區(qū)
cnt:扇區(qū)數(shù)
返回值:
0,ok;其他,失敗.
說 明：
SD卡一個扇區(qū)大小512字節(jié)
*/
u8 SDCardReadData(u8*buf,u32 sector,u32 cnt)
{
u8 r1;
if(SD_Type!=SDCard_TYPE_V2HC)sector<<=9;//轉(zhuǎn)換為字節(jié)地址
if(cnt==1)
{
r1=SendSDCardCmd(SDCard_CMD17,sector,0X01);//讀命令
if(r1==0) //指令發(fā)送成功
{
r1=SDCardRecvData(buf,512); //接收512個字節(jié)
}
}else
{
r1=SendSDCardCmd(SDCard_CMD18,sector,0X01);//連續(xù)讀命令
do
{
r1=SDCardRecvData(buf,512);//接收512個字節(jié)
buf+=512;
}while(--cnt && r1==0);
SendSDCardCmd(SDCard_CMD12,0,0X01); //發(fā)送停止命令
}
SDCardCancelCS();//取消片選
return r1;//
}
/*
函數(shù)功能：向SD卡寫數(shù)據(jù)
函數(shù)參數(shù)：
buf:數(shù)據(jù)緩存區(qū)
sector:起始扇區(qū)
cnt:扇區(qū)數(shù)
返回值：
0,ok;其他,失敗.
說 明：
SD卡一個扇區(qū)大小512字節(jié)
*/
u8 SDCardWriteData(u8*buf,u32 sector,u32 cnt)
{
u8 r1;
if(SD_Type!=SDCard_TYPE_V2HC)sector *= 512;//轉(zhuǎn)換為字節(jié)地址
if(cnt==1)
{
r1=SendSDCardCmd(SDCard_CMD24,sector,0X01);//讀命令
if(r1==0)//指令發(fā)送成功
{
r1=SDCardSendData(buf,0xFE);//寫512個字節(jié)
}
}
else
{
if(SD_Type!=SDCard_TYPE_MMC)
{
SendSDCardCmd(SDCard_CMD55,0,0X01);
SendSDCardCmd(SDCard_CMD23,cnt,0X01);//發(fā)送指令
}
r1=SendSDCardCmd(SDCard_CMD25,sector,0X01);//連續(xù)讀命令
if(r1==0)
{
do
{
r1=SDCardSendData(buf,0xFC);//接收512個字節(jié)
buf+=512;
}while(--cnt && r1==0);
r1=SDCardSendData(0,0xFD);//接收512個字節(jié)
}
}
SDCardCancelCS();//取消片選
return r1;//
}
（3） sd.h
#ifndef SD_H
#define SD_H_
#include "stm32f10x.h"
#include "led.h"
#include "usart.h"
/*----------------------------------------------
本程序SPI接口如下：
PC11 片選 SDCardCS
PC12 時鐘 SDCardSCLK
PD2 輸出 SPI_MOSI--主機輸出從機輸入
PC8 輸入 SPI_MISO--主機輸入從機輸出
------------------------------------------------*/
#define SDCARD_CS PCout(11)
#define SDCARD_SCK PCout(12)
#define SDCARD_MOSI PDout(2)
#define SDCARD_MISO PCin(8)
// SD卡類型定義
#define SDCard_TYPE_ERR 0X00 //卡類型錯誤
#define SDCard_TYPE_MMC 0X01 //MMC卡
#define SDCard_TYPE_V1 0X02
#define SDCard_TYPE_V2 0X04
#define SDCard_TYPE_V2HC 0X06
// SD卡指令表
#define SDCard_CMD0 0 //卡復位
#define SDCard_CMD1 1
#define SDCard_CMD8 8 //命令8 ，SEND_IF_COND
#define SDCard_CMD9 9 //命令9 ，讀CSD數(shù)據(jù)
#define SDCard_CMD10 10 //命令10，讀CID數(shù)據(jù)
#define SDCard_CMD12 12 //命令12，停止數(shù)據(jù)傳輸
#define SDCard_CMD13 16 //命令16，設置扇區(qū)大小 應返回0x00
#define SDCard_CMD17 17 //命令17，讀扇區(qū)
#define SDCard_CMD18 18 //命令18，讀Multi 扇區(qū)
#define SDCard_CMD23 23 //命令23，設置多扇區(qū)寫入前預先擦除N個block
#define SDCard_CMD24 24 //命令24，寫扇區(qū)
#define SDCard_CMD25 25 //命令25，寫多個扇區(qū)
#define SDCard_CMD41 41 //命令41，應返回0x00
#define SDCard_CMD55 55 //命令55，應返回0x01
#define SDCard_CMD58 58 //命令58，讀OCR信息
#define SDCard_CMD59 59 //命令59，使能/禁止CRC，應返回0x00、
/*SD卡回應標記字*/
#define SDCard_RESPONSE_NO_ERROR 0x00 //正確回應
#define SDCard_SD_IN_IDLE_STATE 0x01 //閑置狀態(tài)
#define SDCard_SD_ERASE_RESET 0x02 //擦除復位
#define SDCard_RESPONSE_FAILURE 0xFF //響應失敗
//函數(shù)聲明
u8 SDCardReadWriteOneByte(u8 data); //底層接口，SPI讀寫字節(jié)函數(shù)
void SDCardWaitBusy(void); //等待SD卡準備
u8 SDCardGetAck(u8 Response); //獲得應答
u8 SDCardDeviceInit(void); //初始化
u8 SDCardReadData(u8*buf,u32 sector,u32 cnt); //讀塊(扇區(qū))
u8 SDCardWriteData(u8*buf,u32 sector,u32 cnt); //寫塊(扇區(qū))
u32 GetSDCardSectorCount(void); //讀扇區(qū)數(shù)
u8 GetSDCardCISDCardOutnfo(u8 *cid_data); //讀SD卡CID
u8 GetSDCardCSSDCardOutnfo(u8 *csd_data); //讀SD卡CSD
#endif
（4）運行效果
3.2 SPI硬件時序方式
上面的3.1小節(jié)是采用SPI模擬時序驅(qū)動SD NAND，STM32本身集成有SPI硬件模塊，可以直接利用STM32硬件SPI接口讀寫。
下面貼出底層的適配代碼。 上面貼出的驅(qū)動代碼里，已經(jīng)將驅(qū)動接口部分和協(xié)議邏輯部分區(qū)分開了，替換底層的SIP讀寫代碼非常方便。
（1）主要替換的代碼
/*
函數(shù)功能：SPI初始化(模擬SPI)
硬件連接：
MISO--->PB14
MOSI--->PB15
SCLK--->PB13
*/
void SPI_Init(void)
{
/*開啟時鐘*/
RCC->APB1ENR|=1<<14; //開啟SPI2時鐘
RCC->APB2ENR|=1<<3; //PB
GPIOB->CRH&=0X000FFFFF; //清除寄存器
GPIOB->CRH|=0XB8B00000;
GPIOB->ODR|=0X7<<13; //PB13/14/15上拉--輸出高電平
/*SPI2基本配置*/
SPI2->CR1=0X0; //清空寄存器
SPI2->CR1|=0<<15; //選擇“雙線雙向”模式
SPI2->CR1|=0<<11; //使用8位數(shù)據(jù)幀格式進行發(fā)送/接收；
SPI2->CR1|=0<<10; //全雙工(發(fā)送和接收)；
SPI2->CR1|=1<<9; //啟用軟件從設備管理
SPI2->CR1|=1<<8; //NSS
SPI2->CR1|=0<<7; //幀格式，先發(fā)送高位
SPI2->CR1|=0x0<<3;//當總線頻率為36MHZ時，SPI速度為18MHZ，高速。
SPI2->CR1|=1<<2; //配置為主設備
SPI2->CR1|=1<<1; //空閑狀態(tài)時， SCK保持高電平。
SPI2->CR1|=1<<0; //數(shù)據(jù)采樣從第二個時鐘邊沿開始。
SPI2->CR1|=1<<6; //開啟SPI設備。
}
/*
函數(shù)功能：SPI讀寫一個字節(jié)
*/
u8 SPI_ReadWriteOneByte(u8 data_tx)
{
u16 cnt=0;
while((SPI2->SR&1<<1)==0) //等待發(fā)送區(qū)空--等待發(fā)送緩沖為空
{
cnt++;
if(cnt>=65530)return 0; //超時退出 u16=2個字節(jié)
}
SPI2->DR=data_tx; //發(fā)送一個byte
cnt=0;
while((SPI2->SR&1<<0)==0) //等待接收完一個byte
{
cnt++;
if(cnt>=65530)return 0; //超時退出
}
return SPI2->DR; //返回收到的數(shù)據(jù)
}
函數(shù)功能：SD卡底層接口,通過SPI時序向SD卡讀寫一個字節(jié)
函數(shù)參數(shù)：data是要寫入的數(shù)據(jù)
返 回 值：讀到的數(shù)據(jù)
*/
u8 SDCardReadWriteOneByte(u8 DataTx)
{
return SPI_ReadWriteOneByte(DataTx);
}
（2）運行效果
3.3 SDIO方式
如果想提高SD NAND的讀寫速度，可以采用SDIO協(xié)議，STM32本身有SDIO的硬件支持，配置好SDIO的寄存器即可完成SD NAND的操作。 SDIO的數(shù)據(jù)線都比SPI多，讀寫速度自然沒法比的。
下面貼出STM32F103ZE上面編寫的SDIO協(xié)議讀寫SD NAND的驅(qū)動代碼。
（1）整體工程代碼
（2）sdio.c
#include "sdio_sdcard.h"
#include "string.h"
#include "sys.h"
#include "usart.h"
static u8 CardType=SDIO_STD_CAPACITY_SD_CARD_V1_1; //SD卡類型（默認為1.x卡）
static u32 CSD_Tab[4],CID_Tab[4],RCA=0; //SD卡CSD,CID以及相對地址(RCA)數(shù)據(jù)
static u8 DeviceMode=SD_DMA_MODE; //工作模式,注意,工作模式必須通過SDIO_SdCardSetDeviceMode,后才算數(shù).這里只是定義一個默認的模式(SD_DMA_MODE)
static u8 StopCondition=0; //是否發(fā)送停止傳輸標志位,DMA多塊讀寫的時候用到
volatile SDIO_SD_ERROR_INFO TransferError=SD_OK; //數(shù)據(jù)傳輸錯誤標志,DMA讀寫時使用
volatile u8 TransferEnd=0; //傳輸結束標志,DMA讀寫時使用
SD_CardInfo SDCardInfo; //SD卡信息
//SDIO_SdCardReadDiskSector/SDIO_SdCardWriteDiskSector函數(shù)專用buf,當這兩個函數(shù)的數(shù)據(jù)緩存區(qū)地址不是4字節(jié)對齊的時候,
//需要用到該數(shù)組,確保數(shù)據(jù)緩存區(qū)地址是4字節(jié)對齊的.
__align(4) u8 SDIO_DATA_BUFFER[512];
/*
SD卡與開發(fā)板的SDIO方式接線關系如下:
DATA0---PC8
DATA1---PC9
DATA2---PC10
DATA3---PC11
CLK-----PC1
CMD-----PD2
*/
/*
函數(shù)功能:SDIO方式初始化SD卡
返回值 :錯誤代碼;(0,無錯誤)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardInit(void)
{
u8 clkdiv=0;
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
//SDIO IO口初始化
RCC->APB2ENR|=1<<4; //使能PORTC時鐘
RCC->APB2ENR|=1<<5; //使能PORTD時鐘
RCC->AHBENR|=1<<10; //使能SDIO時鐘
RCC->AHBENR|=1<<1; //使能DMA2時鐘
GPIOC->CRH&=0XFFF00000;
GPIOC->CRH|=0X000BBBBB; //PC.8~12 復用輸出
GPIOD->CRL&=0XFFFFF0FF;
GPIOD->CRL|=0X00000B00; //PD2復用輸出,PD7 上拉輸入
//SDIO外設寄存器設置為默認值
SDIO->POWER=0x00000000;
SDIO->CLKCR=0x00000000;
SDIO->ARG=0x00000000;
SDIO->CMD=0x00000000;
SDIO->DTIMER=0x00000000;
SDIO->DLEN=0x00000000;
SDIO->DCTRL=0x00000000;
SDIO->ICR=0x00C007FF;
SDIO->MASK=0x00000000;
STM32_NVIC_SetPriority(SDIO_IRQn,0,0); //SDIO中斷配置
errorstatus=SDIO_SdPowerON(); //SD卡上電
SDIO_SdCardInitializeCards(); //初始化SD卡
SDIO_SdCardGetInfo(&SDCardInfo); //獲取卡信息
SDIO_SdCardSelectAddr((u32)(SDCardInfo.RCA<<16));//選中SD卡
SDIO_SdCardEnableWideBusOperation(1); //4位寬度,如果是MMC卡,則不能用4位模式
if((errorstatus==SD_OK)||(SDIO_MULTIMEDIA_CARD==CardType))
{
if(SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1||SDCardInfo.CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)
{
clkdiv=SDIO_TRANSFER_CLK_DIV+6; //V1.1/V2.0卡，設置最高72/12=6Mhz
}else clkdiv=SDIO_TRANSFER_CLK_DIV; //SDHC等其他卡，設置最高72/6=12Mhz
SDIO_ClockSet(clkdiv); //設置時鐘頻率,SDIO時鐘計算公式:SDIO_CK時鐘=SDIOCLK/[clkdiv+2];其中,SDIOCLK固定為48Mhz
errorstatus=SDIO_SdCardSetDeviceMode(SD_POLLING_MODE); //設置為查詢模式
}
return errorstatus;
}
/*
函數(shù)功能: SDIO時鐘初始化設置
函數(shù)參數(shù):
clkdiv:時鐘分頻系數(shù)
CK時鐘=SDIOCLK/[clkdiv+2];(SDIOCLK時鐘固定為48Mhz)
*/
void SDIO_ClockSet(u8 clkdiv)
{
u32 tmpreg=SDIO->CLKCR;
tmpreg&=0XFFFFFF00;
tmpreg|=clkdiv;
SDIO->CLKCR=tmpreg;
}
/*
函數(shù)功能: SDIO發(fā)送命令函數(shù)
函數(shù)參數(shù):
cmdindex:命令索引,低六位有效
waitrsp:期待的相應.00/10,無響應;01,短響應;11,長響應
arg:參數(shù)
*/
void SDIO_SendCmd(u8 cmdindex,u8 waitrsp,u32 arg)
{
u32 tmpreg;
SDIO->ARG=arg;
tmpreg=SDIO->CMD;
tmpreg&=0XFFFFF800; //清除index和waitrsp
tmpreg|=cmdindex&0X3F; //設置新的index
tmpreg|=waitrsp<<6; //設置新的wait rsp
tmpreg|=0<<8; //無等待
tmpreg|=1<<10; //命令通道狀態(tài)機使能
SDIO->CMD=tmpreg;
}
/*
函數(shù)功能: SDIO發(fā)送數(shù)據(jù)配置函數(shù)
函數(shù)參數(shù):
datatimeout:超時時間設置
datalen:傳輸數(shù)據(jù)長度,低25位有效,必須為塊大小的整數(shù)倍
blksize:塊大小.實際大小為:2^blksize字節(jié)
dir:數(shù)據(jù)傳輸方向:0,控制器到卡;1,卡到控制器;
*/
void SDIO_SendDataConfig(u32 datatimeout,u32 datalen,u8 blksize,u8 dir)
{
u32 tmpreg;
SDIO->DTIMER=datatimeout;
SDIO->DLEN=datalen&0X1FFFFFF; //低25位有效
tmpreg=SDIO->DCTRL;
tmpreg&=0xFFFFFF08; //清除之前的設置.
tmpreg|=blksize<<4; //設置塊大小
tmpreg|=0<<2; //塊數(shù)據(jù)傳輸
tmpreg|=(dir&0X01)<<1; //方向控制
tmpreg|=1<<0; //數(shù)據(jù)傳輸使能,DPSM狀態(tài)機
SDIO->DCTRL=tmpreg;
}
/*
函數(shù)功能:卡上電
查詢所有SDIO接口上的卡設備,并查詢其電壓和配置時鐘
返回值:錯誤代碼;(0,無錯誤)
*/
SDIO_SD_ERROR_INFO SDIO_SdPowerON(void)
{
u8 i=0;
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u32 response=0,count=0,validvoltage=0;
u32 SDType=SD_STD_CAPACITY;
//配置CLKCR寄存器
SDIO->CLKCR=0; //清空CLKCR之前的設置
SDIO->CLKCR|=0<<9; //非省電模式
SDIO->CLKCR|=0<<10; //關閉旁路,CK根據(jù)分頻設置輸出
SDIO->CLKCR|=0<<11; //1位數(shù)據(jù)寬度
SDIO->CLKCR|=0<<13; //SDIOCLK上升沿產(chǎn)生SDIOCK
SDIO->CLKCR|=0<<14; //關閉硬件流控制
SDIO_ClockSet(SDIO_INIT_CLK_DIV);//設置時鐘頻率(初始化的時候,不能超過400Khz)
SDIO->POWER=0X03; //上電狀態(tài),開啟卡時鐘
SDIO->CLKCR|=1<<8; //SDIOCK使能
for(i=0;i<74;i++)
{
SDIO_SendCmd(SD_CMD_GO_IDLE_STATE,0,0);//發(fā)送CMD0進入IDLE STAGE模式命令.
errorstatus=SDIO_CmdErrorCheck();
if(errorstatus==SD_OK)break;
}
if(errorstatus)return errorstatus;//返回錯誤狀態(tài)
SDIO_SendCmd(SDIO_SEND_IF_COND,1,SD_CHECK_PATTERN);//發(fā)送CMD8,短響應,檢查SD卡接口特性.
//arg[11:8]:01,支持電壓范圍,2.7~3.6V
//arg[7:0]:默認0XAA
//返回響應7
errorstatus=SDIO_CmdResp7Error(); //等待R7響應
if(errorstatus==SD_OK) //R7響應正常
{
CardType=SDIO_STD_CAPACITY_SD_CARD_V2_0; //SD 2.0卡
SDType=SD_HIGH_CAPACITY; //高容量卡
}
SDIO_SendCmd(SD_CMD_APP_CMD,1,0); //發(fā)送CMD55,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus==SD_OK)//SD2.0/SD 1.1
{
//SD卡,發(fā)送ACMD41 SD_APP_OP_COND,參數(shù)為:0x80100000
while((!validvoltage)&&(count<SD_MAX_VOLT_TRIAL))
{
SDIO_SendCmd(SD_CMD_APP_CMD,1,0); //發(fā)送CMD55,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
SDIO_SendCmd(SD_CMD_SD_APP_OP_COND,1,SD_VOLTAGE_WINDOW_SD|SDType);//發(fā)送ACMD41,短響應
errorstatus=SDIO_CmdResp3Error(); //等待R3響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
response=SDIO->RESP1;; //得到響應
validvoltage=(((response>>31)==1)?1:0); //判斷SD卡上電是否完成
count++;
}
if(count>=SD_MAX_VOLT_TRIAL)
{
errorstatus=SD_INVALID_VOLTRANGE;
return errorstatus;
}
if(response&=SD_HIGH_CAPACITY)
{
CardType=SDIO_HIGH_CAPACITY_SD_CARD;
}
}
return(errorstatus);
}
/*
函數(shù)功能: SD卡斷電
返回值:錯誤代碼;(0,無錯誤)
*/
SDIO_SD_ERROR_INFO SD_PowerOFF(void)
{
SDIO->POWER&=~(3<<0);//SDIO電源關閉,時鐘停止
return SD_OK;
}
/*
函數(shù)功能:初始化所有的卡,并讓卡進入就緒狀態(tài)
返回值:錯誤代碼
*/
SDIO_SD_ERROR_INFO SDIO_SdCardInitializeCards(void)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u16 rca = 0x01;
if((SDIO->POWER&0X03)==0)return SD_REQUEST_NOT_APPLICABLE;//檢查電源狀態(tài),確保為上電狀態(tài)
if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
SDIO_SendCmd(SD_CMD_ALL_SEND_CID,3,0); //發(fā)送CMD2,取得CID,長響應
errorstatus=SDIO_CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
CID_Tab[0]=SDIO->RESP1;
CID_Tab[1]=SDIO->RESP2;
CID_Tab[2]=SDIO->RESP3;
CID_Tab[3]=SDIO->RESP4;
}
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_SECURE_DIGITAL_IO_COMBO_CARD==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))//判斷卡類型
{
SDIO_SendCmd(SD_CMD_SET_REL_ADDR,1,0); //發(fā)送CMD3,短響應
errorstatus=SDIO_CmdResp6Error(SD_CMD_SET_REL_ADDR,&rca);//等待R6響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}
if(SDIO_MULTIMEDIA_CARD==CardType)
{
SDIO_SendCmd(SD_CMD_SET_REL_ADDR,1,(u32)(rca<<16));//發(fā)送CMD3,短響應
errorstatus=SDIO_CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}
if(SDIO_SECURE_DIGITAL_IO_CARD!=CardType) //非SECURE_DIGITAL_IO_CARD
{
RCA = rca;
SDIO_SendCmd(SD_CMD_SEND_CSD,3,(u32)(rca<<16));//發(fā)送CMD9+卡RCA,取得CSD,長響應
errorstatus=SDIO_CmdResp2Error(); //等待R2響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
CSD_Tab[0]=SDIO->RESP1;
CSD_Tab[1]=SDIO->RESP2;
CSD_Tab[2]=SDIO->RESP3;
CSD_Tab[3]=SDIO->RESP4;
}
return SD_OK;//卡初始化成功
}
/*
函數(shù)功能:得到卡信息
函數(shù)參數(shù):
cardinfo:卡信息存儲區(qū)
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardGetInfo(SD_CardInfo *cardinfo)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u8 tmp=0;
cardinfo->CardType=(u8)CardType; //卡類型
cardinfo->RCA=(u16)RCA; //卡RCA值
tmp=(u8)((CSD_Tab[0]&0xFF000000)>>24);
cardinfo->SD_csd.CSDStruct=(tmp&0xC0)>>6; //CSD結構
cardinfo->SD_csd.SysSpecVersion=(tmp&0x3C)>>2; //2.0協(xié)議還沒定義這部分(為保留),應該是后續(xù)協(xié)議定義的
cardinfo->SD_csd.Reserved1=tmp&0x03; //2個保留位
tmp=(u8)((CSD_Tab[0]&0x00FF0000)>>16); //第1個字節(jié)
cardinfo->SD_csd.TAAC=tmp; //數(shù)據(jù)讀時間1
tmp=(u8)((CSD_Tab[0]&0x0000FF00)>>8); //第2個字節(jié)
cardinfo->SD_csd.NSAC=tmp; //數(shù)據(jù)讀時間2
tmp=(u8)(CSD_Tab[0]&0x000000FF); //第3個字節(jié)
cardinfo->SD_csd.MaxBusClkFrec=tmp; //傳輸速度
tmp=(u8)((CSD_Tab[1]&0xFF000000)>>24); //第4個字節(jié)
cardinfo->SD_csd.CardComdClasses=tmp<<4; //卡指令類高四位
tmp=(u8)((CSD_Tab[1]&0x00FF0000)>>16); //第5個字節(jié)
cardinfo->SD_csd.CardComdClasses|=(tmp&0xF0)>>4;//卡指令類低四位
cardinfo->SD_csd.RdBlockLen=tmp&0x0F; //最大讀取數(shù)據(jù)長度
tmp=(u8)((CSD_Tab[1]&0x0000FF00)>>8); //第6個字節(jié)
cardinfo->SD_csd.PartBlockRead=(tmp&0x80)>>7; //允許分塊讀
cardinfo->SD_csd.WrBlockMisalign=(tmp&0x40)>>6; //寫塊錯位
cardinfo->SD_csd.RdBlockMisalign=(tmp&0x20)>>5; //讀塊錯位
cardinfo->SD_csd.DSRImpl=(tmp&0x10)>>4;
cardinfo->SD_csd.Reserved2=0; //保留
if((CardType==SDIO_STD_CAPACITY_SD_CARD_V1_1)||(CardType==SDIO_STD_CAPACITY_SD_CARD_V2_0)||(SDIO_MULTIMEDIA_CARD==CardType))//標準1.1/2.0卡/MMC卡
{
cardinfo->SD_csd.DeviceSize=(tmp&0x03)<<10; //C_SIZE(12位)
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp)<<2;
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp&0xC0)>>6;
cardinfo->SD_csd.MaxRdCurrentVDDMin=(tmp&0x38)>>3;
cardinfo->SD_csd.MaxRdCurrentVDDMax=(tmp&0x07);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個字節(jié)
cardinfo->SD_csd.MaxWrCurrentVDDMin=(tmp&0xE0)>>5;
cardinfo->SD_csd.MaxWrCurrentVDDMax=(tmp&0x1C)>>2;
cardinfo->SD_csd.DeviceSizeMul=(tmp&0x03)<<1;//C_SIZE_MULT
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個字節(jié)
cardinfo->SD_csd.DeviceSizeMul|=(tmp&0x80)>>7;
cardinfo->CardCapacity=(cardinfo->SD_csd.DeviceSize+1);//計算卡容量
cardinfo->CardCapacity*=(1<<(cardinfo->SD_csd.DeviceSizeMul+2));
cardinfo->CardBlockSize=1<<(cardinfo->SD_csd.RdBlockLen);//塊大小
cardinfo->CardCapacity*=cardinfo->CardBlockSize;
}else if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //高容量卡
{
tmp=(u8)(CSD_Tab[1]&0x000000FF); //第7個字節(jié)
cardinfo->SD_csd.DeviceSize=(tmp&0x3F)<<16;//C_SIZE
tmp=(u8)((CSD_Tab[2]&0xFF000000)>>24); //第8個字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp<<8);
tmp=(u8)((CSD_Tab[2]&0x00FF0000)>>16); //第9個字節(jié)
cardinfo->SD_csd.DeviceSize|=(tmp);
tmp=(u8)((CSD_Tab[2]&0x0000FF00)>>8); //第10個字節(jié)
cardinfo->CardCapacity=(long long)(cardinfo->SD_csd.DeviceSize+1)*512*1024;//計算卡容量
cardinfo->CardBlockSize=512; //塊大小固定為512字節(jié)
}
cardinfo->SD_csd.EraseGrSize=(tmp&0x40)>>6;
cardinfo->SD_csd.EraseGrMul=(tmp&0x3F)<<1;
tmp=(u8)(CSD_Tab[2]&0x000000FF); //第11個字節(jié)
cardinfo->SD_csd.EraseGrMul|=(tmp&0x80)>>7;
cardinfo->SD_csd.WrProtectGrSize=(tmp&0x7F);
tmp=(u8)((CSD_Tab[3]&0xFF000000)>>24); //第12個字節(jié)
cardinfo->SD_csd.WrProtectGrEnable=(tmp&0x80)>>7;
cardinfo->SD_csd.ManDeflECC=(tmp&0x60)>>5;
cardinfo->SD_csd.WrSpeedFact=(tmp&0x1C)>>2;
cardinfo->SD_csd.MaxWrBlockLen=(tmp&0x03)<<2;
tmp=(u8)((CSD_Tab[3]&0x00FF0000)>>16); //第13個字節(jié)
cardinfo->SD_csd.MaxWrBlockLen|=(tmp&0xC0)>>6;
cardinfo->SD_csd.WriteBlockPaPartial=(tmp&0x20)>>5;
cardinfo->SD_csd.Reserved3=0;
cardinfo->SD_csd.ContentProtectAppli=(tmp&0x01);
tmp=(u8)((CSD_Tab[3]&0x0000FF00)>>8); //第14個字節(jié)
cardinfo->SD_csd.FileFormatGrouop=(tmp&0x80)>>7;
cardinfo->SD_csd.CopyFlag=(tmp&0x40)>>6;
cardinfo->SD_csd.PermWrProtect=(tmp&0x20)>>5;
cardinfo->SD_csd.TempWrProtect=(tmp&0x10)>>4;
cardinfo->SD_csd.FileFormat=(tmp&0x0C)>>2;
cardinfo->SD_csd.ECC=(tmp&0x03);
tmp=(u8)(CSD_Tab[3]&0x000000FF); //第15個字節(jié)
cardinfo->SD_csd.CSD_CRC=(tmp&0xFE)>>1;
cardinfo->SD_csd.Reserved4=1;
tmp=(u8)((CID_Tab[0]&0xFF000000)>>24); //第0個字節(jié)
cardinfo->SD_cid.ManufacturerID=tmp;
tmp=(u8)((CID_Tab[0]&0x00FF0000)>>16); //第1個字節(jié)
cardinfo->SD_cid.OEM_AppliID=tmp<<8;
tmp=(u8)((CID_Tab[0]&0x000000FF00)>>8); //第2個字節(jié)
cardinfo->SD_cid.OEM_AppliID|=tmp;
tmp=(u8)(CID_Tab[0]&0x000000FF); //第3個字節(jié)
cardinfo->SD_cid.ProdName1=tmp<<24;
tmp=(u8)((CID_Tab[1]&0xFF000000)>>24); //第4個字節(jié)
cardinfo->SD_cid.ProdName1|=tmp<<16;
tmp=(u8)((CID_Tab[1]&0x00FF0000)>>16); //第5個字節(jié)
cardinfo->SD_cid.ProdName1|=tmp<<8;
tmp=(u8)((CID_Tab[1]&0x0000FF00)>>8); //第6個字節(jié)
cardinfo->SD_cid.ProdName1|=tmp;
tmp=(u8)(CID_Tab[1]&0x000000FF); //第7個字節(jié)
cardinfo->SD_cid.ProdName2=tmp;
tmp=(u8)((CID_Tab[2]&0xFF000000)>>24); //第8個字節(jié)
cardinfo->SD_cid.ProdRev=tmp;
tmp=(u8)((CID_Tab[2]&0x00FF0000)>>16); //第9個字節(jié)
cardinfo->SD_cid.ProdSN=tmp<<24;
tmp=(u8)((CID_Tab[2]&0x0000FF00)>>8); //第10個字節(jié)
cardinfo->SD_cid.ProdSN|=tmp<<16;
tmp=(u8)(CID_Tab[2]&0x000000FF); //第11個字節(jié)
cardinfo->SD_cid.ProdSN|=tmp<<8;
tmp=(u8)((CID_Tab[3]&0xFF000000)>>24); //第12個字節(jié)
cardinfo->SD_cid.ProdSN|=tmp;
tmp=(u8)((CID_Tab[3]&0x00FF0000)>>16); //第13個字節(jié)
cardinfo->SD_cid.Reserved1|=(tmp&0xF0)>>4;
cardinfo->SD_cid.ManufactDate=(tmp&0x0F)<<8;
tmp=(u8)((CID_Tab[3]&0x0000FF00)>>8); //第14個字節(jié)
cardinfo->SD_cid.ManufactDate|=tmp;
tmp=(u8)(CID_Tab[3]&0x000000FF); //第15個字節(jié)
cardinfo->SD_cid.CID_CRC=(tmp&0xFE)>>1;
cardinfo->SD_cid.Reserved2=1;
return errorstatus;
}
/*
函數(shù)功能: 設置SDIO總線寬度
函數(shù)參數(shù):
wmode:位寬模式.0,1位數(shù)據(jù)寬度;1,4位數(shù)據(jù)寬度;2,8位數(shù)據(jù)寬度
返回值:SD卡錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardEnableWideBusOperation(u32 wmode)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
if(wmode>=2)return SD_UNSUPPORTED_FEATURE;//不支持8位模式
else
{
errorstatus=SDIO_SdCardEnWideBus(wmode);
if(SD_OK==errorstatus)
{
SDIO->CLKCR&=~(3<<11); //清除之前的位寬設置
SDIO->CLKCR|=(u16)wmode<<11;//1位/4位總線寬度
SDIO->CLKCR|=0<<14; //不開啟硬件流控制
}
}
}
return errorstatus;
}
/*
函數(shù)功能:設置SD卡工作模式
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSetDeviceMode(u32 Mode)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
if((Mode==SD_DMA_MODE)||(Mode==SD_POLLING_MODE))DeviceMode=Mode;
else errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
/*
函數(shù)功能:選卡,發(fā)送CMD7,選擇相對地址(rca)為addr的卡,取消其他卡.如果為0,則都不選擇.
函數(shù)參數(shù):
addr:卡的RCA地址
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSelectAddr(u32 addr)
{
SDIO_SendCmd(SD_CMD_SEL_DESEL_CARD,1,addr); //發(fā)送CMD7,選擇卡,短響應
return SDIO_CmdResp1Error(SD_CMD_SEL_DESEL_CARD);
}
/*
函數(shù)功能: SD卡讀取一個塊
函數(shù)參數(shù):
buf:讀數(shù)據(jù)緩存區(qū)(必須4字節(jié)對齊!!)
addr:讀取地址
blksize:塊大小
*/
SDIO_SD_ERROR_INFO SDIO_SdCardReadBlock(u8 *buf,long long addr,u16 blksize)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u8 power;
u32 count=0,*tempbuff=(u32*)buf;//轉(zhuǎn)換為u32指針
u32 timeout=SDIO_DATATIMEOUT;
if(NULL==buf)return SD_INVALID_PARAMETER;
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_SendDataConfig(SD_DATATIMEOUT,0,0,0); //清除DPSM狀態(tài)機配置
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
SDIO_SendDataConfig(SD_DATATIMEOUT,blksize,power,1); //blksize,卡到控制器
SDIO_SendCmd(SD_CMD_READ_SINGLE_BLOCK,1,addr); //發(fā)送CMD17+從addr地址出讀取數(shù)據(jù),短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_READ_SINGLE_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
if(DeviceMode==SD_POLLING_MODE) //查詢模式,輪詢數(shù)據(jù)
{
// INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<10)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
{
if(SDIO->STA&(1<<15)) //接收區(qū)半滿,表示至少存了8個字
{
for(count=0;count<8;count++) //循環(huán)讀取數(shù)據(jù)
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數(shù)據(jù)溢出時間
}else //處理超時
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO->STA&(1<<3)) //數(shù)據(jù)超時錯誤
{
SDIO->ICR|=1<<3; //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO->STA&(1<<1)) //數(shù)據(jù)塊CRC錯誤
{
SDIO->ICR|=1<<1; //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO->STA&(1<<5)) //接收fifo上溢錯誤
{
SDIO->ICR|=1<<5; //清錯誤標志
return SD_RX_OVERRUN;
}else if(SDIO->STA&(1<<9)) //接收起始位錯誤
{
SDIO->ICR|=1<<9; //清錯誤標志
return SD_START_BIT_ERR;
}
while(SDIO->STA&(1<<21)) //FIFO里面,還存在可用數(shù)據(jù)
{
*tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
tempbuff++;
}
// INTX_ENABLE();//開啟總中斷
SDIO->ICR=0X5FF; //清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
SDIO_SdCard_DMAConfig((u32*)buf,blksize,0);
TransferError=SD_OK;
StopCondition=0; //單塊讀,不需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
while(((DMA2->ISR&0X2000)==RESET)&&(TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時
if(TransferError!=SD_OK)errorstatus=TransferError;
}
return errorstatus;
}
/*
函數(shù)功能: SD卡讀取多個塊
函數(shù)參數(shù):
buf:讀數(shù)據(jù)緩存區(qū)
addr:讀取地址
blksize:塊大小
nblks:要讀取的塊數(shù)
返回值:錯誤狀態(tài)
*/
__align(4) u32 *tempbuff;
SDIO_SD_ERROR_INFO SDIO_SdCardReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u8 power;
u32 count=0;
u32 timeout=SDIO_DATATIMEOUT;
tempbuff=(u32*)buf; //轉(zhuǎn)換為u32指針
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關DMA)
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
SDIO_SendDataConfig(SD_DATATIMEOUT,0,0,0); //清除DPSM狀態(tài)機配置
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
if(nblks>1) //多塊讀
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;//判斷是否超過最大接收長度
SDIO_SendDataConfig(SD_DATATIMEOUT,nblks*blksize,power,1);//nblks*blksize,512塊大小,卡到控制器
SDIO_SendCmd(SD_CMD_READ_MULT_BLOCK,1,addr); //發(fā)送CMD18+從addr地址出讀取數(shù)據(jù),短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_READ_MULT_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
if(DeviceMode==SD_POLLING_MODE)
{
// INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<5)|(1<<1)|(1<<3)|(1<<8)|(1<<9))))//無上溢/CRC/超時/完成(標志)/起始位錯誤
{
if(SDIO->STA&(1<<15)) //接收區(qū)半滿,表示至少存了8個字
{
for(count=0;count<8;count++) //循環(huán)讀取數(shù)據(jù)
{
*(tempbuff+count)=SDIO->FIFO;
}
tempbuff+=8;
timeout=0X7FFFFF; //讀數(shù)據(jù)溢出時間
}else //處理超時
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO->STA&(1<<3)) //數(shù)據(jù)超時錯誤
{
SDIO->ICR|=1<<3; //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO->STA&(1<<1)) //數(shù)據(jù)塊CRC錯誤
{
SDIO->ICR|=1<<1; //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO->STA&(1<<5)) //接收fifo上溢錯誤
{
SDIO->ICR|=1<<5; //清錯誤標志
return SD_RX_OVERRUN;
}else if(SDIO->STA&(1<<9)) //接收起始位錯誤
{
SDIO->ICR|=1<<9; //清錯誤標志
return SD_START_BIT_ERR;
}
while(SDIO->STA&(1<<21)) //FIFO里面,還存在可用數(shù)據(jù)
{
*tempbuff=SDIO->FIFO; //循環(huán)讀取數(shù)據(jù)
tempbuff++;
}
if(SDIO->STA&(1<<8)) //接收結束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //發(fā)送CMD12+結束傳輸
errorstatus=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
}
// INTX_ENABLE();//開啟總中斷
SDIO->ICR=0X5FF; //清除所有標記
}
else if(DeviceMode==SD_DMA_MODE)
{
SDIO_SdCard_DMAConfig((u32*)buf,nblks*blksize,0);
TransferError=SD_OK;
StopCondition=1; //多塊讀,需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<5)|(1<<9); //配置需要的中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能
while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)return SD_DATA_TIMEOUT;//超時
while((TransferEnd==0)&&(TransferError==SD_OK));
if(TransferError!=SD_OK)errorstatus=TransferError;
}
}
return errorstatus;
}
/*
函數(shù)功能:SD卡寫1個塊
函數(shù)參數(shù):
buf:數(shù)據(jù)緩存區(qū)
addr:寫地址
blksize:塊大小
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardWriteBlock(u8 *buf,long long addr, u16 blksize)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
u8 power=0,cardstate=0;
u32 timeout=0,bytestransferred=0;
u32 cardstatus=0,count=0,restwords=0;
u32 tlen=blksize; //總長度(字節(jié))
u32*tempbuff=(u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER;//參數(shù)錯誤
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關DMA)
SDIO_SendDataConfig(SD_DATATIMEOUT,0,0,0); //清除DPSM狀態(tài)機配置
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD) //大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16); //發(fā)送CMD13,查詢卡的狀態(tài),短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
timeout=SD_DATATIMEOUT;
while(((cardstatus&0x00000100)==0)&&(timeout>0)) //檢查READY_FOR_DATA位是否置位
{
timeout--;
SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16);//發(fā)送CMD13,查詢卡的狀態(tài),短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
cardstatus=SDIO->RESP1;
}
if(timeout==0)return SD_ERROR;
SDIO_SendCmd(SD_CMD_WRITE_SINGLE_BLOCK,1,addr); //發(fā)送CMD24,寫單塊指令,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_WRITE_SINGLE_BLOCK);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
StopCondition=0; //單塊寫,不需要發(fā)送停止傳輸指令
SDIO_SendDataConfig(SD_DATATIMEOUT,blksize,power,0); //blksize, 控制器到卡
timeout=SDIO_DATATIMEOUT;
if(DeviceMode == SD_POLLING_MODE)
{
// INTX_DISABLE();//關閉總中斷(POLLING模式,嚴禁中斷打斷SDIO讀寫操作!!!)
while(!(SDIO->STA&((1<<10)|(1<<4)|(1<<1)|(1<<3)|(1<<9))))//數(shù)據(jù)塊發(fā)送成功/下溢/CRC/超時/起始位錯誤
{
if(SDIO->STA&(1<<14)) //發(fā)送區(qū)半空,表示至少存了8個字
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else
{
for(count=0;count<8;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=8;
bytestransferred+=32;
}
timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO->STA&(1<<3)) //數(shù)據(jù)超時錯誤
{
SDIO->ICR|=1<<3; //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO->STA&(1<<1)) //數(shù)據(jù)塊CRC錯誤
{
SDIO->ICR|=1<<1; //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO->STA&(1<<4)) //接收fifo下溢錯誤
{
SDIO->ICR|=1<<4; //清錯誤標志
return SD_TX_UNDERRUN;
}else if(SDIO->STA&(1<<9)) //接收起始位錯誤
{
SDIO->ICR|=1<<9; //清錯誤標志
return SD_START_BIT_ERR;
}
// INTX_ENABLE();//開啟總中斷
SDIO->ICR=0X5FF; //清除所有標記
}else if(DeviceMode==SD_DMA_MODE)
{
SDIO_SdCard_DMAConfig((u32*)buf,blksize,1);//SDIO DMA配置
TransferError=SD_OK;
StopCondition=0; //單塊寫,不需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0)
{
SDIO_SdCardInit(); //重新初始化SD卡,可以解決寫入死機的問題
return SD_DATA_TIMEOUT; //超時
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時
if(TransferError!=SD_OK)return TransferError;
}
SDIO->ICR=0X5FF; //清除所有標記
errorstatus=SDIO_SdCardProgrammingState(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=SDIO_SdCardProgrammingState(&cardstate);
}
return errorstatus;
}
/*
函數(shù)功能:SD卡寫多個塊
函數(shù)參數(shù):
buf:數(shù)據(jù)緩存區(qū)
addr:寫地址
blksize:塊大小
nblks:要寫入的塊數(shù)
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardWriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
u8 power = 0, cardstate = 0;
u32 timeout=0,bytestransferred=0;
u32 count = 0, restwords = 0;
u32 tlen=nblks*blksize; //總長度(字節(jié))
u32 *tempbuff = (u32*)buf;
if(buf==NULL)return SD_INVALID_PARAMETER; //參數(shù)錯誤
SDIO->DCTRL=0x0; //數(shù)據(jù)控制寄存器清零(關DMA)
SDIO_SendDataConfig(SD_DATATIMEOUT,0,0,0); //清除DPSM狀態(tài)機配置
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//卡鎖了
if(CardType==SDIO_HIGH_CAPACITY_SD_CARD)//大容量卡
{
blksize=512;
addr>>=9;
}
if((blksize>0)&&(blksize<=2048)&&((blksize&(blksize-1))==0))
{
power=convert_from_bytes_to_power_of_two(blksize);
SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,blksize); //發(fā)送CMD16+設置數(shù)據(jù)長度為blksize,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus; //響應錯誤
}else return SD_INVALID_PARAMETER;
if(nblks>1)
{
if(nblks*blksize>SD_MAX_DATA_LENGTH)return SD_INVALID_PARAMETER;
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
//提高性能
SDIO_SendCmd(SD_CMD_APP_CMD,1,(u32)RCA<<16); //發(fā)送ACMD55,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
SDIO_SendCmd(SD_CMD_SET_BLOCK_COUNT,1,nblks); //發(fā)送CMD23,設置塊數(shù)量,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCK_COUNT);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
SDIO_SendCmd(SD_CMD_WRITE_MULT_BLOCK,1,addr); //發(fā)送CMD25,多塊寫指令,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_WRITE_MULT_BLOCK); //等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
SDIO_SendDataConfig(SD_DATATIMEOUT,nblks*blksize,power,0);//blksize, 控制器到卡
if(DeviceMode==SD_POLLING_MODE)
{
timeout=SDIO_DATATIMEOUT;
while(!(SDIO->STA&((1<<4)|(1<<1)|(1<<8)|(1<<3)|(1<<9))))//下溢/CRC/數(shù)據(jù)結束/超時/起始位錯誤
{
if(SDIO->STA&(1<<14)) //發(fā)送區(qū)半空,表示至少存了8字(32字節(jié))
{
if((tlen-bytestransferred)<SD_HALFFIFOBYTES)//不夠32字節(jié)了
{
restwords=((tlen-bytestransferred)%4==0)?((tlen-bytestransferred)/4):((tlen-bytestransferred)/4+1);
for(count=0;count<restwords;count++,tempbuff++,bytestransferred+=4)
{
SDIO->FIFO=*tempbuff;
}
}else //發(fā)送區(qū)半空,可以發(fā)送至少8字(32字節(jié))數(shù)據(jù)
{
for(count=0;count<SD_HALFFIFO;count++)
{
SDIO->FIFO=*(tempbuff+count);
}
tempbuff+=SD_HALFFIFO;
bytestransferred+=SD_HALFFIFOBYTES;
}
timeout=0X3FFFFFFF; //寫數(shù)據(jù)溢出時間
}else
{
if(timeout==0)return SD_DATA_TIMEOUT;
timeout--;
}
}
if(SDIO->STA&(1<<3)) //數(shù)據(jù)超時錯誤
{
SDIO->ICR|=1<<3; //清錯誤標志
return SD_DATA_TIMEOUT;
}else if(SDIO->STA&(1<<1)) //數(shù)據(jù)塊CRC錯誤
{
SDIO->ICR|=1<<1; //清錯誤標志
return SD_DATA_CRC_FAIL;
}else if(SDIO->STA&(1<<4)) //接收fifo下溢錯誤
{
SDIO->ICR|=1<<4; //清錯誤標志
return SD_TX_UNDERRUN;
}else if(SDIO->STA&(1<<9)) //接收起始位錯誤
{
SDIO->ICR|=1<<9; //清錯誤標志
return SD_START_BIT_ERR;
}
if(SDIO->STA&(1<<8)) //發(fā)送結束
{
if((SDIO_STD_CAPACITY_SD_CARD_V1_1==CardType)||(SDIO_STD_CAPACITY_SD_CARD_V2_0==CardType)||(SDIO_HIGH_CAPACITY_SD_CARD==CardType))
{
SDIO_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //發(fā)送CMD12+結束傳輸
errorstatus=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);//等待R1響應
if(errorstatus!=SD_OK)return errorstatus;
}
}
// INTX_ENABLE();//開啟總中斷
SDIO->ICR=0X5FF; //清除所有標記
}
else if(DeviceMode==SD_DMA_MODE)
{
SDIO_SdCard_DMAConfig((u32*)buf,nblks*blksize,1);//SDIO DMA配置
TransferError=SD_OK;
StopCondition=1; //多塊寫,需要發(fā)送停止傳輸指令
TransferEnd=0; //傳輸結束標置位，在中斷服務置1
SDIO->MASK|=(1<<1)|(1<<3)|(1<<8)|(1<<4)|(1<<9); //配置產(chǎn)生數(shù)據(jù)接收完成中斷
SDIO->DCTRL|=1<<3; //SDIO DMA使能.
timeout=SDIO_DATATIMEOUT;
while(((DMA2->ISR&0X2000)==RESET)&&timeout)timeout--;//等待傳輸完成
if(timeout==0) //超時
{
SDIO_SdCardInit(); //重新初始化SD卡,可以解決寫入死機的問題
return SD_DATA_TIMEOUT; //超時
}
timeout=SDIO_DATATIMEOUT;
while((TransferEnd==0)&&(TransferError==SD_OK)&&timeout)timeout--;
if(timeout==0)return SD_DATA_TIMEOUT; //超時
if(TransferError!=SD_OK)return TransferError;
}
}
SDIO->ICR=0X5FF; //清除所有標記
errorstatus=SDIO_SdCardProgrammingState(&cardstate);
while((errorstatus==SD_OK)&&((cardstate==SD_CARD_PROGRAMMING)||(cardstate==SD_CARD_RECEIVING)))
{
errorstatus=SDIO_SdCardProgrammingState(&cardstate);
}
return errorstatus;
}
/*
函數(shù)功能: SDIO中斷服務函數(shù)
*/
void SDIO_IRQHandler(void)
{
SDIO_SdCardProcessIRQSrc();//處理所有SDIO相關中斷
}
/*
函數(shù)功能: SDIO中斷處理函數(shù)
函數(shù)參數(shù): 處理SDIO傳輸過程中的各種中斷事務
返回值:錯誤代碼
*/
SDIO_SD_ERROR_INFO SDIO_SdCardProcessIRQSrc(void)
{
if(SDIO->STA&(1<<8))//接收完成中斷
{
if(StopCondition==1)
{
SDIO_SendCmd(SD_CMD_STOP_TRANSMISSION,1,0); //發(fā)送CMD12,結束傳輸
TransferError=SDIO_CmdResp1Error(SD_CMD_STOP_TRANSMISSION);
}else TransferError = SD_OK;
SDIO->ICR|=1<<8;//清除完成中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferEnd = 1;
return(TransferError);
}
if(SDIO->STA&(1<<1))//數(shù)據(jù)CRC錯誤
{
SDIO->ICR|=1<<1;//清除中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_DATA_CRC_FAIL;
return(SD_DATA_CRC_FAIL);
}
if(SDIO->STA&(1<<3))//數(shù)據(jù)超時錯誤
{
SDIO->ICR|=1<<3;//清除中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_DATA_TIMEOUT;
return(SD_DATA_TIMEOUT);
}
if(SDIO->STA&(1<<5))//FIFO上溢錯誤
{
SDIO->ICR|=1<<5;//清除中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_RX_OVERRUN;
return(SD_RX_OVERRUN);
}
if(SDIO->STA&(1<<4))//FIFO下溢錯誤
{
SDIO->ICR|=1<<4;//清除中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_TX_UNDERRUN;
return(SD_TX_UNDERRUN);
}
if(SDIO->STA&(1<<9))//起始位錯誤
{
SDIO->ICR|=1<<9;//清除中斷標記
SDIO->MASK&=~((1<<1)|(1<<3)|(1<<8)|(1<<14)|(1<<15)|(1<<4)|(1<<5)|(1<<9));//關閉相關中斷
TransferError = SD_START_BIT_ERR;
return(SD_START_BIT_ERR);
}
return(SD_OK);
}
/*
函數(shù)功能: 檢查CMD0的執(zhí)行狀態(tài)
返回值: sd卡錯誤碼
*/
SDIO_SD_ERROR_INFO SDIO_CmdErrorCheck(void)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
if(SDIO->STA&(1<<7))break; //命令已發(fā)送(無需響應)
}
if(timeout==0)return SD_CMD_RSP_TIMEOUT;
SDIO->ICR=0X5FF; //清除標記
return errorstatus;
}
/*
函數(shù)功能: 檢查R7響應的錯誤狀態(tài)
函數(shù)參數(shù): 返回值:sd卡錯誤碼
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp7Error(void)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
}
if((timeout==0)||(status&(1<<2))) //響應超時
{
errorstatus=SD_CMD_RSP_TIMEOUT; //當前卡不是2.0兼容卡,或者不支持設定的電壓范圍
SDIO->ICR|=1<<2; //清除命令響應超時標志
return errorstatus;
}
if(status&1<<6) //成功接收到響應
{
errorstatus=SD_OK;
SDIO->ICR|=1<<6; //清除響應標志
}
return errorstatus;
}
/*
函數(shù)功能:檢查R1響應的錯誤狀態(tài)
函數(shù)參數(shù):
cmd:當前命令
返回值:sd卡錯誤碼
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp1Error(u8 cmd)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
}
if(status&(1<<2)) //響應超時
{
SDIO->ICR=1<<2; //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
if(status&(1<<0)) //CRC錯誤
{
SDIO->ICR=1<<0; //清除標志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd)return SD_ILLEGAL_CMD;//命令不匹配
SDIO->ICR=0X5FF; //清除標記
return (SDIO_SD_ERROR_INFO)(SDIO->RESP1&SD_OCR_ERRORBITS);//返回卡響應
}
/*
函數(shù)功能: 檢查R3響應的錯誤狀態(tài)
返回值: 錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp3Error(void)
{
u32 status;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
}
if(status&(1<<2)) //響應超時
{
SDIO->ICR|=1<<2; //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
SDIO->ICR=0X5FF; //清除標記
return SD_OK;
}
/*
函數(shù)功能: 檢查R2響應的錯誤狀態(tài)
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp2Error(void)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u32 status;
u32 timeout=SDIO_CMD0TIMEOUT;
while(timeout--)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
}
if((timeout==0)||(status&(1<<2))) //響應超時
{
errorstatus=SD_CMD_RSP_TIMEOUT;
SDIO->ICR|=1<<2; //清除命令響應超時標志
return errorstatus;
}
if(status&1<<0) //CRC錯誤
{
errorstatus=SD_CMD_CRC_FAIL;
SDIO->ICR|=1<<0; //清除響應標志
}
SDIO->ICR=0X5FF; //清除標記
return errorstatus;
}
/*
函數(shù)功能: 檢查R6響應的錯誤狀態(tài)
函數(shù)參數(shù):
cmd:之前發(fā)送的命令
prca:卡返回的RCA地址
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_CmdResp6Error(u8 cmd,u16*prca)
{
SDIO_SD_ERROR_INFO errorstatus=SD_OK;
u32 status;
u32 rspr1;
while(1)
{
status=SDIO->STA;
if(status&((1<<0)|(1<<2)|(1<<6)))break;//CRC錯誤/命令響應超時/已經(jīng)收到響應(CRC校驗成功)
}
if(status&(1<<2)) //響應超時
{
SDIO->ICR|=1<<2; //清除命令響應超時標志
return SD_CMD_RSP_TIMEOUT;
}
if(status&1<<0) //CRC錯誤
{
SDIO->ICR|=1<<0; //清除響應標志
return SD_CMD_CRC_FAIL;
}
if(SDIO->RESPCMD!=cmd) //判斷是否響應cmd命令
{
return SD_ILLEGAL_CMD;
}
SDIO->ICR=0X5FF; //清除所有標記
rspr1=SDIO->RESP1; //得到響應
if(SD_ALLZERO==(rspr1&(SD_R6_GENERAL_UNKNOWN_ERROR|SD_R6_ILLEGAL_CMD|SD_R6_COM_CRC_FAILED)))
{
*prca=(u16)(rspr1>>16); //右移16位得到,rca
return errorstatus;
}
if(rspr1&SD_R6_GENERAL_UNKNOWN_ERROR)return SD_GENERAL_UNKNOWN_ERROR;
if(rspr1&SD_R6_ILLEGAL_CMD)return SD_ILLEGAL_CMD;
if(rspr1&SD_R6_COM_CRC_FAILED)return SD_COM_CRC_FAILED;
return errorstatus;
}
/*
函數(shù)功能:SDIO使能寬總線模式
函數(shù)參數(shù):
enx:0,不使能;1,使能;
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardEnWideBus(u8 enx)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
u32 scr[2]={0,0};
u8 arg=0X00;
if(enx)arg=0X02;
else arg=0X00;
if(SDIO->RESP1&SD_CARD_LOCKED)return SD_LOCK_UNLOCK_FAILED;//SD卡處于LOCKED狀態(tài)
errorstatus=SDIO_SdCardFindSCR(RCA,scr); //得到SCR寄存器數(shù)據(jù)
if(errorstatus!=SD_OK)return errorstatus;
if((scr[1]&SD_WIDE_BUS_SUPPORT)!=SD_ALLZERO) //支持寬總線
{
SDIO_SendCmd(SD_CMD_APP_CMD,1,(u32)RCA<<16); //發(fā)送CMD55+RCA,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_SendCmd(SD_CMD_APP_SD_SET_BUSWIDTH,1,arg);//發(fā)送ACMD6,短響應,參數(shù):10,4位;00,1位.
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_SD_SET_BUSWIDTH);
return errorstatus;
}else return SD_REQUEST_NOT_APPLICABLE; //不支持寬總線設置
}
/*
函數(shù)功能: 檢查卡是否正在執(zhí)行寫操作
函數(shù)參數(shù): pstatus:當前狀態(tài)
返回值:錯誤代碼
*/
SDIO_SD_ERROR_INFO SDIO_SdCardProgrammingState(u8 *pstatus)
{
vu32 respR1 = 0, status = 0;
SDIO_SendCmd(SD_CMD_SEND_STATUS,1,(u32)RCA<<16); //發(fā)送CMD13
status=SDIO->STA;
while(!(status&((1<<0)|(1<<6)|(1<<2))))status=SDIO->STA;//等待操作完成
if(status&(1<<0)) //CRC檢測失敗
{
SDIO->ICR|=1<<0; //清除錯誤標記
return SD_CMD_CRC_FAIL;
}
if(status&(1<<2)) //命令超時
{
SDIO->ICR|=1<<2; //清除錯誤標記
return SD_CMD_RSP_TIMEOUT;
}
if(SDIO->RESPCMD!=SD_CMD_SEND_STATUS)return SD_ILLEGAL_CMD;
SDIO->ICR=0X5FF; //清除所有標記
respR1=SDIO->RESP1;
*pstatus=(u8)((respR1>>9)&0x0000000F);
return SD_OK;
}
/*
函數(shù)功能: 讀取當前卡狀態(tài)
函數(shù)參數(shù):
pcardstatus:卡狀態(tài)
返回值 :錯誤代碼
*/
SDIO_SD_ERROR_INFO SDIO_SdCardSendStatus(uint32_t *pcardstatus)
{
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
if(pcardstatus==NULL)
{
errorstatus=SD_INVALID_PARAMETER;
return errorstatus;
}
SDIO_SendCmd(SD_CMD_SEND_STATUS,1,RCA<<16); //發(fā)送CMD13,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_SEND_STATUS); //查詢響應狀態(tài)
if(errorstatus!=SD_OK)return errorstatus;
*pcardstatus=SDIO->RESP1;//讀取響應值
return errorstatus;
}
/*
函數(shù)功能: 返回SD卡的狀態(tài)
返回值 : SD卡狀態(tài)
*/
SDCardState SDIO_SdCardGetState(void)
{
u32 resp1=0;
if(SDIO_SdCardSendStatus(&resp1)!=SD_OK)return SD_CARD_ERROR;
else return (SDCardState)((resp1>>9) & 0x0F);
}
/*
函數(shù)功能:查找SD卡的SCR寄存器值
函數(shù)參數(shù):
rca:卡相對地址
pscr:數(shù)據(jù)緩存區(qū)(存儲SCR內(nèi)容)
返回值:錯誤狀態(tài)
*/
SDIO_SD_ERROR_INFO SDIO_SdCardFindSCR(u16 rca,u32 *pscr)
{
u32 index = 0;
SDIO_SD_ERROR_INFO errorstatus = SD_OK;
u32 tempscr[2]={0,0};
SDIO_SendCmd(SD_CMD_SET_BLOCKLEN,1,8); //發(fā)送CMD16,短響應,設置Block Size為8字節(jié)
errorstatus=SDIO_CmdResp1Error(SD_CMD_SET_BLOCKLEN);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_SendCmd(SD_CMD_APP_CMD,1,(u32)rca<<16); //發(fā)送CMD55,短響應
errorstatus=SDIO_CmdResp1Error(SD_CMD_APP_CMD);
if(errorstatus!=SD_OK)return errorstatus;
SDIO_SendDataConfig(SD_DATATIMEOUT,8,3,1); //8個字節(jié)長度,block為8字節(jié),SD卡到SDIO.
SDIO_SendCmd(SD_CMD_SD_APP_SEND_SCR,1,0); //發(fā)送ACMD51,短響應,參數(shù)為0
errorstatus=SDIO_CmdResp1Error(SD_CMD_SD_APP_SEND_SCR);
if(errorstatus!=SD_OK)return errorstatus;
while(!(SDIO->STA&(SDIO_FLAG_RXOVERR|SDIO_FLAG_DCRCFAIL|SDIO_FLAG_DTIMEOUT|SDIO_FLAG_DBCKEND|SDIO_FLAG_STBITERR)))
{
if(SDIO->STA&(1<<21))//接收FIFO數(shù)據(jù)可用
{
*(tempscr+index)=SDIO->FIFO; //讀取FIFO內(nèi)容
index++;
if(index>=2)break;
}
}
if(SDIO->STA&(1<<3)) //接收數(shù)據(jù)超時
{
SDIO->ICR|=1<<3; //清除標記
return SD_DATA_TIMEOUT;
}
else if(SDIO->STA&(1<<1)) //已發(fā)送/接收的數(shù)據(jù)塊CRC校驗錯誤
{
SDIO->ICR|=1<<1; //清除標記
return SD_DATA_CRC_FAIL;
}
else if(SDIO->STA&(1<<5)) //接收FIFO溢出
{
SDIO->ICR|=1<<5; //清除標記
return SD_RX_OVERRUN;
}
else if(SDIO->STA&(1<<9)) //起始位檢測錯誤
{
SDIO->ICR|=1<<9; //清除標記
return SD_START_BIT_ERR;
}
SDIO->ICR=0X5FF; //清除標記
//把數(shù)據(jù)順序按8位為單位倒過來.
*(pscr+1)=((tempscr[0]&SD_0TO7BITS)<<24)|((tempscr[0]&SD_8TO15BITS)<<8)|((tempscr[0]&SD_16TO23BITS)>>8)|((tempscr[0]&SD_24TO31BITS)>>24);
*(pscr)=((tempscr[1]&SD_0TO7BITS)<<24)|((tempscr[1]&SD_8TO15BITS)<<8)|((tempscr[1]&SD_16TO23BITS)>>8)|((tempscr[1]&SD_24TO31BITS)>>24);
return errorstatus;
}
/*
函數(shù)功能: 得到NumberOfBytes以2為底的指數(shù)
函數(shù)參數(shù): NumberOfBytes:字節(jié)數(shù)
返回值:以2為底的指數(shù)值
*/
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes)
{
u8 count=0;
while(NumberOfBytes!=1)
{
NumberOfBytes>>=1;
count++;
}
return count;
}
/*
函數(shù)功能: 配置SDIO DMA
函數(shù)參數(shù):
mbuf:存儲器地址
bufsize:傳輸數(shù)據(jù)量
dir:方向;1,存儲器-->SDIO(寫數(shù)據(jù));0,SDIO-->存儲器(讀數(shù)據(jù));
*/
void SDIO_SdCard_DMAConfig(u32*mbuf,u32 bufsize,u8 dir)
{
DMA2->IFCR|=(0XF<<12); //清除DMA2通道4的各種標記
DMA2_Channel4->CCR&=~(1<<0); //關閉DMA 通道4
DMA2_Channel4->CCR&=~(0X7FF<<4); //清除之前的設置,DIR,CIRC,PINC,MINC,PSIZE,MSIZE,PL,MEM2MEM
DMA2_Channel4->CCR|=dir<<4; //從存儲器讀
DMA2_Channel4->CCR|=0<<5; //普通模式
DMA2_Channel4->CCR|=0<<6; //外設地址非增量模式
DMA2_Channel4->CCR|=1<<7; //存儲器增量模式
DMA2_Channel4->CCR|=2<<8; //外設數(shù)據(jù)寬度為32位
DMA2_Channel4->CCR|=2<<10; //存儲器數(shù)據(jù)寬度32位
DMA2_Channel4->CCR|=2<<12; //高優(yōu)先級
DMA2_Channel4->CNDTR=bufsize/4; //DMA2,傳輸數(shù)據(jù)量
DMA2_Channel4->CPAR=(u32)&SDIO->FIFO;//DMA2 外設地址
DMA2_Channel4->CMAR=(u32)mbuf; //DMA2,存儲器地址
DMA2_Channel4->CCR|=1<<0; //開啟DMA通道
}
/*
函數(shù)功能: 讀SD卡
函數(shù)參數(shù):
buf:讀數(shù)據(jù)緩存區(qū)
sector:扇區(qū)地址
cnt:扇區(qū)個數(shù)
返回值:錯誤狀態(tài);0,正常;其他,錯誤代碼;
*/
u8 SDIO_SdCardReadDiskSector(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
long long lsector=sector;
u8 n;
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
sta=SDIO_SdCardReadBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的讀操作
memcpy(buf,SDIO_DATA_BUFFER,512);
buf+=512;
}
}else
{
if(cnt==1)sta=SDIO_SdCardReadBlock(buf,lsector,512); //單個sector的讀操作
else sta=SDIO_SdCardReadMultiBlocks(buf,lsector,512,cnt);//多個sector
}
return sta;
}
/*
函數(shù)功能:寫SD卡
函數(shù)參數(shù):
buf:寫數(shù)據(jù)緩存區(qū)
sector:扇區(qū)地址
cnt:扇區(qū)個數(shù)
返回值:錯誤狀態(tài);0,正常;其他,錯誤代碼;
*/
u8 SDIO_SdCardWriteDiskSector(u8*buf,u32 sector,u8 cnt)
{
u8 sta=SD_OK;
u8 n;
long long lsector=sector;
lsector<<=9;
if((u32)buf%4!=0)
{
for(n=0;n<cnt;n++)
{
memcpy(SDIO_DATA_BUFFER,buf,512);
sta=SDIO_SdCardWriteBlock(SDIO_DATA_BUFFER,lsector+512*n,512);//單個sector的寫操作
buf+=512;
}
}else
{
if(cnt==1)sta=SDIO_SdCardWriteBlock(buf,lsector,512); //單個sector的寫操作
else sta=SDIO_SdCardWriteMultiBlocks(buf,lsector,512,cnt); //多個sector
}
return sta;
}
（3）sdio.h
#ifndef __SDIO_SDCARD_H
#define __SDIO_SDCARD_H
#include "stm32f10x.h"
//SDIO相關標志位
#define SDIO_FLAG_CCRCFAIL ((uint32_t)0x00000001)
#define SDIO_FLAG_DCRCFAIL ((uint32_t)0x00000002)
#define SDIO_FLAG_CTIMEOUT ((uint32_t)0x00000004)
#define SDIO_FLAG_DTIMEOUT ((uint32_t)0x00000008)
#define SDIO_FLAG_TXUNDERR ((uint32_t)0x00000010)
#define SDIO_FLAG_RXOVERR ((uint32_t)0x00000020)
#define SDIO_FLAG_CMDREND ((uint32_t)0x00000040)
#define SDIO_FLAG_CMDSENT ((uint32_t)0x00000080)
#define SDIO_FLAG_DATAEND ((uint32_t)0x00000100)
#define SDIO_FLAG_STBITERR ((uint32_t)0x00000200)
#define SDIO_FLAG_DBCKEND ((uint32_t)0x00000400)
#define SDIO_FLAG_CMDACT ((uint32_t)0x00000800)
#define SDIO_FLAG_TXACT ((uint32_t)0x00001000)
#define SDIO_FLAG_RXACT ((uint32_t)0x00002000)
#define SDIO_FLAG_TXFIFOHE ((uint32_t)0x00004000)
#define SDIO_FLAG_RXFIFOHF ((uint32_t)0x00008000)
#define SDIO_FLAG_TXFIFOF ((uint32_t)0x00010000)
#define SDIO_FLAG_RXFIFOF ((uint32_t)0x00020000)
#define SDIO_FLAG_TXFIFOE ((uint32_t)0x00040000)
#define SDIO_FLAG_RXFIFOE ((uint32_t)0x00080000)
#define SDIO_FLAG_TXDAVL ((uint32_t)0x00100000)
#define SDIO_FLAG_RXDAVL ((uint32_t)0x00200000)
#define SDIO_FLAG_SDIOIT ((uint32_t)0x00400000)
#define SDIO_FLAG_CEATAEND ((uint32_t)0x00800000)
//用戶配置區(qū)
//SDIO時鐘計算公式:SDIO_CK時鐘=SDIOCLK/[clkdiv+2];其中,SDIOCLK一般為72Mhz
//使用DMA模式的時候,傳輸速率可以到24Mhz,不過如果你的卡不是高速卡,可能也會出錯
//出錯就請降低時鐘,使用查詢模式的話,推薦SDIO_TRANSFER_CLK_DIV設置為3或者更大
#define SDIO_INIT_CLK_DIV 0xB2 //SDIO初始化頻率，最大400Kh
#define SDIO_TRANSFER_CLK_DIV 0x04 //SDIO傳輸頻率,該值太小可能會導致讀寫文件出錯
//SDIO工作模式定義,通過SDIO_SdCardSetDeviceMode函數(shù)設置.
#define SD_POLLING_MODE 0 //查詢模式,該模式下,如果讀寫有問題,建議增大SDIO_TRANSFER_CLK_DIV的設置.
#define SD_DMA_MODE 1 //DMA模式,該模式下,如果讀寫有問題,建議增大SDIO_TRANSFER_CLK_DIV的設置.
//SDIO 各種錯誤枚舉定義
typedef enum
{
//特殊錯誤定義
SD_CMD_CRC_FAIL = (1), /*!< Command response received (but CRC check failed) */
SD_DATA_CRC_FAIL = (2), /*!< Data bock sent/received (CRC check Failed) */
SD_CMD_RSP_TIMEOUT = (3), /*!< Command response timeout */
SD_DATA_TIMEOUT = (4), /*!< Data time out */
SD_TX_UNDERRUN = (5), /*!< Transmit FIFO under-run */
SD_RX_OVERRUN = (6), /*!< Receive FIFO over-run */
SD_START_BIT_ERR = (7), /*!< Start bit not detected on all data signals in widE bus mode */
SD_CMD_OUT_OF_RANGE = (8), /*!< CMD's argument was out of range.*/
SD_ADDR_MISALIGNED = (9), /*!< Misaligned address */
SD_BLOCK_LEN_ERR = (10), /*!< Transferred block length is not allowed for the card or the number of transferred bytes does not match the block length */
SD_ERASE_SEQ_ERR = (11), /*!< An error in the sequence of erase command occurs.*/
SD_BAD_ERASE_PARAM = (12), /*!< An Invalid selection for erase groups */
SD_WRITE_PROT_VIOLATION = (13), /*!< Attempt to program a write protect block */
SD_LOCK_UNLOCK_FAILED = (14), /*!< Sequence or password error has been detected in unlock command or if there was an attempt to access a locked card */
SD_COM_CRC_FAILED = (15), /*!< CRC check of the previous command failed */
SD_ILLEGAL_CMD = (16), /*!< Command is not legal for the card state */
SD_CARD_ECC_FAILED = (17), /*!< Card internal ECC was applied but failed to correct the data */
SD_CC_ERROR = (18), /*!< Internal card controller error */
SD_GENERAL_UNKNOWN_ERROR = (19), /*!< General or Unknown error */
SD_STREAM_READ_UNDERRUN = (20), /*!< The card could not sustain data transfer in stream read operation. */
SD_STREAM_WRITE_OVERRUN = (21), /*!< The card could not sustain data programming in stream mode */
SD_CID_CSD_OVERWRITE = (22), /*!< CID/CSD overwrite error */
SD_WP_ERASE_SKIP = (23), /*!< only partial address space was erased */
SD_CARD_ECC_DISABLED = (24), /*!< Command has been executed without using internal ECC */
SD_ERASE_RESET = (25), /*!< Erase sequence was cleared before executing because an out of erase sequence command was received */
SD_AKE_SEQ_ERROR = (26), /*!< Error in sequence of authentication. */
SD_INVALID_VOLTRANGE = (27),
SD_ADDR_OUT_OF_RANGE = (28),
SD_SWITCH_ERROR = (29),
SD_SDIO_DISABLED = (30),
SD_SDIO_FUNCTION_BUSY = (31),
SD_SDIO_FUNCTION_FAILED = (32),
SD_SDIO_UNKNOWN_FUNCTION = (33),
//標準錯誤定義
SD_INTERNAL_ERROR,
SD_NOT_CONFIGURED,
SD_REQUEST_PENDING,
SD_REQUEST_NOT_APPLICABLE,
SD_INVALID_PARAMETER,
SD_UNSUPPORTED_FEATURE,
SD_UNSUPPORTED_HW,
SD_ERROR,
SD_OK = 0
} SDIO_SD_ERROR_INFO;
//SD卡CSD寄存器數(shù)據(jù)
typedef struct
{
u8 CSDStruct; /*!< CSD structure */
u8 SysSpecVersion; /*!< System specification version */
u8 Reserved1; /*!< Reserved */
u8 TAAC; /*!< Data read access-time 1 */
u8 NSAC; /*!< Data read access-time 2 in CLK cycles */
u8 MaxBusClkFrec; /*!< Max. bus clock frequency */
u16 CardComdClasses; /*!< Card command classes */
u8 RdBlockLen; /*!< Max. read data block length */
u8 PartBlockRead; /*!< Partial blocks for read allowed */
u8 WrBlockMisalign; /*!< Write block misalignment */
u8 RdBlockMisalign; /*!< Read block misalignment */
u8 DSRImpl; /*!< DSR implemented */
u8 Reserved2; /*!< Reserved */
u32 DeviceSize; /*!< Device Size */
u8 MaxRdCurrentVDDMin; /*!< Max. read current @ VDD min */
u8 MaxRdCurrentVDDMax; /*!< Max. read current @ VDD max */
u8 MaxWrCurrentVDDMin; /*!< Max. write current @ VDD min */
u8 MaxWrCurrentVDDMax; /*!< Max. write current @ VDD max */
u8 DeviceSizeMul; /*!< Device size multiplier */
u8 EraseGrSize; /*!< Erase group size */
u8 EraseGrMul; /*!< Erase group size multiplier */
u8 WrProtectGrSize; /*!< Write protect group size */
u8 WrProtectGrEnable; /*!< Write protect group enable */
u8 ManDeflECC; /*!< Manufacturer default ECC */
u8 WrSpeedFact; /*!< Write speed factor */
u8 MaxWrBlockLen; /*!< Max. write data block length */
u8 WriteBlockPaPartial; /*!< Partial blocks for write allowed */
u8 Reserved3; /*!< Reserded */
u8 ContentProtectAppli; /*!< Content protection application */
u8 FileFormatGrouop; /*!< File format group */
u8 CopyFlag; /*!< Copy flag (OTP) */
u8 PermWrProtect; /*!< Permanent write protection */
u8 TempWrProtect; /*!< Temporary write protection */
u8 FileFormat; /*!< File Format */
u8 ECC; /*!< ECC code */
u8 CSD_CRC; /*!< CSD CRC */
u8 Reserved4; /*!< always 1*/
} SD_CSD;
//SD卡CID寄存器數(shù)據(jù)
typedef struct
{
u8 ManufacturerID; /*!< ManufacturerID */
u16 OEM_AppliID; /*!< OEM/Application ID */
u32 ProdName1; /*!< Product Name part1 */
u8 ProdName2; /*!< Product Name part2*/
u8 ProdRev; /*!< Product Revision */
u32 ProdSN; /*!< Product Serial Number */
u8 Reserved1; /*!< Reserved1 */
u16 ManufactDate; /*!< Manufacturing Date */
u8 CID_CRC; /*!< CID CRC */
u8 Reserved2; /*!< always 1 */
} SD_CID;
//SD卡狀態(tài)
typedef enum
{
SD_CARD_READY = ((uint32_t)0x00000001),
SD_CARD_IDENTIFICATION = ((uint32_t)0x00000002),
SD_CARD_STANDBY = ((uint32_t)0x00000003),
SD_CARD_TRANSFER = ((uint32_t)0x00000004),
SD_CARD_SENDING = ((uint32_t)0x00000005),
SD_CARD_RECEIVING = ((uint32_t)0x00000006),
SD_CARD_PROGRAMMING = ((uint32_t)0x00000007),
SD_CARD_DISCONNECTED = ((uint32_t)0x00000008),
SD_CARD_ERROR = ((uint32_t)0x000000FF)
}SDCardState;
//SD卡信息,包括CSD,CID等數(shù)據(jù)
typedef struct
{
SD_CSD SD_csd;
SD_CID SD_cid;
long long CardCapacity; //SD卡容量,單位:字節(jié),最大支持2^64字節(jié)大小的卡.
u32 CardBlockSize; //SD卡塊大小
u16 RCA; //卡相對地址
u8 CardType; //卡類型
} SD_CardInfo;
extern SD_CardInfo SDCardInfo;//SD卡信息
//SDIO 指令集
#define SD_CMD_GO_IDLE_STATE ((u8)0)
#define SD_CMD_SEND_OP_COND ((u8)1)
#define SD_CMD_ALL_SEND_CID ((u8)2)
#define SD_CMD_SET_REL_ADDR ((u8)3) /*!< SDIO_SEND_REL_ADDR for SD Card */
#define SD_CMD_SET_DSR ((u8)4)
#define SD_CMD_SDIO_SEN_OP_COND ((u8)5)
#define SD_CMD_HS_SWITCH ((u8)6)
#define SD_CMD_SEL_DESEL_CARD ((u8)7)
#define SD_CMD_HS_SEND_EXT_CSD ((u8)8)
#define SD_CMD_SEND_CSD ((u8)9)
#define SD_CMD_SEND_CID ((u8)10)
#define SD_CMD_READ_DAT_UNTIL_STOP ((u8)11) /*!< SD Card doesn't support it */
#define SD_CMD_STOP_TRANSMISSION ((u8)12)
#define SD_CMD_SEND_STATUS ((u8)13)
#define SD_CMD_HS_BUSTEST_READ ((u8)14)
#define SD_CMD_GO_INACTIVE_STATE ((u8)15)
#define SD_CMD_SET_BLOCKLEN ((u8)16)
#define SD_CMD_READ_SINGLE_BLOCK ((u8)17)
#define SD_CMD_READ_MULT_BLOCK ((u8)18)
#define SD_CMD_HS_BUSTEST_WRITE ((u8)19)
#define SD_CMD_WRITE_DAT_UNTIL_STOP ((u8)20)
#define SD_CMD_SET_BLOCK_COUNT ((u8)23)
#define SD_CMD_WRITE_SINGLE_BLOCK ((u8)24)
#define SD_CMD_WRITE_MULT_BLOCK ((u8)25)
#define SD_CMD_PROG_CID ((u8)26)
#define SD_CMD_PROG_CSD ((u8)27)
#define SD_CMD_SET_WRITE_PROT ((u8)28)
#define SD_CMD_CLR_WRITE_PROT ((u8)29)
#define SD_CMD_SEND_WRITE_PROT ((u8)30)
#define SD_CMD_SD_ERASE_GRP_START ((u8)32) /*!< To set the address of the first write
block to be erased. (For SD card only) */
#define SD_CMD_SD_ERASE_GRP_END ((u8)33) /*!< To set the address of the last write block of the
continuous range to be erased. (For SD card only) */
#define SD_CMD_ERASE_GRP_START ((u8)35) /*!< To set the address of the first write block to be erased.
(For MMC card only spec 3.31) */
#define SD_CMD_ERASE_GRP_END ((u8)36) /*!< To set the address of the last write block of the
continuous range to be erased. (For MMC card only spec 3.31) */
#define SD_CMD_ERASE ((u8)38)
#define SD_CMD_FAST_IO ((u8)39) /*!< SD Card doesn't support it */
#define SD_CMD_GO_IRQ_STATE ((u8)40) /*!< SD Card doesn't support it */
#define SD_CMD_LOCK_UNLOCK ((u8)42)
#define SD_CMD_APP_CMD ((u8)55)
#define SD_CMD_GEN_CMD ((u8)56)
#define SD_CMD_NO_CMD ((u8)64)
/**
* @brief Following commands are SD Card Specific commands.
* SDIO_APP_CMD ：CMD55 should be sent before sending these commands.
*/
#define SD_CMD_APP_SD_SET_BUSWIDTH ((u8)6) /*!< For SD Card only */
#define SD_CMD_SD_APP_STAUS ((u8)13) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_NUM_WRITE_BLOCKS ((u8)22) /*!< For SD Card only */
#define SD_CMD_SD_APP_OP_COND ((u8)41) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CLR_CARD_DETECT ((u8)42) /*!< For SD Card only */
#define SD_CMD_SD_APP_SEND_SCR ((u8)51) /*!< For SD Card only */
#define SD_CMD_SDIO_RW_DIRECT ((u8)52) /*!< For SD I/O Card only */
#define SD_CMD_SDIO_RW_EXTENDED ((u8)53) /*!< For SD I/O Card only */
/**
* @brief Following commands are SD Card Specific security commands.
* SDIO_APP_CMD should be sent before sending these commands.
*/
#define SD_CMD_SD_APP_GET_MKB ((u8)43) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_MID ((u8)44) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RN1 ((u8)45) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RN2 ((u8)46) /*!< For SD Card only */
#define SD_CMD_SD_APP_SET_CER_RES2 ((u8)47) /*!< For SD Card only */
#define SD_CMD_SD_APP_GET_CER_RES1 ((u8)48) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_READ_MULTIPLE_BLOCK ((u8)18) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MULTIPLE_BLOCK ((u8)25) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_ERASE ((u8)38) /*!< For SD Card only */
#define SD_CMD_SD_APP_CHANGE_SECURE_AREA ((u8)49) /*!< For SD Card only */
#define SD_CMD_SD_APP_SECURE_WRITE_MKB ((u8)48) /*!< For SD Card only */
//支持的SD卡定義
#define SDIO_STD_CAPACITY_SD_CARD_V1_1 ((u32)0x00000000)
#define SDIO_STD_CAPACITY_SD_CARD_V2_0 ((u32)0x00000001)
#define SDIO_HIGH_CAPACITY_SD_CARD ((u32)0x00000002)
#define SDIO_MULTIMEDIA_CARD ((u32)0x00000003)
#define SDIO_SECURE_DIGITAL_IO_CARD ((u32)0x00000004)
#define SDIO_HIGH_SPEED_MULTIMEDIA_CARD ((u32)0x00000005)
#define SDIO_SECURE_DIGITAL_IO_COMBO_CARD ((u32)0x00000006)
#define SDIO_HIGH_CAPACITY_MMC_CARD ((u32)0x00000007)
//SDIO相關參數(shù)定義
#define NULL 0
#define SDIO_STATIC_FLAGS ((u32)0x000005FF)
#define SDIO_CMD0TIMEOUT ((u32)0x00010000)
#define SDIO_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SDIO_FIFO_Address ((u32)0x40018080)
//Mask for errors Card Status R1 (OCR Register)
#define SD_OCR_ADDR_OUT_OF_RANGE ((u32)0x80000000)
#define SD_OCR_ADDR_MISALIGNED ((u32)0x40000000)
#define SD_OCR_BLOCK_LEN_ERR ((u32)0x20000000)
#define SD_OCR_ERASE_SEQ_ERR ((u32)0x10000000)
#define SD_OCR_BAD_ERASE_PARAM ((u32)0x08000000)
#define SD_OCR_WRITE_PROT_VIOLATION ((u32)0x04000000)
#define SD_OCR_LOCK_UNLOCK_FAILED ((u32)0x01000000)
#define SD_OCR_COM_CRC_FAILED ((u32)0x00800000)
#define SD_OCR_ILLEGAL_CMD ((u32)0x00400000)
#define SD_OCR_CARD_ECC_FAILED ((u32)0x00200000)
#define SD_OCR_CC_ERROR ((u32)0x00100000)
#define SD_OCR_GENERAL_UNKNOWN_ERROR ((u32)0x00080000)
#define SD_OCR_STREAM_READ_UNDERRUN ((u32)0x00040000)
#define SD_OCR_STREAM_WRITE_OVERRUN ((u32)0x00020000)
#define SD_OCR_CID_CSD_OVERWRIETE ((u32)0x00010000)
#define SD_OCR_WP_ERASE_SKIP ((u32)0x00008000)
#define SD_OCR_CARD_ECC_DISABLED ((u32)0x00004000)
#define SD_OCR_ERASE_RESET ((u32)0x00002000)
#define SD_OCR_AKE_SEQ_ERROR ((u32)0x00000008)
#define SD_OCR_ERRORBITS ((u32)0xFDFFE008)
//Masks for R6 Response
#define SD_R6_GENERAL_UNKNOWN_ERROR ((u32)0x00002000)
#define SD_R6_ILLEGAL_CMD ((u32)0x00004000)
#define SD_R6_COM_CRC_FAILED ((u32)0x00008000)
#define SD_VOLTAGE_WINDOW_SD ((u32)0x80100000)
#define SD_HIGH_CAPACITY ((u32)0x40000000)
#define SD_STD_CAPACITY ((u32)0x00000000)
#define SD_CHECK_PATTERN ((u32)0x000001AA)
#define SD_VOLTAGE_WINDOW_MMC ((u32)0x80FF8000)
#define SD_MAX_VOLT_TRIAL ((u32)0x0000FFFF)
#define SD_ALLZERO ((u32)0x00000000)
#define SD_WIDE_BUS_SUPPORT ((u32)0x00040000)
#define SD_SINGLE_BUS_SUPPORT ((u32)0x00010000)
#define SD_CARD_LOCKED ((u32)0x02000000)
#define SD_CARD_PROGRAMMING ((u32)0x00000007)
#define SD_CARD_RECEIVING ((u32)0x00000006)
#define SD_DATATIMEOUT ((u32)0xFFFFFFFF)
#define SD_0TO7BITS ((u32)0x000000FF)
#define SD_8TO15BITS ((u32)0x0000FF00)
#define SD_16TO23BITS ((u32)0x00FF0000)
#define SD_24TO31BITS ((u32)0xFF000000)
#define SD_MAX_DATA_LENGTH ((u32)0x01FFFFFF)
#define SD_HALFFIFO ((u32)0x00000008)
#define SD_HALFFIFOBYTES ((u32)0x00000020)
//Command Class Supported
#define SD_CCCC_LOCK_UNLOCK ((u32)0x00000080)
#define SD_CCCC_WRITE_PROT ((u32)0x00000040)
#define SD_CCCC_ERASE ((u32)0x00000020)
//CMD8指令
#define SDIO_SEND_IF_COND ((u32)0x00000008)
//相關函數(shù)定義
SDIO_SD_ERROR_INFO SDIO_SdCardInit(void);
void SDIO_ClockSet(u8 clkdiv);
void SDIO_SendCmd(u8 cmdindex,u8 waitrsp,u32 arg);
void SDIO_SendDataConfig(u32 datatimeout,u32 datalen,u8 blksize,u8 dir);
SDIO_SD_ERROR_INFO SDIO_SdPowerON(void);
SDIO_SD_ERROR_INFO SD_PowerOFF(void);
SDIO_SD_ERROR_INFO SDIO_SdCardInitializeCards(void);
SDIO_SD_ERROR_INFO SDIO_SdCardGetInfo(SD_CardInfo *cardinfo);
SDIO_SD_ERROR_INFO SDIO_SdCardEnableWideBusOperation(u32 wmode);
SDIO_SD_ERROR_INFO SDIO_SdCardSetDeviceMode(u32 mode);
SDIO_SD_ERROR_INFO SDIO_SdCardSelectAddr(u32 addr);
SDIO_SD_ERROR_INFO SDIO_SdCardSendStatus(uint32_t *pcardstatus);
SDCardState SDIO_SdCardGetState(void);
SDIO_SD_ERROR_INFO SDIO_SdCardReadBlock(u8 *buf,long long addr,u16 blksize);
SDIO_SD_ERROR_INFO SDIO_SdCardReadMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SDIO_SD_ERROR_INFO SDIO_SdCardWriteBlock(u8 *buf,long long addr, u16 blksize);
SDIO_SD_ERROR_INFO SDIO_SdCardWriteMultiBlocks(u8 *buf,long long addr,u16 blksize,u32 nblks);
SDIO_SD_ERROR_INFO SDIO_SdCardProcessIRQSrc(void);
SDIO_SD_ERROR_INFO SDIO_CmdErrorCheck(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp7Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp1Error(u8 cmd);
SDIO_SD_ERROR_INFO SDIO_CmdResp3Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp2Error(void);
SDIO_SD_ERROR_INFO SDIO_CmdResp6Error(u8 cmd,u16*prca);
SDIO_SD_ERROR_INFO SDIO_SdCardEnWideBus(u8 enx);
SDIO_SD_ERROR_INFO SDIO_SdCardProgrammingState(u8 *pstatus);
SDIO_SD_ERROR_INFO SDIO_SdCardFindSCR(u16 rca,u32 *pscr);
u8 convert_from_bytes_to_power_of_two(u16 NumberOfBytes);
void SDIO_SdCard_DMAConfig(u32*mbuf,u32 bufsize,u8 dir);
u8 SDIO_SdCardReadDiskSector(u8*buf,u32 sector,u8 cnt); //讀SD卡,fatfs/usb調(diào)用
u8 SDIO_SdCardWriteDiskSector(u8*buf,u32 sector,u8 cnt); //寫SD卡,fatfs/usb調(diào)用
#endif
四、移植FATFS文件系統(tǒng)
前面第3章，完成了SD NAND的驅(qū)動代碼編寫，這一章節(jié)實現(xiàn)FATFS文件的移植。
4.1 FATFS文件系統(tǒng)介紹
（1）介紹
FatFs 是一種完全免費開源的 FAT 文件系統(tǒng)模塊，專門為小型的嵌入式系統(tǒng)而設計。它完全用標準C 語言編寫，所以具有良好的硬件平臺獨立性，可以移植到 8051、 PIC、 AVR、 SH、 Z80、 H8、 ARM 等系列單片機上而只需做簡單的修改。它支持 FATl2、 FATl6 和 FAT32，支持多個存儲媒介；有獨立的緩沖區(qū)，可以對多個文件進行讀／寫，并特別對 8 位單片機和 16 位單片機做了優(yōu)化。
（2）特點
【1】Windows兼容的FAT文件系統(tǒng)
【2】不依賴于平臺，易于移植
【3】代碼和工作區(qū)占用空間非常小
【4】多種配置選項
【5】多卷(物理驅(qū)動器和分區(qū))
【6】多ANSI/OEM代碼頁，包括DBCS
【7】在ANSI/OEM或Unicode中長文件名的支持
【8】RTOS的支持
【9】多扇區(qū)大小的支持
【10】只讀，最少API，I/O緩沖區(qū)等等
（3）移植性
fatfs模塊是ANSI C(C89)編寫的。 沒有平臺的依賴, 編譯器只要符合ANSI C標準就可以編譯。
fatf模塊假設大小的字符/短/長8/16/32位和int是16或32位。 這些數(shù)據(jù)類型在integer.h文件中定義。這些數(shù)據(jù)類型在大多數(shù)的編譯器中定義都符合要求。 如果現(xiàn)有的定義與編譯器有任何沖突發(fā)生時，需要自己解決。
4.2 下載源碼
下載地址：http://elm-chan.org/fsw/ff/00index_e.html
FATFS有兩個版本，一個大版本，一個小版本。小版本主要用于8位機(內(nèi)存小)使用。
下載圖：
4.3 源碼結構介紹
將下載的源碼解壓后可以得到兩個文件夾： doc 和 src。 doc 里面主要是對 FATFS 的介紹(離線文檔—英文和日文)，而 src 里面才是我們需要的源碼。
其中，與平臺無關的是：
ffconf.h FATFS配置文件
ff.h 應用層頭文件
ff.c 應用層源文件
diskio.h 硬件層頭文件
interger.h 數(shù)據(jù)類型定義頭文件
option 可選的外部功能（比如支持中文等）
與平臺相關的代碼：
diskio.c 底層接口文件（需要用戶提供）
FATFS 模塊在移植的時候，我們一般只需要修改 2 個文件，即 ffconf.h 和 diskio.c。
FATFS模塊的所有配置項都是存放在 ffconf.h 里面，我們可以通過配置里面的一些選項，來滿足自己的需求。
最頂層是應用層，使用者無需理會 FATFS 的內(nèi)部結構和復雜的 FAT 協(xié)議，只需要調(diào)用FATFS 模塊提供給用戶的一系列應用接口函數(shù)，如 f_open， f_read， f_write 和 f_close 等，就可以像在 PC 上讀寫文件那樣簡單。
中間層 FATFS 模塊， 實現(xiàn)了 FAT 文件讀／寫協(xié)議。 FATFS 模塊提供的是 ff.c 和 ff.h。除非有必要，使用者一般不用修改，使用時將頭文件直接包含進去即可。
需要我們編寫移植代碼的是 FATFS 模塊提供的底層接口，它包括存儲媒介讀／寫接口 （ disk、I/O） 和供給文件創(chuàng)建修改時間的實時時鐘。
4.4 下載源碼并加入到工程
先準備好一個有SD NAND驅(qū)動代碼的STM32工程（代碼前面第3章已經(jīng)貼了），接著就完成下面的步驟。
打開KEIL工程，添加FATFS文件源碼：
加入.h文件主要是方便配。cc936.c 用于支持中文。
4.5 修改代碼進行移植
（1）修改diskio.c文件
注釋掉現(xiàn)在不需要的用到的文件，因為我們現(xiàn)在用的是SD卡，與USB，ATA，MMC卡沒關系。
并加入一個新的宏 :
#define SD 0
定義SD卡的物理驅(qū)動器號為0。
修改 disk_status函數(shù)，該函數(shù)主要是用來獲取磁盤狀態(tài)?，F(xiàn)在未用到，可以直接函數(shù)體內(nèi)代碼刪除。
修改截圖：
代碼示例：
#include "diskio.h" /* fatf底層API */
#include "sd.h" /* SD卡驅(qū)動頭文件 */
/* 定義每個驅(qū)動器的物理驅(qū)動器號*/
#define SD 0
/*-----------------------------------------------------------------------*/
/* 獲取設備(磁盤)狀態(tài) */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE pdrv /* 物理驅(qū)動識別 */
)
{
return 0; //該函數(shù)現(xiàn)在無需用到，直接返回0
}
修改disk_initialize函數(shù)，添加SD卡的初始化，其他不用到的代碼直接刪掉，該函數(shù)成功返回0，失敗返回1。
修改截圖：
代碼示例：
/*-----------------------------------------------------------------------*/
/* 初始化磁盤驅(qū)動 */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* 物理驅(qū)動識別 */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case SD : //選擇SD卡
stat=SD_Init(); //初始化SD卡-用戶自己提供
}
if(stat)return STA_NOINIT; //磁盤未初始化
return 0; //初始化成功
}
修改disk_read函數(shù)，加入SD卡讀任意扇區(qū)的函數(shù)(需要用戶自己提供)，其他不用到的選項可以刪掉。
修改代碼如下：
/*-----------------------------------------------------------------------*/
/* 讀扇區(qū) */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
BYTE pdrv, /* 物理驅(qū)動編號 - 范圍0-9*/
BYTE *buff, /* 數(shù)據(jù)緩沖區(qū)存儲讀取數(shù)據(jù) */
DWORD sector, /* 扇區(qū)地址*/
UINT count /* 需要讀取的扇區(qū)數(shù)*/
)
{
DRESULT res;
int result;
switch (pdrv) {
case SD:
res=SD_Read_Data((u8*)buff,sector,count); //讀SD扇區(qū)函數(shù)--用戶提供
return res; //在此處可以判錯誤
}
return RES_PARERR; //無效參數(shù)
}
修改disk_write 函數(shù)，添加寫扇區(qū)函數(shù)：
代碼：
/*-----------------------------------------------------------------------*/
/* 寫扇區(qū) */
/*-----------------------------------------------------------------------*/
#if _USE_WRITE
DRESULT disk_write (
BYTE pdrv, /* 物理驅(qū)動號*/
const BYTE *buff, /* 要寫入數(shù)據(jù)的首地址 */
DWORD sector, /* 扇區(qū)地址 */
UINT count /* 扇區(qū)數(shù)量*/
)
{
DRESULT res;
int result;
switch (pdrv) {
case SD:
res=SD_Write_Data((u8*)buff,sector,count); //寫入扇區(qū)
return res;
}
return RES_PARERR; //無效參數(shù)
}
#endif
修改disk_ioctl 函數(shù)，填充ioctl命令功能。這些功能是標準的命令，在diskio.h有定義。
代碼如下：
/*-----------------------------------------------------------------------*/
/* 其他函數(shù) */
/*-----------------------------------------------------------------------*/
#if _USE_IOCTL
DRESULT disk_ioctl (
BYTE pdrv, /* 物理驅(qū)動號 */
BYTE cmd, /* 控制碼 */
void *buff /* 發(fā)送/接收數(shù)據(jù)緩沖區(qū)地址 */
)
{
DRESULT res;
int result;
switch (pdrv) {
case SD:
switch(cmd)
{
case CTRL_SYNC: //等待寫過程
SD_CS(0); //選中SD卡
if(SD_Wait_Ready())result = RES_ERROR;/*等待卡準備好*/
else res = RES_OK; //成功
SD_CS(1); //釋放SD卡
break;
case GET_SECTOR_SIZE://獲取扇區(qū)大小
*(DWORD*)buff = 512;
res = RES_OK; //成功
break;
case GET_BLOCK_SIZE: //獲取塊大小
*(WORD*)buff = 8; //塊大小(扇區(qū)為單位)，一塊等于8個扇區(qū)
res = RES_OK;
break;
case GET_SECTOR_COUNT: //獲取總扇區(qū)數(shù)量
*(DWORD*)buff = SD_Get_Sector_Count();
res = RES_OK;
break;
default: //命令錯誤
res = RES_PARERR;
break;
}
return res;
}
return RES_PARERR; //返回狀態(tài)
}
（2）修改ffconf.h文件
需要注意的一些宏配置：
#define _CODE_PAGE 936 //采用中文GBK編碼 (64行)
#define _USE_LFN 3 //動態(tài)的堆上工作 （93行）
#define _MAX_LFN 255 /*_USE_LFN選項開關LFN(長文件名)特性。
#define _VOLUMES 1 /* 支持的磁盤數(shù)量(邏輯驅(qū)動器)。 */ (142行)
#define _MIN_SS 512 (165行)
#define _MAX_SS 512 /*這些選項配置支持扇區(qū)大小的范圍。(512,1024, 4096*/
#define _FS_NORTC 0 /*啟用RTC時間功能*/ (202行)
#define _NORTC_MON 1
#define _NORTC_MDAY 1
#define _NORTC_YEAR 2015 //年
/*需要實現(xiàn)：get_fattime()函數(shù)*/
ffconf.h 文件源碼：
/*---------------------------------------------------------------------------/
/ FatFs - FAT文件系統(tǒng)模塊配置文件 R0.11a (C)ChaN, 2015
/---------------------------------------------------------------------------*/
#define _FFCONF 64180 /* 版本識別*/
/*---------------------------------------------------------------------------/
/ 功能配置
/---------------------------------------------------------------------------*/
#define _FS_READONLY 0
/* 這個選項開關只讀配置。(0:讀/寫或1:只讀)
/只讀配置刪除編寫API函數(shù),f_write(),f_sync(),
/ f_unlink(),f_mkdir(),f_chmod(),f_rename(),f_truncate(),f_getfree()
/寫和可選的功能. */
#define _FS_MINIMIZE 0
/*此選項定義刪除一些基本的API函數(shù)極小化水平?！ ?
/
/ 0:所有基本功能都是激活的?！ ?
/ 1:f_stat(),f_getfree(),f_unlink(),f_mkdir(),f_chmod(),f_utime(),
/ f_truncate()和f_rename()函數(shù)刪除?！ ?
/ 2:f_opendir(),f_readdir()和f_closedir()中除了1?！ ?
/ 3:f_lseek()函數(shù)刪除除了2。*/
#define _USE_STRFUNC 1
/*這個選項開關字符串函數(shù),f_gets(),f_putc(),f_puts()和
/ f_printf()?！ ?
/
/ 0:禁用字符串函數(shù)?！ ?
/ 1:啟用沒有LF-CRLF轉(zhuǎn)換?！ ?
/ 2:啟用LF-CRLF(回車換行)轉(zhuǎn)換。*/
#define _USE_FIND 0
/*這個選項開關過濾目錄讀取特性和相關功能,
/ f_findfirst()和f_findnext()。(0:禁用或1:啟用)*/
#define _USE_MKFS 1
/* 這個選項開關f_mkfs()函數(shù)。(0:禁用或1:啟用) */
#define _USE_FASTSEEK 1
/* 這個選項開關快速尋求功能。(0:禁用或1:啟用) */
#define _USE_LABEL 1
/* 磁盤卷標這個選項開關功能,f_getlabel()和f_setlabel()。
/(0:禁用或1:啟用) */
#define _USE_FORWARD 0
/* 這個選項開關f_forward()函數(shù)。(0:禁用或1:啟用)
/啟用它,也_FS_TINY需要設置為1. */
/*---------------------------------------------------------------------------/
/ 語言環(huán)境和名稱空間配置
/---------------------------------------------------------------------------*/
#define _CODE_PAGE 936 //采用中文GBK編碼
/* 這個選項指定OEM代碼頁在目標系統(tǒng)上使用?！ ?
/不正確的代碼頁的設置會導致文件打開失敗.
/
/ 1 - ASCII (沒有擴展字符。Non-LFN cfg。只有)
/ 437 - U.S.
/ 720 - 阿拉伯語
/ 737 - 希臘語；
/ 771 - 阿富汗
/ 775 - 波羅的海
/ 850 - 拉丁1
/ 852 - 拉丁2
/ 855 - 西里爾字母
/ 857 - 土耳其語
/ 860 - 葡萄牙語
/ 861 - 冰島語
/ 862 - 希伯來人
/ 863 - 加拿大法語
/ 864 - 阿拉伯語
/ 865 - 日耳曼民族的
/ 866 - 俄語
/ 869 - 希臘 2
/ 932 - 日本人 (DBCS)
/ 936 - 簡體中文(DBCS)
/ 949 - 韓國人 (DBCS)
/ 950 - 繁體中文(DBCS)
*/
#define _USE_LFN 3 //動態(tài)的堆上工作
#define _MAX_LFN 255
/*_USE_LFN選項開關LFN(長文件名)特性。
/
/ 0:禁用LFN特性。_MAX_LFN沒有影響?！ ?
/ 1:啟用LFN BSS靜態(tài)工作緩沖區(qū)?？偸遣皇蔷€程安全的?！ ?
/ 2:啟用LFN與動態(tài)緩沖棧上的工作。
/ 3:使LFN與動態(tài)緩沖區(qū)在堆上工作。
/
/ 當啟用LFN（長文件名）特性,Unicode(選項/ unicode.c)必須處理功能
/被添加到項目中。LFN工作緩沖區(qū)占用(_MAX_LFN + 1)* 2字節(jié)?！ ?
/當使用堆棧緩沖區(qū),照顧堆棧溢出。當使用堆
/工作緩沖區(qū)內(nèi)存,內(nèi)存管理功能,ff_memalloc()和
/ ff_memfree(),必須添加到項目中。 */
#define _LFN_UNICODE 0
/* 這個選項開關字符編碼的API。(0:ANSI / OEM或1:Unicode)
路徑名/使用Unicode字符串,并設置_LFN_UNICODE啟用LFN特性
/1。這個選項也會影響行為的字符串的I / O功能。
*/
#define _STRF_ENCODE 3
/* 當_LFN(長文件名)_UNICODE是1,這個選項選擇文件的字符編碼
/通過字符串讀取/寫入I /O功能,f_gets(),f_putc(),f_puts和f_printf().
/
/ 0: ANSI/OEM
/ 1: UTF-16LE
/ 2: UTF-16BE
/ 3: UTF-8
/
/ 當_LFN_UNICODE = 0時,該選項沒有影響。*/
#define _FS_RPATH 0
/* 這個選項配置相對路徑的功能?！ ?
/ 0:禁用相對路徑特性和刪除相關功能。
/ 1:啟用相對路徑特性。f_chdir()和f_chdrive()是可用的?！ ?
/ 2:f_getcwd()函數(shù)可用除了1?！ ?
/注意,目錄項讀通過f_readdir()這個選項。
*/
/*---------------------------------------------------------------------------/
/ 驅(qū)動/卷配置
/---------------------------------------------------------------------------*/
#define _VOLUMES 1
/* 支持的磁盤數(shù)量(邏輯驅(qū)動器)。 */
#define _STR_VOLUME_ID 0
#define _VOLUME_STRS "RAM","NAND","CF","SD1","SD2","USB1","USB2","USB3"
/* STR_VOLUME_ID選項開關卷ID字符串功能?！ ?
/當_STR_VOLUME_ID設置為1時,也可以使用預先定義的字符串在路徑名稱/數(shù)量。
為每個_VOLUME_STRS定義驅(qū)動ID字符串
/邏輯驅(qū)動器。條目的數(shù)量必須等于_VOLUMES。有效字符
/驅(qū)動ID字符串:a - z和0 - 9。*/
#define _MULTI_PARTITION 0
/* 這個選項開關多分區(qū)的特性。在默認情況下(0),每個邏輯驅(qū)動器
/號綁定到相同的物理驅(qū)動器號
/物理驅(qū)動器將被安裝。當啟用分區(qū)特性(1),
/每個邏輯驅(qū)動器號是綁定到任意物理驅(qū)動器和分區(qū)
/中列出VolToPart[]。還f_fdisk()函數(shù)可用. */
#define _MIN_SS 512
#define _MAX_SS 512
/* 這些選項配置支持扇區(qū)大小的范圍。(512,1024,
/ 2048或4096)總是為大多數(shù)系統(tǒng)設置兩個512,卡和所有類型的內(nèi)存
/硬盤。但是可能需要更大的值為車載閃存和一些
/類型的光學媒體。當_MAX_SS大于_MIN_SS,fatf配置
/變量扇區(qū)大小和GET_SECTOR_SIZE命令必須執(zhí)行 disk_ioctl()函數(shù). */
#define _USE_TRIM 0
/* 這個選項開關ATA-TRIM特性。(0:禁用或1:啟用)
/啟用削減特性,也應該實現(xiàn)CTRL_TRIM命令
/ disk_ioctl()函數(shù)。*/
#define _FS_NOFSINFO 0
/*
如果你需要知道正確的自由空間體積FAT32,設置一些0
/選項,f_getfree()函數(shù)在第一次后體積將迫使山
/全脂肪掃描。位1控制使用的集群數(shù)量分配?！ ?
/ bit0 = 0:使用免費的集群計算FSINFO如果可用?！ ?
/ bit0 = 1:不相信自由FSINFO集群計算?！ ?
/ bit1 = 0:最后使用集群可用FSINFO如果數(shù)量分配?！ ?
/ bit1 = 1:不相信最后分配FSINFO集群數(shù)量.
*/
/*---------------------------------------------------------------------------/
/ 系統(tǒng)配置列表
/---------------------------------------------------------------------------*/
#define _FS_TINY 0
/* 這個選項開關小緩沖區(qū)配置。(0:正?；?:小)
/小配置,文件對象的大小(FIL)_MAX_SS減少字節(jié)。而不是私人部門從文件對象,緩沖了
/公共部門緩沖文件系統(tǒng)中的對象(fatf)是用于該文件
/數(shù)據(jù)傳輸. */
#define _FS_NORTC 0
#define _NORTC_MON 1
#define _NORTC_MDAY 1
#define _NORTC_YEAR 2015 //年
/* _FS_NORTC選項開關時間戳的特性。如果系統(tǒng)沒有/
RTC函數(shù)或不需要有效的時間戳,_FS_NORTC 1設置為禁用/
時間戳的特性。所有對象修改fatf將有一個固定的時間戳。/
固定的時間定義為_NORTC_MON _NORTC_MDAY _NORTC_YEAR?！ ?
/當啟用時間戳特性(_FS_NORTC = = 0),需要實現(xiàn)get_fattime()函數(shù)?！ ?
添加到項目RTC讀當前時間形式。_NORTC_MON, /
_NORTC_MDAY和_NORTC_YEAR沒有效果?！ ?
/這些選項沒有影響只讀配置(_FS_READONLY = = 1)。 */
#define _FS_LOCK 0
/* _FS_LOCK選項開關控制復制的文件打開的文件鎖定功能
/和非法操作打開對象。這個選項_FS_READONLY時必須是0
/是1?！ ?
/ 0:禁用文件鎖定功能。為了避免體積腐敗、應用程序
/應該避免非法打開,刪除和重命名的開放對象?！ ?
/ > 0:啟用文件鎖定功能。值定義了多少文件/子目錄
可以同時打開的/文件鎖的控制之下。注意,這個文件獨立于re-entrancy /鎖功能。 */
#define _FS_REENTRANT 0
#define _FS_TIMEOUT 1000
#define _SYNC_t HANDLE
/* _FS_REENTRANT選項開關re-entrancy fatf的(線程安全)
/模塊本身。注意,不管這個選項,文件訪問不同
/體積始終是凹角和音量控制功能,f_mount(),f_mkfs()
/和f_fdisk()函數(shù),總是不凹角。只有文件/目錄的訪問
/相同的體積是這個功能的控制。
/
/ 0:禁用re-entrancy。_FS_TIMEOUT和_SYNC_t沒有效果?！ ?
/ 1:啟用re-entrancy。還提供用戶同步處理程序,
/ ff_req_grant(),ff_rel_grant(),ff_del_syncobj()和ff_cre_syncobj()
/函數(shù),必須添加到項目中。樣品中可用
/選項
/ syscall.c。
/
/ _FS_TIMEOUT定義超時時間單位的滴答聲?！ ?
/ _SYNC_t定義了O
/ S依賴同步對象類型。例如處理、ID、OS_EVENT *
/ SemaphoreHandle_t等. .O / S的頭文件定義需要
/包括在ff.c的范圍。 */
#define _WORD_ACCESS 0
/* _WORD_ACCESS選項是一個只有依賴于平臺的選擇。
它定義了這個詞/訪問方法是用來體積上的數(shù)據(jù)。
/
/ 0:逐字節(jié)的訪問?？偸羌嫒菟衅脚_?！ ?
/ 1:詞的訪問。不要選擇這個,除非在下列條件。
/
/ *地址對齊內(nèi)存訪問總是允許所有指令。
/ *字節(jié)順序的記憶是低位優(yōu)先。
/
/如果是這樣的情況,_WORD_ACCESS也可以減少代碼的大小設置為1?！ ?
/下表顯示允許設置某種類型的處理器。
/
/ 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:高位優(yōu)先。 /
* 2:不支持不連續(xù)的內(nèi)存訪問?！ ?
* 3:一些編譯器生成LDM(邏輯磁盤管理器 ) / STM mem_cpy(內(nèi)存拷貝)函數(shù)。
*/
（3）實現(xiàn)動態(tài)內(nèi)存分配函數(shù)與時間函數(shù)
ff.h文件有動態(tài)內(nèi)存的釋放，動態(tài)內(nèi)存申請，時間獲取函數(shù)接口。
在diskio.c文件實現(xiàn)函數(shù)功能：
代碼實現(xiàn)如下：
//動態(tài)內(nèi)存分配
void* ff_memalloc (UINT msize) /* 分配內(nèi)存塊 */
{
return (void*)malloc(msize); //分配空間
}
//動態(tài)內(nèi)存釋放
void ff_memfree (void* mblock) /* 空閑內(nèi)存塊 */
{
free(mblock); //釋放空間
}
//返回FATFS時間
//獲得時間
DWORD get_fattime (void)
{
//Get_RTC_Timer(); //獲取一次RTC時間
return (RTC_Timer.year-1980)<<25| //年
RTC_Timer.month<<21| //月
RTC_Timer.day<<16| //日
RTC_Timer.hour<<11| //時
RTC_Timer.minute<<5| //分
RTC_Timer.sec; //秒
}
/*
Return Value
Currnet local time is returned with packed into a DWORD value. The bit field is as follows:
bit31:25
Year origin from the 1980 (0..127)
bit24:21
Month (1..12)
bit20:16
Day of the month(1..31)
bit15:11
Hour (0..23)
bit10:5
Minute (0..59)
bit4:0
Second / 2 (0..29)
*/
（4）修改堆?？臻g
完成了上述的修改，還需要修改堆?？臻g，因為長文件支持需要占用堆空間。
修改STM32啟動文件如下：
（5）編譯工程測試
修改完畢之后，給開發(fā)板插上SD卡，調(diào)用API函數(shù)在SD卡創(chuàng)建一個文件，并寫入數(shù)據(jù)，測試是否成功：
#include "ff.h"
FATFS fs; // 用戶定義的文件系統(tǒng)結構體
FIL file; // 用戶定義的文件系統(tǒng)結構體
u8 buff[]="123 知識??！";
int main(void)
{
u32 data; //檢測SD卡容量
u8 i,res;
LED_Init(); //LED燈初始化
Delay_Init();
KEY_Init();
USART1_Init(72,115200);
USART2_Init(36,115200);
FLASH_Init();
Set_Font_addr(); //字庫地址初始化
FSMC_SRAM_Init();
LCD_Init();
RTC_Init(); //RTC時鐘初始化
while(SD_Init()) //檢測不到SD卡,SD相關硬件初始化
{
i=!i;
LCD_ShowString(60,150,200,16,16,"SD Card Error! Please Check SD Card!!",0xf800);
Delay_ms(500);
LED1(i)//DS0閃爍
}
f_mount(&fs,"0",1); // 注冊工作區(qū)，驅(qū)動器號 0，初始化后其他函數(shù)可使用里面的參數(shù)
printf("注冊工作區(qū)！n");
if(f_mkfs("0",0,4096)) //格式化SD卡
{
printf("格式化失?。?！n");
}
else
{
printf("格式化成功?。");
}
res = f_open(&file, "/file.c", FA_OPEN_ALWAYS | FA_READ | FA_WRITE);
if(res==0)
{
printf("文件創(chuàng)建成功??！n");
}
else
{
printf("文件創(chuàng)建失敗??！n");
}
res =f_write(&file,buff,strlen((const char*)buff),&data);
if(res==0)
{
printf("數(shù)據(jù)寫入成功?。");
}
else
{
printf("數(shù)據(jù)寫入失?。?！n");
}
printf("成功寫入%d字節(jié)數(shù)據(jù)n",data);
f_close(&file); //關閉文件
//_FS_RPATH
while(1)
{
Delay_ms(1000);
LED1(1);
Delay_ms(500);
LED1(0);
}
}
五、案例使用
5.1 讀取GBK字庫文件(LCD漢字顯示)
產(chǎn)品開發(fā)中，如果設備帶有LCD顯示屏，一般會顯示各種文字提示，或者機器操作說明，顯示中文需要字庫，為了方便字模的提取，可以將字庫文件制作好之后放到SD NAND上，通過文件系統(tǒng)打開字庫文件，讀取字模進行顯示。
下面貼出文件系統(tǒng)讀取字模的核心代碼：
/*
函數(shù)功能: 顯示GBK字庫數(shù)據(jù)
u32 x 范圍0~319
u32 y 范圍0~479
u32 size 數(shù)據(jù)的寬度(必須是8的倍數(shù)) 是正方形
u8 *p 中文
說明: 取模橫向坐標必須保證是8的倍數(shù)
*/
void ILI9341_DisplayGBKData(u32 x,u32 y,u32 size,u8 *p)
{
FIL fp;
UINT br;
u8 L,H;
u32 Addr;
u16 font_size=size/8*size; //字體占用的點陣碼字節(jié)大小
u8 *buff=NULL;
H=*p;
L=*(p+1);
if(L<0x7f)L=L-0x40;
else L=L-0x41;
H=H-0x81;
Addr=(190*H+L)*font_size; //中文在字庫里的偏移量
buff=malloc(font_size); //使用的堆空間
if(buff==NULL)return;
switch(size)
{
case 16:
if(f_open(&fp,"0:/font/gbk16.DZK",FA_READ)!=FR_OK)
{
printf("f_open error.rn");
}
f_lseek(&fp,Addr);
f_read(&fp,buff,font_size,&br);
f_close(&fp);
break;
case 24:
f_open(&fp,"0:/font/gbk24.DZK",FA_READ);
f_lseek(&fp,Addr);
f_read(&fp,buff,font_size,&br);
f_close(&fp);
break;
case 32:
break;
}
//顯示中文
ILI9341_DisplayData(x,y,size,size,buff);
//釋放空間
free(buff);
}
這是讀取字模，顯示的效果：
5.2 讀取MP3文件播放(開機音樂)
這個例子是演示文件系統(tǒng)的目錄掃描函數(shù)使用方式，讀取指定目錄下的MP3文件進行播放。
u8 PlayerMP3(const char *path);
FATFS FatFs;
int main()
{
LED_Init();
BEEP_Init();
KeyInit();
USARTx_Init(USART1,72,115200);
SDCardDeviceInit(); //初始化SD卡
// res=f_mkfs("0:",FM_ANY,0,work,sizeof work);
// if(res)printf("格式化失敗!n");
// else printf("格式化成功!n");
f_mount(&FatFs, "0:", 0); //注冊工作區(qū)
PlayerMP3("0:/MP3");
while(1)
{
DelayMs(100);
LED0=!LED0;
}
}
/*
函數(shù)功能: 掃描目錄mp3播放
0表示成功 1表示失敗
*/
u8 PlayerMP3(const char *path)
{
DIR dir;
FRESULT res;
FILINFO fno; //存放讀取的文件信息
char *abs_path=NULL;
/*1. 打開目錄*/
res=f_opendir(&dir,path);
if(res!=FR_OK)return res;
/*2. 循環(huán)讀取目錄*/
while(1)
{
res=f_readdir(&dir,&fno);
if(fno.fname[0] == 0 || res!=0)break;
printf("文件名稱: %s,文件大小: %ld 字節(jié)rn",fno.fname,fno.fsize);
/*過濾目錄*/
if(strstr(fno.fname,".mp3"))
{
//申請存放文件名稱的長度
abs_path=malloc(strlen(path)+strlen(fno.fname)+1);
if(abs_path==NULL)break;
strcpy(abs_path,path);
strcat(abs_path,"/");
strcat(abs_path,fno.fname);
printf("abs_path=%sn",abs_path);
VS1053_MP3(0,0,abs_path);
free(abs_path);
}
}
/*3. 關閉目錄*/
f_closedir(&dir);
return 0;
}
閱讀全文
