Logiciels - Programmation PIC - Bases

Logiciels > Programmation PIC > Bases > MP > Lecture / écriture en EEProm

Dernière mise à jour : 29/07/2009

Présentation

Les exemples décrits ici montrent comment stocker une valeur donnée dans la mémoire EEProm interne d'un PIC, et comment relire cette valeur plus tard, après une coupure d'alimentation par exemple.

Qu'est-ce qu'une EEProm ?

Une EEProm est une mémoire dans laquelle on peut écrire des données, et où les données stockées peuvent être effacées et remplacées par d'autres, à l'aide de commandes électriques. Pas besoin de disposer d'un effaceur à ultra-violet (UV) pour effacer son contenu, comme c'est le cas des EPROM avec fenêtre à quartz. La durée de rétention des données stockées dans l'EEProm est estimée à une centaine d'années, et le nombre de cycles d'écriture est estimé à un million. La taille de la mémoire EEProm dépend du PIC, elle peut être de 128 octets pour un 16F627A ou 16F628A, ou de 256 octets pour un 16F648A ou 18F2520.

Quel type de données peut-on sauver en EEProm ?

Chaque "cellule" de stockage de l'EEProm a une taille de 8 bits, pour chacune il s'agit d'un octet. Les procédures mises à disposition dans MikroPascal pour stocker ou lire des données dans l'EEProm opèrent octet par octet, ce qui est fort pratique pour stocker... des octets. Mais vous pouvez fort bien utiliser les 8 bits d'un octet de façon individuelle, pour par exemple stocker 8 informations binaire dans une seule et même cellule d'un octet. Vous pouvez aussi stocker une donnée plus large qui dépasse la taille d'un octet, par exemple une variable de type word nécessitant 16 bits pour pouvoir être manipulée. Pour cela, il suffit de découper en deux la variable word (16 bits) pour disposer de deux informations de type Octet (8 bits) qui peuvent alors être stockées dans deux cellules de la mémoire EEProm. Pour récupérer cette information par la suite, il suffit de relire les deux informations de 8 bits et de les raccomoder pour reconstituer le mot (Word) de 16 bits d'origine. Les exemples donnés par la suite montrent comment stocker et lire des données de 1 bit, des données de 8 bits, et des données de 16 bits.

Ecriture / lecture d'une donnée de 8 bits (un octet)

L'exemple suivant montre comment écrire une valeur tenant dans un octet (valeur comprise entre 0 et 255), dans une cellule mémoire de l'EEProm interne d'un PIC de type 16F628A, mais cette méthode s'applique à tous les PIC qui possèdent une telle EEProm. Quatre boutons poussoirs et une led sont mis en oeuvre.

Le schéma électronique

Le schéma qui suit est complet, mais les deux broches d'alimentation du PIC ne sont pas représentées. La borne 4 n'est reliée à rien car la configuration du PIC indique que cette broche doit être utilisée en tant qu'entrée / sortie normale (RA5) et non en tant qu'entrée de remise à zéro générale (MCLR).

pic_tuto_base_eeprom_001a

Le fonctionnement général du circuit est le suivant :
- selon le bouton poussoir enfoncé (SW1, SW2, SW3 ou SW4), une valeur différente est stockée en EEProm (valeur 1, 2, 3 ou 4), toujours dans la même zone mémoire. Valeur 1 si bouton poussoir SW1 enfoncé, valeur 2 si bouton poussoir SW2 enfoncé, etc. Au moment de l'appui sur un bouton poussoir, la led clignote un nombre de fois qui correspond au numéro du bouton : une fois si SW1 enfoncé, deux fois si SW2 enfoncé, etc.
- lors de la mise sous tension du circuit, la led clignote un nombre de fois égal à la valeur attachée au dernier bouton poussoir enfoncé. Ainsi, si on appui sur SW3, que l'on met hors tension le montage et qu'on le rallume, la led D1 clignote 3 fois. Pour cet exercice, le port A est configuré en sortie et le port B est configuré en entrée (voir au besoin PIC - Bases - Configuration minimale), et la lecture des boutons poussoir est assurée par la routine Button de MikroPascal (voir au besoin PIC - Bases - Lecture poussoir). La sauvegarde et le rappel des données stockées en EEProm sont assurés par les fonctions EEProm_Write et EEProm_Read.

Le logiciel

Le code ci-dessous correspond au programme complet.

program electronique_pic_tuto_base_eeprom_001a;
 
var
  iValue: byte;
 
// initialisation générale
procedure Init;
begin
  TRISA := %00000000; // port A configuré en sortie
  TRISB := %11111111; // port B configuré en entrée
  CMCON := $07; // désactivation comparateurs
  OPTION_REG.NOT_RBPU := 0; // mise en service pullup
  iValue := 0;
end;
 
// clignotement led
procedure Led_Blink(iCount: byte);
var
  i: byte;
begin
  for i := 1 to iCount do
  begin
    PORTA.0 := 1;
    Delay_ms(200);
    PORTA.0 := 0;
    Delay_ms(200);
  end;
end;
 
// sauvegarde dans EEProm
procedure Value_Save(iVal: byte);
begin
  iValue := iVal;
  EEProm_Write(0, iValue);
  Led_Blink(iValue);
end;
 
// lecture dans EEProm
procedure Value_Load;
begin
  iValue := EEProm_Read(0);
  if iValue > 4 then
  iValue := 0;
  Led_Blink(iValue);
end;
 
// programme principal
begin
  Init;
  Value_Load;
  while true do
  begin
    if Button(PORTB, 0, 50, 0) then Value_Save(1);
    if Button(PORTB, 1, 50, 0) then Value_Save(2);
    if Button(PORTB, 2, 50, 0) then Value_Save(3);
    if Button(PORTB, 3, 50, 0) then Value_Save(4);
    Delay_ms(100);
  end;
end.

Descriptif du logiciel

Procédure Init
Cette routine d'initialisation générale, qui est appelée une seule fois au moment de la mise sous tension du PIC, permet de définir l'orientation des broches des ports A et B, grâce aux lignes TRISA et TRISB. La ligne CMCON = 7 permet de désactiver le fonctionnement des comparateurs du PIC (ce n'est pas obligatoire ici, mais il faut y penser si vous voulez pouvoir exploiter toutes les lignes du ports A, et notament les lignes RA3 et RA4). La ligne OPTION_REG.NOT_RBPU := 0 indique que l'on veut exploiter les "résistances de rappel" internes (pullup) du port B, ce qui permet d'économiser quatre résistances de rappel externes sur les entrées RB0 à RB3.

Procédure Led_blink
Cette routine permet de faire clignoter la led un nombre de fois égal à la valeur du paramètre transmis dans la procédure même. Pour plus de détails, consulter la page PIC - Bases - Activation sortie.

Procédure Value_Save
Cette routine permet de stocker dans la première zone mémoire de l'EEProm, la valeur de la variable iValue. La procédure EEProm_Write utilisée pour cela attend qu'on lui fournisse deux valeurs : une première valeur qui correspond à l'adresse physique (emplacement mémoire), et une seconde valeur qui est celle que l'on veut sauver à l'endroit spécifié. La première valeur peut être comprise entre 0 et 127 si le PIC possède une taille mémoire de 128 octets, elle peut être comprise entre 0 et 255 si le PIC possède une taille mémoire de 256 octets. La seconde valeur (celle à stocker) doit obligatoirement être comprise entre 0 et 255. Dans le cas qui nous concerne, la valeur de l'adresse physique où l'on stocke la valeur désirée est égale à 0, elle correspond au premier octet de la zone mémoire EEProm.

Procédure Value_Load
Cette routine permet d'aller récupérer la valeur qui a été stockée avec la routine EEProm_Write, grâce à la fonction EEProm_Read, qui demande juste qu'on lui fournisse l'adresse mémoire où il faut aller chercher la valeur de la donnée stockée. Dans le cas présent, la valeur stockée l'a toujours été à l'adresse physique de valeur zéro, premier octet de la zone mémoire EEProm. Après avoir lu la valeur de l'octet présent à l'adresse physique 0, on regarde si elle est supérieure à la valeur 4. Si c'est le cas, on change la valeur lue par la valeur 0. La raison en est simple : tous les octets de la zone mémoire EEProm possèdent par défaut la valeur 255 ($FF), tous les bits de chaque octet sont à 1. Si on continuait dans la foulée avec cette valeur, la led clignoterait 255 fois au moment du premier démarrage...

Programme principal
Rien de barbare. On se contente de regarder régulièrement (au travers d'une boucle qui tourne indéfiniment), si un des poussoirs est enfoncé. Si tel est le cas, on stocke en EEProm la valeur qui correspond à l'indice du poussoir en question.