CCS/LAUNCHXL-F28379D: SD card problem

Part Number: LAUNCHXL-F28379D
Other Parts Discussed in Thread: C2000WARE

Tool/software: Code Composer Studio

I'm doing my project using SD card. The data will be sent from PC through SCI and will be stored at SD card. I use driverlib to do this project. The data sent from PC is successfully received, but I can't store them into SD card. I checked the expressions and it shows me that the f_open returns FR_NOT_READY. This is my code. I use hercules to connect to the kit, CCS version 7.1.0, C2000 ware 1_00_05_00. 

#include <stdio.h>
#include <string.h>
#include "driverlib.h"
#include "device.h"
#include "ff.h"
#include "diskio.h"

void configGPIO(void);
void configSPI(void);
void configSCI(void);
__interrupt void sciaRXFIFOISR(void);


uint16_t countReceive = 0;
uint16_t count = 0;

FRESULT fresult;
FIL	myfile;
FATFS	fatfs;
FRESULT res;

WORD br, bw;

char buff[255];
char receive_buff[255];
char rData[255];

bool flag = false;

void main(void)
{
	Device_init();
	Device_initGPIO();
	Interrupt_initModule();
	Interrupt_initVectorTable();
	configSPI();
	configGPIO();

	Interrupt_register(INT_SCIA_RX, &sciaRXFIFOISR);

	configSCI();

	Interrupt_enable(INT_SCIA_RX);

	Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);

	EINT;
	ERTM;

	while(1)
	{
//		if(flag == true)
//		{
//			flag = false;
//			fresult = f_open(&myfile, "filetest.txt", FA_READ);
//			do
//			{
//				f_read(&myfile, receive_buff, sizeof(receive_buff)-1, &br);
//			}
//			while(br == sizeof(receive_buff)-1);
//			fresult = f_close(&myfile);
//		}
	}
}
void configGPIO()
{
	//
	// GPIO123 is SPISOMIA
	//
	GPIO_setMasterCore(123, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_123_SPISOMIC);
	GPIO_setPadConfig(123, GPIO_PIN_TYPE_PULLUP);
	GPIO_setQualificationMode(123, GPIO_QUAL_ASYNC);

	//
	// GPIO122 is SPISIMOA
	//
	GPIO_setMasterCore(122, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_122_SPISIMOC);
	GPIO_setPadConfig(122, GPIO_PIN_TYPE_PULLUP);
	GPIO_setQualificationMode(122, GPIO_QUAL_ASYNC);

	//
	// GPIO124 is SPICLKA
	//
	GPIO_setMasterCore(124, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_124_SPICLKC);
	GPIO_setPadConfig(124, GPIO_PIN_TYPE_PULLUP);
	GPIO_setQualificationMode(124, GPIO_QUAL_ASYNC);

	//
	// GPIO125 is SPISTEA
	//
	GPIO_setMasterCore(125, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_125_SPISTEC);
	GPIO_setPadConfig(125, GPIO_PIN_TYPE_PULLUP);
	GPIO_setQualificationMode(125, GPIO_QUAL_ASYNC);

	//
	// GPIO28 is the SCI Rx pin.
	//
	GPIO_setMasterCore(42, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_42_SCITXDA);
	GPIO_setDirectionMode(42, GPIO_DIR_MODE_IN);
	GPIO_setPadConfig(42, GPIO_PIN_TYPE_STD);
	GPIO_setQualificationMode(42, GPIO_QUAL_ASYNC);

	//
	// GPIO29 is the SCI Tx pin.
	//
	GPIO_setMasterCore(43, GPIO_CORE_CPU1);
	GPIO_setPinConfig(GPIO_43_SCIRXDA);
	GPIO_setDirectionMode(43, GPIO_DIR_MODE_OUT);
	GPIO_setPadConfig(43, GPIO_PIN_TYPE_STD);
	GPIO_setQualificationMode(43, GPIO_QUAL_ASYNC);
}

void configSPI()
{
	//
	//	Reset module
	//
	SPI_disableModule(SPIC_BASE);
	//
	//	SPI configuration
	//
	SPI_setConfig(SPIC_BASE, DEVICE_LSPCLK_FREQ, SPI_PROT_POL0PHA0, SPI_MODE_MASTER, 500000, 16);
	SPI_disableLoopback(SPIC_BASE);
	SPI_setEmulationMode(SPIC_BASE, SPI_EMULATION_FREE_RUN);

	//
	//	Enable SPI module
	//
	SPI_enableModule(SPIC_BASE);
}

void configSCI()
{
	SCI_setConfig(SCIA_BASE, DEVICE_LSPCLK_FREQ, 9600, (SCI_CONFIG_WLEN_8 |
                                                        SCI_CONFIG_STOP_ONE |
                                                        SCI_CONFIG_PAR_NONE));
    SCI_resetChannels(SCIA_BASE);
    SCI_resetRxFIFO(SCIA_BASE);
    SCI_resetTxFIFO(SCIA_BASE);
    SCI_clearInterruptStatus(SCIA_BASE, SCI_INT_TXFF | SCI_INT_RXFF);
    SCI_enableFIFO(SCIA_BASE);
    SCI_enableModule(SCIA_BASE);
    SCI_performSoftwareReset(SCIA_BASE);

    SCI_enableInterrupt(SCIA_BASE, (SCI_INT_RXFF | SCI_INT_TXFF));
    SCI_setFIFOInterruptLevel(SCIA_BASE, SCI_FIFO_TX2, SCI_FIFO_RX1);
    SCI_disableInterrupt(SCIA_BASE, SCI_INT_RXERR);  //


    Interrupt_enable(INT_SCIA_RX);
    Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);
}

__interrupt void sciaRXFIFOISR()
{
	flag = true;
	rData[countReceive] = SCI_readCharBlockingFIFO(SCIA_BASE);
	countReceive++;


	int i;
	for(i = 0; i < sizeof(rData); i++)
	{
		buff[i] = rData[i];
	}

	res = f_mount(0, &fatfs);
	if(res == FR_OK)
	{
		flag = false;
	}
	fresult = f_open(&myfile, "filetest.txt", FA_CREATE_ALWAYS|FA_WRITE);
	f_lseek(&myfile, myfile.fsize);
	f_write(&myfile,buff, strlen(buff), &bw);
	f_close(&myfile);

	SCI_clearOverflowStatus(SCIA_BASE);
	SCI_clearInterruptStatus(SCIA_BASE, SCI_INT_RXFF);
	Interrupt_clearACKGroup(INTERRUPT_ACK_GROUP9);

}

Thanks in advance!