Class File n'est pas reconnue (VSC plateformio)

Version imprimable

Bonjour à tous
Voilà un nouveau problème dans mon projet que je n'arrive pas à résoudre et toutes mes recherches se sont avérées vaines.
J'ai déjà utilisé le SPIFFS dans d'autres projets et cela a toujours bien fonctionné. Là, je fais exactement la même procédure et la 'class' File semble avoir disparue:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 //***************** Ecriture SPIFFS ********************************** void ecritureFichier(const char *dir, const char *msg){ bool ok=false; size_t lg; char buffer[160]; File fic = SPIFFS.open(dir,"w"); if(!fic){ afficMsg(ERWRT); //"Accès fichier impossible" return ok; } lg=fic.print(msg); // Ecrit le message en SPIFFS retourne la longueur delaiM(300); fic.close(); ok=true; sprintf(buf, "Nb car: %d",lg); memcpy(buf,msg,16); afficMsg(buf); }
File est souligné en rouge avec ce message:

Citation:

'File' was not declared in this scope
identifier "File" is undefinedC/C++(20)

Si je tente la compilation, j'obtiens ce message:

Citation:

File fic = SPIFFS.open(dir,"w");
^~~~
src/main.cpp:241:3: note: suggested alternative:
In file included from .pio/libdeps/az-delivery-devkit-v4/TFT_eSPI/Processors/TFT_eSPI_ESP32.h:138,
from .pio/libdeps/az-delivery-devkit-v4/TFT_eSPI/TFT_eSPI.h:101,
from src/main.cpp:3:
C:/Users/Mormic/.platformio/packages/framework-arduinoespressif32/libraries/FS/src/FS.h:46:7: note: 'fs::File'
class File : public Stream

Une idée du problème?

Hello,

Utilisez le namespace complet

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
void ecritureFichier(const char *dir, const char *msg){
  bool ok=false;
  size_t lg;
  char buffer[160];
  fs::File fic = SPIFFS.open(dir,"w");  // Ajout de fs::
  if(!fic){
    afficMsg(ERWRT);
    return ok;
  }
  lg=fic.print(msg);
  delaiM(300);
  fic.close();  
  ok=true;  
  sprintf(buf, "Nb car: %d",lg);
  memcpy(buf,msg,16);
  afficMsg(buf);
}

05/11/2025, 10h57
mormic

Bonjour fred1599
je n'aurai jamais trouvé cette solution de namespace complet qui permet la compilation du sketch.
Par contre, maintenant c'est le mot 'open' de SPIFFS.open qui est souligné en rouge; mais cela ne semble pas bloquant.

Citation:

class "fs::SPIFFSFS" has no member "open"C/C++(135)

Merci pour votre aide.

Voici une version un peu optimisé
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 bool ecritureFichier(const char *dir, const char *msg){ fs::File fic = SPIFFS.open(dir,"w"); if(!fic){ afficMsg(ERWRT); return false; } size_t lg = fic.print(msg); delaiM(300); fic.close(); sprintf(buf, "Nb car: %d", lg); memcpy(buf, msg, 16); afficMsg(buf); return true; }
Un des problèmes que j'avais relevé dans votre précédent code était le type de retour incohérent défini dans votre fonction et incohérent avec le retour en cas d'accès fichier impossible.

Pour le soulignement rouge sur SPIFFS.open, tant que la compilation passe et que votre code fonctionne, c'est juste l'IntelliSense qui est un peu perdu. Vous pouvez l'ignorer en toute sécurité.

05/11/2025, 15h20
Artemus24

Citation:

“SPIFFS is currently deprecated and may be removed in future releases of the core. Please consider moving your code to LittleFS.”

Pourquoi continuer à utiliser SpiFFS alors que celui-ci est déprécié ?

Merci Artemus24 pour cette remarque.
En effet, il n'y a pas de raison particulière à ne pas utiliser LittleFS, juste une vieille habitude.
Je viens donc de passer avec LittleFS, mais je suis toujous obligé d'écrire le nameSpace complet "fs::File fic" alors que tous les exemples sont "File fic" ? Qu'en pensz-vous?

ma routine d'écriture:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 //***************** Ecriture SPIFFS ********************************** bool ecritureFichier(const char *nomFic, const char *msg){ size_t lg; char buffer[160]; fs::File fic = LittleFS.open(nomFic,"w"); if(!fic){ return false;; } lg=fic.print(msg); // Ecrit le message en SPIFFS retourne la longueur delaiM(300); fic.close(); sprintf(buf, "Nb car: %d",lg); memcpy(buf,msg,16); //le buf est affiche au retour return true; }

Voici un petit exemple d'utilisation de LittleFS avec une ESP32 sous l'IDE Arduino :

Code:

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
116
117
118
119
120
121
122
123
124
/*************************************************/
/*                                               */
/*     Lecture d'un fichier en Mémoire Flash     */
/*                                               */
/*************************************************/
 
 
#include <string.h>
#include "LittleFS.h"
 
const char* MyPath="/Fichier.txt";
 
File MyFile;
 
int Flag;
 
/*---------------------------*/
/* Structure de la ligne Lue */
/*---------------------------*/
 
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 */
/*-----------*/
 
void setup()
{
	Serial.begin(115200);
	delay(1000);
 
	Serial.println("\e[1;31m+----------+\e[0m");
	Serial.println("\e[1;31m| LittleFS |\e[0m");
	Serial.println("\e[1;31m+----------+\e[0m\r\n");
 
	if(!LittleFS.begin(true))
	{
		Serial.println("Erreur LittleFS");
		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);
	}
}

06/11/2025, 16h21
fred1599

Citation:

Pourquoi continuer à utiliser SpiFFS alors que celui-ci est déprécié ?

Pour un nouveau projet, privilégiez LittleFS. Pour un projet existant qui fonctionne bien avec SPIFFS, il n'y a pas d'urgence à migrer sauf si vous rencontrez des limitations ou des problèmes de fiabilité.

Citation:

Je viens donc de passer avec LittleFS, mais je suis toujous obligé d'écrire le nameSpace complet "fs::File fic"

C'est une bonne pratique !