bonsai

Bonsaï

Un minuscule gestionnaire de fichiers persistants pour les systèmes embarqués basés sur ARM.

Caractéristiques

• Structure de répertoire persistant avec création de fichiers imbriqués.
• Prend en charge tous les microcontrôleurs ATSAMC2X / ​​ATSAMD2X.
• Configuration minimale - Identification automatique du périphérique.
• Conducteur périphérique de mémoire non volatile intégré.

Exemples

Créer un fichier.

Dans cet exemple, un fichier appelé réseau est créé dans root / config. Si le fichier de configuration n'existe pas, Bonsai le créera et placera le réseautage à l'intérieur. Le répertoire racine est créé par défaut lorsqu'une classe Bonsai est instanciée.

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

Supprimer un fichier

Le fichier OLD_DATA est supprimé, ainsi que son contenu.

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

Voir l'API complète pour plus d'informations.

Contribuer

Les contributions sont les bienvenues.

Découvrez comment contribuer.

Structure de fichiers

Une fois écrit, un fichier réside contiguë à une limite de ligne dans la mémoire flash. Un fichier peut s'étendre sur plusieurs lignes à condition qu'il adhère aux limites de taille de ses champs constitutifs, et qu'il s'inscrit dans la partition Flash Bonsai. Ses quatre premiers champs sont fixés en taille et composent l'en-tête de fichier. La taille des champs suivants - et donc le fichier dans son intégralité - est dérivé de l'en-tête. Les trois derniers champs varient en taille et composent le corps de la structure des fichiers. Notamment, un fichier ne stocke pas sa propre adresse, car l'adresse d'un fichier est l'adresse de son premier membre.

Manche	Taille des données	Adresse parentale	# des adresses enfants	Poignée	Données	Adresses de l'enfant
1 octet	2 octets	4 octets	1 octet	variable	variable	variable
Tête				Corps

En conséquence, le tableau ci-dessus est exprimé dans le firmware en tant que structure 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 ;

La taille de n'importe quel fichier peut être exprimée en termes de file_t , donc:

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 

Le fichier racine, le fichier système et l'adresse d'espace libre (FSA)

Lors de l'initialisation, Bonsai recherchera un fichier système au début de sa partition flash. Si l'on n'existe pas, le bonsaï en créera un ainsi qu'un fichier racine. Le fichier racine est, sans surprise, le parent de tous les fichiers créés par l'utilisateur. Sa poignée est root et elle est initialisée sans aucune donnée. Le fichier système est un fichier spécial qui réside une ligne avant l'adresse du fichier racine. Il n'a ni adresses des parents ni des enfants et est utilisé pour la gestion générale de la mémoire. Surtout, le fichier système stocke l'adresse d'espace libre (FSA) qui est elle-même utilisée pour déterminer l'emplacement du fichier suivant à écrire (encore une fois, le fichier système stocke la FSA comme des données, et non comme une adresse enfant. La FSA n'est pas un fichier, et la traiter comme on n'aurait pas de sens). Ce mécanisme fonctionne de telle sorte que lorsqu'un fichier est écrit, la FSA est incrémentée à l'adresse de ligne immédiatement après la fin du fichier écrit. Inversement, lorsqu'un fichier est supprimé, la FSA est décrémentée à l'adresse de ligne à laquelle le fichier supprimé a été localisé. Il est donc vrai que la taille maximale d'un fragment de mémoire est ROW_SIZE - 1 ou 255 octets.

API de bas niveau

La classe Bonsai met en œuvre un ensemble de méthodes de lecture et d'écriture de fichiers de base. Ces méthodes ne sont pas impliquées dans la traversée du chemin du fichier. Ils interagissent plutôt directement avec les adresses et sont généralement appelés par l'API de niveau supérieur. Ils sont:

 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