fatfs_sup.c

Go to the documentation of this file.

#include "user_config.h"
#include "fatfs.sup/fatfs.h"

#ifdef AVR
#include <stdlib.h>
#endif

#include "printf/mathio.h"

#include "lib/time.h"


FATFS Fatfs[_VOLUMES];                            /* File system object for each logical drive */

#if _MULTI_PARTITION != 0
const PARTITION Drives[] =
{
    {
        0,0
    }
    ,
    {
        0,1
    }
};
#endif

#if FATFS_DEBUG > 0
static const char *err_msg[] =
{
    "OK",
    "DISK_ERR",
    "INT_ERR",
    "NOT_READY",
    "NO_FILE",
    "NO_PATH",
    "INVALID_NAME",
    "DENIED",
    "EXIST",
    "INVALID_OBJECT",
    "WRITE_PROTECTED",
    "INVALID_DRIVE",
    "NOT_ENABLED",
    "NO_FILE_SYSTEM",
    "MKFS_ABORTED",
    "TIMEOUT",
    "LOCKED",
    "NOT_ENOUGH_CORE",
    "TOO_MANY_OPEN_FILES",
    "INVALID_PARAMETER",
    NULL
};
#endif




MEMSPACE
uint32_t tm_to_fat(tm_t *t)
{
    uint32_t fat;
/* Pack date and time into a uint32_t variable */
    fat = ((uint32_t)(t->tm_year - 80) << 25)
        | (((uint32_t)t->tm_mon+1) << 21)
        | (((uint32_t)t->tm_mday) << 16)
        | ((uint32_t)t->tm_hour << 11)
        | ((uint32_t)t->tm_min << 5)
        | ((uint32_t)t->tm_sec >> 1);
    return(fat);
}
MEMSPACE
DWORD get_fattime (void)
{
    time_t t;
/* Get GMT time */
    time(&t);
    return( tm_to_fat(localtime(&t)));
}


MEMSPACE
void put_rc (int rc)
{
#if FATFS_DEBUG > 0
    char *ptr;
    if(rc > 19)
        ptr = "INVALID ERROR MESSAGE";
    else
        ptr = (char *) err_msg[(int)rc];
    printf("rc=%u FR_%s\n", rc, ptr);
#else
    printf("rc=%u\n", rc);
#endif
}


DWORD   AccSize;

WORD    AccFiles, AccDirs;






MEMSPACE
int fatfs_scan_files (
char* path                                        /* Pointer to the working buffer with start path */
)
{
    DIR dirs;
    FRESULT fr;
    int i;
    FILINFO info;

    fr = f_opendir(&dirs, path);
    if (fr == FR_OK) {
        while (((fr = f_readdir(&dirs, &info)) == FR_OK) && info.fname[0]) {
            if (info.fattrib & AM_DIR) {
                AccDirs++;
                i = strlen(path);
                path[i] = '/'; strcpy(path+i+1, info.fname);
                fr = fatfs_scan_files(path);
                path[i] = 0;
                if (fr != FR_OK) break;
            } else {
//              xprintf(PSTR("%s/%s\n"), path, info.fname);
                AccFiles++;
                AccSize += info.fsize;
            }
#ifdef ESP8266
            optimistic_yield(1000);
            wdt_reset();
#endif
        }
    }

    return fr;
}

MEMSPACE
char *fatfs_fstype(int type)
{
    char *ptr;
    switch(type)
    {
        case FS_FAT12:
            ptr = "FAT12";
            break;
        case FS_FAT16:
            ptr = "FAT16";
            break;
        case FS_FAT32:
            ptr = "FAT32";
            break;
        case FS_EXFAT:
            ptr = "EXFAT";
            break;
        default:
             ptr = "UNKNOWN";
            break;
    }
    return(ptr);
}

MEMSPACE
void fatfs_status(char *ptr)
{
    long p2;
    int res;
    FATFS *fs;
    char label[24+2];
    DWORD vsn; // volume serial number

    while(*ptr == ' ' || *ptr == '\t')
        ++ptr;
    printf("fatfs status:%s\n",ptr);
    res = f_getfree(ptr, (DWORD*)&p2, &fs);
    if (res)
    {
        put_rc(res);
        return;
    }
    printf("FAT type                = %s\n",  fatfs_fstype(fs->fs_type));
    printf("Bytes/Cluster           = %lu\n", (DWORD)fs->csize * 512);
    printf("Number of FATs          = %u\n",  fs->n_fats);
    printf("Root DIR entries        = %u\n",  fs->n_rootdir);
    printf("Sectors/FAT             = %lu\n", fs->fsize);
    printf("Number of clusters      = %lu\n", fs->n_fatent - 2);
    printf("FAT start (lba)         = %lu\n", fs->fatbase);
    printf("DIR start (lba,clustor) = %lu\n", fs->dirbase);
    printf("Data start (lba)        = %lu\n", fs->database);

#if _USE_LABEL
    res = f_getlabel(ptr, label, (DWORD*)&vsn);
    if (res)
    {
        put_rc(res);
        return;
    }
    printf("Volume name             = %s\n", label[0] ? label : "<blank>");
    printf("Volume S/N              = %04X-%04X\n", (WORD)((DWORD)vsn >> 16), (WORD)(vsn & 0xFFFF));
#endif

    AccSize = AccFiles = AccDirs = 0;
    res = fatfs_scan_files(ptr);
    if (res)
    {
        put_rc(res);
        return;
    }
    printf("%u files, %lu bytes.\n%u folders.\n"
                 "%lu KB total disk space.\n%lu KB available.\n",
            AccFiles, AccSize, AccDirs,
            (fs->n_fatent - 2) * fs->csize / 2, p2 * fs->csize / 2
    );

}



MEMSPACE
void fatfs_filinfo_list(FILINFO *info)
{
    char attrs[6];
    if(info->fname[0] == 0)
    {
        printf("fatfs_filinfo_list: empty\n");
        return;
    }
    attrs[0] = (info->fattrib & AM_DIR) ? 'D' : '-';
    attrs[1] = (info->fattrib & AM_RDO) ? 'R' : '-';
    attrs[2] = (info->fattrib & AM_HID) ? 'H' : '-';
    attrs[3] = (info->fattrib & AM_SYS) ? 'S' : '-';
    attrs[4] = (info->fattrib & AM_ARC) ? 'A' : '-';
    attrs[5] = 0;
    printf("%s %u/%02u/%02u %02u:%02u %9lu %s",
        attrs,
        (info->fdate >> 9) + 1980, (info->fdate >> 5) & 15, info->fdate & 31,
        (info->ftime >> 11), (info->ftime >> 5) & 63,
        info->fsize, info->fname);
    printf("\n");
}