Помогите подключить FatFs к STM32F105RBT6 + SDHC

[Donker]

Пытаюсь подключить FatFs (http://elm-chan.org/fsw/ff/00index_e.html) к STM32F105RBT6 + карта SDHC (поддержка старых SD не требуется), проект в Keil 5.26,

отладка в оперативной памяти (из 64кб - 40кб под прошивку 24кб оставшаяся оперативная память)

Создал проект с тремя основными функциями - инициализация SDHC (предполагается работа только с одной картой), чтение N секторов в буфер начиная со стартового адреса,

запись N секторов из буфера начиная со стартового адреса, проверял на буферах размером до 8 секторов, всё надежно работает.

Пытаюсь подключить библиотеку, нужно написать функцию disk_read:

Нажмите, чтобы открыть спойлер

DRESULT disk_read (
    BYTE pdrv,        /* Physical drive nmuber to identify the drive */
    BYTE *buff,        /* Data buffer to store read data */
    DWORD sector,    /* Start sector in LBA */
    UINT count        /* Number of sectors to read */
)
{
//////////////////////////////////////////////////////////////////////////
if(0 == spi_SD_Read_Block(buff, sector, uint8_t (count))) {return RES_OK;}
else {return RES_ERROR;}
//////////////////////////////////////////////////////////////////////////    
}

получаю ошибку:

fatfs/diskio.cpp(159): error: no matching function for call to 'spi_SD_Read_Block'

моя функция:

Нажмите, чтобы открыть спойлер

unsigned char spi_SD_Read_Block (char* bf, uint32_t SD_adr, uint8_t adr_count) //чтение секторов из SD карты
{
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
unsigned char result;
long int cnt = 0;
//**************************************************  **************************************************  ***************
for(uint8_t i=0; i ‹ adr_count; i++)
  {    
    SD_adr = SD_adr+i;        
    unsigned char SD_adr_0 = SD_adr;            //разбивка адреса uint32_t на 4 байта
    unsigned char SD_adr_1 = SD_adr ›› 8;
    unsigned char SD_adr_2 = SD_adr ›› 16;
    unsigned char SD_adr_3 = SD_adr ›› 24;
    //-----------------------------------------------------------------------------------------------------------------        
    first_ACMD17 = spi_WaitReady();
    if(first_ACMD17 == waiting) {return 1;} //превышено время ожидания
    spi_SD_cmd (0x51, SD_adr_3, SD_adr_2, SD_adr_1, SD_adr_0, 0x95);        //CMD17 даташит стр 50 и 96
    cnt=0;
    do     
        {
        result=spi_SendRecvByte(0xFF);
        cnt++;
        }
        while ((result!=0x00) && (cnt ‹ waiting));
    after_ACMD17 = cnt;  
    if (cnt == waiting) return 2; //превышено время ожидания        
    spi_SendRecvByte(0xFF);
    cnt=0;
    do     //Ждем начала блока
        {
        result=spi_SendRecvByte(0xFF);
        cnt++;
        }
        while ((result!=0xFE) && (cnt ‹ waiting));
    first_read = cnt;
    if (cnt == waiting) return 3;
    for (cnt=0;cnt‹512;cnt++)    bf[cnt+(512*i)]=spi_SendRecvByte(0xFF); //получаем байты блока из шины в буфер
    spi_SendRecvByte(0xFF);                    //Получаем контрольную сумму
    spi_SendRecvByte(0xFF);
  }    
return 0;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
}

Что не так?

Второй вопрос: я саму библиотеку правильно скачал http://elm-chan.org/fsw/ff/arc/ff13c.zip ?

Третий вопрос: мой проект написан на C++ а библиотека FatFs на C, как правильно, в этом случае, её подключать?

[Donker]

Уточнение, если поставить такую заглушку:

Код:

char buffer[10]; if(0 == spi_SD_Read_Block(buffer, sector, uint8_t (count))) {return RES_OK;} else {return RES_ERROR;}

код компилируется, т.е. компилятору не нравиться передача указателя на буфер, но почему?!

BYTE это обычный unsigned char, после подключения FatFs я могу в своём коде поменять unsigned char или uint8_t на BYTE и ничего не изменится.

typedef unsigned char BYTE; /* char must be 8-bit */

[Donker]

С буфером вопрос решился - я что то думал что unsigned char и просто char в данном случае одно и тоже, а это не так.
Остальные вопросы в силе, (скоро новые возникнут).

[Donker]

Новые вопросы:

Есть некоторые успехи, в этой тестовой функции:

Нажмите, чтобы открыть спойлер

void ff_test(void) 
{
//////////////////////////////////////////////////////////////////////////////////////////////	
FATFS fs;
FRESULT res;
sprintf(lines[0],"Ready!"); //UART_Printf("Ready!\r\n");

// mount the default drive
res = f_mount(&fs, "", 0);	
sprintf(lines[0],"f_mount, res: %d", res); 	lcd_refr();		
if(res != FR_OK)
  {
	//UART_Printf("f_mount() failed, res = %d\r\n", res);
  return;
  }
//UART_Printf("f_mount() done!\r\n");
//---------------------------------------------------------------------------------------------
uint32_t freeClust;
FATFS* fs_ptr = &fs;
// Warning! This fills fs.n_fatent and fs.csize!
res = f_getfree("", &freeClust, &fs_ptr);
sprintf(lines[1],"f_getfree, res: %d", res); 	lcd_refr();			
if(res != FR_OK)
  {
	///UART_Printf("f_getfree() failed, res = %d\r\n", res);
	return;
  }
///UART_Printf("f_getfree() done!\r\n");
uint32_t totalBlocks = (fs.n_fatent - 2) * fs.csize;
uint32_t freeBlocks = freeClust * fs.csize;
//UART_Printf("Total blocks: %lu (%lu Mb)\r\n", totalBlocks, totalBlocks / 2000);
//UART_Printf("Free blocks: %lu (%lu Mb)\r\n", freeBlocks, freeBlocks / 2000);
sprintf(lines[2],"Total blocks: %d Mb", (totalBlocks / 2048)); 	
sprintf(lines[3],"Free blocks: %d Mb", (freeBlocks / 2048)); 	lcd_refr();	
//---------------------------------------------------------------------------------------------
DIR dir;
res = f_opendir(&dir, "/");
sprintf(lines[4],"f_opendir, res: %d", res); 	lcd_refr();			
if(res != FR_OK)
  {
	///UART_Printf("f_opendir() failed, res = %d\r\n", res);
	return;
  }
FILINFO fileInfo;
uint32_t totalFiles = 0;
uint32_t totalDirs = 0;
//UART_Printf("--------\r\nRoot directory:\r\n");
uint8_t st=0;	
for(;;)
	{
	res = f_readdir(&dir, &fileInfo);
	if((res != FR_OK) || (fileInfo.fname[0] == '\0')) {break;}
  if(fileInfo.fattrib & AM_DIR) 
	  {
		//UART_Printf("  DIR  %s\r\n", fileInfo.fname);
		sprintf(lines[5+st],"DIR %s", fileInfo.fname); 
		st++;
		totalDirs++;
    } 
		else 
		  {
			//UART_Printf("  FILE %s\r\n", fileInfo.fname);
			sprintf(lines[5+st],"FILE %s", fileInfo.fname);
			st++;	
			totalFiles++;
      }
  }
	
//UART_Printf("(total: %lu dirs, %lu files)\r\n--------\r\n",totalDirs, totalFiles);
sprintf(lines[15],"total: %d dr, %d fl",totalDirs, totalFiles);		
lcd_refr();		
//---------------------------------------------------------------------------------------------
res = f_closedir(&dir);
sprintf(lines[16],"f_closedir, res: %d", res); 	lcd_refr();
if(res != FR_OK)
  {
	//UART_Printf("f_closedir() failed, res = %d\r\n", res);
	return;
  }
//---------------------------------------------------------------------------------------------
//UART_Printf("Writing to log.txt...\r\n");
char writeBuff[128];
snprintf(writeBuff, sizeof(writeBuff), "Total blocks: %d (%d Mb); Free blocks: %d (%d Mb)\r\n", totalBlocks, totalBlocks / 2048, freeBlocks, freeBlocks / 2048);
FIL logFile;
res = f_open(&logFile, "log.txt", FA_OPEN_APPEND | FA_WRITE);
sprintf(lines[17],"f_open, res: %d", res); 	lcd_refr();	
if(res != FR_OK)
  {
	//UART_Printf("f_open() failed, res = %d\r\n", res);
	return;
  }
unsigned int bytesToWrite = strlen(writeBuff);
unsigned int bytesWritten;
res = f_write(&logFile, writeBuff, bytesToWrite, &bytesWritten);
sprintf(lines[18],"f_write, res: %d", res); 	lcd_refr();	
if(res != FR_OK)
	{
	//UART_Printf("f_write() failed, res = %d\r\n", res);
	return;
  }
if(bytesWritten ‹ bytesToWrite)
  {
  //UART_Printf("WARNING! Disk is full.\r\n");
  }
//_delay_ms(1);	
res = f_close(&logFile);
sprintf(lines[18],"f_close, res: %d", res); 	lcd_refr();	
if(res != FR_OK)
	{
	//UART_Printf("f_close() failed, res = %d\r\n", res);
	return;
  }
//---------------------------------------------------------------------------------------------
    //UART_Printf("Reading file...\r\n");
    FIL msgFile;
    res = f_open(&msgFile, "log.txt", FA_READ);
    if(res != FR_OK) {
        //UART_Printf("f_open() failed, res = %d\r\n", res);
        return;
    }

    char readBuff[128];
    unsigned int bytesRead;
    res = f_read(&msgFile, readBuff, sizeof(readBuff)-1, &bytesRead);
    if(res != FR_OK) {
        //UART_Printf("f_read() failed, res = %d\r\n", res);
        return;
    }

    readBuff[bytesRead] = '\0';
    //UART_Printf("```\r\n%s\r\n```\r\n", readBuff);

    res = f_close(&msgFile);
    if(res != FR_OK) {
        //UART_Printf("f_close() failed, res = %d\r\n", res);
        return;
    }

    // Unmount
    res = f_mount(NULL, "", 0);
    if(res != FR_OK) {
        //UART_Printf("Unmount failed, res = %d\r\n", res);
        return;
    }

    //UART_Printf("Done!\r\n");
}

все функции до f_close нормально работают (как минимум возвращают 0, а не код ошибки, и делают ожидаемые вещи),
а вот f_close возвращает 1, почему такое может быть?

Нужно ли настраивать таймер на 10ms и вызывать в нём disk_timerproc (я вообще не нашёл такой функции в FatFs)?

Каким образом и где FatFs создаёт буферы для чтения и записи сектров, указатели которых передаются в функции
disk_write и disk_read, если они создаются динамически, можно ли их заставить создаваться в стеке без потери функциональности
библиотеки?

[mike-y-k]

Donker, если код положить в файл .txt, то его вполне можно без проблем нормально посмотреть, иначе смайлики, пропавшие конструкции,…
Правда желательно сразу указать кодировку для русского текста…

[scorpi_0n]

disk_write и disk_read, если они создаются динамически, можно ли их заставить создаваться в стеке без потери функциональности библиотеки?

Кто-то видел упоминания кучи? Я - нет. Может потому что переписывал по своему, может потому что выкашивал лишнее.
Либа Чена универсальна, типа, но монструозна. Она годится для ознакомления и как пример, и только. Ну разве что и для простых поделок, где думать не надо. Отсюда и все сложности в понимании происходящего.

[Donker]

scorpi_0n, т.е. вы хотите сказать что по вашему мнению в этой библиотеке вообще не используются динамических переменных, и я могу быть уверенным что в крайнем случае получу ошибку при работе с файлами а не переполнение оперативки в микроконтроллере?

[Donker]

Вот весь проект:
https://yadi.sk/d/w98_y4E7kJN6Eg


Уточнение, перераспределение памяти для отладки в RAM - 44кб под
прошивку 20кб оставшаяся оперативная память память.

Сейчас появилась такая проблема, в fileWork.cpp в функции ff_test
есть строка:

res = f_open(&logFile, "log.txt", FA_OPEN_APPEND | FA_WRITE);

если выходить из функции до неё, то всо нормально, выполнение этой строки, в какой то момент(не пойму что я сделал), начало приводить к зависанию МК, до этого проблема была только с f_close (код ошибки 1), и ведь строки в log.txt успешно добавлялись!

Карта подключена к J10 (схема в проекте), к J2 подключен экран 20x4,
lines[NumLines][20] массив для хранения строк отладочного экрана строки
крутятся энкодером, пробовал подавать питание на J1 убирая перемычку J4, на проблему это не повлияло.

[realid]

mike-y-k, для этого существует тег CODE.

[Donker]

Нашёл ошибку, в функции чтения и записи секторов (spi_SD_Write_Block и spi_SD_Read_Block) они корректно работали
только при чтении одного сектора, иначе адрес котцался, так правильно:

Нажмите, чтобы открыть спойлер

	uint32_t SD_adr_tmp = SD_adr+i;		
	unsigned char SD_adr_0 = SD_adr_tmp;            //разбивка адреса uint32_t на 4 байта
	unsigned char SD_adr_1 = SD_adr_tmp ›› 8;
	unsigned char SD_adr_2 = SD_adr_tmp ›› 16;
	unsigned char SD_adr_3 = SD_adr_tmp ›› 24;

но исправление на вышеописанную проблему никак не повлияло.

Кстати, я беру некоторый код отсюда: https://eax.me/stm32-fatfs/ вам тут ничего не кажется подозрительным?