Avec l’introduction de la carte HAT, la Fondation Raspberry Pi a normalisé l’utilisation d’une EEPROM présente sur la carte HAT, destinée à configurer automatiquement le système d’exploitation Raspberry Pi OS (ou Raspbian) pour qu’il prenne en compte le matériel présent sur la carte HAT présente sur le connecteur GPIO. Une sorte de Plug-and-Play…

Au sommaire :

1 Explorer l’EEPROM d’une carte HAT sur Raspberry Pi
2 Références
3 Sources

Explorer l’EEPROM d’une carte HAT sur Raspberry Pi

[stextbox id=’alert’ caption=’EEPROM HAT’]Claude a déjà présenté plusieurs articles sur le blog, le plus récent concerne l’installation de Lazarus sur le Raspberry Pi 4. A la fin de cet article, il évoquait son projet d’écran pour ULM en OpenGL. Les composants seront embarqués sur une carte HAT dont l’EEPROM assurera la configuration du système pour une utilisation automatique.[/stextbox]

L’EEPROM de la carte HAT

Si vous avez déjà bricolé avec des cartes prototypes HAT vous avez sans doute remarqué la présence d’une petite mémoire visible en bas à droite sur la photo ci-dessous :

C’est une EEPROM lue au boot et qui permet de configurer automatiquement votre RPi pour prendre en compte le matériel. Cette mémoire est loin d’être pleine et c’est l’endroit idéal pour stocker les paramètres de calibrage des capteurs de mon projet OpenAvionics Primary Flight Display. C’est aussi l’occasion de vous présenter la mise en œuvre de Lazarus.
Voir aussi l’article de Claude sur Lazarus.

Accéder à l’EEPROM

L’EEPROM est câblée sur le bus I2C0 en principe réservé au système. Il faut donc d’abord autoriser l’accès I2C via le volet « Interfaces » du programme « Configuration du Raspberry Pi » si ce n’est déjà fait. Il faut ensuite autoriser l’accès au bus I2C0 en éditant en sudo le fichier /boot/config.txt et d’ajouter la ligne ci-dessous dans le fichier :

dtparam=i2c0=on

Ce qui donne :

# Uncomment some or all of these to enable the optional hardware interfaces
dtparam=i2c0=on
dtparam=i2c1=on
dtparam=i2c_arm=on

# Uncomment some or all of these to enable the optional hardware interfaces

dtparam=i2c0=on

dtparam=i2c1=on

dtparam=i2c_arm=on

Rebooter et vérifier la détection de l’EEPROM en lançant la commande i2cdetect 0 qui doit indiquer la présence de la mémoire à l’adresse 0x50 :

Nota : il est possible d’empiler plusieurs cartes HAT avec des adresses d’EEPROM différentes mais les cartes proto que j’ai eu sous la main ont toutes l’adresse 0x50 non modifiable.

Lecture / écriture de l’EEPROM

Pour lire le contenu d’une case mémoire de l’EEPROM il faut envoyer son adresse (sur 2 octets) sur le bus, puis faire une lecture. On peut alors faire autant de lectures que souhaité pour lire les cases mémoires suivantes.

Pour écrire 1 case il faut écrire 3 octets : les 2 premiers pour l’adresse et le troisième pour la donnée. Il faut ensuite attendre 10 ms pendant lesquels la mémoire gère le cycle d’écriture et ce temps est indisponible. L’EEPROM est aussi programmable par pages de 16, 32 ou 64 octets selon le fabricant : on envoie la séquence complète 2 octets d’adresse (multiple de 16, 32, 64 respectivement) puis les octets de données de la page. On attend toujours 10ms pour passer à la page suivante.

Le programme qui programme

Pour avoir un outil facilement utilisable dans mes programmes rien de mieux qu’un objet
(= une classe pour les programmeurs C/C++) qui expose une API générique. Je l’ai appelé THat_eeprom_ctrl. Voyons la mise en œuvre avec Lazarus :

Initialisation

L’initialisation consiste à obtenir un handle (fonction fpopen) pour nos lectures/écriture sur le bus I2C0 à l’adresse 0x50 (Eeprom_addr) et de dimensionner un buffer pour stocker les données (SetLength(FeBuf, eSize[AType]);) en prenant en compte la taille de l’EEPROM qui peut être du type 24C16, 24C32, 24C64… La plus courante est la 24C32 soit 32kBit ou encore 4ko.

constructor THat_eeprom_ctlr.Create(AOwner: TComponent; AType: TEpromCapacity);
begin
    inherited Create(AOwner);
    try
        FLastError:= '';
        FHandle:= fpopen(RPi_I2C0_DevPath, O_RDWR);
        fpIOCtl(FHandle, I2C_SLAVE, Pointer(Eeprom_addr));
        FInitDone:= True;
        FLastErrorNo:= -1;
        FLastError:= '';
        FeType:= AType;
        SetLength(FeBuf, eSize[AType]);
    except
        FInitDone := False;
        FLastError:= 'Error create hat eeprom controler';
    end;
end;

constructor THat_eeprom_ctlr.Create(AOwner: TComponent; AType: TEpromCapacity);

begin

inherited Create(AOwner);

try

FLastError:= '';

FHandle:= fpopen(RPi_I2C0_DevPath, O_RDWR);

fpIOCtl(FHandle, I2C_SLAVE, Pointer(Eeprom_addr));

FInitDone:= True;

FLastErrorNo:= -1;

FLastError:= '';

FeType:= AType;

SetLength(FeBuf, eSize[AType]);

except

FInitDone := False;

FLastError:= 'Error create hat eeprom controler';

end;

Lecture d’un octet

Il faut au préalable décoder l’adresse pour présenter les octets d’adresse dans l’ordre octet de poids fort et octet de poids faible. Il n’y a plus qu’à lancer un fpwrite de 2 octets suivi d’un fpread d’un octet.

function THat_eeprom_ctlr.ReadByte(Addr: UInt16): byte;
begin
    try
        FLastError:= '';
        bufAddr.bytes[1]:= byte(Addr and $FF);
        bufAddr.bytes[0]:= byte(Addr shr 8);
        fpwrite(FHandle, bufAddr.bytes[0], 2);
        fpread(FHandle, bufAddr.Value, 1);
    except
        FLastError:= 'Error read value';
        Exit;
    end;
    Result:= bufAddr.Value;
end;

function THat_eeprom_ctlr.ReadByte(Addr: UInt16): byte;

begin

try

FLastError:= '';

bufAddr.bytes[1]:= byte(Addr and $FF);

bufAddr.bytes[0]:= byte(Addr shr 8);

fpwrite(FHandle, bufAddr.bytes[0], 2);

fpread(FHandle, bufAddr.Value, 1);

except

FLastError:= 'Error read value';

Exit;

end;

Result:= bufAddr.Value;

end;

Ecriture d’un octet

Formatage de l’adresse idem que pour l’écriture, ajout de la valeur à écrire et il ne reste plus qu’à lancer la séquence d’écriture des 3 octets :

procedure THat_eeprom_ctlr.WriteByte(Addr: UInt16; Data: byte);
begin
    try
        FLastError:= '';
        bufAddr.bytes[1]:= byte(Addr and $FF);
        bufAddr.bytes[0]:= byte(Addr shr 8);
        bufAddr.Value:= Data;
        fpwrite(FHandle, bufAddr.bytes[0], 3);
        Delay(WriteTime); // 10 ms delay
    except
        //FLastErrorNo:= fpErrorNo;
        FLastError:= 'Error write value';
    end;
end;

procedure THat_eeprom_ctlr.WriteByte(Addr: UInt16; Data: byte);

begin

try

FLastError:= '';

bufAddr.bytes[1]:= byte(Addr and $FF);

bufAddr.bytes[0]:= byte(Addr shr 8);

bufAddr.Value:= Data;

fpwrite(FHandle, bufAddr.bytes[0], 3);

Delay(WriteTime); // 10 ms delay

except

//FLastErrorNo:= fpErrorNo;

FLastError:= 'Error write value';

end;

RAZ de l’EEPROM

Je passe sur la lecture et l’écriture de blocs qui ne devraient plus vous poser de problème maintenant. Regardons juste la fonction Blank qui efface toutes les données (la valeur d’une EEPROM vierge est 0xFF). On créé un buffer qui comprend l’adresse en entête puis les données de la page initialisées à 0xFF. Puis on écrit les blocs avec un délai de 10 ms jusqu’à remplir la mémoire :

procedure THat_eeprom_ctlr.BlankEprom;
const
    BufferLength = AddrSize + PageSize;
var i, Addr: UInt16;
    wBuffer: array [0..BufferLength-1] of byte;
begin
    try
        FLastError:= '';
        for i:= AddrSize to BufferLength-1 do wBuffer[i]:= $FF;
        Addr:= 0;
        repeat
            wBuffer[1]:= byte(Addr and $FF);
            wBuffer[0]:= byte(Addr shr 8);
            fpwrite(FHandle, wBuffer, BufferLength);
            Delay(WriteTime);
            Addr:= Addr + PageSize;
        until Addr &gt;= Length(FeBuf);
    except
        //FLastErrorNo:= fpErrorNo;
        FLastError:= 'Error blank eeprom';
    end;
end;

procedure THat_eeprom_ctlr.BlankEprom;

const

BufferLength = AddrSize + PageSize;

var i, Addr: UInt16;

wBuffer: array [0..BufferLength-1] of byte;

begin

try

FLastError:= '';

for i:= AddrSize to BufferLength-1 do wBuffer[i]:= $FF;

Addr:= 0;

repeat

wBuffer[1]:= byte(Addr and $FF);

wBuffer[0]:= byte(Addr shr 8);

fpwrite(FHandle, wBuffer, BufferLength);

Delay(WriteTime);

Addr:= Addr + PageSize;

until Addr >= Length(FeBuf);

except

//FLastErrorNo:= fpErrorNo;

FLastError:= 'Error blank eeprom';

end;

Sauvegarde / récupération

Lire et écrire notre EEPROM est la base. Sauvegarder le contenu et pouvoir le recharger c’est mieux. Pour cela nous allons utiliser le format Intel hex. Voici le programme d’écriture, le buffer est ici un TStringList dans lequel on va stocker les valeurs en texte dans le format sHex= ‘:10%s00%s’ où 10 est le nombre de données en hexadecimal, 00 indique qu’on a une ligne de données, entre les deux on intercale l’adresse de début de ligne et on termine par les données et le checksum. La fin du fichier est indiquée par une ligne au format sHexEOF. Notre buffer constitué il n’y a plus qu’à utiliser la méthode SaveToFile pour sauvegarder nos données :

procedure THat_eeprom_ctlr.BufferToHexFile(AFilename: AnsiString);
const sHex= ':10%s00%s';
    sHexEOF= ':00000001FF' + EOL;
var OutList: TStringList;
    Addr, StartAddr: UInt16;
    CS: byte;
    HexData, OutStr: AnsiString;
begin
    try
        FLastError:= '';
        try
            OutList:= TStringList.Create;
            OutList.LineBreak := EOL;

            HexData:= '';
            CS:= $10;
            for Addr:= 0 to Length(FeBuf)-1 do
            begin
                HexData:= HexData + IntToHex(FeBuf[Addr], 2);
                CS:= CS + FeBuf[Addr];
                if (Addr and $F = $F)
                then begin
                    StartAddr:= Addr and $FFF0;
                    CS:= not( CS + byte(StartAddr shr 8) + byte(StartAddr and $F0) ) + 1;
                    OutStr:= Format(sHex, [IntToHex(StartAddr, 4), HexData])
                        + IntToHex(CS, 2);
                    OutList.Add(OutStr);
                    HexData:= '';
                    CS:= $10;
                end;
            end;
            OutList.Add(sHexEOF);
            OutList.SaveToFile(AFilename);
        except
            //FLastErrorNo:= fpErrorNo;
            FLastError:= 'Error write hex file';
        end;
    finally
        OutList.Free;
    end;
end;

procedure THat_eeprom_ctlr.BufferToHexFile(AFilename: AnsiString);

const sHex= ':10%s00%s';

sHexEOF= ':00000001FF' + EOL;

var OutList: TStringList;

Addr, StartAddr: UInt16;

CS: byte;

HexData, OutStr: AnsiString;

begin

try

FLastError:= '';

try

OutList:= TStringList.Create;

OutList.LineBreak := EOL;

HexData:= '';

CS:= $10;

for Addr:= 0 to Length(FeBuf)-1 do

begin

HexData:= HexData + IntToHex(FeBuf[Addr], 2);

CS:= CS + FeBuf[Addr];

if (Addr and $F = $F)

then begin

StartAddr:= Addr and $FFF0;

CS:= not( CS + byte(StartAddr shr 8) + byte(StartAddr and $F0) ) + 1;

OutStr:= Format(sHex, [IntToHex(StartAddr, 4), HexData])

+ IntToHex(CS, 2);

OutList.Add(OutStr);

HexData:= '';

CS:= $10;

end;

OutList.Add(sHexEOF);

OutList.SaveToFile(AFilename);

except

//FLastErrorNo:= fpErrorNo;

FLastError:= 'Error write hex file';

end;

finally

OutList.Free;

end;

Nota : EOL est la fin de ligne qui est un caractère CR sous Linux et CR+LF pour Windows.

Le programme qui affiche

Le point fort de Lazarus est de pouvoir créer rapidement une interface graphique à faire enrager les ayatollahs de la commande en ligne. Il suffit de créer un nouveau projet de type Application pour que Lazarus vous créé la fenêtre de lancement et son unité de code.

Initialisation

A la création de la fenêtre de l’application on initialise une instance de notre objet, et c’est tout :
procedure TfHatEeprom.FormCreate(Sender: TObject);
begin
    Eeprom:= THat_eeprom_ctlr.Create(Self, ec32);
end;

A la création de la fenêtre de l’application on initialise une instance de notre objet, et c’est tout :

procedure TfHatEeprom.FormCreate(Sender: TObject);

begin

Eeprom:= THat_eeprom_ctlr.Create(Self, ec32);

end;

Affichage du contenu de l’EEPROM

Notre objet se charge de la lecture des données. Il n’y a plus qu’à mettre en forme : dans notre fiche (fenêtre) on met un composant Memo, nommé mDump, qui permet d’afficher les données converties en texte lisible. La lecture et l’affichage sont déclenchés par un élément d’un composant Menu (MenuItem) qui appelle la fonction de lecture, la fonction de formatage pour la présentation est séparée pour pouvoir être réutilisée :

procedure TfHatEeprom.miLoadClick(Sender: TObject);
begin
  Eeprom.EpromToBuffer;
  ShowEpromBuffer;
End ;

procedure TfHatEeprom.ShowEpromBuffer;
const
  sDump=  '%s: %s   %s';
var eeData: byte;
    i: LongInt;
    asHex, asChar: AnsiString;
    buf: array of byte;
begin
  mDump.Lines.Clear;
  asHex:= '';
  asChar:= '';
  buf:= Eeprom.EpromBuffer;
  for i:=0 to Length(buf)-1 do
  begin
    asHex:= asHex + IntToHex(buf[i], 2) + ' ';
    if (buf[i] &gt;= $20) and  (buf[i] &lt; $7F)
      then asChar:= asChar + char(buf[i])
      else asChar:= asChar + '.';
    if (i and $F = $F)
    then begin
      mDump.Lines.Add( Format(sDump, [IntToHex(i-$F, 4), asHex, asChar]) );
      asHex:= '';
      asChar:= '';
      mDump.Update;
      Application.ProcessMessages;
    end;
  end;
end;

procedure TfHatEeprom.miLoadClick(Sender: TObject);

begin

Eeprom.EpromToBuffer;

ShowEpromBuffer;

End ;

procedure TfHatEeprom.ShowEpromBuffer;

const

sDump= '%s: %s %s';

var eeData: byte;

i: LongInt;

asHex, asChar: AnsiString;

buf: array of byte;

begin

mDump.Lines.Clear;

asHex:= '';

asChar:= '';

buf:= Eeprom.EpromBuffer;

for i:=0 to Length(buf)-1 do

begin

asHex:= asHex + IntToHex(buf[i], 2) + ' ';

if (buf[i] >= $20) and (buf[i] < $7F)

then asChar:= asChar + char(buf[i])

else asChar:= asChar + '.';

if (i and $F = $F)

then begin

mDump.Lines.Add( Format(sDump, [IntToHex(i-$F, 4), asHex, asChar]) );

asHex:= '';

asChar:= '';

mDump.Update;

Application.ProcessMessages;

end;

et voici le résultat :

Suite au prochain épisode

Dans la seconde et dernière partie nous verrons comment interpréter le contenu de l’EEPROM et comment insérer vos données propres en respectant le standard HAT. Et si je suis de bonne humeur je vous livre le code complet et l’exécutable.

Références

HAT : Hardware Attached on Top

EEPROM : Electrically Erasable Programable Read Only Memory, ou mémoire programmable à lecture seule, effaçable et reprogrammable électriquement – passons sur l’incohérence due à des raisons historiques !

Introducing Raspberry Pi HATs

Sources

https://sourceforge.net/projects/openavionics/

4 réflexions au sujet de « Exploration de l’EEPROM HAT du Raspberry Pi (Partie 1/2) »

Bud Spencer 21 juin 2020 à 19 h 32 min

« (= une classe pour les programmeurs C/C++) » …
Des objets en C … Bonne chance .. 😉

Répondre ↓
Terence Hill 25 juin 2020 à 21 h 45 min

« HAT : Hardware Attached on Top »
Je n’avais jamais réalisé que hat était un acronyme… je me coucherai moins bête ce soir.

Répondre ↓
1. François MOCQ 26 juin 2020 à 8 h 44 min
  
  merci 😀
  
  Répondre ↓
Ping : Exploration de l’EEPROM HAT du Raspberry Pi (Partie 2/2) - Framboise 314, le Raspberry Pi à la sauce française....
AmesisProject 20 juillet 2020 à 23 h 02 min

Super article. Je vais aller voire la suite tte suite. Surtout qu’en ce moment je m’intéresse au fichier bin des calculateur moteur et c’est grandement ressemblent. Merci François

Répondre ↓

Laisser un commentaire Annuler la réponse

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.

Framboise 314, le Raspberry Pi à la sauce française….

La référence du Raspberry Pi en France – Par l'auteur du livre "Raspberry Pi 4" paru aux Edts. ENI

Exploration de l’EEPROM HAT du Raspberry Pi (Partie 1/2)

Explorer l’EEPROM d’une carte HAT sur Raspberry Pi

L’EEPROM de la carte HAT

Accéder à l’EEPROM

Lecture / écriture de l’EEPROM

Le programme qui programme

Initialisation

Lecture d’un octet

Ecriture d’un octet

RAZ de l’EEPROM

Sauvegarde / récupération

Le programme qui affiche

Initialisation

Affichage du contenu de l’EEPROM

Suite au prochain épisode

Références

Sources

4 réflexions au sujet de « Exploration de l’EEPROM HAT du Raspberry Pi (Partie 1/2) »

Laisser un commentaire Annuler la réponse