1. Objectif pédagogique

À la fin de ce cours, vous saurez :

• Comprendre le rôle et les limites de l’EEPROM interne d’un Arduino.
• Lire et écrire des données persistantes avec EEPROM.read() et EEPROM.write().
• Optimiser les écritures avec EEPROM.update().
• Sauvegarder et relire des variables complètes avec EEPROM.put() et EEPROM.get().
• Créer un projet simple qui conserve ses paramètres après extinction.

Précaution à prendre

En quelque minutes les cellules EEPROM peuvent se détérioré et altéré votre carte.

2. Présentation de L'EEPROM

Qu’est‑ce que l’EEPROM ?
L’EEPROM (Electrically Erasable Programmable Read-Only Memory) est une mémoire non volatile : elle garde les données même sans alimentation.

Caractéristiques :

• Capacité limitée : ex. 1024 octets sur un Arduino Uno.
• Accès octet par octet ou via des variables complètes.
• Durée de vie ~100 000 écritures par cellule (éviter les écritures inutiles).

Applications : sauvegarde de paramètres, compteurs, scores, restauration d’état après redémarrage.

3. Matériel nécessaire

• Arduino Uno (ou Nano, Mega…)
• Câble USB
• (Optionnel) Bouton poussoir + résistance 10 kΩ
• (Optionnel) LED + résistance 220 Ω

Schéma minimaliste : pour les premiers exemples, aucun câblage n’est requis.

4. Explication du fonctionnement

L’EEPROM est organisée en cases numérotées (adresses). Chaque case stocke un octet (0–255). Imaginez un meuble avec 1024 tiroirs : chaque tiroir peut contenir un petit papier avec un nombre. Quand vous éteignez l’Arduino, les papiers restent en place.

5. Premier code minimaliste

Exemple simple : écrire puis lire un octet à l’adresse 0.

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);

  // Écrire 42 à l'adresse 0
  EEPROM.write(0, 42);

  // Lire la valeur stockée à l'adresse 0
  byte valeur = EEPROM.read(0);

  Serial.print("Valeur lue : ");
  Serial.println(valeur);
}

void loop() {
  // Vide
}

Ce que fait ce code : écrit le nombre 42 à l'adresse 0, puis le relit et l'affiche sur le moniteur série.

6. Décryptage du code

• #include <EEPROM.h> : active la bibliothèque EEPROM.
• EEPROM.write(adresse, valeur) : écrit un octet.
• EEPROM.read(adresse) : lit un octet.
• Les adresses vont de 0 à EEPROM.length()-1.
• Erreur fréquente : écrire trop souvent (surtout dans loop()) use la mémoire.

7. Expérimentation guidée

Propositions faciles :

• Changer la valeur écrite (ex. EEPROM.write(0, 100)).
• Utiliser une autre adresse (ex. adresse 10).
• Écrire plusieurs valeurs et les relire.

8. Fonctions avancées

En complément de read() et write(), Arduino fournit :

EEPROM.update(adresse, valeur)

Écrit seulement si la valeur est différente de celle déjà stockée — utile pour économiser les cycles d'écriture.

#include <EEPROM.h>

void setup() {
  Serial.begin(9600);
  EEPROM.update(0, 42); // Écrit seulement si nécessaire
  Serial.println("Valeur mise à jour !");
}

void loop() {}

EEPROM.put(adresse, variable)

Permet d'enregistrer une variable complète (int, float, struct...) en une seule instruction.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  info.compteur = 123;
  info.temperature = 24.5;
  EEPROM.put(0, info);
  Serial.println("Données sauvegardées !");
}

void loop() {}

EEPROM.get(adresse, variable)

Lit directement une variable complète depuis l'EEPROM (complément de put).

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees info;

void setup() {
  Serial.begin(9600);
  EEPROM.get(0, info);
  Serial.print("Compteur : ");
  Serial.println(info.compteur);
  Serial.print("Température : ");
  Serial.println(info.temperature);
}

void loop() {}

Astuce : put() et get() gèrent automatiquement la taille en octets — attention à la place restante dans l'EEPROM.

9. Vérification avant écriture dans l’EEPROM

Avant d’enregistrer une donnée en mémoire EEPROM, il est essentiel de vérifier que sa valeur a réellement changé. En effet, si la donnée est identique à celle déjà stockée, une réécriture inutile détériorera prématurément la cellule mémoire, qui ne supporte qu’un nombre limité de cycles d’écriture. Pour protéger la durée de vie de l’EEPROM, il faut donc ajouter systématiquement une étape de vérification avant d’écrire.

Voici un exemple fiable et simple, utilisable pour tout type de donnée basique (comme un octet) :

#include <EEPROM.h>

int adresse = 0;         // Adresse mémoire EEPROM
byte nouvelleValeur = 42; // Valeur à écrire

void setup() {
  Serial.begin(9600);

  // Lire la valeur actuelle dans l’EEPROM
  byte ancienneValeur = EEPROM.read(adresse);

  // Vérifier si la valeur a changé avant d’écrire
  if (ancienneValeur != nouvelleValeur) {
    EEPROM.write(adresse, nouvelleValeur);
    Serial.println("Valeur mise à jour dans l’EEPROM.");
  } else {
    Serial.println("Valeur identique, écriture évitée pour préserver l’EEPROM.");
  }
}

void loop() {
  // Rien ici
}

Cette méthode simple protège efficacement l’EEPROM contre les écritures redondantes et prolonge sa durée de vie.

Exemple fiable de vérification avant écriture avec EEPROM.get() et EEPROM.put()

Pour éviter d’écrire inutilement dans l’EEPROM une structure Donnees, on peut comparer la donnée à écrire avec celle déjà stockée, puis n’écrire que si elles diffèrent.

#include <EEPROM.h>

struct Donnees {
  int compteur;
  float temperature;
};

Donnees infoNew;  // Nouvelle donnée à sauvegarder
Donnees infoOld;  // Donnée lue depuis EEPROM

void setup() {
  Serial.begin(9600);
  delay(1000); // Attente pour le moniteur série

  // Initialisation des nouvelles données
  infoNew.compteur = 123;
  infoNew.temperature = 24.5;

  // Lire la donnée existante dans EEPROM à l'adresse 0
  EEPROM.get(0, infoOld);

  // Comparer byte à byte pour vérifier si les données ont changé
  if (memcmp(&infoNew, &infoOld, sizeof(Donnees)) != 0) {
    EEPROM.put(0, infoNew);
    Serial.println("Données mises à jour dans l’EEPROM.");
  } else {
    Serial.println("Données identiques, écriture évitée.");
  }
}

void loop() {
  // Rien ici
}

10. Résumé

• Lecture/écriture d'octets : read() / write().
• Éviter les écritures inutiles : update().
• Stocker/charger des variables complètes : put() / get().
• Penser à la taille disponible et à l'usure des cellules.

Ressources complémentaires

• Documentation officielle : arduino.cc — EEPROM
• Bibliothèque EEPROM.h incluse par défaut
• Conseil pratique : limiter les écritures inutiles pour préserver la mémoire