bonsai

Bonsai

Un pequeño y persistente administrador de archivos para sistemas integrados basados ​​en ARM.

Características

• Estructura de directorio persistente con creación de archivos anidados.
• Admite todos los microcontroladores ATSAMC2X/ ATSAMD2X.
• Configuración mínima: identificación automática del dispositivo.
• Controlador periférico de memoria no volátil incorporado.

Ejemplos

Crear un archivo.

En este ejemplo, un archivo llamado red se crea en root/config. Si el archivo de configuración no existe, Bonsai lo creará y colocará redes dentro de él. El directorio raíz se crea de forma predeterminada cuando se instancia una clase Bonsai .

Bonsai bonsai;
bonsai.create_file( " root/config/networking " );

Eliminar un archivo

El archivo Old_Data se elimina, junto con su contenido.

Bonsai bonsai;
bonsai.delete_file( " root/config/old_data " );

Consulte la API completa para obtener más información.

Contribuir

Las contribuciones son más bienvenidas.

Mira cómo contribuir.

Estructura de archivo

Una vez escrito, un archivo reside contiguamente en un límite de fila en la memoria flash. Un archivo puede abarcar múltiples filas siempre que se adhiera a los límites de tamaño de sus campos constituyentes, y que se ajuste dentro de la partición Flash Bonsai. Sus primeros cuatro campos son de tamaño fijo y inventan el encabezado del archivo. El tamaño de los campos seguidos, y por lo tanto el archivo en su totalidad, se deriva del encabezado. Los últimos tres campos varían en tamaño y constituyen el cuerpo de la estructura del archivo. En particular, un archivo no almacena su propia dirección, ya que la dirección de un archivo es la dirección de su primer miembro.

Tamaño del mango	Tamaño de datos	Dirección principal	# de direcciones infantiles	Manejar	Datos	Direcciones infantiles
1 byte	2 bytes	4 bytes	1 byte	variable	variable	variable
Encabezamiento				Cuerpo

En consecuencia, la tabla anterior se expresa en el firmware como una estructura file_t .

 typedef struct {
    uint8_t handle_size;        // the size of handle in bytes
    uint16_t data_size;         // the size of data in bytes
    uint32_t parent_addr;       // the address of this file's parent file
    uint8_t num_child_addrs;    // the number of children immediately descendant from this file
    uint8_t *handle;            // the handle or name of this file
    uint8_t *data;              // the actual data this file contains
    uint32_t *child_addrs;      // children addresses
    /* ... */
} file_t ;

El tamaño de cualquier archivo se puede expresar en términos de un file_t , por lo tanto:

handle_size + sizeof (handle_size) +   // handle_size bytes plus one more for storing the size of handle_size
data_size + sizeof (data_size) +       // same for data
sizeof (parent_addr) +                 // four bytes for the parent address
sizeof (num_child_addrs) +             // one byte for storing the number of child addresses
(num_child_addrs * sizeof ( uint32_t )); // four bytes for every child address 

El archivo root, el archivo del sistema y la dirección de espacio libre (FSA)

Tras la inicialización, Bonsai buscará un archivo del sistema al comienzo de su partición flash. Si uno no existe, Bonsai creará uno y un archivo root. El archivo root es, como era de esperar, el padre de todos los archivos creados por el usuario. Su mango es root y se inicializa sin ningún dato. El archivo del sistema es un archivo especial que reside una fila antes de la dirección del archivo root. No tiene direcciones de padres ni hijos y se utiliza para la gestión general de la memoria. De manera crucial, el archivo del sistema almacena la dirección de espacio libre (FSA) que se utiliza para determinar la ubicación del siguiente archivo que se escribirá (nuevamente, el archivo del sistema almacena la FSA como datos, no como una dirección infantil. La FSA no es un archivo, y tratarlo como uno no tiene sentido). Este mecanismo funciona de tal manera que cuando se escribe un archivo, la FSA se incrementa a la dirección de fila inmediatamente después del final del archivo escrito. Por el contrario, cuando se elimina un archivo, la FSA se disminuye a la dirección de fila en la que se encontraba el archivo eliminado. Por lo tanto, es el caso que el tamaño máximo de un fragmento de memoria es ROW_SIZE - 1 o 255 bytes.

API de bajo nivel

La clase Bonsai implementa un conjunto de métodos para la lectura y escritura de archivos básicos. Estos métodos no están involucrados con el recorrido de la ruta de archivo. Más bien, interactúan directamente con las direcciones y generalmente son llamadas por la API de nivel superior. Ellos son:

 void put ( file_t &file);                             // writes a file to flash memory
file_t get ( const uint32_t address);                 // retrieves a file from memory
void del ( const uint32_t address);                   // erases all rows containing a file
void mov ( const uint32_t dest, const uint32_t src);  // moves a file from src to dest