逐飞LPC55S69 IOT开发板之SD及FATFS

胤幻1988 · 发表于 2020-12-15 18:30:19

今天有空，移植了一下FATFS,当然还是在MCUXpresso的开发环境下。首先工程需要支持的外设库，如果一开始新建工程未选择的话。我们可以这样调出SDK元件的管理：

选择对应的，自己需要的。然后开始配置SD的引脚：

然后更新代码，将改动生成到代码中。如果程序中使用了FreeRTOS那么会报一个冲突。就是fsl_sdmmc_event.h里面也对systick_handle 进行了定义。报错重复重复定义。
我们这里有2中选择：
1、如果程序中目前用到FreeRTOS，那fsl_sdmmc_event.h里面的延时全部换成FreeRTOS的延时函数。
2、自己定义一个延时函数。我们这里展示没开FreeRTOS，我就把之前的延时函数放到该处了。
对应fsl_sdmmc_event.c里面的程序修改

#include "fsl_sdmmc_event.h"
#include "delay.h" //自己定义的，用的utick
....
void SDMMCEVENT_InitTimer(void)
{
/* Set systick reload value to generate 1ms interrupt */
//SysTick_Config(CLOCK_GetFreq(kCLOCK_CoreSysClk) / 1000U);
}
//void SysTick_Handler(void)
//{
// g_eventTimeMilliseconds++;
//}
void SDMMCEVENT_Delay(uint32_t milliseconds)
{
/*
uint32_t startTime = g_eventTimeMilliseconds;
uint32_t periodTime = 0;
while (periodTime < milliseconds)
{
periodTime = g_eventTimeMilliseconds - startTime;
}
*/
delay_ms(milliseconds);
}

复制代码

然后在delay.c 及utick的中断函数中，增加SD的延时函数计时标志：

//SD FATFS的延时 1ms触发一次
extern volatile uint32_t g_eventTimeMilliseconds;
//utick的中断回调函数
void UTICK0_Callback(void)
{
delay_count++;
//
if(delay_count%5000==0)
{
g_eventTimeMilliseconds++;
}
}

复制代码

接下来，我们开始写SD的初始化及挂载FATFA,及几个测试程序(挂载，创建系统，创建文件夹，读写TXT，遍历目录)：
sd.h:

/*
* sd.h
*
* Created on: 2020年12月15日
* Author: Administrator
*/
#ifndef SD_H_
#define SD_H_
#include "clock_config.h"
#include "fsl_common.h"
#include "fsl_reset.h"
#include "fsl_gpio.h"
#include <stdio.h>
#include <string.h>
#include "fsl_sd.h"
#include "fsl_debug_console.h"
#include "ff.h"
#include "diskio.h"
#include "fsl_sd_disk.h"
#include "pin_mux.h"
#include <stdbool.h>
#include "fsl_iocon.h"
#define BOARD_SDIF_BASEADDR SDIF
#define BOARD_SDIF_CLKSRC kCLOCK_SDio
#define BOARD_SDIF_CLK_FREQ CLOCK_GetSdioClkFreq()
#define BOARD_SDIF_CLK_ATTACH kMAIN_CLK_to_SDIO_CLK
#define BOARD_SDIF_IRQ SDIO_IRQn
#define BOARD_MMC_VCC_SUPPLY kMMC_VoltageWindows270to360
#define BOARD_SD_CARD_DETECT_PIN 17
#define BOARD_SD_CARD_DETECT_PORT 0
#define BOARD_SD_CARD_DETECT_GPIO GPIO
#define BOARD_SD_DETECT_TYPE kSDMMCHOST_DetectCardByHostCD
#define BOARD_SDIF_CD_GPIO_INIT() \
{ \
CLOCK_EnableClock(kCLOCK_Gpio2); \
GPIO_PinInit(BOARD_SD_CARD_DETECT_GPIO, BOARD_SD_CARD_DETECT_PORT, BOARD_SD_CARD_DETECT_PIN, \
&(gpio_pin_config_t){kGPIO_DigitalInput, 0U}); \
}
#define BOARD_SDIF_CD_STATUS() \
GPIO_PinRead(BOARD_SD_CARD_DETECT_GPIO, BOARD_SD_CARD_DETECT_PORT, BOARD_SD_CARD_DETECT_PIN)
#define BOARD_SDIF_CLK_ATTACH kMAIN_CLK_to_SDIO_CLK
/* buffer size (in byte) for read/write operations */
#define BUFFER_SIZE (100U)
extern FATFS g_fileSystem; /* File system object */
extern FIL g_fileObject; /* File object */
extern SDK_ALIGN(uint8_t g_bufferWrite[SDK_SIZEALIGN(BUFFER_SIZE, SDMMC_DATA_BUFFER_ALIGN_CACHE)],
MAX(SDMMC_DATA_BUFFER_ALIGN_CACHE, SDMMCHOST_DMA_BUFFER_ADDR_ALIGN));
extern SDK_ALIGN(uint8_t g_bufferRead[SDK_SIZEALIGN(BUFFER_SIZE, SDMMC_DATA_BUFFER_ALIGN_CACHE)],
MAX(SDMMC_DATA_BUFFER_ALIGN_CACHE, SDMMCHOST_DMA_BUFFER_ADDR_ALIGN));
extern const sdmmchost_detect_card_t s_sdCardDetect;
extern FRESULT error;
extern UINT bytesWritten;
extern UINT bytesRead;
extern const TCHAR driverNumberBuffer[];
extern TCHAR * fileName;
void fatfs_sdcard_init(void);
uint8_t fatfs_sdcard_mkfs(void);
uint8_t fatfs_sdcard_mkdir(char* dirname);
uint8_t fatfs_sdcard_readdir(char* dirname);
void fatfs_sdcard_writetxt(char* fileName,char* writedata );
void fatfs_sdcard_readtxt(char* fileName,uint32_t len);
uint8_t fatfs_sdcard_readMaxtxt(char* fileName);
status_t sdcardWaitCardInsert(void);
void MySD_Init(void);
#endif /* SD_H_ */

复制代码

sd.c

/*
* sd.c
*
* Created on: 2020年12月15日
* Author: Administrator
*/
#include "sd.h"
#include "string.h"
FATFS g_fileSystem; /* File system object */
FIL g_fileObject; /* File object */
DIR directory; /* Directory object */
FILINFO fileInformation;
//数据对其格式
SDK_ALIGN(uint8_t g_bufferWrite[SDK_SIZEALIGN(BUFFER_SIZE, SDMMC_DATA_BUFFER_ALIGN_CACHE)],
MAX(SDMMC_DATA_BUFFER_ALIGN_CACHE, SDMMCHOST_DMA_BUFFER_ADDR_ALIGN));
SDK_ALIGN(uint8_t g_bufferRead[SDK_SIZEALIGN(BUFFER_SIZE, SDMMC_DATA_BUFFER_ALIGN_CACHE)],
MAX(SDMMC_DATA_BUFFER_ALIGN_CACHE, SDMMCHOST_DMA_BUFFER_ADDR_ALIGN));
const sdmmchost_detect_card_t s_sdCardDetect = {
.cdType = BOARD_SD_DETECT_TYPE,
.cdTimeOut_ms = (~0U),
};
FRESULT error;
UINT bytesWritten;
UINT bytesRead;
const TCHAR driverNumberBuffer[3U] = {SDDISK + '0', ':', '/'};
volatile bool failedFlag = false;
char ch = '0';
BYTE work[FF_MAX_SS];//
TCHAR * fileName = "/config.txt";
//初始化SD并挂载到FATFS系统上
void fatfs_sdcard_init(void) {
static uint8_t initFlag = 0;
if(initFlag == 0) {
CLOCK_EnableClock(kCLOCK_InputMux);
CLOCK_AttachClk(BOARD_SDIF_CLK_ATTACH);
CLOCK_SetClkDiv(kCLOCK_DivSdioClk, (uint32_t)(SystemCoreClock / FSL_FEATURE_SDIF_MAX_SOURCE_CLOCK + 1U), true);
initFlag = 1;
}
if (sdcardWaitCardInsert() != kStatus_Success) {
PRINTF("\r\nPlease insert a card into board.\r\n");
}
if (f_mount(&g_fileSystem, driverNumberBuffer, 1U)) {
PRINTF("Mount volume failed.\r\n");
}
#if (FF_FS_RPATH >= 2U)
error = f_chdrive((char const *)&driverNumberBuffer[0U]);
if (error) {
PRINTF("Change drive failed.\r\n");
}
#endif
}
//f_mkfs 会格式化掉现有的分区不常用
/*
在驱动器上创建一个文件系统
FRESULT f_mkfs (
BYTE Drive, //逻辑驱动器号
BYTE PartitioningRule, //分区规则
WORD AllocSize //分配单元大小
);
参数:
Drive 待格式化的逻辑驱动器号(0-9)。
PartitioningRule
当给定0时，首先在驱动器上的第一个扇区创建一个分区表，然后文件系统被创建在分区上。这被称为FDISK格式化，用于硬盘和存储卡。当给定1时，文件系统从第一个扇区开始创建，而没有分区表。这被称为超级软盘(SFD)格式化，用于软盘和可移动磁盘。
AllocSize
指定每簇中以字节为单位的分配单元大小。数值必须是0或从512到32K之间2的幂。当指定0时，簇大小取决于卷大小。
返回值
FR_OK (0) 函数成功。
FR_INVALID_DRIVE 驱动器号无效。
FR_NOT_READY 由于驱动器中没有存储介质或任何其他原因，而导致磁盘驱动器无法工作。
FR_WRITE_PROTECTED 驱动器被写保护。
FR_NOT_ENABLED 逻辑驱动器没有工作区。
FR_DISK_ERR由于底层磁盘I/O函数中的错误，而导致该函数失败。
FR_MKFS_ABORTED 由于下列原因之一，而导致函数在开始格式化前终止：
磁盘容量太小
参数无效
该驱动器不允许的簇大小。
描述
f_mkfs函数当_FS_READOLNY == 0并且_USE_MKFS == 1时可用。
f_mkfs函数在驱动器中创建一个FAT文件系统。对于可移动媒介，有两种分区规则：FDISK和SFD，通过参数PartitioningRule选择。FDISK格式在大多数情况下被推荐使用。该函数当前不支持多分区，因此，物理驱动器上已存在的分区将被删除，并且重新创建一个占据全部磁盘空间的新分区。
根据Microsoft发布的FAT规范，FAT分类：FAT12/FAT16/FAT32，由驱动器上的簇数决定。因此，选择哪种FAT分类，取决于卷大小和指定的簇大小。簇大小影响文件系统的性能，并且大簇会提高性能
*/
uint8_t fatfs_sdcard_mkfs(void)
{
#if FF_USE_MKFS //Create an FAT/exFAT volume
PRINTF("\r\nMake file system......The time may be long if the card capacity is big.\r\n");
if (f_mkfs(driverNumberBuffer, FM_ANY, 0U, work, sizeof work))
{
PRINTF("Make file system failed.\r\n");
return -1;
}
#endif /* FF_USE_MKFS */
return 0;
}
//创建一个新文件夹
uint8_t fatfs_sdcard_mkdir(char* dirname)
{
PRINTF("\r\nCreate directory......\r\n");
//error = f_mkdir(_T("/dir_1"));
error = f_mkdir(_T(dirname));
if (error)
{
if (error == FR_EXIST)
{
PRINTF("Directory exists.\r\n");
}
else
{
PRINTF("Make directory failed.\r\n");
return -1;
}
}
PRINTF("\r\nCreate a file in that directory......\r\n");
return 0;
}
//遍历路径下文件
uint8_t fatfs_sdcard_readdir(char* dirname)
{
PRINTF("\r\nList the file in that directory......\r\n");
if (f_opendir(&directory, dirname))
{
PRINTF("Open directory failed.\r\n");
return -1;
}
for (;;)
{
error = f_readdir(&directory, &fileInformation);
/* To the end. */
if ((error != FR_OK) || (fileInformation.fname[0U] == 0U))
{
break;
}
if (fileInformation.fname[0] == '.')
{
continue;
}
if (fileInformation.fattrib & AM_DIR)
{
PRINTF("Directory file : %s.\r\n", fileInformation.fname);
}
else
{
PRINTF("General file : %s.\r\n", fileInformation.fname);
}
}
return 0;
}
void fatfs_sdcard_writetxt(char* fileName,char* writedata ) {
uint8_t i;
memset(g_bufferWrite, ' ', sizeof(g_bufferWrite));
g_bufferWrite[BUFFER_SIZE - 2U] = '\r';
g_bufferWrite[BUFFER_SIZE - 1U] = '\n';
PRINTF("Write.\r\n");
error = f_open(&g_fileObject, (const TCHAR*)fileName, (FA_WRITE | FA_CREATE_ALWAYS));
if (error) {
if (error == FR_EXIST) {
PRINTF("File exists.\r\n");
} else {
PRINTF("Open file failed.\r\n");
}
fatfs_sdcard_init();
error = f_open(&g_fileObject, (const TCHAR*)fileName, (FA_WRITE | FA_CREATE_ALWAYS));
}
for(i=0;i<BUFFER_SIZE;i++) { // Writting Bytes
if(writedata[i]=='\0') break;
g_bufferWrite[i] = writedata[i];
}
error = f_write(&g_fileObject, g_bufferWrite, sizeof(g_bufferWrite), &bytesWritten);
if ((error) || (bytesWritten != sizeof(g_bufferWrite))) {
PRINTF("Write file failed. \r\n");
}
if (f_close(&g_fileObject)) {
PRINTF("\r\nClose file failed.\r\n");
}
}
void fatfs_sdcard_readtxt(char* fileName,uint32_t len) {
uint8_t i;
PRINTF("Read.\r\n");
error = f_open(&g_fileObject, (const TCHAR*)fileName, FA_READ);
if (error) {
if (error == FR_EXIST) {
PRINTF("File exists.\r\n");
} else {
PRINTF("Open file failed.\r\n");
}
fatfs_sdcard_init();
error = f_open(&g_fileObject, (const TCHAR*)fileName, FA_READ);
}
if (f_lseek(&g_fileObject, 0U)) {
PRINTF("Set file pointer position failed. \r\n");
}
memset(g_bufferRead, 0U, sizeof(g_bufferRead));
error = f_read(&g_fileObject, g_bufferRead, sizeof(g_bufferRead), &bytesRead);
if ((error) || (bytesRead != sizeof(g_bufferRead))) {
PRINTF("Read file failed. \r\n");
}
for(i=0;i<len;i++) { // Read Bytes
PRINTF("%c",g_bufferRead[i]);
}
if (f_close(&g_fileObject)) {
PRINTF("\r\nClose file failed.\r\n");
}
}
uint8_t fatfs_sdcard_readMaxtxt(char* fileName) {
uint8_t i;
PRINTF("Read ALL TEXT.\r\n");
error = f_open(&g_fileObject, (const TCHAR*)fileName, FA_READ);
if (error) {
if (error == FR_EXIST) {
PRINTF("File exists.\r\n");
} else {
PRINTF("Open file failed.\r\n");
}
fatfs_sdcard_init();
error = f_open(&g_fileObject, (const TCHAR*)fileName, FA_READ);
}
/* Move the file pointer */
if (f_lseek(&g_fileObject, 0U))
{
PRINTF("Set file pointer position failed. \r\n");
failedFlag = true;
}
//读取数据，最大值100个
memset(g_bufferRead, 0U, sizeof(g_bufferRead));
error = f_read(&g_fileObject, g_bufferRead, sizeof(g_bufferRead), &bytesRead);
if ((error) || (bytesRead != sizeof(g_bufferRead)))
{
PRINTF("Read file failed. \r\n");
failedFlag = true;
}
//输出读取的数据
for(i=0;i<BUFFER_SIZE;i++) { // Read Bytes
if(g_bufferRead[i]=='\n') break;
PRINTF("%c",g_bufferRead[i]);
}
if (f_close(&g_fileObject))
{
PRINTF("\r\nClose file failed.\r\n");
return -1;
}
return 0;
}
uint8_t fatfs_sdcard_write_readAlltxt(char* fileName,uint32_t len) {
memset(g_bufferWrite, 'a', sizeof(g_bufferWrite));
g_bufferWrite[BUFFER_SIZE - 2U] = '\r';
g_bufferWrite[BUFFER_SIZE - 1U] = '\n';
PRINTF("\r\nWrite/read file until encounters error......\r\n");
while (true)
{
if (failedFlag || (ch == 'q'))
{
break;
}
PRINTF("\r\nWrite to above created file.\r\n");
error = f_write(&g_fileObject, g_bufferWrite, sizeof(g_bufferWrite), &bytesWritten);
if ((error) || (bytesWritten != sizeof(g_bufferWrite)))
{
PRINTF("Write file failed. \r\n");
failedFlag = true;
continue;
}
/* Move the file pointer */
if (f_lseek(&g_fileObject, 0U))
{
PRINTF("Set file pointer position failed. \r\n");
failedFlag = true;
continue;
}
PRINTF("Read from above created file.\r\n");
memset(g_bufferRead, 0U, sizeof(g_bufferRead));
error = f_read(&g_fileObject, g_bufferRead, sizeof(g_bufferRead), &bytesRead);
if ((error) || (bytesRead != sizeof(g_bufferRead)))
{
PRINTF("Read file failed. \r\n");
failedFlag = true;
continue;
}
PRINTF("Compare the read/write content......\r\n");
if (memcmp(g_bufferWrite, g_bufferRead, sizeof(g_bufferWrite)))
{
PRINTF("Compare read/write content isn't consistent.\r\n");
failedFlag = true;
continue;
}
PRINTF("The read/write content is consistent.\r\n");
PRINTF("\r\nInput 'q' to quit read/write.\r\nInput other char to read/write file again.\r\n");
ch = GETCHAR();
PUTCHAR(ch);
PRINTF("\r\nThe example will not read/write file again.\r\n");
if (f_close(&g_fileObject))
{
PRINTF("\r\nClose file failed.\r\n");
return -1;
}
}
return 0;
}
status_t sdcardWaitCardInsert(void) {
g_sd.host.base = SD_HOST_BASEADDR;
g_sd.host.sourceClock_Hz = SD_HOST_CLK_FREQ;
g_sd.usrParam.cd = &s_sdCardDetect;
if (SD_HostInit(&g_sd) != kStatus_Success) {
PRINTF("\r\nSD host init fail\r\n");
return kStatus_Fail;
}
SD_PowerOffCard(g_sd.host.base, g_sd.usrParam.pwr);
if (SD_WaitCardDetectStatus(SD_HOST_BASEADDR, &s_sdCardDetect, true) == kStatus_Success) {
PRINTF("\r\nCard inserted.\r\n");
SD_PowerOnCard(g_sd.host.base, g_sd.usrParam.pwr);
} else {
PRINTF("\r\nCard detect fail.\r\n");
return kStatus_Fail;
}
return kStatus_Success;
}
void MySD_Init(void)
{
CLOCK_EnableClock(kCLOCK_InputMux);
/* attach main clock to SDIF */
CLOCK_AttachClk(BOARD_SDIF_CLK_ATTACH);
/* need call this function to clear the halt bit in clock divider register */
CLOCK_SetClkDiv(kCLOCK_DivSdioClk, (uint32_t)(SystemCoreClock / FSL_FEATURE_SDIF_MAX_SOURCE_CLOCK + 1U), true);
//GPIO 复用
/* Enables the clock for the I/O controller.: Enable Clock. */
CLOCK_EnableClock(kCLOCK_Iocon);
/* Enables the clock for the GPIO0 module */
CLOCK_EnableClock(kCLOCK_Gpio0);
/* Enables the clock for the GPIO1 module */
CLOCK_EnableClock(kCLOCK_Gpio1);
IOCON->PIO[0][17] = ((IOCON->PIO[0][17] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT017 (pin 8) is configured as SD0_CARD_DET_N. */
| IOCON_PIO_FUNC(PIO0_17_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_17_DIGIMODE_DIGITAL));
IOCON->PIO[0][24] = ((IOCON->PIO[0][24] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT024 (pin 70) is configured as SD0_D0. */
| IOCON_PIO_FUNC(PIO0_24_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_24_DIGIMODE_DIGITAL));
IOCON->PIO[0][25] = ((IOCON->PIO[0][25] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT025 (pin 79) is configured as SD0_D1. */
| IOCON_PIO_FUNC(PIO0_25_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_25_DIGIMODE_DIGITAL));
if (Chip_GetVersion()==1)
{
IOCON->PIO[0][9] = ((IOCON->PIO[0][9] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT09 (pin 55) is configured as SD0_POW_EN. */
| IOCON_PIO_FUNC(PIO0_9_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_9_DIGIMODE_DIGITAL));
}
else
{
IOCON->PIO[0][9] = ((IOCON->PIO[0][9] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT09 (pin 55) is configured as SD0_POW_EN. */
| IOCON_PIO_FUNC(PIO0_9_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO0_9_DIGIMODE_DIGITAL));
}
IOCON->PIO[1][16] = ((IOCON->PIO[1][16] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT116 (pin 87) is configured as SD0_CMD. */
| IOCON_PIO_FUNC(PIO1_16_FUNC_ALT4)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO1_16_DIGIMODE_DIGITAL));
IOCON->PIO[1][5] = ((IOCON->PIO[1][5] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT15 (pin 31) is configured as SD0_D2. */
| IOCON_PIO_FUNC(PIO1_5_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO1_5_DIGIMODE_DIGITAL));
IOCON->PIO[1][6] = ((IOCON->PIO[1][6] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT16 (pin 5) is configured as SD0_D3. */
| IOCON_PIO_FUNC(PIO1_6_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO1_6_DIGIMODE_DIGITAL));
IOCON->PIO[1][8] = ((IOCON->PIO[1][8] &
/* Mask bits to zero which are setting */
(~(IOCON_PIO_FUNC_MASK | IOCON_PIO_DIGIMODE_MASK)))
/* Selects pin function.
* : PORT18 (pin 24) is configured as SD0_CLK. */
| IOCON_PIO_FUNC(PIO1_8_FUNC_ALT2)
/* Select Digital mode.
* : Enable Digital mode.
* Digital input is enabled. */
| IOCON_PIO_DIGIMODE(PIO1_8_DIGIMODE_DIGITAL));
}

复制代码

然后在main函数页面，进行调用即可：

/**
* @file seekfreePrj_demo.c
* @brief Application entry point.
*/
#include <stdio.h>
#include "board.h"
#include "peripherals.h"
#include "pin_mux.h"
#include "clock_config.h"
#include "LPC55S69_cm33_core0.h"
#include "fsl_debug_console.h"
/* TODO: insert other include files here. */
#include "sd.h"
#include "ff.h"
#include "diskio.h"
#include "fsl_sd_disk.h"
#include "semphr.h"
#include "task.h"
#include "delay.h"
#include "led.h"
#include "key.h"
/* TODO: insert other definitions and declarations here. */
/*
* @brief Application entry point.
*/
int main(void) {
//uint8_t key=0,key_tmp=0;
/* Init board hardware. */
BOARD_InitBootPins();
BOARD_InitBootClocks();
BOARD_InitBootPeripherals();
#ifndef BOARD_INIT_DEBUG_CONSOLE_PERIPHERAL
/* Init FSL debug console. */
BOARD_InitDebugConsole();
#endif
LED_Init();
KEY_Init();
//MySD_Init();
PRINTF("the systemclock is: %d Mhz\n",SystemCoreClock/1000000);
PRINTF("the for1mclock is: %d Mhz\n",CLOCK_GetFro1MFreq()/1000000);
PRINTF("FATFS SDCard example.\r\n");
fatfs_sdcard_init();
fatfs_sdcard_mkdir("/dir");
fatfs_sdcard_writetxt("/dir/test.txt",(char*)("Helloworld!\r\n"));
fatfs_sdcard_readtxt("/dir/test.txt",strlen("Helloworld!\r\n"));
PRINTF("THE SEND STR3 LEN IS %d.\r\n",strlen("Helloworld!\r\n"));
fatfs_sdcard_readMaxtxt("/dir/test.txt");
//fatfs_sdcard_readdir((char*)("2:/dir"));
fatfs_sdcard_readdir((char*)("2:/"));
/* Enter an infinite loop, just incrementing a counter. */
while(1) {
}
}

复制代码

编译无误，插上SD卡，下载程序，查看串口输出（这里吐槽下，这个SD卡的位置，真是服了，一点不方便，难拿难插）：

好了，MCUXpresso虽然有点小BUG，但整体还是蛮好用的。SD及FATFS的移植就到这。
谢谢大家观看！

阅读全文

jobszheng5 · 发表于 2020-12-16 10:40:24

看上去现在移植起来非常方便了啊

胤幻1988 · 发表于 2020-12-16 11:57:53

jobszheng5 发表于 2020-12-16 10:40
看上去现在移植起来非常方便了啊

是的，但是有些功能还得摸索。

jobszheng5 · 发表于 2020-12-17 09:25:26

这是“师傅领进门，修行在个人。”

[分享] 逐飞LPC55S69 IOT开发板之SD及FATFS

热心会员

站长推荐 /4