fatfs_sup.c

Go to the documentation of this file.

 
#include "user_config.h"
#include "fatfs.h"
 
#ifdef AVR
#include <stdlib.h>
#endif
 
#include "mathio.h"
 
#include "time.h"
 
FATFS Fatfs[FF_VOLUMES];                          /* File system object for each logical drive */
 
#if FF_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;
 
static
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
int fatfs_status(char *name)
{
    long p2;
    int res;
    FATFS *fs;
    char label[24+2];
    DWORD vsn;                                    // volume serial number
    char buff[MAX_NAME_LEN+1];
 
    memset(buff,0,sizeof(buff)-1);
    while(*name == ' ' || *name == '\t')
        ++name;
 
    printf("MMC SLOW clock=%8ld\n", (long)MMC_SLOW);
    printf("MMC FAST clock=%8ld\n", (long)MMC_FAST);
 
    if(!name || !*name)
    {
        strcpy(buff,".");
    }
    else
    {
        strcpy(buff,name);
    }
    printf("fatfs status:%s\n",buff);
    res = f_getfree(buff, (DWORD*)&p2, &fs);
    if (res)
    {
        printf("fatfs_status f_getfree failed\n");
        return(0);
    }
    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 FF_USE_LABEL
    res = f_getlabel(buff, label, (DWORD*)&vsn);
    if (res)
    {
        printf("fatfs_status f_getlabel failed\n");
        return(0);
    }
    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(buff);
    if (res)
    {
        printf("fatfs_status fatfs_scan_files failed\n");
        return(0);
    }
    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
        );
    return(1);
}
 
 
 
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");
}