Arduino tutoriel : La mémoire EEPROM

Mise à jour le 18/11/2021 : Le but de ces tutoriels doivent vous permettre de vous familiarisez avec le stokage de données dans la mémoire EEPROM de votre carte Arduino

Sommaire :

Taille de la mémoire EEPROM de la famille Arduino
Bibliothèque EEPROM et ses fonctions.
- EEPROM Clear
- EEPROM Read . Lit l’EEPROM et envoie ses valeurs à l’ordinateur.
  - Exemple de programme pour la fonction read
- EEPROM Write
- EEPROM Crc
- EEPROM Get
- EEPROM Iteration
- EEPROM Put . écrire tout type de variable du langage Arduino, pouvant s’étaler sur 1 ou 2 ou encore plus d’octets
- EEPROM Update
Visualisation des premiers 512 octets en EEPROM dans une carte Arduino
Retour au menu le langage Arduino

Taille de la mémoire de la famille Arduino

ATmega8	512 octets
ATmega168	512 octets
ATmega328P	1024 octets
ATmega1280	4 Ko (4096 octets)
ATmega2560	4 Ko (4096 octets)

Retour au sommaire

Bibliothèque EEPROM et ses fonctions

Le microcontrôleur de la carte basée sur Arduino et Genuino AVR a une EEPROM: mémoire dont les valeurs sont conservées lorsque la carte est éteinte (comme un petit disque dur). Cette bibliothèque vous permet de lire et d’écrire ces octets.

EEPROM Clear : Efface les octets de l’EEPROM.

Syntaxe :

Retour au sommaire

EEPROM Read : Lit l’EEPROM et envoie ses valeurs à l’ordinateur.

Syntaxe : EEPROM.read(adresse)

Exemple de programme pour la fonction read

//
//
//
//
//* Lecture d'une memoire EEPROM
//*
//* Lit la valeur de chaque octet de la mémoire EEPROM et l’affiche
//* sur le moniteur de l'ordinateur.
//* Cet exemple de code est dans le domaine public.
//*
//* un complement de commentaire a été réalisé par RedOhm
//* Herve Mazelin le 16/07/2019
//* 
//* Le lien https://www.arduino.cc/en/Tutorial/EEPROMRead

// Pour inclure la librairie EEPROM dans un programme, on ajoutera
// au début du programme la ligne suivante 
#include <EEPROM.h>

//
// Declaration de mes variables utiles pour le programme 
//
// la variable adresse possede la valeur de debut de memoire 
int address = 0;
// Declaration de la variable value en un octet 
// Un octet stocke un nombre non signé de 8 bits, compris entre 0 et 255.
byte value;


// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties

void setup() {
  // initialisation de la connexion série
  // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
  // dans notre programme 9600
  Serial.begin(9600);
  
  // Attendez que le port s'ouvre
  // Une while boucle bouclera continuellement et infiniment jusqu'à ce 
  // que l'expression entre parenthèses () devienne fausse.
  // Quelque chose doit changer la variable testée,
  // sinon la boucle while ne se fermera jamais
  while (!Serial)   {
    ; // attendez que le port série se connecte. 
      // Nécessaire pour le port USB natif uniquement
  }
  
}

// Le programme principal s’exécute par une boucle infinie appelée Loop 
void loop()
{
  // lit un octet à partir de l'adresse actuelle de la mémoire EEPROM
  value = EEPROM.read(address);
  Serial.print(address);
  Serial.print("\t");
  Serial.print(value, DEC);
  Serial.println();
  
  // on increment la variable adresse pour pouvoir lire l'ensemble 
  // de l'espace mémoire  
  address = address + 1;
  if (address == EEPROM.length()) {
    address = 0;
  }

  //Plutôt que de coder en dur la longueur, vous devriez utiliser 
  //la fonction de longueur pré-fournie.
  //Cela rendra votre code portable à tous les processeurs AVR.


  //Met le programme en pause pendant la durée (en millisecondes) 
  //spécifiée en tant que paramètre. (Il y a 1000 millisecondes 
  //dans une seconde.)
  delay (200);
  
  
}

//* Lecture d'une memoire EEPROM

//*

//* Lit la valeur de chaque octet de la mémoire EEPROM et l’affiche

//* sur le moniteur de l'ordinateur.

//* Cet exemple de code est dans le domaine public.

//*

//* un complement de commentaire a été réalisé par RedOhm

//* Herve Mazelin le 16/07/2019

//*

//* Le lien https://www.arduino.cc/en/Tutorial/EEPROMRead

// Pour inclure la librairie EEPROM dans un programme, on ajoutera

// au début du programme la ligne suivante

#include <EEPROM.h>

// Declaration de mes variables utiles pour le programme

// la variable adresse possede la valeur de debut de memoire

int address = 0;

// Declaration de la variable value en un octet

// Un octet stocke un nombre non signé de 8 bits, compris entre 0 et 255.

byte value;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

// dans notre programme 9600

Serial.begin(9600);

// Attendez que le port s'ouvre

// Une while boucle bouclera continuellement et infiniment jusqu'à ce

// que l'expression entre parenthèses () devienne fausse.

// Quelque chose doit changer la variable testée,

// sinon la boucle while ne se fermera jamais

while (!Serial) {

; // attendez que le port série se connecte.

// Nécessaire pour le port USB natif uniquement

}

// Le programme principal s’exécute par une boucle infinie appelée Loop

void loop()

{

// lit un octet à partir de l'adresse actuelle de la mémoire EEPROM

value = EEPROM.read(address);

Serial.print(address);

Serial.print("\t");

Serial.print(value, DEC);

Serial.println();

// on increment la variable adresse pour pouvoir lire l'ensemble

// de l'espace mémoire

address = address + 1;

if (address == EEPROM.length()) {

address = 0;

}

//Plutôt que de coder en dur la longueur, vous devriez utiliser

//la fonction de longueur pré-fournie.

//Cela rendra votre code portable à tous les processeurs AVR.

//Met le programme en pause pendant la durée (en millisecondes)

//spécifiée en tant que paramètre. (Il y a 1000 millisecondes

//dans une seconde.)

delay (200);

}

Retour au sommaire

EEPROM Write : Enregistre les valeurs dans l’EEPROM.

Syntaxe : EEPROM.write ( adresse , val ) ;

addresse : l’adresse (=localisation) de l’octet à écrire, de 0 à 511 (type int)

val : l’octet à écrire à l’emplacement indiqué, entre 0 to 255 (type byte)

Exemple de programme pour la fonction write

//
//
//
//* ecriture d'une memoire EEPROM
//* Stocke les valeurs lues depuis l'entrée analogique 0 dans l'EEPROM.
//* Ces valeurs resteront dans l’EEPROM lorsque le tableau sera
//* désactivé et peut être récupéré plus tard par un autre croquis
//*
//*
//* Cet exemple de code est dans le domaine public.
//*
//* un complement de commentaire a été réalisé par RedOhm
//* Herve Mazelin le 18/07/2019
//* 
//* Le lien https://www.arduino.cc/en/Tutorial/EEPROMWrite


// Pour inclure la librairie EEPROM dans un programme, on ajoutera
// au début du programme la ligne suivante 
#include <EEPROM.h>



//
// Declaration de mes variables utiles pour le programme 
//

// forcage 0 de l'adresse pour ecrire dans la mémoire EEPROM 
// (c'est-à-dire l'octet sur lequel nous allons écrire)
int addr = 0;



// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
void setup()
{
  
}

// Le programme principal s’exécute par une boucle infinie appelée Loop
void loop() {

//Nous avons besoin de diviser par 4 la valeur ,car les entrées analogiques
//vont de 0 à 1023 et chaque octet de la mémoire EEPROM ne peut contenir
//qu'une valeur de 0 à 255 ..
  int val = analogRead(0) / 4;

// Ecrivez la valeur dans l'octet approprié de la mémoire EEPROM.
// Ces valeurs resteront dans l'espace mémoire même la carte éteinte
  EEPROM.write(addr, val);

  
// Plutôt que de coder en dur la longueur, vous devriez utiliser 
// la fonction de longueur pré-fournie.
// Cela rendra votre code portable à tous les processeurs AVR.
  
  addr = addr + 1;
  if (addr == EEPROM.length()) {
    addr = 0;
  }

  

  delay(100);
}

//* ecriture d'une memoire EEPROM

//* Stocke les valeurs lues depuis l'entrée analogique 0 dans l'EEPROM.

//* Ces valeurs resteront dans l’EEPROM lorsque le tableau sera

//* désactivé et peut être récupéré plus tard par un autre croquis

//*

//* Cet exemple de code est dans le domaine public.

//*

//* un complement de commentaire a été réalisé par RedOhm

//* Herve Mazelin le 18/07/2019

//*

//* Le lien https://www.arduino.cc/en/Tutorial/EEPROMWrite

// Pour inclure la librairie EEPROM dans un programme, on ajoutera

// au début du programme la ligne suivante

#include <EEPROM.h>

// Declaration de mes variables utiles pour le programme

// forcage 0 de l'adresse pour ecrire dans la mémoire EEPROM

// (c'est-à-dire l'octet sur lequel nous allons écrire)

int addr = 0;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécutée qu'une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup()

{

}

// Le programme principal s’exécute par une boucle infinie appelée Loop

void loop() {

//Nous avons besoin de diviser par 4 la valeur ,car les entrées analogiques

//vont de 0 à 1023 et chaque octet de la mémoire EEPROM ne peut contenir

//qu'une valeur de 0 à 255 ..

int val = analogRead(0) / 4;

// Ecrivez la valeur dans l'octet approprié de la mémoire EEPROM.

// Ces valeurs resteront dans l'espace mémoire même la carte éteinte

EEPROM.write(addr, val);

// Plutôt que de coder en dur la longueur, vous devriez utiliser

// la fonction de longueur pré-fournie.

// Cela rendra votre code portable à tous les processeurs AVR.

addr = addr + 1;

if (addr == EEPROM.length()) {

addr = 0;

}

delay(100);

}

Retour au sommaire

EEPROM Crc : Calcule le CRC du contenu de l’EEPROM comme s’il s’agissait d’un tableau.
Un CRC est un moyen simple de vérifier si les données ont été modifiées ou sont corrompues.

EEPROM Get : Extrait les valeurs de l’EEPROM et imprime sous forme de float en série.

EEPROM Iteration : Comprendre comment parcourir les emplacements de mémoire EEPROM.

EEPROM Put : Mettez des valeurs dans EEPROM en utilisant une sémantique de variable.

EEPROM Update : stocke les valeurs lues dans EEPROM, en écrivant la valeur uniquement si elle est différente afin d’augmenter la durée de vie de l’EEPROM.

Retour au sommaire

Visualisation des premiers 512 octets en EEPROM dans une carte Arduino

//
//
//********************************************************************
//
// But : Visualisation des premiers 512 octets en EEPROM dans 
//       une carte Arduino
//
// A savoir : quantité de mémoire EEPROM sur un Atmega2560
//  4Ko (4096 octets)de disponible
//
// RedOhm : 
// Hervé Mazelin
// Le 14/07/2019
//
//********************************************************************
 
// Pour inclure la librairie EEPROM dans un programme, on ajoutera
// au début du programme la ligne suivante 
#include <EEPROM.h>

// Declaration de mes variables utile pour le programme 
int adresse = 0 ;
int ligne =0;
int compt = 0;
int compt1 = 19 ;

// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécuter une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
void setup() {

// initialisation de la connexion série
// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
// dans notre programme 9600
Serial.begin(9600);
// Arret du programme pendant 1mm
delay (1000);
Serial.println(" ========================================================");
Serial.println("    Affichage des adresses et des valeurs se trouvant    "); 
Serial.println("                     dans EEPROM                         ");
Serial.println(" ========================================================");


 Serial.println("    ");
   Serial.print("      ");

  // Preparation du comptage des colonnes de 0 a 9
  for ( compt =0; compt <= 9 ; compt++)
  {
  Serial.print(" ");
   Serial.print(compt);
    Serial.print("  ");
  }

  // Preparation du comptage des colonnes de 10 a 20
  for ( compt = 10 ; compt <= 19 ; compt++)
  {
  Serial.print(" ");
   Serial.print(compt);
    Serial.print(" ");
  }  

  // Position du numero 0
  Serial.println("");
  Serial.print("  "); 
   Serial.print(adresse);
    Serial.print("   ");
    
  for ( adresse =0; adresse <= 511 ; adresse++)
  {
    // commence à lire le premier octet (adresse 0) de la mémoire EEPROM 
    // conversion au format int pour affichage valeur numérique
    Serial.print(int(EEPROM.read(adresse)));
    Serial.print(" ");
    delay (100);
    if (( adresse == compt1)&(adresse <= 99))
      { 
        Serial.println("");
        Serial.print(" ");
        Serial.print(adresse);
        Serial.print("   ");
        compt1 =compt1+20 ;
      }
    // affichage des adresses au-dessus de 99  
    else if (adresse == compt1)
        {        
        Serial.println("");
        Serial.print(" ");
        Serial.print(adresse);
        Serial.print("  ");
        compt1 =compt1+20 ;
        }
       
  }
 


}

// Le programme principal s’exécute par une boucle infinie appelée Loop 
void loop() {


  
}

100

101

102

103

104

105

//********************************************************************

// But : Visualisation des premiers 512 octets en EEPROM dans

// une carte Arduino

// A savoir : quantité de mémoire EEPROM sur un Atmega2560

// 4Ko (4096 octets)de disponible

// RedOhm :

// Hervé Mazelin

// Le 14/07/2019

//********************************************************************

// Pour inclure la librairie EEPROM dans un programme, on ajoutera

// au début du programme la ligne suivante

#include <EEPROM.h>

// Declaration de mes variables utile pour le programme

int adresse = 0 ;

int ligne =0;

int compt = 0;

int compt1 = 19 ;

// Un programme Arduino doit impérativement contenir la fonction "setup"

// Elle ne sera exécuter une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup() {

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

// dans notre programme 9600

Serial.begin(9600);

// Arret du programme pendant 1mm

delay (1000);

Serial.println(" ========================================================");

Serial.println(" Affichage des adresses et des valeurs se trouvant ");

Serial.println(" dans EEPROM ");

Serial.println(" ========================================================");

Serial.println(" ");

Serial.print(" ");

// Preparation du comptage des colonnes de 0 a 9

for ( compt =0; compt <= 9 ; compt++)

{

Serial.print(" ");

Serial.print(compt);

Serial.print(" ");

}

// Preparation du comptage des colonnes de 10 a 20

for ( compt = 10 ; compt <= 19 ; compt++)

{

Serial.print(" ");

Serial.print(compt);

Serial.print(" ");

}

// Position du numero 0

Serial.println("");

Serial.print(" ");

Serial.print(adresse);

Serial.print(" ");

for ( adresse =0; adresse <= 511 ; adresse++)

{

// commence à lire le premier octet (adresse 0) de la mémoire EEPROM

// conversion au format int pour affichage valeur numérique

Serial.print(int(EEPROM.read(adresse)));

Serial.print(" ");

delay (100);

if (( adresse == compt1)&(adresse <= 99))

{

Serial.println("");

Serial.print(" ");

Serial.print(adresse);

Serial.print(" ");

compt1 =compt1+20 ;

}

// affichage des adresses au-dessus de 99

else if (adresse == compt1)

{

Serial.println("");

Serial.print(" ");

Serial.print(adresse);

Serial.print(" ");

compt1 =compt1+20 ;

}

// Le programme principal s’exécute par une boucle infinie appelée Loop

void loop() {

}

EEPROM vue des premiers 512 octets

Retour au sommaire