Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Jag håller på läsa och skriva till minneskort via SPI, men jag har inte fått det klart än då jag tycker att C-koden för biblioteket är enormt krångligt och det handlar mest bara "klistra in" massa filter "här & där". Sådant gillar inte jag. Jag vill ha det snyggt strukturerat och alla bibliotekfiler ska ligga i en gemensam mapp. Inte vara utspridda.
Så därför undrar jag om det finns något universialbibliotek där man kan skicka SPI kommandon till ett minneskort och läsa utav data eller skriva data till minneskortet?
Jag hade tänkt att det skulle ske i FAT32 formatet.
ST har ett bibliotek för minneskort, men även detta bibliotek ser svårt ut och biblioteket är inte heller komplett. Man måste komplettera med 3:e parts bibliotek från någon okänd källa, vilket jag tycker är dåligt. På Youtube så brukar detta bibliotek användas. https://github.com/eziya/STM32_SPI_SDCARD
Biblioteket fungerar, men det är mycket jobb att få det bra. Biblioteket är dessutom dåligt dokumenterat, så blir det en bug någonstans, så är man körd direkt.
Jag vill ha det enkelt. Öppna fil, skriv data, stäng fil. Klart!
Här är ett universialbibliotek https://github.com/1nv1/ulibSD
Men detta bibliotek passar inte SDHC minneskort, vilket är dagens moderna minneskort som går att köpa i vanliga butiker.
Så därför undrar jag om det finns något universialbibliotek där man kan skicka SPI kommandon till ett minneskort och läsa utav data eller skriva data till minneskortet?
Jag hade tänkt att det skulle ske i FAT32 formatet.
ST har ett bibliotek för minneskort, men även detta bibliotek ser svårt ut och biblioteket är inte heller komplett. Man måste komplettera med 3:e parts bibliotek från någon okänd källa, vilket jag tycker är dåligt. På Youtube så brukar detta bibliotek användas. https://github.com/eziya/STM32_SPI_SDCARD
Biblioteket fungerar, men det är mycket jobb att få det bra. Biblioteket är dessutom dåligt dokumenterat, så blir det en bug någonstans, så är man körd direkt.
Jag vill ha det enkelt. Öppna fil, skriv data, stäng fil. Klart!
Här är ett universialbibliotek https://github.com/1nv1/ulibSD
Men detta bibliotek passar inte SDHC minneskort, vilket är dagens moderna minneskort som går att köpa i vanliga butiker.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Är SDHC en öppen spec? Jag minns när jag meckade med det för 10 år sen att man kunde köra någon långsam variant utan problem men gick man upp i hastighet så fanns det div licenser och grejs som skulle till.
Är det månne därför det är en sådan soppa för dig att hitta något gratis som funkar?
Är det månne därför det är en sådan soppa för dig att hitta något gratis som funkar?
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Det måste det väll vara? ST ger ju ut öppen källkod till SDHC.
Det fungerar för mig, men jag ogillar att det är sådana grötiga bibliotek på GitHub. Vissa bibliotek är bra, men när det kommer till SD-kort så är biblioteken skrivna som de vore skrivna av en kodapa.
Det fungerar för mig, men jag ogillar att det är sådana grötiga bibliotek på GitHub. Vissa bibliotek är bra, men när det kommer till SD-kort så är biblioteken skrivna som de vore skrivna av en kodapa.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Du får väl kräva dina pengar tillbaka och hänvisa till att de inte uppfyller de önskade kraven om ordning och reda!
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Nu har jag hittat biblioteket som jag söker efter. FatFS heter det.
http://elm-chan.org/fsw/ff/00index_e.html
Detta är ett universialbibliotek som passar all hårdvara. Det enda man behöver göra är att porta om bibliotekets MAI funktioner till plattformens funktioner.
Att ha en RTC som kan spotta ut en variabel som symboliserar tiden, ska jag redan implementera. Inga problem.
Men resten av funktionerna då?
Hur kan jag få detta att kommunicera med SPI?
För tanken med FatFS är att den ska kunna kommunicera med SPI.
http://elm-chan.org/fsw/ff/00index_e.html
Detta är ett universialbibliotek som passar all hårdvara. Det enda man behöver göra är att porta om bibliotekets MAI funktioner till plattformens funktioner.
Dessa funktioner ärYou need to provide only MAI functions required by FatFs module and nothing else. If a working device control module for the target system is available, you need to write only glue functions to attach it to the FatFs module. If not, you need to port another device control module or write it from scratch. Most of MAI functions are not that always required. For instance, the write function is not required in read-only configuration. Following table shows which function is required depends on the configuration options.
- disk_status
- disk_initialize
- disk_read
- disk_write
- disk_ioctl
- get_fattime
Där DWORD är alltså en uint32_t.DWORD get_fattime (void);
Kod: Markera allt
Currnet local time shall be returned as bit-fields packed into a DWORD value. The bit fields are as follows:
bit31:25
Year origin from the 1980 (0..127, e.g. 37 for 2017)
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, e.g. 25 for 50)
Men resten av funktionerna då?
Hur kan jag få detta att kommunicera med SPI?
För tanken med FatFS är att den ska kunna kommunicera med SPI.
Du har inte behörighet att öppna de filer som bifogats till detta inlägg.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
SD, SDHC mfl är exakt samma standard, skillnaden är hastighet, minnesstorlek och fysisk storlek.
Ett SD kort läser du som vilket annat SPI-minne som helst, dvs MISO, MOSI, Klocka och CS.
Inga större konstigheter.
Filsystemet får dina drivrutiner ta hand om, om du nu vill använda ett filsystem, vilket iofs inte är nödvändigt.
Dock vill du kunna utnyttja kortet maximalt, dvs kunna använda samtliga MISO/MOSI kanaler i full hastighet får du betala en licensavgift till SDA.
Ett SD kort läser du som vilket annat SPI-minne som helst, dvs MISO, MOSI, Klocka och CS.
Inga större konstigheter.
Filsystemet får dina drivrutiner ta hand om, om du nu vill använda ett filsystem, vilket iofs inte är nödvändigt.
Dock vill du kunna utnyttja kortet maximalt, dvs kunna använda samtliga MISO/MOSI kanaler i full hastighet får du betala en licensavgift till SDA.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
På samma sätt som alla SPI-funktioner,Men resten av funktionerna då?
Hur kan jag få detta att kommunicera med SPI?
disk_read
disk_write
Anropar typ "spi-write" eller "dpi_read
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Jo, med vilken data?
Det står bara så här att man ska översätta det som kommer igenom argumentet hos funktionerna. Detta är från filen diskio.c.
En annan teori är att använda detta c-kod.
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.c
Så jag får en diskio.c fil som ser ut så här.
Det står bara så här att man ska översätta det som kommer igenom argumentet hos funktionerna. Detta är från filen diskio.c.
Kod: Markera allt
/*-----------------------------------------------------------------------*/
/* Get Drive Status */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case DEV_RAM :
result = RAM_disk_status();
// translate the reslut code here
return stat;
case DEV_MMC :
result = MMC_disk_status();
// translate the reslut code here
return stat;
case DEV_USB :
result = USB_disk_status();
// translate the reslut code here
return stat;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* Inidialize a Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive nmuber to identify the drive */
)
{
DSTATUS stat;
int result;
switch (pdrv) {
case DEV_RAM :
result = RAM_disk_initialize();
// translate the reslut code here
return stat;
case DEV_MMC :
result = MMC_disk_initialize();
// translate the reslut code here
return stat;
case DEV_USB :
result = USB_disk_initialize();
// translate the reslut code here
return stat;
}
return STA_NOINIT;
}
/*-----------------------------------------------------------------------*/
/* Read Sector(s) */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
BYTE *buff, /* Data buffer to store read data */
LBA_t sector, /* Start sector in LBA */
UINT count /* Number of sectors to read */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// translate the arguments here
result = RAM_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case DEV_MMC :
// translate the arguments here
result = MMC_disk_read(buff, sector, count);
// translate the reslut code here
return res;
case DEV_USB :
// translate the arguments here
result = USB_disk_read(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
}
/*-----------------------------------------------------------------------*/
/* Write Sector(s) */
/*-----------------------------------------------------------------------*/
#if FF_FS_READONLY == 0
DRESULT disk_write (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
const BYTE *buff, /* Data to be written */
LBA_t sector, /* Start sector in LBA */
UINT count /* Number of sectors to write */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// translate the arguments here
result = RAM_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case DEV_MMC :
// translate the arguments here
result = MMC_disk_write(buff, sector, count);
// translate the reslut code here
return res;
case DEV_USB :
// translate the arguments here
result = USB_disk_write(buff, sector, count);
// translate the reslut code here
return res;
}
return RES_PARERR;
}
#endif
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE pdrv, /* Physical drive number (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
DRESULT res;
int result;
switch (pdrv) {
case DEV_RAM :
// Process of the command for the RAM drive
return res;
case DEV_MMC :
// Process of the command for the MMC/SD card
return res;
case DEV_USB :
// Process of the command the USB drive
return res;
}
return RES_PARERR;
}
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.c
Så jag får en diskio.c fil som ser ut så här.
Kod: Markera allt
#include "ff.h" /* Obtains integer types */
#include "diskio.h" /* Declarations of disk functions */
/* Definitions of physical drive number for each drive */
#define DEV_RAM 0 /* Example: Map Ramdisk to physical drive 0 */
#define DEV_MMC 1 /* Example: Map MMC/SD card to physical drive 1 */
#define DEV_USB 2 /* Example: Map USB MSD to physical drive 2 */
/*-----------------------------------------------------------------------*/
/* Get Drive Status */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE pdrv /* Physical drive number to identify the drive */
)
{
return SD_disk_status(pdrv);
}
/*-----------------------------------------------------------------------*/
/* Inidialize a Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE pdrv /* Physical drive number to identify the drive */
)
{
return SD_disk_initialize(pdrv);
}
/*-----------------------------------------------------------------------*/
/* Read Sector(s) */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
BYTE pdrv, /* Physical drive number to identify the drive */
BYTE *buff, /* Data buffer to store read data */
LBA_t sector, /* Start sector in LBA */
UINT count /* Number of sectors to read */
)
{
return SD_disk_read(pdrv, buff, sector, count);
}
/*-----------------------------------------------------------------------*/
/* Write Sector(s) */
/*-----------------------------------------------------------------------*/
#if FF_FS_READONLY == 0
DRESULT disk_write (
BYTE pdrv, /* Physical drive nmuber to identify the drive */
const BYTE *buff, /* Data to be written */
LBA_t sector, /* Start sector in LBA */
UINT count /* Number of sectors to write */
)
{
return SD_disk_write(pdrv, buff, sector, count);
}
#endif
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE pdrv, /* Physical drive number (0..) */
BYTE cmd, /* Control code */
void *buff /* Buffer to send/receive control data */
)
{
return SD_disk_ioctl(pdrv, cmd, buff);
}
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Finns ju mängder med info på fatFS hemsida, bara att läsa på.
- JimmyAndersson
- Inlägg: 26309
- Blev medlem: 6 augusti 2005, 21:23:33
- Ort: Oskarshamn (En bit utanför)
- Kontakt:
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Bra! Hårt och känslokallt ska det vara.
De ska minsann få veta hur det var att inte ha något forum att fråga...
Daniel:
Koden i ditt senaste inlägg är ju ganska snårig.
En funktion som anropar en funktion som...
Jag kan inte språket/miljön du använder men det ser ut som att du behöver ändra det som har med SPI att göra, så det motsvarar din miljö.
Jag är tillräckligt knasig för att programmera allt jag gör i assembler eller php, men jag förstår C tillräckligt för att hänga med, så visa gärna mer kod, eller en länk till hela koden.
De ska minsann få veta hur det var att inte ha något forum att fråga...
Daniel:
Koden i ditt senaste inlägg är ju ganska snårig.
En funktion som anropar en funktion som...
Jag kan inte språket/miljön du använder men det ser ut som att du behöver ändra det som har med SPI att göra, så det motsvarar din miljö.
Jag är tillräckligt knasig för att programmera allt jag gör i assembler eller php, men jag förstår C tillräckligt för att hänga med, så visa gärna mer kod, eller en länk till hela koden.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Det minsta man kan begära är att dokumentation, kodexempel mm studeras.
Och som sagt, det finns rätt mycket information på sidan som TS länkar till.
Och som sagt, det finns rätt mycket information på sidan som TS länkar till.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Jag har inplementerat fatFS i PIC16 via SPI och STM32 med SDIO.
Har för mig det bara var lägga in SPI anrop i platform och diskio. Sen var det en ms tickfunktion man behövde specca för timing.
Sen får man tänka på att ändra hastighet på SPI vid initeriering och sedan ökar man den.
Har för mig det bara var lägga in SPI anrop i platform och diskio. Sen var det en ms tickfunktion man behövde specca för timing.
Sen får man tänka på att ändra hastighet på SPI vid initeriering och sedan ökar man den.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Hej!
Det enda jag har gjort är att jag har lagt till filen integer.h och jag har ändrat i fatfs_sd.c och fatfs_sd.h
Filerna fatfs_sd.c och fatfs_sd.h har jag hittat här:
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.h
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.c
Det jag har modifierat är att jag har exempelvis flyttat om lite i headerfilen fatfs_sd.h till diskio.h och alla #define från fatfs_sd.h till fatfs_sd.c bara för att jag inte ska kunna komma åt dessa från andra ställen i min användrarkod. När det kommer till variablerna Timer1 och Timer2 i fatfs_sd.c så har jag gjort om detta.
Till
För att använda detta så måste man inkludera följande.
I sin main.c fil.
Där efter så ska man anropa denna kod för att deklarera SPI enheten.
Så nu är det mest bara att anropa följande funktioner. Dessa funktioner finns dock inte med i Memory Card.zip filen som jag bifogar. Kopiera bara denna kod och kör funktionerna.
Men det fel jag får är FR_DISK_ERR, vilket betyder att den inte hittar någon FAT volym när jag anropar SD_Make_Filesystem() funktionen.
Nu får jag bara FR_NOT_READY. Men när jag monterar SD kortet så får jag FR_OK.
Edit: Nu får jag bara FR_DISK_ERR efter att jag har verkligen sett till så SD-kortet sitter fast + att jag har dragit ned SPI-klockans hastighet.
Här hamnar jag idag när jag öppnar en fil efter jag har monterat SD-kortet.
Sedan här
Sedan kommer jag hit.
Om man vill konfiguera FatFS så är det bara att ändra parametrarna i ffconf.h, exempelvis detta. Det är EXAKT samma parametrar i FATFS i STM32CubeIDE.
Jag delar med mig av koden som jag använder. Färdig att direkt använda för egentligen alla system. Bara ändra SPI anropen bara.JimmyAndersson skrev: ↑17 juni 2021, 23:34:32 Bra! Hårt och känslokallt ska det vara.
De ska minsann få veta hur det var att inte ha något forum att fråga...
Daniel:
Koden i ditt senaste inlägg är ju ganska snårig.
En funktion som anropar en funktion som...
Jag kan inte språket/miljön du använder men det ser ut som att du behöver ändra det som har med SPI att göra, så det motsvarar din miljö.
Jag är tillräckligt knasig för att programmera allt jag gör i assembler eller php, men jag förstår C tillräckligt för att hänga med, så visa gärna mer kod, eller en länk till hela koden.
Jag lägger upp mitt exempelprojekt i form av C-kod. Denna C-kod är universial och passar alla system, så länge man ändrar SPI anropen i fatfs_sd.c filen.Rick81 skrev: ↑18 juni 2021, 07:50:31 Jag har inplementerat fatFS i PIC16 via SPI och STM32 med SDIO.
Har för mig det bara var lägga in SPI anrop i platform och diskio. Sen var det en ms tickfunktion man behövde specca för timing.
Sen får man tänka på att ändra hastighet på SPI vid initeriering och sedan ökar man den.
Det enda jag har gjort är att jag har lagt till filen integer.h och jag har ändrat i fatfs_sd.c och fatfs_sd.h
Filerna fatfs_sd.c och fatfs_sd.h har jag hittat här:
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.h
https://github.com/eziya/STM32_SPI_SDCA ... fatfs_sd.c
Det jag har modifierat är att jag har exempelvis flyttat om lite i headerfilen fatfs_sd.h till diskio.h och alla #define från fatfs_sd.h till fatfs_sd.c bara för att jag inte ska kunna komma åt dessa från andra ställen i min användrarkod. När det kommer till variablerna Timer1 och Timer2 i fatfs_sd.c så har jag gjort om detta.
Kod: Markera allt
/* timeout 200ms */
Timer1 = 200;
/* loop until receive a response or timeout */
do {
token = SPI_RxByte();
} while((token == 0xFF) && Timer1);
Kod: Markera allt
/* timeout 200ms */
uint16_t end_time = 200;
uint32_t time = HAL_GetTick();
/* loop until receive a response or timeout */
do {
token = SPI_RxByte();
} while((token == 0xFF) && (end_time > HAL_GetTick() - time));
Kod: Markera allt
#include "Memory Card/fatfs_sd.h"
#include "Memory Card/ff.h"
Där efter så ska man anropa denna kod för att deklarera SPI enheten.
Kod: Markera allt
void SD_SPI_init(SPI_HandleTypeDef* hspi, GPIO_TypeDef* CS_Pin_Port, uint16_t CS_Pin)
Kod: Markera allt
static FIL fil;
FRESULT SD_Mont_Card(){
FATFS fs;
return f_mount(&fs, "", 0);
}
FRESULT SD_Umont_Card() {
return f_mount(NULL, "", 1);
}
FRESULT SD_Open_Existing_File_With_Read_Write(char* filename) {
return f_open(&fil, filename, FA_READ | FA_WRITE); // Posix "r+"
}
FRESULT SD_Make_Filesystem() {
uint32_t work[FF_MAX_SS];
MKFS_PARM opt;
opt.fmt = FM_FAT32;
opt.au_size = 0;
opt.align = 0;
opt.n_fat = 0;
opt.n_root = 0;
return f_mkfs("", &opt, work, FF_MAX_SS);
}
FRESULT SD_Create_New_File_With_Read_Write(char* filename) {
return f_open(&fil, filename, FA_CREATE_ALWAYS | FA_WRITE | FA_READ); // Posix "w+"
}
FRESULT SD_Append_Existing_File_With_Read_Write(char* filename) {
return f_open(&fil, filename, FA_OPEN_APPEND | FA_WRITE | FA_READ); // Posix "a+"
}
FRESULT SD_Close_File() {
return f_close(&fil);
}
FRESULT SD_Check_Space(uint32_t* totalSpace, uint32_t* freeSpace){
FATFS *pfs;
DWORD fre_clust;
FRESULT status = f_getfree("", &fre_clust, &pfs);
*totalSpace = (uint32_t)((pfs->n_fatent - 2) * pfs->csize * 0.5);
*freeSpace = (uint32_t)(fre_clust * pfs->csize * 0.5);
return status;
}
FRESULT SD_Read_File(uint8_t* buffer, uint32_t bytes_to_read, uint32_t* bytes_read){
return f_read(&fil, buffer, bytes_to_read, bytes_read);
}
FRESULT SD_Write_File(uint8_t* buffer, uint32_t bytes_to_write, uint32_t* bytes_written){
return f_write(&fil, buffer, bytes_to_write, bytes_written);
}
Men det fel jag får är FR_DISK_ERR, vilket betyder att den inte hittar någon FAT volym när jag anropar SD_Make_Filesystem() funktionen.
Nu får jag bara FR_NOT_READY. Men när jag monterar SD kortet så får jag FR_OK.
Edit: Nu får jag bara FR_DISK_ERR efter att jag har verkligen sett till så SD-kortet sitter fast + att jag har dragit ned SPI-klockans hastighet.
Här hamnar jag idag när jag öppnar en fil efter jag har monterat SD-kortet.
Kod: Markera allt
FRESULT SD_Create_New_File_With_Read_Write(char* filename) {
return f_open(&fil, filename, FA_CREATE_ALWAYS | FA_WRITE | FA_READ); // Posix "w+"
}
Kod: Markera allt
/*-----------------------------------------------------------------------*/
/* Open or Create a File */
/*-----------------------------------------------------------------------*/
FRESULT f_open (
FIL* fp, /* Pointer to the blank file object */
const TCHAR* path, /* Pointer to the file name */
BYTE mode /* Access mode and open mode flags */
)
{
FRESULT res;
DIR dj;
FATFS *fs;
#if !FF_FS_READONLY
DWORD cl, bcs, clst, tm;
LBA_t sc;
FSIZE_t ofs;
#endif
DEF_NAMBUF
if (!fp) return FR_INVALID_OBJECT;
/* Get logical drive number */
mode &= FF_FS_READONLY ? FA_READ : FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_CREATE_NEW | FA_OPEN_ALWAYS | FA_OPEN_APPEND;
res = mount_volume(&path, &fs, mode); <-------------------------- HÄR
Kod: Markera allt
/*-----------------------------------------------------------------------*/
/* Determine logical drive number and mount the volume if needed */
/*-----------------------------------------------------------------------*/
static FRESULT mount_volume ( /* FR_OK(0): successful, !=0: an error occurred */
const TCHAR** path, /* Pointer to pointer to the path name (drive number) */
FATFS** rfs, /* Pointer to pointer to the found filesystem object */
BYTE mode /* !=0: Check write protection for write access */
)
{
int vol;
DSTATUS stat;
LBA_t bsect;
DWORD tsect, sysect, fasize, nclst, szbfat;
WORD nrsv;
FATFS *fs;
UINT fmt;
/* Get logical drive number */
*rfs = 0;
vol = get_ldnumber(path);
if (vol < 0) return FR_INVALID_DRIVE;
/* Check if the filesystem object is valid or not */
fs = FatFs[vol]; /* Get pointer to the filesystem object */
if (!fs) return FR_NOT_ENABLED; /* Is the filesystem object available? */
#if FF_FS_REENTRANT
if (!lock_fs(fs)) return FR_TIMEOUT; /* Lock the volume */
#endif
*rfs = fs; /* Return pointer to the filesystem object */
mode &= (BYTE)~FA_READ; /* Desired access mode, write access or not */
if (fs->fs_type != 0) { /* If the volume has been mounted */
stat = disk_status(fs->pdrv);
if (!(stat & STA_NOINIT)) { /* and the physical drive is kept initialized */
if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) { /* Check write protection if needed */
return FR_WRITE_PROTECTED;
}
return FR_OK; /* The filesystem object is already valid */
}
}
/* The filesystem object is not valid. */
/* Following code attempts to mount the volume. (find an FAT volume, analyze the BPB and initialize the filesystem object) */
fs->fs_type = 0; /* Clear the filesystem object */
fs->pdrv = LD2PD(vol); /* Volume hosting physical drive */
stat = disk_initialize(fs->pdrv); /* Initialize the physical drive */
if (stat & STA_NOINIT) { /* Check if the initialization succeeded */
return FR_NOT_READY; /* Failed to initialize due to no medium or hard error */ <----------------------------HÄR!!!!!!!!!
}
Kod: Markera allt
#define FF_MIN_SS 512
#define FF_MAX_SS 4096
/* This set of options configures the range of sector size to be supported. (512,
/ 1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
/ harddisk, but a larger value may be required for on-board flash memory and some
/ type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
/ for variable sector size mode and disk_ioctl() function needs to implement
/ GET_SECTOR_SIZE command. */
Du har inte behörighet att öppna de filer som bifogats till detta inlägg.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Nu har jag fått det att fungera, men tror jag har hittat något riktigt mystiskt!
Om jag står i min main funktion och anropar
Då fungerar detta riktigt bra!
Men om jag anropar denna kod.
Vars funktion SD_Mont_Card(FATFS* fs) ser ut så här
Då får jag hard fault error. Nu tror jag inte på spöken, men man kan ju undra.
Det som händer är att strukturen fs tappar all sin data. Jag förstår inte varför.
Så här ser det ut när jag inte gör SD_Mount_Card funktionen. Då fungerar det bra! Så här ser det ut direkt innan jag får hard fault error. Här kör jag SD_Mount_Card funktionen. Jag befinner mig i alltså f_mount funktionen. Här går jag ut f_mount. Ser ni! Jag har tappat ALL data. Varför?
Om jag står i min main funktion och anropar
Kod: Markera allt
int main()
.....
FATFS fs; // file system
FRESULT mount_result = f_mount(&fs, "/", 1);
.....
Men om jag anropar denna kod.
Kod: Markera allt
int main()
.....
FATFS fs; // file system
FRESULT mount_result = SD_Mont_Card(&fs);
.....
Kod: Markera allt
FRESULT SD_Mont_Card(FATFS* fs){
return f_mount(&fs, "/", 1);
}
Det som händer är att strukturen fs tappar all sin data. Jag förstår inte varför.
Så här ser det ut när jag inte gör SD_Mount_Card funktionen. Då fungerar det bra! Så här ser det ut direkt innan jag får hard fault error. Här kör jag SD_Mount_Card funktionen. Jag befinner mig i alltså f_mount funktionen. Här går jag ut f_mount. Ser ni! Jag har tappat ALL data. Varför?
Du har inte behörighet att öppna de filer som bifogats till detta inlägg.
Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?
Titta på vad du kallar f_mount med för värde. Du skickar inte samma sak!