Schlagwort-Archive: EEPROM

ESP8266 EEProm richtig verwenden

Grundlagen

Der ESP8266 verfügt je nach Bestückung des verwendeten ESP-Moduls über ein Flash Speicher, der von 1KBit bis zu 16 KBit haben kann.

Beim ESP wird hiervon fester Bereich von 4096 Byte für eine „qasi“ EEProm reserviert, welches vom Programm gelesen und auch beschrieben werden kann. Diese Daten bleiben wie das Programm nach einem neustart erhalten.

Die Größe dies für den EEProm reservierten Bereichs ist in der spi_flash.h unter SPI_FLASH_SEC_SIZE (4096) definiert.

Quelle: www.ullisroboterseite.de
Quelle: www.ullisroboterseite.de

EEproms eignet sich perfekt zum speichern non Daten bzw. von Daten Strukturen, die nach einem Neustart des ESP wieder zur Verfügung stehen sollen.
Da es sich hierbei aber immer noch um eine Flash Ram handelt und diese vom Hersteller mit einer maximalen beschreibbarkeit von ca. 10.000 mal angegeben werden, sollten hier nur Daten gespeichert werden, die keiner häufigen oder gar zyklischen Änderung unterliegen. 

Deshaln eignet sich dieser Speicher auch nicht für Messdaten, für  Konfigurationsdaten, die sich aber nur selten ändern, ist er perfekt.

Verwendung

Die definition erfolgt als Arduino-typischer Klassenkonstruktor mit der Klasse EEPROMClass, diese stellt eine Reihe vordefinierter Funktionen bereit, die für das Handling mit dem EEProm notwendig sind.

Mit „void EEPROMClass::begin(size_t size)“ wird das Objekt zunächst initialisiert.

Dabei wird ein interner Puffer mit Namen _datain der angegeben Größe angelegt.
In diesen Bereich, der nun als EEPROM deklarierte ist, wird nun der Puffer eingelesen.
Alle nachfolgende Lese- bzw. Schreib Operationen in disem Zwischenpuffer.
Dieser Zwischenpuffer wird erst dann in den Flash Speicher übertragen, wenn man dies mit der Methode EEPROM.commit(); anfordert oder das Programm die Operation mit einem EEPROM.end(); abschließt.

Die internen Variablen _dirty vermerkt, ob eine Änderung des Dateninhalts stattgefunden hat. Ein Zurückschreiben des Pufferinhalts erfolg deshalb nur dann, wenn auch eine Änderung stattgefunden hat.

Die Methode getDataPtr() liefert den Zeiger auf den internen Pufferspeicher. Bei einem Aufruf dieser Methode wird _dirty gesetzt, da der Pufferinhalt über diesen Zeiger abgeändert werden könnte.

Der Kalssenaufruf EEPROMClass benötigt beim Konstruktor die Angabe der Speicheradresse (Sektornummer) in EEPROM.cpp, _SPIFFS_end ergibt sich aus der in der IDE festgelegten SPIFFS-Konfiguration.

Die vordefinierte Instanz der Klasse EEPROM wir folgt angelegt:

EEEPROMClass EEPROM((((uint32_t)&_SPIFFS_end - 0x40200000) / SPI_FLASH_SEC_SIZE));

Um z.B. Konfigurationsdaten in Verbindung mit dem EEPROM zu lesen und zu speichern, bietet es sich an die Daten in einer Structur zu verwalten.

 

typedef struct {
  int PHysteresisH1 = 10;          // Fall Back Hysteresis für Relais 
  int PThresholdH1 = 100;          // Schwellwert für Relais 
  int PHysteresisL1 = 10;          // Fall Back Hysteresis für Relais 
  int PThresholdL1 = 50;           // Schwellwert für Relais 
  int PRelaisStateL1 = 0;          // 0- NO / 1- NC
  int PRelaisStateH1 = 0;          // 0- NO / 1- NC
  int PRelaisStateErr = 1;         // 0- NO / 1- NC
  int PSerialOutState = 0;         // 0- OFF / 1- ON
  int PWifiState = 0;              // 0- OFF / 1- ON
  int PMode = 0;                   // 0= relative / 1= Absolut Druck
  int PACMode = 0;                 // 0= keine Autocalibration / 1= Autokalibration
  int PDeltaAC = 10;               // Maximale Abeichung Druckdifferenz 
  int PCalibrationTime = 5000;     // Calibration Counter Time in ms
  unsigned long PHoldTime = 500;   // Für Abfallverzögerung in ms
} PSettings;
PSettings psettings;

Um Speicherplatz zu sparen, sollte der Pufferspeicher nicht größer als notwendig initialisiert werden. Die Maximale Größe beträgt 4096.

Lesen von Daten aus dem Pufferspeicher

EEPROM.begin(1024); // Puffergröße die verwendet werden soll
EEPROM.get(512, psettings); // Anfangsadresse bei der die definierte Structur abgelegt ist
EEPROM.end(); // schließen der EEPROM Operation

Schreiben von Daten in den Pufferspeicher und anschließende Übernahme in den Flash mit commit()

EEPROM.begin(1024);
EEPROM.put(0, settings); //Schreiben einer zweiten Structur ab Adresse 0
EEPROM.commit();
EEPROM.end();

Quellen Verweise:
www.ullisroboterseite.de
www.kriwanek.de

TextToEEprom

TextToEEprom
TextToEEprom
TextToEEprom.zip
Version: 1.0
2.0 MiB
688 Downloads
Details

TextToEEprom

In Mikrokontroller Anwendungen werden Texte z.B. für eine Displayausgabe häufig in externen EEProm Bausteinen abgelegt.

Das Programm “TextToEEprom” dient der Erstellung, der Pflege sowie dem Brennen der indizierten Textfiles in ein EEprom des Typs 24cxx. Je nach Anwendung können verschiedene 24cxx EEPromtypen ausgewählt werden. Die Übertragung der Daten kann seriell, direkt durch dem Microkontroller oder mit einem kleinen externen I2C-Brenner dessen Bauanleitung in der beiliegenden Dokumentation zu finden ist erfolgen. Der Bauplan für den Brenner und diverse Beispieleprogramme für die Nutzung mit einem Mikrokontroller sind als Basic Code in der beiliegeneden Hilfe enthalten. Dieser Code kann so auch leicht in beliebige ander Programmiersprachen portiert werden.

Um einen schnellen Zugriff auf die einzelnen Texte zu erhalten, wird jedem Text ein Index zugewiessen. Diese Indizis, die am Anfang des EEproms liegen, referenzieren (ähnlich einem Zeiger) die Startadresse des entsprechenden Textes im Speicherbereich des EEProms.

Im Programm wird nun z.B. von der fünften Speicherstelle des EEProm der Index für den Fünften Text im EEProm geladen und anschließend begonnen den Text Zeichen für Zeichen aus dem EEProm aus zu lesen und auszugeben, bis die Textende Markierung erreicht wird.

Das Textende wird durch einen frei definierbaren Bytewert gekenzeichent, der im Programm definiert werden kann.


Pseudo Code für die Verwendung der EEProm Daten:

Diese Beispiele zeigen, wie eine 24Cxx EEProm direkt mit einem PIC Microkontroller und der serielle Schnittstelle programmiert werden kann. Um ein besseres Verständnis der Funktionsweise zu erreichen, wurden die Programmteile mit vielen Kommentaren versehen. In diesem Beispiel wurde ein PIC 16F877 verwendet. Die Firmware kann mittels Bootloader über die Hardware serielle Schnittstelle des PIC (MAX 232 nötig) und Microcode Studio übertragen werden, dies erlaubt eine schnelle Fehlersuche bzw. Änderung der Software.
Diese Schnittstelle wird ebenfals für das Übertragen der EEprom Daten aus dem Programm TextToEEProm genutzt.
Die Beispielprogramme zeigen das Laden des EEProms mit Daten von der seriellen Schnittstelle, die Funktionsweise einer Textausgabe der mit TextToEEProm erstellten Texte und den Einsatz dieser Texte in einem kleinem Menü, dass über drei Tasten und ein LCD Display gesteuert werden kann.

Pic Basic Code Beispiel:Ladeprogramm für das EEprom (24C32 bzw. 24C64)‘————————[ Texte in das EEProm laden ]————————–
’24C32 10101ddd  (4K EEPROM) Adresse im Wordformat
TextToEEProm:
CONT = %10101000
ADDR = 0                    ‚Variable Addr mit null initialisieren
READDATA:
HSERIN 6000,START,[CHAR]            ‚Zeit um die Übertragung zu starten
IF CHAR = 251 THEN START            ‚End of File Zeichen
I2CWRITE SDA,SCL,CONT,ADDR,[CHAR]         ‚Daten in das EEProm schreiben
PAUSE 10                    ’10 ms Brenndauer abwarten
I2CREAD SDA,SCL,CONT,ADDR,[CHAR]        (Optional bei verwendung von ECHO)
HSEROUT [CHAR]                ‚Echo zum Sender (Optional bei verwendung von ECHO)
ADDR = ADDR + 1                ‚Addresse um eins erhöhen
GOTO READDATATextausgabe auf das LCD-Display (EEprom 24C32 bzw. 24C64)‘—————-[ LCD Ausgabe mit Word Pointer H/L ]—————————
’24LC32 4K Bytes %10101ddd (4K EEPROM) Adresse im Wordformat
‚TEXT => Erster Text ab INDEX
DiplayOut:                    ‚Der Index des Textes
CONT = %10101000
TEMP_WORD = (TEXT + OFFSET) * 2        ‚*2 Byte (High/Low)
I2CREAD SDA,SCL,CONT,TEMP_WORD,[ADDR]    ‚I*2 bei Word Pointer, lade Startadresse
READCHAR:
I2CREAD SDA,SCL,CONT,ADDR,[Char]
IF CHAR = 0 THEN RETURN            ‚End of Text Zeichen erkannt
ADDR = ADDR + 1                ‚Addresse um eins erhöhen
LCDOUT CHAR                    ‚Zeichen in das Display schreiben
GOTO READCHARTypischer Programmaufbau für eine Menüführung mit Displayausgabe

‚—————————[ Funktionsmenue ]———————————-
SETUP:
OFFSET = 11                    ‚Text offset Setup Menue
TEXT = 0                        ‚0-„Einstellungen …   “
GOSUB DISPLAYOUT                ‚Textausgabe aus EEProm
PAUSE 700
TEXT = 0                    ‚Setze Hauptmenüeintrag „Rollobedienung“
BACKTOSETUP:
OFFSET = 20                    ‚Text offset Setup Hauptmenue
MENUMAX = 2                    ‚0-3 Anzahl der Menü Einträge

‚******************************** Aktionsmenü  *********************************
MENU:
GOSUB DisplayOut
LOOP:
GOSUB GET_TASTER
SELECT CASE TASTER
CASE 1   ‚Zurück blättern
IF TEXT > 0 THEN                ‚Maximale Anzahl der Einträge erreicht?
TEXT = TEXT – 1
ELSE
TEXT = MENUMAX
ENDIF
GOSUB DISPLAYOUT
CASE 2    ‚Vor blättern
IF TEXT < MENUMAX THEN            ‚Minimale Anzahl der Einträge erreicht?
Text = Text + 1
ELSE
TEXT = 0
ENDIF
GOSUB DISPLAYOUT
CASE 4                        ‚Menüeintrag auswählen
PAUSE 255                    ‚255 ms warten Tastenwiederholrate
IF OFFSET = 20 THEN                ‚Hauptmenü
BRANCHL TEXT, [A0,A1,INIT]            ‚Init ist der letze Eintrag und beendet das Menü
ENDIF
IF OFFSET = 30 then B0
IF OFFSET = 40 then B1
END SELECT
GOTO LOOP

‚************************ Untermenüs *******************************************
A0:
TEXT = WERT                    ‚Atuellen Wert zugewiessen
OFFSET = 30                    ‚Text offset B0
MENUMAX = 3                    ‚Anzahl der Menü Einträge
GOTO MENU

A1:
TEXT = STATUS.2                 ‚Aktuelle Einstellung Binär 0 oder 1
OFFSET = 40                    ‚Text offset B1
MENUMAX = 2                    ‚Anzahl der Menü Einträge
GOTO MENU

‚********************* Aktionen der Untermenüs *********************************
B0:
SELECT CASE TEXT
CASE 0        ‚Eintrag 0
….
CASE 1        ‚Eintrag 1
::::
CASE 2        ‚Eintrag 2
….
CASE 2        ‚Eintrag 3
….
END SELECT
TEXT = 0                    ‚Setze Hauptmenüeintrag A0
GOTO BACKTOSETUP

B1:
SELECT CASE TEXT
CASE is < 2    ‚Eintrag 0..1
…..
CASE 2        ‚Eintrag 3
…..
END SELECT
TEXT = 1                    ‚Setze Hauptmenüeintrag A1
GOTO BACKTOSETUP

Was ist neu

Version 1.22.1  Neu

  • Es wurde eine Updatesuche integriert, die es nun ermöglicht, bequem aus der Anwendung heraus nach einen aktuelleren Version dieser Software zu suchen und diese dann direkt herunterzuladen.

Version 1.22.0

  • Erweiterung der EEProm Typen