Explication de l’EEPROM Arduino | Tutoriel

Ce tutoriel explique ce qu’est l’EEPROM Arduino et à quoi elle sert. Nous allons également vous montrer comment écrire et lire à partir de l’EEPROM et construire un exemple de projet pour mettre en pratique les concepts appris.

Nous avons un tutoriel similaire pour l’ESP32 : Mémoire Flash ESP32 – Stocker des données permanentes (écriture et lecture)

introduction

Lorsque vous définissez et utilisez une variable, les données générées dans une esquisse ne durent que tant que l’Arduino est allumé. Si vous réinitialisez ou éteignez l’Arduino, les données stockées disparaissent.

Si vous souhaitez conserver les données stockées pour une utilisation future, vous devez utiliser l’EEPROM Arduino. Cela stocke les données de la variable même lorsque l’Arduino se réinitialise ou que l’alimentation est coupée.

Qu’est-ce qu’une EEPROM ?

Le microcontrôleur sur la carte Arduino (ATMEGA328 dans le cas d’Arduino UNO, illustré dans la figure ci-dessous) possède une EEPROM (Electrically Erasable Programmable Read-Only Memory). Il s’agit d’un petit espace qui peut stocker des variables d’octets.

Les variables stockées dans l’EEPROM y sont conservées, événement lorsque vous réinitialisez ou éteignez l’Arduino. Simplement, l’EEPROM est un stockage permanent similaire à un disque dur dans les ordinateurs.

L’EEPROM peut être lue, effacée et réécrite électroniquement. Dans Arduino, vous pouvez facilement lire et écrire à partir de l’EEPROM en utilisant le EEPROM bibliothèque.

Combien d’octets pouvez-vous stocker ?

Chaque position EEPROM peut enregistrer un octet, ce qui signifie que vous ne pouvez stocker que des nombres de 8 bits, qui incluent des valeurs entières comprises entre 0 et 255.

Les octets que vous pouvez stocker sur EEPROM dépendent des microcontrôleurs sur les cartes Arduino. Jetez un œil au tableau ci-dessous :

Cependant, si vous avez besoin de stocker plus de données, vous pouvez vous procurer une EEPROM externe.

La durée de vie finie de l’EEPROM

L’EEPROM a une durée de vie limitée. Dans Arduino, l’EEPROM est spécifiée pour gérer 100 000 cycles d’écriture/effacement pour chaque position. Cependant, les lectures sont illimitées. Cela signifie que vous pouvez lire à partir de l’EEPROM autant de fois que vous le souhaitez sans compromettre sa durée de vie.

Applications dans les projets Arduino – Mémoriser le dernier état

L’EEPROM est utile dans les projets Arduino qui doivent conserver des données même lorsque l’Arduino se réinitialise ou lorsque l’alimentation est coupée.

Il est particulièrement utile de se souvenir du dernier état d’une variable ou de se souvenir du nombre de fois qu’un appareil a été activé.

Par exemple, imaginez le scénario suivant :

• Vous contrôlez une lampe avec votre Arduino et la lampe est allumée ;
• L’Arduino perd soudainement de la puissance ;
• Lorsque l’alimentation est rétablie, la lampe reste éteinte – elle ne conserve pas son dernier changement.

Vous ne voulez pas que cela se produise. Vous voulez que l’Arduino se souvienne de ce qui se passait avant de perdre de l’alimentation et revienne au dernier état.

Pour résoudre ce problème, vous pouvez enregistrer l’état de la lampe dans l’EEPROM et ajouter une condition à votre croquis pour vérifier dans un premier temps si l’état de la lampe correspond à l’état précédemment enregistré dans l’EEPROM.

Nous illustrerons cela avec un exemple plus loin dans cet article dans l’exemple : L’EEPROM Arduino se souvient de l’état de la LED stockée.

Lire et écrire

Vous pouvez facilement lire et écrire dans l’EEPROM en utilisant le EEPROM bibliothèque.

Pour inclure la bibliothèque EEPROM :

#include <EEPROM.h>

Écrivez

Pour écrire des données dans l’EEPROM, vous utilisez le EEPROM.écrire() fonction qui prend deux arguments. Le premier est l’emplacement ou l’adresse EEPROM où vous souhaitez enregistrer les données, et le second est la valeur que nous voulons enregistrer :

EEPROM.write(address, value);

Par exemple, pour écrire 9 sur l’adresse 0, vous aurez :

EEPROM.write(0, 9);

Lire

Pour lire un octet de l’EEPROM, vous utilisez le EEPROM.lire() une fonction. Cette fonction prend l’adresse de l’octet en argument.

EEPROM.read(address);

Par exemple, pour lire l’octet stocké précédemment à l’adresse 0. :

EEPROM.read(0);

Cela reviendrait 9, qui est la valeur stockée à cet emplacement.

Mettre à jour une valeur

le EEPROM.mise à jour() fonction est particulièrement utile. Il n’écrit sur l’EEPROM que si la valeur écrite est différente de celle déjà enregistrée.

Comme l’EEPROM a une espérance de vie limitée en raison de cycles d’écriture/effacement limités, l’utilisation du EEPROM.mise à jour() fonction au lieu de EEPROM.écrire() économise des cycles.

Vous utilisez le EEPROM.mise à jour() fonctionnent comme suit :

EEPROM.update(address, value);

Pour le moment, nous en avons 9 stockés à l’adresse 0. Donc, si nous appelons :

EEPROM.update(0, 9);

Il n’écrira plus sur l’EEPROM, car la valeur actuellement enregistrée est la même que celle que nous voulons écrire.

Exemple : l’EEPROM Arduino se souvient de l’état de la LED stockée

Dans cet exemple, nous allons vous montrer comment faire en sorte que l’Arduino se souvienne de l’état de la LED stockée, même lorsque nous réinitialisons l’Arduino ou que l’alimentation est coupée.

La figure suivante montre ce que nous allons illustrer :

Pièces nécessaires

Voici les pièces requises pour ce projet (cliquez sur les liens ci-dessous pour trouver le meilleur prix à Conseiller Maker):

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schémas

Voici les schémas de circuit pour ce projet. Il s’agit simplement d’un bouton-poussoir qui allume et éteint une LED.

Code

Copiez le code suivant dans l’IDE Arduino et téléchargez-le sur votre carte Arduino. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM.

/*
 * Rui Santos 
 * Complete Project Details https://www.raspberryme.com
 */

#include <EEPROM.h>

const int buttonPin = 8;    // pushbutton pin
const int ledPin = 4;       // LED pin

int ledState;                // variable to hold the led state
int buttonState;             // the current reading from the input pin
int lastButtonState = LOW;   // the previous reading from the input pin


// the following variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 50;    // the debounce time; increase if the output flickers

void setup() {
  // set input and output
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);

  // initialize serial monitor
  Serial.begin (9600);

  //check stored LED state on EEPROM using function defined at the end of the code
  checkLedState(); 
}

void loop() {
  // read the state of the switch into a local variable
  int reading = digitalRead(buttonPin);

  if(reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if(reading != buttonState) {
      buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if(buttonState == HIGH) {
        ledState = !ledState;
      }
    }
  }

  // set the LED state
  digitalWrite(ledPin, ledState);
  // save the current LED state in the EEPROM
  EEPROM.update(0, ledState);
  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState
  lastButtonState = reading;
}

// Prints and upates the LED state
// when the Arduino board restarts or powers up
void checkLedState() {
   Serial.println("LED status after restart: ");
   ledState = EEPROM.read(0);
   if(ledState == 1) {
    Serial.println ("ON");
    digitalWrite(ledPin, HIGH);
   } 
   if(ledState == 0) {
    Serial.println ("OFF");
    digitalWrite(ledPin, LOW);
   }
}

Afficher le code brut

Il s’agit d’un code anti-rebond qui change l’état de la LED chaque fois que vous appuyez sur le bouton-poussoir. Mais il y a quelque chose de spécial à propos de ce code – il se souvient de l’état de la LED enregistrée, même après la réinitialisation ou la mise sous tension de l’Arduino.

Fondamentalement, nous enregistrons l’état actuel de la LED dans le étatled variable et enregistrez-la dans l’EEPROM avec la ligne suivante :

EEPROM.update(0,ledState);

Au début du code sur le mettre en place(), nous vérifions le étatled enregistré sur EEPROM et allumez ou éteignez la led en fonction de cet état lorsque nous redémarrons le programme. Nous faisons cela avec une fonction que nous avons créée à la fin du code, checkLedState()

void checkLedState() {
    Serial.println("LED status after restart: ");
    ledState = EEPROM.read(0);
     if (ledState == 1) {
       Serial.println ("ON");
       digitalWrite(ledPin, HIGH);
     } 
     if (ledState == 0) {
       Serial.println ("OFF");
       digitalWrite(ledPin, LOW);
     }
}

Manifestation

Pour une démonstration de cet exemple, regardez la vidéo ci-dessous.

Conclusion

Dans cet article, vous avez découvert l’EEPROM Arduino et son utilité. Vous avez créé une esquisse Arduino qui se souvient du dernier état de la LED même après la réinitialisation de l’Arduino.

Ceci est juste un exemple simple pour vous permettre de comprendre comment l’utilisation de l’EEPROM. L’idée est que vous appliquiez les concepts appris dans ce didacticiel à vos propres projets.

Si vous aimez Arduino, nous vous recommandons de jeter un œil à nos ressources Arduino :

Nous espérons que vous avez trouvé cet article utile.

Merci d’avoir lu.