feeling/esp32_test_littlefs
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

initial commit

Browse Source
This commit is contained in:
feeling001@gmail.com
2026-06-08 14:33:53 +02:00
commit a7eb474a97
8 changed files with 686 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+16
View File
@@ -0,0 +1,16 @@
# PlatformIO build artefacts
.pio/
.pioenvs/
.piolibdeps/
# IDE
.vscode/
.idea/
*.suo
*.user
# macOS
.DS_Store
# Linux
*~
Makefile
+132
View File
@@ -0,0 +1,132 @@
# ============================================================
# Makefile – LittleFS test ESP32-S3
# Usage :
# make BOARD=esp32s3_zero # build
# make flash BOARD=esp32s3_zero # build + flash firmware
# make flashfs BOARD=esp32s3_zero # upload la partition LittleFS
# make monitor BOARD=esp32s3_zero # ouvre le moniteur série
# make all BOARD=esp32s3_n16r8v # build + flash firmware + flashfs
# make clean # nettoyage
#
# Boards disponibles :
# esp32s3_zero – Waveshare ESP32-S3-Zero (4 MB flash)
# esp32s3_n16r8v – Generic ESP32-S3 N16R8V (16 MB flash / 8 MB PSRAM OPI)
# ============================================================
# ── Valeur par défaut de la carte ──────────────────────────────
BOARD ?= esp32s3_zero
# ── Outil PlatformIO ───────────────────────────────────────────
PIO := pio
# ── Port série (optionnel, PIO le détecte automatiquement) ─────
# PORT ?= /dev/ttyUSB0
# ── Cibles valides ─────────────────────────────────────────────
VALID_BOARDS := esp32s3_zero esp32s3_n16r8v
.PHONY: all build flash flashfs monitor clean check-board help
# ─────────────────────────────────────────────────────────────
# help (cible par défaut si aucun argument)
# ─────────────────────────────────────────────────────────────
help:
@echo ""
@echo " ┌─────────────────────────────────────────────────────────┐"
@echo " │ Makefile – LittleFS test ESP32-S3 │"
@echo " └─────────────────────────────────────────────────────────┘"
@echo ""
@echo " Utilisation : make <cible> BOARD=<carte>"
@echo ""
@echo " Cartes disponibles :"
@echo " esp32s3_zero – Waveshare ESP32-S3-Zero (4 MB flash)"
@echo " esp32s3_n16r8v – ESP32-S3 N16R8V (16 MB flash / 8 MB PSRAM OPI)"
@echo ""
@echo " Cibles :"
@echo " build – Compile le firmware (défaut)"
@echo " flash – Compile et flashe le firmware"
@echo " flashfs – Upload la partition LittleFS (répertoire data/)"
@echo " monitor – Ouvre le moniteur série (Ctrl+C pour quitter)"
@echo " all – build + flash + flashfs"
@echo " clean – Supprime les artefacts de build"
@echo " help – Affiche ce message"
@echo ""
@echo " Exemples :"
@echo " make BOARD=esp32s3_zero"
@echo " make flash BOARD=esp32s3_n16r8v"
@echo " make all BOARD=esp32s3_zero"
@echo ""
# ─────────────────────────────────────────────────────────────
# Vérification de la valeur de BOARD
# ─────────────────────────────────────────────────────────────
check-board:
@if ! echo "$(VALID_BOARDS)" | grep -qw "$(BOARD)"; then \
echo ""; \
echo " ERREUR : carte inconnue '$(BOARD)'"; \
echo " Cartes valides : $(VALID_BOARDS)"; \
echo ""; \
exit 1; \
fi
@echo " → Carte sélectionnée : $(BOARD)"
# ─────────────────────────────────────────────────────────────
# build – compilation uniquement
# ─────────────────────────────────────────────────────────────
build: check-board
@echo ""
@echo " ── Compilation pour $(BOARD) ──────────────────────────────"
$(PIO) run -e $(BOARD)
# ─────────────────────────────────────────────────────────────
# flash – compilation + upload du firmware
# ─────────────────────────────────────────────────────────────
flash: check-board
@echo ""
@echo " ── Flash firmware → $(BOARD) ──────────────────────────────"
ifdef PORT
$(PIO) run -e $(BOARD) -t upload --upload-port $(PORT)
else
$(PIO) run -e $(BOARD) -t upload
endif
# ─────────────────────────────────────────────────────────────
# flashfs – upload la partition LittleFS (contenu de data/)
# ─────────────────────────────────────────────────────────────
flashfs: check-board
@echo ""
@echo " ── Upload LittleFS partition → $(BOARD) ───────────────────"
ifdef PORT
$(PIO) run -e $(BOARD) -t uploadfs --upload-port $(PORT)
else
$(PIO) run -e $(BOARD) -t uploadfs
endif
# ─────────────────────────────────────────────────────────────
# monitor – moniteur série
# ─────────────────────────────────────────────────────────────
monitor: check-board
@echo ""
@echo " ── Moniteur série ($(BOARD)) – Ctrl+C pour quitter ────────"
ifdef PORT
$(PIO) device monitor -e $(BOARD) --port $(PORT)
else
$(PIO) device monitor -e $(BOARD)
endif
# ─────────────────────────────────────────────────────────────
# all – build + flash + flashfs
# ─────────────────────────────────────────────────────────────
all: build flash flashfs
@echo ""
@echo " ✔ all : build + flash + flashfs terminé pour $(BOARD)"
# ─────────────────────────────────────────────────────────────
# clean – suppression des artefacts
# ─────────────────────────────────────────────────────────────
clean:
@echo ""
@echo " ── Nettoyage ───────────────────────────────────────────────"
$(PIO) run -t clean || true
rm -rf .pio
@echo " ✔ Nettoyage terminé"
README.md
+129
View File
@@ -0,0 +1,129 @@
# esp32_littlefs_test
Test verbeux de LittleFS sur ESP32-S3 avec PlatformIO (framework Arduino, espressif32@6).
## Cartes supportées
| Environnement PIO | Carte physique | Flash | PSRAM |
|---|---|---|---|
| `esp32s3_zero` | Waveshare ESP32-S3-Zero | 4 MB QIO | — |
| `esp32s3_n16r8v` | Generic ESP32-S3 N16R8V | 16 MB QIO | 8 MB OPI |
## Prérequis
- [PlatformIO Core](https://docs.platformio.org/en/latest/core/installation/) installé (`pip install platformio`)
- Driver USB-JTAG / USB-CDC selon la carte (pas de driver externe sur la plupart des ES32-S3)
## Utilisation avec le Makefile
```bash
# Afficher l'aide
make
# Compiler uniquement
make BOARD=esp32s3_zero
# Compiler + flasher le firmware
make flash BOARD=esp32s3_zero
# Uploader la partition LittleFS (contenu de data/)
make flashfs BOARD=esp32s3_zero
# Tout en une commande
make all BOARD=esp32s3_n16r8v
# Ouvrir le moniteur série
make monitor BOARD=esp32s3_zero
# Nettoyer les artefacts
make clean
```
### Spécifier un port série manuellement
```bash
make flash BOARD=esp32s3_zero PORT=/dev/ttyACM0
```
## Utilisation directe avec PlatformIO
```bash
# Build
pio run -e esp32s3_zero
# Flash firmware
pio run -e esp32s3_zero -t upload
# Upload partition LittleFS
pio run -e esp32s3_zero -t uploadfs
# Moniteur série
pio device monitor -e esp32s3_zero
```
## Séquence de tests effectués
| Étape | Description |
|---|---|
| 1 | Montage de LittleFS (avec formatage automatique si nécessaire) |
| 2 | Affichage des infos de la partition (total / utilisé / libre) |
| 3 | Écriture d'un fichier texte UTF-8 |
| 4 | Relecture et vérification du contenu (round-trip) |
| 5 | Écriture binaire (256 octets, valeurs 0x00…0xFF) |
| 6 | Relecture binaire et vérification byte-à-byte |
| 7 | Listage du répertoire racine |
| 8 | Test d'append (ajout à un fichier existant) |
| 9 | Renommage de fichier |
| 10 | Suppression de tous les fichiers de test |
| 11 | Vérification de l'absence des fichiers supprimés |
| 12 | Démontage propre |
| 13 | Résumé PASS / FAIL |
## Sortie attendue
```
╔════════════════════════════════════════╗
║ TEST LittleFS – ESP32-S3 ║
╚════════════════════════════════════════╝
Compilé le : Jun 8 2025 12:00:00
CPU Freq : 240 MHz
Flash size : 4 MB
Free heap : 346120 octets
── Étape 1 : Montage de LittleFS
[ OK ] LittleFS.begin()
── Étape 2 : Informations de la partition
[INFO] Taille totale : 1376256 octets (1344 KB)
...
── Étape 13 : ...
╔════════════════════════════════════════╗
║ RÉSUMÉ DES TESTS ║
╠════════════════════════════════════════╣
║ PASS : 20 FAIL : 0 ║
╠════════════════════════════════════════╣
║ ✔ Tous les tests sont PASSÉS ! ║
╚════════════════════════════════════════╝
```
## LED de statut
Après les tests, la LED intégrée (`LED_BUILTIN`) clignote :
- **Lentement (500 ms)** : tous les tests sont passés ✔
- **Rapidement (100 ms)** : un ou plusieurs tests ont échoué ✘
## Structure du projet
```
esp32_littlefs_test/
├── platformio.ini # Configuration PlatformIO (2 environnements)
├── Makefile # Makefile avec paramètre BOARD=
├── default.csv # Table de partitions 4 MB (esp32s3_zero)
├── default_16MB.csv # Table de partitions 16 MB (esp32s3_n16r8v)
├── src/
│ └── main.cpp # Code de test LittleFS
├── data/ # Contenu uploadé sur LittleFS (vide = OK)
│ └── .gitkeep
└── README.md
```
data/.gitkeep
+4
View File
@@ -0,0 +1,4 @@
Ce répertoire est uploadé tel-quel sur la partition LittleFS via :
pio run -t uploadfs -e <env>
Il peut rester vide pour le test de validation.
default.csv
+10
View File
@@ -0,0 +1,10 @@
# Partition table for ESP32-S3 – 4 MB flash
# Adapted for LittleFS (no OTA to keep a large FS partition)
#
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x140000,
app1, app, ota_1, 0x150000, 0x140000,
littlefs, data, spiffs, 0x290000, 0x160000,
coredump, data, coredump,0x3F0000, 0x10000,
1 # Partition table for ESP32-S3 – 4 MB flash
2 # Adapted for LittleFS (no OTA to keep a large FS partition)
3 #
4 # Name, Type, SubType, Offset, Size, Flags
5 nvs, data, nvs, 0x9000, 0x5000,
6 otadata, data, ota, 0xe000, 0x2000,
7 app0, app, ota_0, 0x10000, 0x140000,
8 app1, app, ota_1, 0x150000, 0x140000,
9 littlefs, data, spiffs, 0x290000, 0x160000,
10 coredump, data, coredump,0x3F0000, 0x10000,
default_16MB.csv
+10
View File
@@ -0,0 +1,10 @@
# Partition table for ESP32-S3 N16R8V – 16 MB flash
# Generous app partitions + large LittleFS
#
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x5000,
otadata, data, ota, 0xe000, 0x2000,
app0, app, ota_0, 0x10000, 0x300000,
app1, app, ota_1, 0x310000, 0x300000,
littlefs, data, spiffs, 0x610000, 0x9E0000,
coredump, data, coredump,0xFF0000, 0x10000,
1 # Partition table for ESP32-S3 N16R8V – 16 MB flash
2 # Generous app partitions + large LittleFS
3 #
4 # Name, Type, SubType, Offset, Size, Flags
5 nvs, data, nvs, 0x9000, 0x5000,
6 otadata, data, ota, 0xe000, 0x2000,
7 app0, app, ota_0, 0x10000, 0x300000,
8 app1, app, ota_1, 0x310000, 0x300000,
9 littlefs, data, spiffs, 0x610000, 0x9E0000,
10 coredump, data, coredump,0xFF0000, 0x10000,
platformio.ini
+57
View File
@@ -0,0 +1,57 @@
; ============================================================
; PlatformIO configuration – LittleFS test
; Boards: esp32s3_zero | esp32s3_n16r8v
; ============================================================
[platformio]
default_envs = esp32s3_zero
; ─────────────────────────────────────────
; Common settings shared by all envs
; ─────────────────────────────────────────
[env]
platform = espressif32@6
framework = arduino
; LittleFS filesystem upload tool
board_build.filesystem = littlefs
; Serial monitor speed
monitor_speed = 115200
monitor_rts = 0
monitor_dtr = 0
; Build flags common to all targets
build_flags =
-DCORE_DEBUG_LEVEL=5
-DARDUINO_USB_CDC_ON_BOOT=1
; Pas de lib_deps : LittleFS est inclus dans espressif32@6 (framework-arduinoespressif32)
; #include <LittleFS.h> suffit
; ─────────────────────────────────────────
; Waveshare ESP32-S3-Zero
; Flash : 4 MB QIO / PSRAM : none
; ─────────────────────────────────────────
[env:esp32s3_zero]
board = waveshare_esp32_s3_zero
; Partition scheme with LittleFS (default_8MB has ota+littlefs)
board_build.partitions = default.csv
upload_speed = 921600
monitor_speed = 115200
; ─────────────────────────────────────────
; Generic ESP32-S3 N16R8V
; Flash : 16 MB QIO / PSRAM : 8 MB OPI
; ─────────────────────────────────────────
[env:esp32s3_n16r8v]
board = esp32-s3-devkitc-1
board_build.partitions = default_16MB.csv
board_upload.flash_size = 16MB
board_build.arduino.memory_type = qio_opi ; OPI PSRAM
upload_speed = 921600
monitor_speed = 115200
build_flags =
${env.build_flags}
-DBOARD_HAS_PSRAM
src/main.cpp
+328
View File
@@ -0,0 +1,328 @@
/**
* @file main.cpp
* @brief Test verbeux LittleFS sur ESP32-S3
*
* Séquence de tests :
* 1. Montage du système de fichiers LittleFS
* 2. Affichage des infos de la partition (total / utilisé / libre)
* 3. Écriture d'un fichier texte
* 4. Relecture et vérification du contenu
* 5. Écriture binaire (tableau d'octets)
* 6. Relecture binaire et vérification byte-à-byte
* 7. Listage du répertoire racine
* 8. Test d'append (ajout à un fichier existant)
* 9. Renommage de fichier
* 10. Suppression de tous les fichiers de test
* 11. Vérification de la suppression
* 12. Démontage propre
* 13. Résumé PASS / FAIL
*/
#include <Arduino.h>
#include <LittleFS.h>
// ──────────────────────────────────────────────────────────────
// Macros de log colorées (ANSI – visible dans un terminal VT100)
// ──────────────────────────────────────────────────────────────
#define CLR_RESET "\033[0m"
#define CLR_GREEN "\033[32m"
#define CLR_RED "\033[31m"
#define CLR_CYAN "\033[36m"
#define CLR_YELLOW "\033[33m"
#define CLR_BOLD "\033[1m"
#define LOG_INFO(fmt, ...) Serial.printf(" [INFO] " fmt "\r\n", ##__VA_ARGS__)
#define LOG_OK(fmt, ...) Serial.printf(CLR_GREEN " [ OK ] " fmt CLR_RESET "\r\n", ##__VA_ARGS__)
#define LOG_FAIL(fmt, ...) Serial.printf(CLR_RED " [FAIL] " fmt CLR_RESET "\r\n", ##__VA_ARGS__)
#define LOG_STEP(n, fmt, ...) \
Serial.printf(CLR_CYAN CLR_BOLD "\n── Étape %d : " fmt CLR_RESET "\r\n", n, ##__VA_ARGS__)
#define LOG_WARN(fmt, ...) Serial.printf(CLR_YELLOW " [WARN] " fmt CLR_RESET "\r\n", ##__VA_ARGS__)
// ──────────────────────────────────────────────────────────────
// Noms des fichiers de test
// IMPORTANT : ne pas utiliser FILE_WRITE / FILE_READ / FILE_APPEND
// comme noms de variables — ce sont des macros définies dans FS.h
// ("w", "r", "a"). On préfixe avec TEST_ pour éviter le conflit.
// ──────────────────────────────────────────────────────────────
static const char* TEST_FILE_TEXT = "/test_text.txt";
static const char* TEST_FILE_BIN = "/test_binary.bin";
static const char* TEST_FILE_APPEND = "/test_append.txt";
static const char* TEST_FILE_RENAMED = "/test_renamed.txt";
// ──────────────────────────────────────────────────────────────
// Compteurs globaux de tests
// ──────────────────────────────────────────────────────────────
static uint32_t g_pass = 0;
static uint32_t g_fail = 0;
// ──────────────────────────────────────────────────────────────
// Helpers
// ──────────────────────────────────────────────────────────────
static void check(bool condition, const char* label)
{
if (condition) {
LOG_OK("%s", label);
g_pass++;
} else {
LOG_FAIL("%s", label);
g_fail++;
}
}
/** Liste récursive d'un répertoire */
static void listDir(const char* path, uint8_t depth = 0)
{
File root = LittleFS.open(path);
if (!root || !root.isDirectory()) {
LOG_WARN("Impossible d'ouvrir le répertoire : %s", path);
return;
}
File entry = root.openNextFile();
while (entry) {
for (uint8_t i = 0; i < depth; i++) Serial.print(" ");
if (entry.isDirectory()) {
Serial.printf(" [DIR] %s\r\n", entry.name());
listDir(entry.path(), depth + 1);
} else {
Serial.printf(" [FIL] %-30s %6lu octets\r\n",
entry.name(), (unsigned long)entry.size());
}
entry = root.openNextFile();
}
}
/** Supprime un fichier et log le résultat */
static void removeFile(const char* path)
{
if (LittleFS.exists(path)) {
bool ok = LittleFS.remove(path);
LOG_INFO("Suppression de %s -> %s", path, ok ? "succes" : "ERREUR");
check(ok, String(String("remove(") + path + ")").c_str());
} else {
LOG_WARN("Fichier absent (skip remove) : %s", path);
}
}
// ──────────────────────────────────────────────────────────────
// setup()
// ──────────────────────────────────────────────────────────────
void setup()
{
Serial.begin(115200);
delay(2000); // Laisse le temps à l'hôte de s'connecter
Serial.println();
Serial.println(CLR_BOLD "╔════════════════════════════════════════╗" CLR_RESET);
Serial.println(CLR_BOLD "║ TEST LittleFS – ESP32-S3 ║" CLR_RESET);
Serial.println(CLR_BOLD "╚════════════════════════════════════════╝" CLR_RESET);
Serial.printf(" Compilé le : %s %s\r\n", __DATE__, __TIME__);
Serial.printf(" CPU Freq : %u MHz\r\n", (unsigned)(ESP.getCpuFreqMHz()));
Serial.printf(" Flash size : %u MB\r\n", (unsigned)(ESP.getFlashChipSize() / (1024*1024)));
Serial.printf(" Free heap : %u octets\r\n", (unsigned)ESP.getFreeHeap());
// ── Étape 1 : Montage ───────────────────────────────────────
LOG_STEP(1, "Montage de LittleFS");
bool mounted = LittleFS.begin(true); // true = formater si nécessaire
check(mounted, "LittleFS.begin()");
if (!mounted) {
LOG_FAIL("Abandon : impossible de monter LittleFS");
return;
}
// ── Étape 2 : Informations de la partition ───────────────────
LOG_STEP(2, "Informations de la partition");
size_t total = LittleFS.totalBytes();
size_t used = LittleFS.usedBytes();
size_t free_ = total - used;
LOG_INFO("Taille totale : %7u octets (%u KB)", (unsigned)total, (unsigned)(total/1024));
LOG_INFO("Utilisé : %7u octets (%u KB)", (unsigned)used, (unsigned)(used /1024));
LOG_INFO("Libre : %7u octets (%u KB)", (unsigned)free_, (unsigned)(free_/1024));
check(total > 0, "Partition non nulle");
// ── Étape 3 : Écriture texte ─────────────────────────────────
LOG_STEP(3, "Ecriture d'un fichier texte");
const char* textContent =
"Ligne 1 : Hello from LittleFS!\n"
"Ligne 2 : ESP32-S3 test ecriture / lecture.\n"
"Ligne 3 : Caracteres speciaux : eaü\n"
"Ligne 4 : Fin du fichier texte.\n";
{
File f = LittleFS.open(TEST_FILE_TEXT, "w"); // "w" = FILE_WRITE
check(f, "open(\"w\") - fichier texte");
if (f) {
size_t written = f.print(textContent);
LOG_INFO("Octets ecrits : %u / %u", (unsigned)written, (unsigned)strlen(textContent));
check(written == strlen(textContent), "Nombre d'octets ecrits correct");
f.close();
LOG_INFO("Fichier ferme : %s", TEST_FILE_TEXT);
}
}
// ── Étape 4 : Relecture et vérification texte ────────────────
LOG_STEP(4, "Relecture et verification du fichier texte");
{
File f = LittleFS.open(TEST_FILE_TEXT, "r"); // "r" = FILE_READ
check(f, "open(\"r\") - fichier texte");
if (f) {
String readBack = f.readString();
f.close();
LOG_INFO("Octets relus : %u", (unsigned)readBack.length());
bool match = (readBack == String(textContent));
check(match, "Contenu texte identique (round-trip)");
if (!match) {
LOG_FAIL("--- Attendu ---");
Serial.println(textContent);
LOG_FAIL("--- Obtenu ---");
Serial.println(readBack);
} else {
LOG_INFO("Apercu contenu :");
int lineCount = 0;
for (char c : readBack) {
Serial.print(c);
if (c == '\n' && ++lineCount >= 2) break;
}
Serial.println();
}
}
}
// ── Étape 5 : Écriture binaire ───────────────────────────────
LOG_STEP(5, "Ecriture d'un fichier binaire (256 octets)");
uint8_t binData[256];
for (int i = 0; i < 256; i++) binData[i] = (uint8_t)i; // 0x00 … 0xFF
{
File f = LittleFS.open(TEST_FILE_BIN, "w"); // "w" = FILE_WRITE
check(f, "open(\"w\") - fichier binaire");
if (f) {
size_t written = f.write(binData, sizeof(binData));
LOG_INFO("Octets ecrits : %u / %u", (unsigned)written, (unsigned)sizeof(binData));
check(written == sizeof(binData), "Nombre d'octets ecrits correct (binaire)");
f.close();
}
}
// ── Étape 6 : Relecture binaire byte-à-byte ──────────────────
LOG_STEP(6, "Relecture binaire et verification byte-a-byte");
{
File f = LittleFS.open(TEST_FILE_BIN, "r"); // "r" = FILE_READ
check(f, "open(\"r\") - fichier binaire");
if (f) {
check((size_t)f.size() == sizeof(binData), "Taille fichier binaire correcte");
uint8_t buf[256] = {0};
size_t bytesRead = f.read(buf, sizeof(buf));
f.close();
LOG_INFO("Octets relus : %u", (unsigned)bytesRead);
bool allMatch = (bytesRead == sizeof(binData));
uint32_t errors = 0;
for (size_t i = 0; i < bytesRead && i < sizeof(binData); i++) {
if (buf[i] != binData[i]) {
allMatch = false;
errors++;
if (errors <= 5)
LOG_FAIL("Byte[%u] attendu=0x%02X obtenu=0x%02X",
(unsigned)i, binData[i], buf[i]);
}
}
if (errors > 5)
LOG_FAIL("... et %u autre(s) erreur(s).", (unsigned)(errors - 5));
check(allMatch, "Contenu binaire identique (round-trip)");
}
}
// ── Étape 7 : Listage du répertoire ──────────────────────────
LOG_STEP(7, "Listage du répertoire racine");
LOG_INFO("Contenu de '/' :");
listDir("/");
// ── Étape 8 : Test d'append ───────────────────────────────────
LOG_STEP(8, "Test d'append (ajout a un fichier existant)");
{
// Première écriture
File f1 = LittleFS.open(TEST_FILE_APPEND, "w"); // "w" = FILE_WRITE
check(f1, "open(\"w\") - fichier append (creation)");
if (f1) { f1.println("Premiere ligne."); f1.close(); }
// Ajout
File f2 = LittleFS.open(TEST_FILE_APPEND, "a"); // "a" = FILE_APPEND
check(f2, "open(\"a\") - ajout");
if (f2) { f2.println("Deuxieme ligne ajoutee."); f2.close(); }
// Relecture
File f3 = LittleFS.open(TEST_FILE_APPEND, "r"); // "r" = FILE_READ
check(f3, "open(\"r\") - verification append");
if (f3) {
String content = f3.readString();
f3.close();
bool hasBoth = content.indexOf("Premiere") >= 0 &&
content.indexOf("Deuxieme") >= 0;
check(hasBoth, "Les deux lignes presentes apres append");
LOG_INFO("Contenu apres append :\n%s", content.c_str());
}
}
// ── Étape 9 : Renommage ───────────────────────────────────────
LOG_STEP(9, "Renommage de fichier");
{
bool renamed = LittleFS.rename(TEST_FILE_APPEND, TEST_FILE_RENAMED);
check(renamed, "rename() - succes");
check(!LittleFS.exists(TEST_FILE_APPEND), "Ancien nom absent apres rename");
check(LittleFS.exists(TEST_FILE_RENAMED), "Nouveau nom present apres rename");
}
// ── Étape 10 : Suppression ────────────────────────────────────
LOG_STEP(10, "Suppression de tous les fichiers de test");
removeFile(TEST_FILE_TEXT);
removeFile(TEST_FILE_BIN);
removeFile(TEST_FILE_RENAMED);
// ── Étape 11 : Vérification de la suppression ─────────────────
LOG_STEP(11, "Verification de l'absence des fichiers supprimes");
check(!LittleFS.exists(TEST_FILE_TEXT), "TEST_FILE_TEXT absent");
check(!LittleFS.exists(TEST_FILE_BIN), "TEST_FILE_BIN absent");
check(!LittleFS.exists(TEST_FILE_RENAMED), "TEST_FILE_RENAMED absent");
LOG_INFO("Contenu final du FS (doit être vide) :");
listDir("/");
// ── Étape 12 : Démontage ──────────────────────────────────────
LOG_STEP(12, "Démontage propre de LittleFS");
LittleFS.end();
LOG_OK("LittleFS.end() appelé");
// ── Étape 13 : Résumé ─────────────────────────────────────────
Serial.println();
Serial.println(CLR_BOLD "╔════════════════════════════════════════╗" CLR_RESET);
Serial.println(CLR_BOLD "║ RÉSUMÉ DES TESTS ║" CLR_RESET);
Serial.println(CLR_BOLD "╠════════════════════════════════════════╣" CLR_RESET);
Serial.printf( CLR_BOLD "║ " CLR_GREEN "PASS : %-3u" CLR_BOLD " " CLR_RED "FAIL : %-3u" CLR_BOLD " ║\r\n" CLR_RESET,
(unsigned)g_pass, (unsigned)g_fail);
Serial.println(CLR_BOLD "╠════════════════════════════════════════╣" CLR_RESET);
if (g_fail == 0) {
Serial.println(CLR_BOLD CLR_GREEN "║ ✔ Tous les tests sont PASSÉS ! ║" CLR_RESET);
} else {
Serial.printf( CLR_BOLD CLR_RED "║ ✘ %2u test(s) en ÉCHEC ! ║\r\n" CLR_RESET,
(unsigned)g_fail);
}
Serial.println(CLR_BOLD "╚════════════════════════════════════════╝" CLR_RESET);
}
// ──────────────────────────────────────────────────────────────
// loop() – rien à faire, on clignote juste la LED interne
// ──────────────────────────────────────────────────────────────
void loop()
{
// LED built-in sur la plupart des boards ESP32-S3 : GPIO 48 ou 21
// On clignote pour indiquer que le firmware tourne toujours.
#ifdef LED_BUILTIN
static bool ledState = false;
digitalWrite(LED_BUILTIN, ledState ? HIGH : LOW);
ledState = !ledState;
delay(g_fail == 0 ? 500 : 100); // lent = OK, rapide = erreur
#else
delay(1000);
#endif
}