Läsa och skriva till minneskort via SPI - Något universialbibliotek?

PIC, AVR, Arduino, Raspberry Pi, Basic Stamp, PLC mm.
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

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.
Användarvisningsbild
AndLi
Inlägg: 17050
Blev medlem: 11 februari 2004, 18:17:59
Ort: Knivsta
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av AndLi »

Ä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?
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

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.
Användarvisningsbild
AndLi
Inlägg: 17050
Blev medlem: 11 februari 2004, 18:17:59
Ort: Knivsta
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av AndLi »

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!
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

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.
You 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.
Dessa funktioner är
  • disk_status
  • disk_initialize
  • disk_read
  • disk_write
  • disk_ioctl
  • get_fattime
Dessa kan hittas i diskio.c och ff.c. Funktionen get_fattime vill ha
DWORD get_fattime (void);
Där DWORD är alltså en uint32_t.

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)
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.
modules.png
Du har inte behörighet att öppna de filer som bifogats till detta inlägg.
Användarvisningsbild
TomasL
EF Sponsor
Inlägg: 45175
Blev medlem: 23 september 2006, 23:54:55
Ort: Borås
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av TomasL »

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.
Användarvisningsbild
TomasL
EF Sponsor
Inlägg: 45175
Blev medlem: 23 september 2006, 23:54:55
Ort: Borås
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av TomasL »

Men resten av funktionerna då?
Hur kan jag få detta att kommunicera med SPI?
På samma sätt som alla SPI-funktioner,
disk_read
disk_write
Anropar typ "spi-write" eller "dpi_read
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

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.

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;
}
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.

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);
}
Användarvisningsbild
TomasL
EF Sponsor
Inlägg: 45175
Blev medlem: 23 september 2006, 23:54:55
Ort: Borås
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av TomasL »

Finns ju mängder med info på fatFS hemsida, bara att läsa på.
Användarvisningsbild
JimmyAndersson
Inlägg: 26308
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?

Inlägg av JimmyAndersson »

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...
:trash:


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.
Användarvisningsbild
TomasL
EF Sponsor
Inlägg: 45175
Blev medlem: 23 september 2006, 23:54:55
Ort: Borås
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av TomasL »

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.
Rick81
Inlägg: 746
Blev medlem: 30 december 2005, 13:07:09

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av Rick81 »

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.
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

Hej!
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...
:trash:


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 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.
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.
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.
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);
Till

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));
För att använda detta så måste man inkludera följande.

Kod: Markera allt

#include "Memory Card/fatfs_sd.h"
#include "Memory Card/ff.h"
I sin main.c fil.

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)
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.

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+"
}
Sedan här

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

Sedan kommer jag hit.

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!!!!!!!!!
	}
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.

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.
DanielM
Inlägg: 2166
Blev medlem: 5 september 2019, 14:19:58

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av DanielM »

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

Kod: Markera allt

int main()
	.....
	FATFS fs;  // file system
	FRESULT mount_result = f_mount(&fs, "/", 1);
	.....
Då fungerar detta riktigt bra!

Men om jag anropar denna kod.

Kod: Markera allt

int main()
	.....
	FATFS fs;  // file system
	FRESULT mount_result = SD_Mont_Card(&fs);
	.....
Vars funktion SD_Mont_Card(FATFS* fs) ser ut så här

Kod: Markera allt

FRESULT SD_Mont_Card(FATFS* fs){
	return f_mount(&fs, "/", 1);
}
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!
2021-06-20 (1).png
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.
2021-06-20 (2).png
Här går jag ut f_mount. Ser ni! Jag har tappat ALL data. Varför?
2021-06-20 (3).png
Du har inte behörighet att öppna de filer som bifogats till detta inlägg.
Användarvisningsbild
AndLi
Inlägg: 17050
Blev medlem: 11 februari 2004, 18:17:59
Ort: Knivsta
Kontakt:

Re: Läsa och skriva till minneskort via SPI - Något universialbibliotek?

Inlägg av AndLi »

Titta på vad du kallar f_mount med för värde. Du skickar inte samma sak!
Skriv svar