f_write problems SD SPI

carlos henrique nascimento martins

Intellectual 620 points

Hi Friend, after a long effort I discovered that my hardware was with problem, that now has solved .

After initial test I verified that when I try write in SD CARD my code, return error.

The error showed by FATFS is FR_INVALID_OBJECT

I Verified this error on FATFS site and the message meaning :

FR_INVALID_OBJECT : The file/directory object is invalid or a null pointer is given.

My code is paste below, someone can help me understand why this error happen and what I need to do to solve this. Thanks too much and have a good day .

//*****************************************************************************
//
// sd_card.c - Example program for reading files from an SD card.
//
// Copyright (c) 2011-2012 Texas Instruments Incorporated. All rights reserved.
// Software License Agreement
//
// Texas Instruments (TI) is supplying this software for use solely and
// exclusively on TI's microcontroller products. The software is owned by
// TI and/or its suppliers, and is protected under applicable copyright
// laws. You may not combine this software with "viral" open-source
// software in order to form a larger program.
//
// THIS SOFTWARE IS PROVIDED "AS IS" AND WITH ALL FAULTS.
// NO WARRANTIES, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT
// NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. TI SHALL NOT, UNDER ANY
// CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES, FOR ANY REASON WHATSOEVER.
//
// This is part of revision 9453 of the EK-LM4F232 Firmware Package.
//
//*****************************************************************************

#include <string.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "driverlib/fpu.h"
#include "driverlib/gpio.h"
#include "driverlib/interrupt.h"
#include "driverlib/rom.h"
#include "driverlib/sysctl.h"
#include "driverlib/systick.h"
#include "utils/cmdline.h"
#include "utils/uartstdio.h"
#include "third_party/fatfs/src/ff.h"
#include "third_party/fatfs/src/diskio.h"
#include "third_party/fatfs/port/mmc-ek-lm4f232h5qd.h"

#define GPIO_PA0_U0RX 0x00000001
#define GPIO_PA1_U0TX 0x00000401

#define GPIO_PA2_SSI0CLK 0x00000802
#define GPIO_PA3_SSI0FSS 0x00000C02
#define GPIO_PA4_SSI0RX 0x00001002
#define GPIO_PA5_SSI0TX 0x00001402
static FIL Fil;
//#define NUM_SSI_DATA 3

//*****************************************************************************
//
//! \addtogroup example_list
//! <h1>SD card using FAT file system (sd_card)</h1>
//!
//! This example application demonstrates reading a file system from an SD
//! card. It makes use of FatFs, a FAT file system driver. It provides a
//! simple command console via a serial port for issuing commands to view and
//! navigate the file system on the SD card.
//!
//! The first UART, which is connected to the USB debug virtual serial port on
//! the evaluation board, is configured for 115,200 bits per second, and 8-N-1
//! mode. When the program is started a message will be printed to the
//! terminal. Type ``help'' for command help.
//!
//! For additional details about FatFs, see the following site:
//! http://elm-chan.org/fsw/ff/00index_e.html
//
//*****************************************************************************

//*****************************************************************************
//
// Defines the size of the buffers that hold the path, or temporary data from
// the SD card. There are two buffers allocated of this size. The buffer size
// must be large enough to hold the longest expected full path name, including
// the file name, and a trailing null character.
//
//*****************************************************************************
#define PATH_BUF_SIZE 80

//*****************************************************************************
//
// Defines the size of the buffer that holds the command line.
//
//*****************************************************************************
#define CMD_BUF_SIZE 64

//*****************************************************************************
//
// The following are data structures used by FatFs.
//
//*****************************************************************************
static FATFS g_sFatFs;

//*****************************************************************************
//
// A structure that holds a mapping between an FRESULT numerical code, and a
// string representation. FRESULT codes are returned from the FatFs FAT file
// system driver.
//
//*****************************************************************************
typedef struct
{
FRESULT fresult;
char *pcResultStr;
}
tFresultString;

//*****************************************************************************
//
// A macro to make it easy to add result codes to the table.
//
//*****************************************************************************
#define FRESULT_ENTRY(f) { (f), (#f) }

//*****************************************************************************
//
// A table that holds a mapping between the numerical FRESULT code and it's
// name as a string. This is used for looking up error codes for printing to
// the console.
//
//*****************************************************************************
tFresultString g_sFresultStrings[] =
{
FRESULT_ENTRY(FR_OK),
FRESULT_ENTRY(FR_NOT_READY),
FRESULT_ENTRY(FR_NO_FILE),
FRESULT_ENTRY(FR_NO_PATH),
FRESULT_ENTRY(FR_INVALID_NAME),
FRESULT_ENTRY(FR_INVALID_DRIVE),
FRESULT_ENTRY(FR_DENIED),
FRESULT_ENTRY(FR_EXIST),
FRESULT_ENTRY(FR_RW_ERROR),
FRESULT_ENTRY(FR_WRITE_PROTECTED),
FRESULT_ENTRY(FR_NOT_ENABLED),
FRESULT_ENTRY(FR_NO_FILESYSTEM),
FRESULT_ENTRY(FR_INVALID_OBJECT),
FRESULT_ENTRY(FR_MKFS_ABORTED)
};

//*****************************************************************************
//
// A macro that holds the number of result codes.
//
//*****************************************************************************
#define NUM_FRESULT_CODES (sizeof(g_sFresultStrings) / sizeof(tFresultString))

//*****************************************************************************
//*****************************************************************************
//
// This function returns a string representation of an error code that was
// returned from a function call to FatFs. It can be used for printing human
// readable error messages.
//
//*****************************************************************************
const char *
StringFromFresult(FRESULT fresult)
{
unsigned int uIdx;

//
// Enter a loop to search the error code table for a matching error code.
//
for(uIdx = 0; uIdx < NUM_FRESULT_CODES; uIdx++)
{
//
// If a match is found, then return the string name of the error code.
//
if(g_sFresultStrings[uIdx].fresult == fresult)
{
return(g_sFresultStrings[uIdx].pcResultStr);
}
}

//
// At this point no matching code was found, so return a string indicating
// an unknown error.
//
return("UNKNOWN ERROR CODE");
}

//*****************************************************************************
//
// This is the handler for this SysTick interrupt. FatFs requires a timer tick
// every 10 ms for internal timing purposes.
//
//*****************************************************************************
void
SysTickHandler(void)
{
//
// Call the FatFs tick timer.
//
disk_timerproc();
//UARTprintf("\n\tick");
}

//*****************************************************************************
//
// This function implements the "ls" command. It opens the current directory
// and enumerates through the contents, and prints a line for each item it
// finds. It shows details such as file attributes, time and date, and the
// file size, along with the name. It shows a summary of file sizes at the end
// along with free space.
//
//*****************************************************************************
//
// The error routine that is called if the driver library encounters an error.
//
//*****************************************************************************
#ifdef DEBUG
void
__error__(char *pcFilename, unsigned long ulLine)
{
}
#endif

//*****************************************************************************
//
// The program main function. It performs initialization, then runs a command
// processing loop to read commands from the console.
//
//*****************************************************************************

int
main(void)
{

FRESULT fresult;

static DIR g_sDirObject;
static FILINFO g_sFileInfo;
unsigned long ulTotalSize;
FATFS *pFatFs;
unsigned int bw;
ulTotalSize = 0;

//
// Enable lazy stacking for interrupt handlers. This allows floating-point
// instructions to be used within interrupt handlers, but at the expense of
// extra stack usage.
//
ROM_FPULazyStackingEnable();

//
// Set the system clock to run at 50MHz from the PLL.
//
// ROM_SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN |
// SYSCTL_XTAL_16MHZ);

ROM_SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
SYSCTL_XTAL_16MHZ);
//
// Enable the peripherals used by this example.
//
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);
ROM_SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);

//_______________________________________________

ROM_GPIOPinConfigure(GPIO_PA0_U0RX);
ROM_GPIOPinConfigure(GPIO_PA1_U0TX);
//_______________________________________________
//
// Configure SysTick for a 100Hz interrupt. The FatFs driver wants a 10 ms
// tick.
//
ROM_SysTickPeriodSet(ROM_SysCtlClockGet() / 100);
ROM_SysTickEnable();
ROM_SysTickIntEnable();

//
// Enable Interrupts
//
ROM_IntMasterEnable();

//
// Set GPIO A0 and A1 as UART.
//
ROM_GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);

//
// Initialize the UART as a console for text I/O.
//
UARTStdioInit(0);

//
// Print hello message to user.
//

UARTprintf(" uSD FIRMWARE V.10072013\n");
UARTprintf(" Iniciando montagem do volume \n");
//
// Mount the file system, using logical disk 0.
//
UARTprintf(" Inicializando SDCARD \n");
while(disk_initialize(0));
UARTprintf(" SDCARD Iniciado com sucesso \n");

fresult = f_mount(0, &g_sFatFs);

if(fresult != FR_OK)
{
UARTprintf("f_mount error: %s\n", StringFromFresult(fresult));
return(1);
}
else
{
UARTprintf("FR_OK \n");
}

fresult = f_getfree("/", &ulTotalSize, &pFatFs);

UARTprintf(", %10uK bytes free\n", ulTotalSize * pFatFs->sects_clust / 2);

fresult = f_open(&Fil, "message.TXT", FA_WRITE | FA_CREATE_NEW);
if (fresult != FR_OK )
{
UARTprintf(" ERRO \n");
}

else
{

UARTprintf(" CARTÃO ABERTO \n");
}

fresult = f_write(&Fil, "teste escrita realizado com sucesso \r\n", 35 ,&bw);

if (fresult != FR_OK )
{
UARTprintf(" WRITE ERROR \n");
UARTprintf("Erro de escrita : %s\n", StringFromFresult(fresult));
}

else
{

UARTprintf(" escrita realizada com sucesso \n");
}

fresult = f_close(&Fil);
if(fresult != FR_OK)
{
UARTprintf("Falha ao finalizar o SDCARD ", StringFromFresult(fresult));
return(1);
}
else
{
UARTprintf("Cartão Finalizado \n");
}

}

over 12 years ago

0 blueshift g5 over 11 years ago

Prodigy 170 points

Hi,

I am facing similar problem albeit the error code I am sometimes receiving is FR_NOT_READY or FR_DISK_ERR or FR_WRITE_PROTECTED.

I am developing on TivaC Dev Board dk-tm4c123g. Attached is my SDCard APIs

Fullscreen 1526.sdcard.c Download

/****************************************************************************
 *  Include:
****************************************************************************/
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <inc/hw_memmap.h>
#include <driverlib/fpu.h>
#include <driverlib/gpio.h>
#include <driverlib/interrupt.h>
#include <driverlib/pin_map.h>
#include <driverlib/rom.h>
#include <driverlib/sysctl.h>
#include <driverlib/systick.h>
#include <inc/hw_nvic.h>
#include <inc/hw_types.h>

#include "Middleware/fatfs/src/ff.h"
#include "Middleware/fatfs/src/diskio.h"
#include "Application/ustdlib.h"
#include "Middleware/uartstdio.h"
#include "Middleware/sdcard.h"

/****************************************************************************/

/****************************************************************************
 *  Macro definitions:
****************************************************************************/

// Defines the size of the buffers that hold the path, or temporary data from
// the SD card.  There are two buffers allocated of this size.  The buffer size
// must be large enough to hold the longest expected full path name, including
// the file name, and a trailing null character.
#define PATH_BUF_SIZE           50

// Defines the size of temporary data buffer when manipulating file paths, or
// reading/writing data on SD card.
#define TEMP_BUF_SIZE			40

// A macro that holds the number of result codes.
#define NUM_FRESULT_CODES       (sizeof(g_psFResultStrings) /                 \
                                 sizeof(tFResultString))

// Defines the SSI Peripheral No. to use for SDCard
// Currently Used: SSI No.0 - SYSCTL_PERIPH_SSI0
#define SDCARD_SSI_PERIPHERAL SYSCTL_PERIPH_SSI0

// A macro to make it easy to add result codes to the table.
#define FRESULT_ENTRY(f)        { (f), (#f) }
//*****************************************************************************


/****************************************************************************
 *  Global variables
****************************************************************************/

// This buffer holds the full path to the current working directory.  Initially
// it is root ("/").
static char g_pcCwdBuf[PATH_BUF_SIZE] = "/";

// A temporary data buffer used when manipulating file paths, or reading data
// from the SD card.
static char g_pcTmpBuf[TEMP_BUF_SIZE];

// The following are data structures used by FatFs.
static FATFS g_sFatFs;
static DIR g_sDirObject;
static FILINFO g_sFileInfo;
static FIL g_sFileObject;

// A structure that holds a mapping between an FRESULT numerical code, and a
// string representation.  FRESULT codes are returned from the FatFs FAT file
// system driver.
typedef struct
{
    FRESULT iFResult;
    char *pcResultStr;
}
tFResultString;

// A table that holds a mapping between the numerical FRESULT code and it's
// name as a string.  This is used for looking up error codes for printing to
// the console.
tFResultString g_psFResultStrings[] =
{
    FRESULT_ENTRY(FR_OK),
    FRESULT_ENTRY(FR_DISK_ERR),
    FRESULT_ENTRY(FR_INT_ERR),
    FRESULT_ENTRY(FR_NOT_READY),
    FRESULT_ENTRY(FR_NO_FILE),
    FRESULT_ENTRY(FR_NO_PATH),
    FRESULT_ENTRY(FR_INVALID_NAME),
    FRESULT_ENTRY(FR_DENIED),
    FRESULT_ENTRY(FR_EXIST),
    FRESULT_ENTRY(FR_INVALID_OBJECT),
    FRESULT_ENTRY(FR_WRITE_PROTECTED),
    FRESULT_ENTRY(FR_INVALID_DRIVE),
    FRESULT_ENTRY(FR_NOT_ENABLED),
    FRESULT_ENTRY(FR_NO_FILESYSTEM),
    FRESULT_ENTRY(FR_MKFS_ABORTED),
    FRESULT_ENTRY(FR_TIMEOUT),
    FRESULT_ENTRY(FR_LOCKED),
    FRESULT_ENTRY(FR_NOT_ENOUGH_CORE),
    FRESULT_ENTRY(FR_TOO_MANY_OPEN_FILES),
    FRESULT_ENTRY(FR_INVALID_PARAMETER),
};

FRESULT iFResult;

/****************************************************************************/


/****************************************************************************
 *  Function Definations for this file:
****************************************************************************/
uint8_t initSdCard(void)
{
    // Enable the SSI Peripheral
    ROM_SysCtlPeripheralEnable(SDCARD_SSI_PERIPHERAL);

    // Mount the file system, using logical disk 0.
    iFResult = f_mount(0, &g_sFatFs);
    if(iFResult != FR_OK)
        UARTprintf("f_mount error: %s\n", StringFromFResult(iFResult));

    return (uint8_t)iFResult;
}

uint8_t write_SDCard(char *filename, const void *writebuff, unsigned int *bw, char fmode)
{
	FRESULT iFResult;

	memset(g_pcTmpBuf, 0, sizeof(g_pcTmpBuf));

	// First, check to make sure that the current path (CWD), plus the file
	// name, plus a separator and trailing null, will all fit in the temporary
	// buffer that will be used to hold the file name.  The file name must be
	// fully specified, with path, to FatFs.
	//
	if((ustrlen(g_pcCwdBuf) + ustrlen(filename) + 1 + 1) > sizeof(g_pcTmpBuf))
	{
//		UARTprintf("Resulting path name is too long\n");
		return ERR_CODE_FNAME_LONG;
	}

	// Copy the current path to the temporary buffer so it can be manipulated.
	ustrncpy(g_pcTmpBuf, g_pcCwdBuf, ustrlen(g_pcCwdBuf));

	// If not already at the root level, then append a separator.
	if(ustrcmp("/", g_pcCwdBuf))
	{
		strcat(g_pcTmpBuf, "/");
	}

	// Now finally, append the file name to result in a fully specified file.
	strcat(g_pcTmpBuf, filename);

	// Open the file for writing.
	iFResult = f_open(&g_sFileObject, g_pcTmpBuf,(FA_OPEN_ALWAYS |
			FA_WRITE |
			FA_READ));

	// If there was some problem opening the file, then return an error.
	if(iFResult != FR_OK)
	{
//		UARTprintf("Error in Opening file - %s\n", StringFromFResult(iFResult));
		return ((uint8_t)iFResult);
	}

	UARTprintf("Open Success - %u bytes\n", g_sFileObject.fsize);

	//Move File Pointer to the end of file if Append mode selected
	if(fmode == FILE_APPEND_WRITE)
		f_lseek(&g_sFileObject, g_sFileObject.fsize);

	iFResult = f_write(&g_sFileObject, writebuff, ustrlen(writebuff),
			bw);

	if(iFResult != FR_OK) {
//		UARTprintf("Error Code: %s\n",  StringFromFResult(iFResult));
		return ((int)iFResult);
	}

//	UARTprintf("Bytes Written - %u\n", *bw);

	//If 0 bytes read or
	if((*bw == 0) || (*bw !=ustrlen(writebuff)))
	{
//		UARTprintf("\n");
//		UARTprintf("Zero bytes written");
		return ERR_CODE_ZEROBYTES;
	}

	iFResult = f_close(&g_sFileObject);
//	UARTprintf("Result Close Code%s\n",  StringFromFResult(iFResult));

	// Return success.
	return ((int)iFResult);
}

const char *
StringFromFResult(FRESULT iFResult)
{
    uint_fast8_t ui8Idx;

    //
    // Enter a loop to search the error code table for a matching error code.
    //
    for(ui8Idx = 0; ui8Idx < NUM_FRESULT_CODES; ui8Idx++)
    {
        //
        // If a match is found, then return the string name of the error code.
        //
        if(g_psFResultStrings[ui8Idx].iFResult == iFResult)
        {
            return(g_psFResultStrings[ui8Idx].pcResultStr);
        }
    }

    //
    // At this point no matching code was found, so return a string indicating
    // an unknown error.
    //
    return("UNKNOWN ERROR CODE");
}

1512.sdcard.hand I am calling through main() as below:

[code]	unsigned char testbuff[25] = "Hello World1. This is me";
	unsigned int retbytes;
	unsigned char fres;

	fres = write_SDCard("createfile.txt", testbuff,&retbytes,FILE_OVERWRITE);

	unsigned char testbuff2[25] = "Hello World3. This is me";
	fres = write_SDCard("testsdcard3.txt", testbuff2,&retbytes,FILE_OVERWRITE);

	unsigned char testbuff3[25] = "Hello World4. This is me";
	fres = write_SDCard("testsdcard4.txt", testbuff3,&retbytes,FILE_OVERWRITE);

[/code]

First file is created is successfully. It is however sometimes I get above error codes when I try to manually execute the functions again for testing.

Please help.

0 carlos henrique nascimento martins over 11 years ago in reply to blueshift g5

Intellectual 620 points

Try change this line

fres = write_SDCard("createfile.TXT", testbuff,&retbytes,FILE_OVERWRITE);

Best regards

0 blueshift g5 over 11 years ago in reply to carlos henrique nascimento martins

Prodigy 170 points

Hi carlos,

Thanks for replying. But it didnt solved the problem.

One thing I observed. I have another function for listing files based on search term. I am posting the code below:

/******************************************************************************
 * Function Name: list_SDCard
 *
 * Function Description: This function must be called for listing of files
 *
 * Function Parameters:
 * char *startwith - Search pattern in filename
 * uint8_t listno - Fetch item from the list according to list number(1,2,..)
 * char *fnamebuff - Buffer for the fetched filename item
 *
 * Function Returns: void
 *
 ********************************************************************************/

uint8_t list_SDCard(char *startwith, uint8_t listno, char *fnamebuff)
{
	unsigned char buff_filename[MAX_CHARS_IN_LINE];
	FRESULT iFResult;
	uint8_t ui8MatchFileCount = 0;
	//	    uint8_t ui8TotalFileCount = 0;

#if _USE_LFN
	char pucLfn[_MAX_LFN + 1];
	g_sFileInfo.lfname = pucLfn;
	g_sFileInfo.lfsize = sizeof(pucLfn);
#endif

	memset(buff_filename, 0, sizeof(buff_filename));
	//
	// Open the current directory for access.
	//
	iFResult = f_opendir(&g_sDirObject, g_pcCwdBuf);

	//
	// Check for error and return if there is a problem.
	//
	if(iFResult != FR_OK)
	{
		return((int)iFResult);
	}


	//
	// Enter loop to enumerate through all directory entries.
	//
	for(;;)
	{
		//
		// Read an entry from the directory.
		//
		iFResult = f_readdir(&g_sDirObject, &g_sFileInfo);

		//
		// Check for error and return if there is a problem.
		//
		if(iFResult != FR_OK)
		{
			return((int)iFResult);
		}

		//
		// If the file name is blank, then this is the end of the listing.
		//
		if(!g_sFileInfo.fname[0])
		{
			//Total file count available here
			return ERR_CODE_NOFILE;
		}
		//	    	else
		//	    		ui8TotalFileCount++;

		//
		// If the attribute is directory, then increment the directory count.
		//
		if(g_sFileInfo.fattrib & AM_DIR)
		{
			continue;
		}

		//
		// Otherwise, it is a file.  Increment the file count, and add in the
		// file size to the total.
		//
		else
		{
			//Check if pattern matches
			if(!ustrncasecmp(startwith, g_sFileInfo.fname, ustrlen(startwith))) {
				ui8MatchFileCount++;
			}
			else
				continue;

		}

		if(ui8MatchFileCount == listno) {
#if _USE_LFN
//			buff_filename = ((*g_sFileInfo.lfname)?g_sFileInfo.lfname:g_sFileInfo.fname);
			if(*g_sFileInfo.lfname)
				ustrncpy(buff_filename, g_sFileInfo.lfname, ustrlen(g_sFileInfo.lfname));
			else
				ustrncpy(buff_filename, &g_sFileInfo.fname, ustrlen(g_sFileInfo.fname));
			//CHECK ADDRESS AND VALUE HERE//
#else
			buff_filename = g_sFileInfo.fname;
#endif
			ustrncpy(fnamebuff, buff_filename, ustrlen(buff_filename));
//			UARTprintf("s");
			break;
		}

	} // End of for loop

	return ((int)iFResult); // At this step, it returns FR_OK
}

My calling sequence in main() is as follows:

	unsigned char testbuff[25] = "Hello World1. This is me";
	unsigned char readbuff[30];
	unsigned int retbytes;
	unsigned char fres;
	fres = write_SDCard("createfile.TXT", testbuff,&retbytes,FILE_OVERWRITE);

	memset(readbuff, 0, sizeof(readbuff));
	fres = list_SDCard("great", 1, (char *)readbuff); //read filename if found in readbuff

	unsigned char testbuff2[25] = "Hello World3. This is me";
	fres = write_SDCard("testsdcard3.TXT", testbuff2,&retbytes,FILE_OVERWRITE);

	unsigned char testbuff3[25] = "Hello World4. This is me";
	fres = write_SDCard("testsdcard4.TXT", testbuff3,&retbytes,FILE_OVERWRITE);

The issue observed is if I skip the list_SDCard(), then I don't get FR_WRITE_PROTECTED Error Code. So I believe the issue is with list_SDCard() function. I believe that function may be messing with FatFS filesystem; but I cant figure at what point.

Need help seriously.

0 blueshift g5 over 11 years ago in reply to blueshift g5

Prodigy 170 points

I debugged list_SDCard() function.

I have total 8 files on my SDCard. I have observed on one iteration of listing, the global variable 'g_pcCwdBuf' defined in sdcard.c file is losing its value of "\" which is Root Directory and showing any garbage value.

This is after calling:

iFResult = f_readdir(&g_sDirObject, &g_sFileInfo);

and

iFResult = f_opendir(&g_sDirObject, g_pcCwdBuf);

Ideally, the above function call shouldn't modify the global variable since it is FATFS API. Tell me solution.

0 blueshift g5 over 11 years ago in reply to blueshift g5

Prodigy 170 points

Another observation is if I call list_SDCard() before any SDWrite() function, g_pcCwdBuf variable has garbage after calling f_opendir() inside it as above. It also affects other variables. See screenshot below

0 blueshift g5 over 11 years ago in reply to blueshift g5

Prodigy 170 points

I learned even with all this, during write_SDCard(), FatFS API functions are failing with giving FR_WRITE_PROTECTED error.

Dont know where I am going wrong. I have used the FatFS library vR0.09b that came with Tiva Library Installation.

0 blueshift g5 over 11 years ago in reply to blueshift g5

Prodigy 170 points

I changed the stack size and the issue is solved! :-P :-)

Arm-based microcontrollers

Arm-based microcontrollers forum

f_write problems SD SPI