Simple File System

Simple File System (sFS) is very simple file system for for embedded devices. Support fast append to file operation. The type of FS is RA (Read-Append). It is optimized for FLASH-like types of memories, where write/erase operation is much time consuming that reading. Primary use of sFS is store data from connected sensors to external memory.

Properties of sFS:

• sFS is Read-Append oriented file system
• does not support extended info as file owner, protected access, file rights, ...
• Configurable for small (in kB) and large (in MB) memory capacity - it is possible to shring overhead, by reducing max. count of files and size of single file record (row).

Predefined variants

Simple File system predefine 4 variants of configurations. The configuration is tetermined only by "Files" and "Column per file" values. Other value depend on these basic setting.

				HEADER	HEADER	HEADER	META	META	META	DATA
	Variant	Files	Column per file	ADDRESS	RECORD_LENGTH	SIZE	ADDRESS	RECORD_LENGH	SIZE	ADDRESS
Ultra small	U	1	4	32	32	32	64	48	48	112
eXtra small	X	2	8	32	32	64	96	96	192	288
Small	S	8	16	32	32	256	288	192	1536	1824
Large	L	22	42	32	32	704	736	504	11088	11824

Properties of files in sFS:

• binary format,
• CSV-like format: data are always stored in rows. Each row contains of set of columns, or data from external sensors,
• each file has limitted count of columns, depending on memory capacity,
• files is FS is self-descripted; there is stored also information how to interpret that file,
• only to last file if sFS can be append data; other files are locked (can't be extended))
• file name is automatically generated (depending on HW ID of used memory),

Supporting platforms:

• STM32
• ESP32 (in future)
• native C app (in simulation mode)

Supported memories:

• SPI-like: FLASH memory. Winbond W32 with high capacity
• 1-wire: EEPROM memory. E.g. Maxim integrated DS28EC20 with maximum 20kB of capacity
• RAM memory - as a dektop application (in SIMULATION mode)

Each class of memories has own limitations:

• normal size (FLASH): 1 - 16MB.
• limited size (EEPROM): 1 - 1024 kB

Technical documentation

SIMPLE_FS

sFS Memory map

Memory map for sfS v.1

• MAC - Manufacturer
  
• MT - Memory Type
• CAP - Capacity code
  
• CC - Size variant
  
• MF - Max files
  
• MS - Max. sensors per file
  
• NP - Number of parts (column) in file
• RL - Record length (length of one record in file [B])

Examples of use

Create instance of simpleFS

#include "sensor_FS.h"
//....
SimpleFS_t *FS;
// create drives for physical sensors
SensorInterface_t *driverADC = &adcSensor;
SensorInterface_t *driverTime = &timeSensor;
 
// init drivers
driverADC->Init(NULL, DUMMY_VALUE);
driverTime->Init(NULL, FORMAT_META_FMT_SPECIAL_TIME);
 
//init FS in SIMULATION mode
init_FS(NULL, NULL, 0);
/* init FS on STM32 application, use SPI FLASH memory   */
/* FS_init(&hspi1, SPI1_CS_GPIO_Port, SPI1_CS_Pin);     */
FS_write_preamble();
FS_create_file();
// add sensors to opened file.
uint8_t sensor_index = 0;
file_add_sensor(sensor_index++, 0, driverTime);
file_add_sensor(sensor_index++, 0, driverADC);
FS_commit_file_header();

Fill file with data

FS = FS_open_last_file();
SensorInterface_t *sd;
SensorValue_t *sv;
 
 if (FS) {
     file_data_row_begin(FS);
     for (uint8_t p = 0; p < file_get_num_parts(FS); p++) {
         RecordDescriptor_t ffd = file_column_format(FS, p);
         sd = FS_sensor_driver(ffd.sensor_type);
         if (sd != NULL) {
             sv = sd->getValue();                // read value from sensor
             int len = get_sensor_data_length(FS->file.format[p].value_format.meta_length);
             file_store_data(FS, p, sv);   // add value to file
         }
     }
     //write values to file
     file_data_row_commit(FS);
 }

Versions

[24.6.2021] v0.1.0, FW version: sFS

• first version,
• works with SPI FLASH memory
• data drivers:
  • one-wire DS18B20,
  • internal MCU peripherals: RTC clock, ADC converter
  • primitive data types

Author

Juraj Dudak