Discussion :

[mormic]

Bonjour à tous

Ma question est: puis-je avoir 100 fichiers de 8 octets déclarés dans le système SPIFFS d'un ESP32 avec 3.145.728 octets de flash memory?

J'utilise le système de fichiers SPIFFS pour stocker des informations de 8 octets.
exemples: O1500715 qui correspond à Ouverture du système 1 à 50% à 07h15.
Mes fichiers devraient s'appeler: M00, M01, M02,......., jusqu'à M99 si j'ai 100 fichiers.

Je n'ai pas trouvé d'information sur la taille prise par enregistrement.
Si quelqu'un pouvait m'éclairer. Merci

[Artemus24]

Salut Mormic.

Ce n'est pas une bonne idée de procéder ainsi.
Si je devais gérer vos données, j'utiliserai pour cela l'organisation séquentielle indexée.
Sauf que jusqu'à présent, je n'en ai pas eu besoin.
Et je n'ai pas cherché à savoir comme faire dans un ESP32 pour répondre à votre question.
Attention, je ne parle pas des SGBD, qui pour la plupart aujourd'hui sont de type relationnelle.

Si par contre, la volumétrie risque d'être un problème, dans ce cas, oui, il vous faut une base de données.
Elle sera distante, sur un serveur, comme MySql et votre ESP32 devra y accéder.

Cordialement.
Artemus24.
@+

[mormic]

Merci Artemus pour cette solution.

Si je devais gérer vos données, j'utiliserai pour cela l'organisation séquentielle indexée.

C'est à dire que je devrais mettre toutes mes informations bout à bout dans un seul fichier SPIFFS et avoir un fichier index qui m'indique où sont les infos.
par exemple: O1500715F2801920O5602130... pour les données et 000816... pour l'index sur deux ou trois octets selon la taille du fichier.

ou bien en recherchant en série les débuts d'enregistrement par leur longeur.
par exemple: 08O150071508F280192010O560213027.....

Je préfère ne pas avoir à utiliser une base de données externes pour ce projet.

Cordialement
Michel

[Artemus24]

Salut mormic.

Ma réponse est ce qui m'est venu à l'esprit en vous lisant.
A vrai dire, ce n'est pas la plus judicieuse du tout, mais l'idée est bien d'indexer ses données.

Votre question est légitime mais nous ne connaissons pas la raison qui vous amène à stocker vos données.
Pourquoi avez-vous besoin de stocker cela dans la mémoire flash de l'ESP32 ?

Cela me fait penser à une trace de chaque changement d'état de vos systèmes.
Le système 1 s'ouvre à telle heure avec telle niveau d'ouverture.
Puis il va se ferme à telle autre heure et ainsi de suite durant toute la journée.

Et ensuite, qu'est-ce que vous faite de ces données ?
Le lendemain, je suppose que ceux de la veille sont supprimées, non ?

Je préfère ne pas avoir à utiliser une base de données externes pour ce projet.

Pourquoi donc ? Pas de statistiques en vue sur une longue période ?
Histoire de connaitre le rendement de vos système, par exemple.

Je ne suis pas du tout familiarisé avec le SPIFFS.
J'utilise LITTLE FS pour stocker des fichiers de type HTML, CSS et javascript.
Ceux-ci ne sont lus et envoyés car dans mon projet domotique, je gère un mini serveur web.

Quelle est la volumétrie de ce stockage ?
Vous dites : " si j'ai 100 fichiers."
Dois-je comprendre que vous pourriez avoir bien plus de 100 fichiers ? Quelle est le maximum ?

La taille de la mémoire flash est limité à 4Mo. Est-ce suffisant ?

J'ai fait une recherche sur le net afin de connaitre les ordres à appliquer au SPIFFS.
Le SPIFFS est-il opérationnel : "if(!SPIFFS.begin(true)){".
Pour ouvrir en mode append : "myfile = SPIFFS.open("/test.txt", FILE_APPEND);".
Pour ouvrir en mode read : "myfile = SPIFFS.open("/test.txt", FILE_READ);".
Pour fermer : "myfile.close();".
Pour ajouter : "myFile.print("votre ligne");".
Pour lire séquentiellement : "while(myFile.available()) { String line = myFile.read()); }"

Je n'ai rien trouvé sur une lecture relative et c'est dommage car cela vous aurait évité de créer un tableau.

Au démarrage de votre ESP32, vous lisez le contenu de votre fichier SPIFFS que vous stocker dans une structure.
La structure sera un tableau indicé. Les indices en 'C' commence à partir de 0. Elle est la suivante :
--> mode : 1 char : ouverture ou fermeture
--> system : 1 char : numéro d'identification du système.
--> pour : 1 smallint : pourcentage
--> heure : 1 integer : l'heure.

Rappel : smallint occupe deux octets, tandis que integer occupe quatre octets

A chaque nouvelle ajout, vous le faites en fin de fichier.

Je n'ai pas trouvé d'information sur la taille prise par enregistrement.

C'est celle de la structure, donc huit octets + un octet contenant le caractère nul.
Le nul est la marque de fin de la chaîne de caractères.

Dans votre tableau, pour accéder à la n^ième ligne, il suffit de dire tab[n]. Pour lire l'heure, tab[n].heure.

Cordialement.
Artemus24.
@+

[mormic]

Votre question est légitime mais nous ne connaissons pas la raison qui vous amène à stocker vos données.
Pourquoi avez-vous besoin de stocker cela dans la mémoire flash de l'ESP32 ?

Je charge dans la mémoire flash des programmes de manoeuvre de volets roulants . Par exemple "Ouvrir le volet N°1 à 100% à 07h00, Fermer le volet N° 1 de 40% à 12h15, etc (soit 8 octets nécessaires)
Au niveau du SPIFFS, l'enregistrement se fait ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//***************** Ecriture SPIFFS **********************************
void ecritureFichier(fs::FS &fs, const char *dir, const char *message){
  File fic = fs.open(dir, FILE_WRITE);
  if(!fic){
    sBt.println(msg[1]);    //"Pas de fichier"
    return;
  }
  if(fic.print(message)){
    sBt.println(msg[2]);    //"Fichier ecrit"
  } else {
    sBt.println(msg[3]);    //"Erreur d'ecriture"
  }
  fic.close();
}

Avec pour dir par exemple: /M05.txt dans lequel le message est mon enregistrement O1800715 pour Ouverture volet 1 de 80% à 07h15.
Je peux avoir jusqu'à 10 programmes de 10 manoeuvres. En fonction de la saison, ou autre, je sélectionne un programme. Celui-ci restera actif jusqu'au moment où j'en sélectionnerai un autre.
Donc j'ai besoin de 10 x 10 x 8 octets ce qui n'est pas énorme.
C'est assez simpliste, mais cela fonctionne bien avec pour l'instant que quelques fichiers. Je ne voudrais pas, après avoir monté tout le système, me rendre compte qu'il y a une limite.
Ce que je ne sais pas, c'est si le système SPIFFS accepte d'avoir 100 pseudo-directories. C'est à dire puis-je avoir de /M00.txt à M99.txt fichiers.
La solution serait d'essayer sur ma maquette de programmer 100 manoeuvres ce qui est fastidieux et pas très élégant!

Sinon je vous remercie pour toutes les informations intéressantes que vous divulguez.

Cordialement
Michel

[kaitlyn]

Salut,

D’après la doc que j'ai lue en diagonale, chaque fichier occupera au minimum 4096 octets.
Il est donc préférable de tout mettre dans un seul fichier et des fonctions genre seek/fseek permettront de s'y déplacer facilement.

https://docs.espressif.com/projects/...ge/spiffs.html

[Artemus24]

Salut Mormic.

Je comprend mieux l'usage que vous faites de vos données. Elles sont justes destinées à la lecture.
Je vous conseille de bien dissocier les données du sketch. Vous n'avez pas différencier les saisons.
A moins que cela n'a aucune importance, je suppose que seul l'heure local est importante.

Je vous conseille de créer un fichier unique contenant toutes vos lignes triés sur l'heure.

Je charge dans la mémoire flash des programmes de manœuvre de volets roulants .

Comment faites-vous pour mettre à jour vos données dans la SPIFFS ? Vous pouvez recharger vos données, sans écraser le sketch.

Au niveau du SPIFFS, l'enregistrement se fait ainsi:

Dans votre sketch, il n'y a aucune écriture à faire car vous ne faites que lire les données depuis votre SPIFFS.

Je me suis posé la question suivante :
--> Quand vous dites ouvrir tel volet à 07H15, comment savez vous s'il est déjà ouvert ou pas ?

Je vais vous exposer l'algorithme :

a) afin d'économiser la batterie de votre ESP32, vous pouvez la mettre en veille.
Ce qui implique qu'à chaque démarrage, disons toutes les 30 secondes, vous devez connaitre le contexte précédent.
Si c'est trop compliqué pour vous, on peut remplacer cette mise en veille par un sleep(30).

b) Au démarrage, vous ouvrez l'unique fichier qui sera trié selon l'heure.
Vous lisez la première ligne.

c) vous êtes maintenant dans la boucle générale.
Si la ligne a été traité, vous passez à la suivante.
Sinon, tant qu'elle n'est pas traité, vous restez positionné dessus.

d) si vous n'êtes pas dans la bonne saison, vous passez à la ligne suivante

e) vous testez l'heure. Si l'heure est attente vous passez à la suite du traitement.
Si l'heure n'est pas atteinte, vous ne faites rien sinon attendre.

C'est dans cette boucle interne que vous pouvez utiliser le sleep de 30 secondes.

f) l'heure est atteinte, vous faites le traitement demandé en fonction :
--> du système
--> de l'ouverture ou de la fermeture
--> du positionnement en pourcentage

vous passez au §c).

g) vous venez d'atteindre la fin du fichier.
Tant que l'heure système est inférieur à 23H59, vous ne faites rien.
Sinon, vous fermez le fichier et vous l'ouvrez en lecture afin de vous repositionnez à son début.

En fonction de la saison, ou autre, je sélectionne un programme.

Je vous conseille d'ajouter une donnée supplémentaire que vous nommerez saison.
Un seul caractère suffit où vous pouvez indiquer :
--> soit la saison : de 1 à 4.
--> soit le mois : de A à L.

Donc j'ai besoin de 10 x 10 x 8 octets ce qui n'est pas énorme.

Vous oubliez les séparateurs de vos données.

La structure de la ligne est composée de :
--> saison : 1 char : la période du traitement
--> mode : 1 char : ouverture ou fermeture
--> system : 1 char : numéro d'identification du système.
--> pour : 1 smallint : pourcentage
--> heure : 1 integer : l'heure.

Ce qui fait au total 9 octets + la marque de fin de la ligne qui est le caractère nul, soit au total 10 octets.
Il y a un petit problème auquel personne ne pense, les alignements de frontières des données.
Un integer s'aligne sur des multiples de 4, un smallint sur des multiples de 2.
Le mieux est de tout mettre en char et de faire la conversion quand cela sera nécessaire.

En théorie, la mémoire flash est de 4 Mo, soit 4 194 304. Une ligne fait 10 octets.
Vous avez la possibilité de mettre (en théorie) jusqu'à 419 430 lignes.
Vous avez largement la place de mettre vos cent lignes et même un peu plus.

Selon les conseils de Kaitlyn, un fichier occupe au minimum 4096 octets. Donc perte d'espace si plusieurs fichiers.
C'est pourquoi, je vous conseille de créer un seul fichier contenant toutes les lignes gérant vos volets.

Je n'ai pas traité, mais vous devez récupérer l'heure par le protocole NTP (Network Time Protocol).

Voilà, je vous ai exposer une solution. Bonne continuation !

Cordialement.
Artemus24.
@+

[mormic]

merci pour toutes ces infos.

Je vais donc modifier la gestion des enregistrements dans le SPIFFS en écrivant un seul fichier.

Cordialement
Michel

[Artemus24]

Salut mormic.

Je te donne ci-après un exemple avec LittleFS.

Voici le fichier que je charge dans la mémoire Flash de mon ESP32 :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
A0700O010
A0800C020
A0900O030
A1000C100

la structure est la suivante :
--> Saison : 1 caractère.
--> Heure : 4 caractères.
--> Systeme : 1 caractère.
--> Taux : 3 caractères.

Et voici le sketch, juste la partie qui gère le fichier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/*****************************************/
/*                                       */
/* Lecture d'un fichier en Mémoire Flash */
/*                                       */
/*****************************************/
 
#include <string.h>
#include "LITTLEFS.h"
 
const char* MyPath="/Fichier.txt";
 
File MyFile;
 
int Flag;
 
typedef struct {
	char Saison[2];
	char Heure[5];
	char Systeme[2];
	char Taux[4];
	char Eof[2];
} MyStruct;
 
MyStruct MyLine;
 
/*-------------------------------------*/
/* Lecture du fichier en mémoire Flash */
/*-------------------------------------*/
 
void Lecture(void)
{
	memset(&MyLine, 0, sizeof(MyLine));
 
	MyFile.readBytes((char*)&MyLine.Saison, 1);
	MyFile.readBytes((char*)&MyLine.Heure,  4);
	MyFile.readBytes((char*)&MyLine.Systeme,1);
	MyFile.readBytes((char*)&MyLine.Taux,   3);
	MyFile.readBytes((char*)&MyLine.Eof,    2);
 
	Serial.println("--------------");
	Serial.printf("Saison  : %s\r\n", MyLine.Saison);
	Serial.printf("Heure   : %s\r\n", MyLine.Heure);
	Serial.printf("Systeme : %s\r\n", MyLine.Systeme);
	Serial.printf("Taux    : %s\r\n", MyLine.Taux);
	Serial.println("--------------");
}
 
/*----------------------*/
/* Démarrage de l'ESP32 */
/*----------------------*/
 
void setup()
{
	Serial.begin(115200);
	delay(1000);
 
	if(!LITTLEFS.begin(true))
	{
		Serial.println("Erreur SPIFFS");
		return;
	}
 
	MyFile = LITTLEFS.open(MyPath, FILE_READ);
	Flag = 1;
}
 
/*-----------------*/
/* Boucle Générale */
/*-----------------*/
 
void loop()
{
	if (MyFile.available())
	{
		if (Flag )
		{
			Lecture();
			Flag = 0;
		}
 
		sleep(1);
 
		if (!strcmp(MyLine.Heure, "0700"))
		{
			Serial.println("Ligne 1 Traitée !");
			Flag = 1;
		}
 
		if (!strcmp(MyLine.Heure, "0800"))
		{
			Serial.println("Ligne 2 Traitée !");
			Flag = 1;
		}
 
		if (!strcmp(MyLine.Heure, "0900"))
		{
			Serial.println("Ligne 3 Traitée !");
			Flag = 1;
		}
 
		if (!strcmp(MyLine.Heure, "1000"))
		{
			Serial.println("Ligne 4 Traité !");
			Flag = 1;
		}
	}
	else
	{
		Serial.println("--------------");
		Serial.println("Fin du fichier");
 
		MyFile.close();
		MyFile = LITTLEFS.open(MyPath, FILE_READ);
	}
}

J'ai créé une structure où je place la ligne lue dedans.
Comme je gère des chaines de caractères (char) du type langage 'C', je suis obligé de mettre le caractère nul en fin de chaîne.
La chaine de caractères est plus grande de 1 caractère, que ce qui est stocké dans le fichier.
Bien que la lecture soit légèrement plus compliquée, elle simplifie la manipulation de ces chaînes dans la suite du sketch.

J'utilise le "FLAG" pour dire si je dois relire ou pas le fichier.
J'ai simulé le fonctionnement en affichant une ligne quand l'heure est sélectionnée.

Sais-tu comment lire l'heure ?

Je pense que pour la suite, tu n'auras pas trop de problème.

Voici le chargement du fichier :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
Chip : esp32
Using partition scheme from Arduino IDE.
Start: 0x290000
Size : 0x170000
mklittlefs : C:\Users\Patron\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.6\tools\mklittlefs.exe
 
esptool : C:\Users\Patron\AppData\Local\Arduino15\packages\esp32\tools\esptool_py\3.0.0\esptool.exe
 
[LittleFS] data   : L:\Espressif\Exercices\09.LittleFS\LittleFS_01\data
[LittleFS] offset : 0
[LittleFS] start  : 2686976
[LittleFS] size   : 1472
[LittleFS] page   : 256
[LittleFS] block  : 4096
->/Fichier.txt
[LittleFS] upload : C:\Users\Patron\AppData\Local\Temp\arduino_build_390001/LittleFS_01.littlefs.bin
[LittleFS] address: 2686976
[LittleFS] port   : COM6
[LittleFS] speed  : 921600
[LittleFS] mode   : dio
[LittleFS] freq   : 80m
 
->esptool.py v3.0-dev
->Serial port COM6
->Connecting.......
->Chip is ESP32-D0WDQ6 (revision 1)
->Features: WiFi, BT, Dual Core, 240MHz, VRef calibration in efuse, Coding Scheme None
->WARNING: Detected crystal freq 41.01MHz is quite different to normalized freq 40MHz. Unsupported crystal in use?
->Crystal is 40MHz
->MAC: 94:b9:7e:ea:77:ac
->Uploading stub...
->Running stub...
->Stub running...
->Changing baud rate to 921600
->Changed.
->Configuring flash size...
->Auto-detected Flash size: 4MB
->Compressed 1507328 bytes to 1721...
->Writing at 0x00290000... (100 %)
->Wrote 1507328 bytes (1721 compressed) at 0x00290000 in 0.1 seconds (effective 194493.8 kbit/s)...
->Hash of data verified.
->
->Leaving...
->Hard resetting via RTS pin...

A moins de me tromper, la taille du fichier compressée est de 1721 octets dans la mémoire flash.

Si je compte manuellement le nombre d'octets dans mon fichier, j'ai quatre lignes de 9 caractères + CR et LF.
Soit au total 11 caractères x 4 = 44 caractères.
Il y a aussi une marque de fin de fichier, peut-être 1 caractère (EOF) en plus, soit 45 caractères.

Quand le commpte-rendu dit 1 507 328 octets, j'ai du mal à comprendre ce qu'il met d'autre.

Et voici un exemple d'exécution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
ets Jun  8 2016 00:22:57
 
rst:0x1 (POWERON_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:1
load:0x3fff0018,len:4
load:0x3fff001c,len:1216
ho 0 tail 12 room 4
load:0x40078000,len:10944
load:0x40080400,len:6388
entry 0x400806b4
--------------
Saison  : A
Heure   : 0700
Systeme : O
Taux    : 010
--------------
Ligne 1 Traitée !
--------------
Saison  : A
Heure   : 0800
Systeme : C
Taux    : 020
--------------
Ligne 2 Traitée !
--------------
Saison  : A
Heure   : 0900
Systeme : O
Taux    : 030
--------------
Ligne 3 Traitée !
--------------
Saison  : A
Heure   : 1000
Systeme : C
Taux    : 100
--------------
Ligne 4 Traité !
--------------
Fin du fichier
--------------
Saison  : A
Heure   : 0700
Systeme : O
Taux    : 010
--------------
Ligne 1 Traitée !
--------------
Saison  : A
Heure   : 0800
Systeme : C
Taux    : 020
--------------
Ligne 2 Traitée !
--------------
Saison  : A
Heure   : 0900
Systeme : O
Taux    : 030
--------------
Ligne 3 Traitée !
--------------
Saison  : A
Heure   : 1000
Systeme : C
Taux    : 100
--------------
Ligne 4 Traité !
--------------
Fin du fichier
--------------
Saison  : A
Heure   : 0700
Systeme : O
Taux    : 010
--------------
Ligne 1 Traitée !
--------------
Saison  : A
Heure   : 0800
Systeme : C
Taux    : 020
--------------
Ligne 2 Traitée !
--------------
Saison  : A
Heure   : 0900
Systeme : O
Taux    : 030
--------------
Ligne 3 Traitée !
--------------
Saison  : A
Heure   : 1000
Systeme : C
Taux    : 100
--------------
Ligne 4 Traité !
--------------
Fin du fichier
--------------
Saison  : A
Heure   : 0700
Systeme : O
Taux    : 010
--------------
Ligne 1 Traitée !
--------------

Cordialement.
Artemus24.
@+