Feste Adresse für Variable im EEPROM?

Rund um die LCL und andere Komponenten

Feste Adresse für Variable im EEPROM?

Beitragvon Timm Thaler » 9. Mär 2018, 02:28 Feste Adresse für Variable im EEPROM?

Mal wieder Embedded AVR: Ich speichere mehrere Variablen und Arrays im internen Eeprom.
Code: Alles auswählen
type
  ee_uint16 = record
    val, chk : uint16;
  end;
 
var
  counter : ee_uint16; section '.eeprom';
  para1 : array [1..32] of ee_uint16; section '.eeprom';
  para2 : array [1..7, 1..6] of ee_uint16; section '.eeprom';
 

Der Record dient nur dazu, zu jedem Wert einen inversen Wert zu speichern, um auf Eeprom-Fehler zu prüfen. (Checksumme über den Eeprom ist ungünstig, weil ich die jedesmal neu berechnen müsste und weil ich dann nicht weiss, welcher Wert ungültig ist.)

Funktioniert auch soweit, aber jetzt habe ich das Problem: Füge ich weitere Variablen ein, verschiebt der Compiler die Adressen der Variablen. Damit stimmen vorher abgespeicherte Parameter nicht oder werden falsch zugeordnet.

Kann ich die Adressen der Variablen und die Startadressen der Arrays festlegen? Ich habe es mit "absolute" versucht, aber der Compiler meckert, dass würde in Verbindung mit "section" nicht gehen.

Btw: Gibt es eine Möglichkeit, sich beim Compilieren die Größe des genutzten Flash, Sram und Eeprom anzeigen zu lassen?
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon siro » 10. Mär 2018, 07:42 Re: Feste Adresse für Variable im EEPROM?

Guten Morgen Tim Thaler,
wenn Du "alle" EEprom Variablen in einem einzigen Record speicherst,
dan sollte es funktionieren.
Dann kannst Du neue Variablen hinten anhängen und die vorigen bleiben erhalten.
Code: Alles auswählen
 
type
  ee_uint16 = record
    val, chk : uint16;
  end;
 
var ee : record      //  section '.eeprom';   kommt das hier hin oder unten beim end ? vermutlich unten
  counter : ee_uint16;
  para1 : array [1..32] of ee_uint16;
  para2 : array [1..7, 1..6] of ee_uint16;
  // hier kommen dann die weiteren Variablen
 
  checksum: Byte;  // optional eine checksumme ganz hinten.
end;   


Ich hab meinen Record einfach ee genannt und da sind dann alle Variablem / Kalibriererte etc.
hintereinander aufgeführt.

mit ee.counter usw. kanst Du dann drauf zugreifen.


Siro
Grüße von Siro
Bevor ich "C" ertragen muß, nehm ich lieber Lazarus...
siro
 
Beiträge: 290
Registriert: 23. Aug 2016, 13:25
Wohnort: Berlin
OS, Lazarus, FPC: Windows 7 Windows 8.1 Windows 10 | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 11. Mär 2018, 21:28 Re: Feste Adresse für Variable im EEPROM?

Also sehe ich das richtig: "absolute" läßt sich in Verbindung mit "section: .eeprom" nicht verwenden?

Kann ich denn davon ausgehen, dass der Compiler - wenn ich keine weiteren Eeprom-Variablen vorher deklariere - für die bestehenden Variablen immer die gleichen Eeprom-Adressen nimmt?
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon siro » 12. Mär 2018, 10:16 Re: Feste Adresse für Variable im EEPROM?

Hallo Tim Thaler, ich glaube jetzt habe ich erst dein Problem verstanden...

Vorab:
"absolute" ist unverrückbar, also immer eine feste Adresse.
Die Adresse einer section steht im Linkerfile, wobei mehrere Variablen Blöcke usw. in einer section angelegt werden können.
Daher ist "absolute" und "section" nicht kombinierbar.

Um auf das EEPROM zuzugreifen, werden ja spezielle Funktionen benötigt.
eeprom_read oder eeprom_write oder ähnliches.
Der Bereich liegt ja nicht, wie der RAM, so im Speicher, dass man direkt darauf zugreifen könnte.
Dazu werden ja die Register EEPROM Address, EEPROM Data, EEPROM Control Register usw. benötigt.
Um den Anwender es zu erleichtern hat man dafür wohl entsprechnede Makros (Bibliotheken) gebaut,

Folgend eine reine Spekulation von mir, ich weis nicht ob das beim AVR-Pascal auch so abläuft.
Korrekturen erbeten :wink:

Wenn ich das richtig verstehe, dann wird aus einer Deklaration von
counter : ee_uint16; section '.eeprom';
erstmal NICHTS. Hier wird lediglich eine Adresse festgelegt für die Variable counter, welche später im EEPROM liegen soll.
Wo ? weis man aber nicht. Ich nenne dieAdresse mal symbolisch EE_ADDRESS_COUNTER

erst wenn man nun darauf zugreift
counter:=13;
dann wird daraus vom Compiler der Code erzeugt:
eeprom_write_word (&counter,EE_ADDRESS_COUNTER);

beim Lesen dann:
counter:=eeprom_read_word (EE_ADDRESS_COUNTER);

Damit unterliegt die Verwaltung der eigentlichen EEPROM Adressen erstmal dem Compiler bzw. Linker.
Damit müste es Dir "theoretisch" egal sein, wo die Adressen liegen.
Ich vermute nun, das Problem was Du meinst ist,
wenn Du deinen Code erweiterst, liegen schon Werte im EEPROM, die sich durch Neucompilierung nun
in der Adresse verschoben haben.

Habe ich das Problem so richtig verstanden ?

somit stünde Dir offen die Adressverwaltung im EEPROM komplett selbst zu übernehmen,
indem Du die entsprechenden Funktionen mit einer von Dir gewünschten Adresse verwendest.

Wie ich grad sehe, hat dazu Mathias schon ein Tutorial erstellt:
http://wiki.freepascal.org/AVR_Embedded ... _EEPROM/de
wobei hier noch die Interrupts gesperrt werden sollten. :wink:

Der Vollständigkeit halber:
Code: Alles auswählen
procedure EEPROM_write(Address: int16; Data: byte);
  begin
 
    // Prüfen, ob bereit zum schreiben.
    while (EECR and (1 shl EEPE)) <> 0 do begin
    end;
 
    EEAR := Address;
    EEDR := Data;
// hier ALLE interrupts sperren   CLI
    EECR := EECR or (1 shl EEMPE); // Es müssen 2 Zeilen sein !
    EECR := EECR or (1 shl EEPE);
//  hier Interrupts wieder ermöglichen  SEI
  end;



Siro
Grüße von Siro
Bevor ich "C" ertragen muß, nehm ich lieber Lazarus...
siro
 
Beiträge: 290
Registriert: 23. Aug 2016, 13:25
Wohnort: Berlin
OS, Lazarus, FPC: Windows 7 Windows 8.1 Windows 10 | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 12. Mär 2018, 11:39 Re: Feste Adresse für Variable im EEPROM?

siro hat geschrieben:Habe ich das Problem so richtig verstanden ?


Ja genau, und diese Prozeduren verwende ich auch zum Eeprom-Zugriff:
Code: Alles auswählen
function load_eeprom_byte(paddr : pbyte) : uint8;
var
  value : uint8;
begin
  while (EECR and (1 shl EEWE)) <> 0 do// Warten auf Eeprom bereit
  EEAR := uint16(paddr);
  EECR := EECR or (1 shl EERE);
  value := EEDR;  // Byte auslesen
  load_eeprom_byte := value;
end;
 
procedure store_eeprom_byte(paddr : pbyte; value : uint8);
begin
  while (EECR and (1 shl EEWE)) <> 0 do// Warten auf Eeprom bereit
  EEAR := uint16(paddr);
  EEDR := value;  // Byte schreiben
  avr_cli();
  EECR := EECR or (1 shl EEMWE); // nicht zusammenfassen
  EECR := EECR or (1 shl EEWE);
  avr_sei();
end;

Der Zugriff erfolgt über den Adresspointer:
Code: Alles auswählen
  for k := 1 to paralen do begin
    val := load_eeprom_byte(@para1[k].val);
    if (val xor $FF) = load_eeprom_byte(@para1[k].chk) then begin
        Lpara1[k] := val;  // Parameter im SRAM
    end else begin
      error.eeprom := true// sonst Flag Fehler Eeprom setzen
    end;
  end;
 

(Diese etwas umständliche Art über den SRAM erfolgt hier, weil erst Standardwerte aus dem Flash in dem SRAM gespiegelt werden, und wenn gültige Eeprom-Werte vorliegen diese die Standardwere überschreiben, so dass auch bei korrupten Eeprom eine Grundfunktion gegeben ist. Der Zugriff auf den SRAM geht dann schneller als jedesmal die Parameter wieder zu holen und zu prüfen.)

Aber prinzipiell geht es mir darum, dass @para1 auch nach einem Neukompilieren immer die gleiche Adresse liefert, damit vorher abgelegte Werte wieder verwendet werden.

Im Controller ist EEsave gesetzt, so dass der Eeprom beim neu Flashen erhalten bleibt.
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon siro » 12. Mär 2018, 17:27 Re: Feste Adresse für Variable im EEPROM?

Wenn Du wie beschrieben einen einzigen Record nimmst,
in dem alle EEPROM Daten vorhanden sind, lässt es sich meiner Meinung nach leichter handhaben.

Zudem würde ich ich nicht jedes Bytes direkt hintereinander anlegen für eine Sicherheitskopie.
Ich habe bei mir 2 komplette "normale" Records im EEPROM hintereinander abgelegt.

Wenn da nix weiter außer diesen beiden Blöcken benötigt wird,
dann kannst Du den EE-Speicher durch 2 teilen und der erste Block befindet sich dann ab Adresse 0
und der zweite ab z.B. Adresse 512 (bei einem 1K EEPROM)
Aufteilung kann natürlich auch anders erfolgen.

Aber Du legst nur jeweils EINE Adresse fest wo der Record starten soll.
const EE_BLOCK_1 = 0;
const EE_BLOCK_2 = 512;

Wenn Du dann beachtest, daß alle späteren Werte die hinzukommen immer ans Ende hängst, bleiben auch alle Werte
davor an den gleichen Adressen, der Record wird nur größer.

Sofern dein RAM das hergibt, kannst Du dann eine komplette Kopie des Records im RAM anlegen,
die beim Starten zunächst mit Werten aus dem Flash vorbelegt werden oder wie auch immer initialisiert werden.
Wenn dann die beiden EEPROM Blöcke identisch sind, dann mit den EEPROM Daten füllen.

Der Zugriff während des Programmlaufs erfolgt normalerweise dann immer mit den RAM Block
ee.BlaBla

Bei Änderungen wird bei mir der gesamte Block neu gespeichert.
Glücklicherweise sind bei mir nur sehr selten Änderungen nötig.
Zudem habe ich sogar noch meine EEPROM Blöcke in einzelne Bereiche aufgeteilt, die dann auch nur gespeichert werden mit zusätzlichen Prüfsummen.
Ich habe da aber alles in "C" machen müssen und mit externen EEPROMs, daher kann ich keine für Dich gültigen Code posten,
hab aber mal probiert es in Pascal zu codieren.

Das sind ja nur Anregungen, wie man das gestaltet bleibt letztlich jedem selbst überlassen.

Hier mal ein bissle Code, den ich aber nicht testen konnte.
Code: Alles auswählen
 
function EEPROM_read(Address: int16): byte;
begin
//.......
end;
 
procedure EEPROM_write(Address: int16; Data: byte);
begin
//.......
end;
 
const EE_BLOCK_1 = 0;    // Startadresse des ersten Records im EEPROM
const EE_BLOCK_2 = 512// Startadresse der Kopie im EEPROM
 
// Daten die im EEPROM abgelegt werden sollen:
Type TEErecord = packed record
  counter : uint16;
  para1   : array [1..32]      of uint16;
  para2   : array [1..7, 1..6] of uint16;
end;
 
var ee:TEErecord;  // der Record im RAM
 
// prüft ob beide records im EEPROM identisch sind
// liefert FALSE wenn Fehler vorhanden sind
function EE_Verify:Boolean;
var i: uint16;      // Zaehler Variable
begin
  result:=FALSE;
  for i:=0 to SizeOf(TEErecord)-1 do begin  // den gesamten Record durchlaufen
    if EEPROM_read(EE_BLOCK_1+i)
    <> EEPROM_read(EE_BLOCK_2+i) then exit;
  end;
  result:=TRUE;
end;
 
// kopiert den kompletten EEPROM record in den RAM
procedure EE_TO_RAM(ee_adr:uint16);
var p:^byte = @ee;  // Zeiger auf das erste Byte im RAM setzen
var i: uint16;      // Schleifenzaehler Variable
begin
  for i:=0 to SizeOf(TEErecord)-1 do begin  // den gesamten Record auslesen
    p^:=EEPROM_read(ee_adr+i);   // ein Byte aus dem EEPROM lesen und im RAM ablegen
    inc(p);                      // Zeiger auf das nächstes Byte im RAM
  end;
end;
 
// kopiert den kompletten RAM record ins EEPROM
procedure RAM_TO_EE(ee_adr:uint16);
var p:^byte = @ee;  // Zeiger auf das erste Byte im RAM setzen
var i: uint16;      // Schleifenzaehler Variable
begin
  for i:=0 to SizeOf(TEErecord)-1 do begin  // den gesamten Record auslesen
    EEPROM_write(ee_adr+i,p^);   // ein Byte aus RAM lesen und im EEPROM ablegen
    inc(p);                      // Zeiger auf das nächstes Byte im RAM
  end;
end;
 
 
 
Grüße von Siro
Bevor ich "C" ertragen muß, nehm ich lieber Lazarus...
siro
 
Beiträge: 290
Registriert: 23. Aug 2016, 13:25
Wohnort: Berlin
OS, Lazarus, FPC: Windows 7 Windows 8.1 Windows 10 | 
CPU-Target: 64Bit
Nach oben

Beitragvon Mathias » 12. Mär 2018, 18:02 Re: Feste Adresse für Variable im EEPROM?

Das sieht ähnlich aus, wie der Code hier im letzten Post: viewtopic.php?f=12&t=11470
Mit Lazarus sehe ich gün
Mit Java und C/C++ sehe ich rot
Mathias
 
Beiträge: 3855
Registriert: 2. Jan 2014, 17:21
Wohnort: Schweiz
OS, Lazarus, FPC: Linux (die neusten Trunc) | 
CPU-Target: 64Bit
Nach oben

Beitragvon Mathias » 13. Mär 2018, 17:00 Re: Feste Adresse für Variable im EEPROM?

Timm Thaler hat geschrieben:Mal wieder Embedded AVR: Ich speichere mehrere Variablen und Arrays im internen Eeprom.
Code: Alles auswählen
type
  ee_uint16 = record
    val, chk : uint16;
  end;
 
var
  counter : ee_uint16; section '.eeprom';
  para1 : array [1..32] of ee_uint16; section '.eeprom';
  para2 : array [1..7, 1..6] of ee_uint16; section '.eeprom';
 

Der Record dient nur dazu, zu jedem Wert einen inversen Wert zu speichern, um auf Eeprom-Fehler zu prüfen. (Checksumme über den Eeprom ist ungünstig, weil ich die jedesmal neu berechnen müsste und weil ich dann nicht weiss, welcher Wert ungültig ist.)

Funktioniert auch soweit, aber jetzt habe ich das Problem: Füge ich weitere Variablen ein, verschiebt der Compiler die Adressen der Variablen. Damit stimmen vorher abgespeicherte Parameter nicht oder werden falsch zugeordnet.

Kann ich die Adressen der Variablen und die Startadressen der Arrays festlegen? Ich habe es mit "absolute" versucht, aber der Compiler meckert, dass würde in Verbindung mit "section" nicht gehen.

Btw: Gibt es eine Möglichkeit, sich beim Compilieren die Größe des genutzten Flash, Sram und Eeprom anzeigen zu lassen?


Verstehe ich es richtig, du willst dies machen, was hier beschrieben ist ?
https://www.mikrocontroller.net/articles/AVR-Tutorial:_Speicher#EEPROM_2
Mit Lazarus sehe ich gün
Mit Java und C/C++ sehe ich rot
Mathias
 
Beiträge: 3855
Registriert: 2. Jan 2014, 17:21
Wohnort: Schweiz
OS, Lazarus, FPC: Linux (die neusten Trunc) | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 13. Mär 2018, 17:12 Re: Feste Adresse für Variable im EEPROM?

Mathias hat geschrieben:Verstehe ich es richtig, du willst dies machen, was hier beschrieben ist ?


Das funktioniert ja alles schon. Was ich wollte ist, dass ich die Adresse, an der eine Eeprom-Variable im Eeprom steht festlegen kann. Damit auch nach einem Neukompilieren die gleiche Adresse verwendet wird und das Programm auf die vorher abgelegten Daten zugreifen kann.

Ich lass das jetzt so und vertraue drauf, dass der Compiler immer die gleichen Adressen nimmt, solange ich nicht dran rumfummel.
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon Mathias » 13. Mär 2018, 17:43 Re: Feste Adresse für Variable im EEPROM?

Aber irgendwie verstehe ich die mit
Code: Alles auswählen
section '.eeprom'; 
nicht.
Dies macht doch irgendwie nur Sinn, wen man bei Flashen dies schon mit einer Constante belegt ?

Code: Alles auswählen
var
  sc : String = 'AVR-Code ist so schön';  section '.eeprom';
oder
Code: Alles auswählen
const
  sc : String = 'AVR-Code ist so schön';  section '.eeprom';


Nur wen ich auslesen will, kommt nur Müll.
Code: Alles auswählen
begin
  UARTInit;
 
  // String lesen, inklusive Längenbyte.
  SetLength(s, EEPROM_read(0)); // Länge auslesen.
  for i := 1 to Length(s) do begin
    s[i] := char(EEPROM_read(i));
  end;
 
  repeat
    UARTSendString(s);
    UARTSendString(#13#10);
  until 1 = 2;
end.


Oder habe ich etwas falsch verstanden ?
Mit Lazarus sehe ich gün
Mit Java und C/C++ sehe ich rot
Mathias
 
Beiträge: 3855
Registriert: 2. Jan 2014, 17:21
Wohnort: Schweiz
OS, Lazarus, FPC: Linux (die neusten Trunc) | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 13. Mär 2018, 20:51 Re: Feste Adresse für Variable im EEPROM?

Natürlich geht das nicht.

Mit section '.eeprom' teilst Du dem Compiler mit, dass diese Variable oder Konstante im Eeprom und nicht im Sram liegt. So wie Du mit section '.progmem' mitteilst, dass die Konstante oder der String im Flash liegt.

Nun kann normalerweise ein hex-File, also das File, welches den Programmcode enthält, der in den AVR geschrieben wird, nur Code enthalten, der im Flash liegt*.

Für "sc : String = 'AVR-Code ist so schön'; section '.eeprom';" müsste der Compiler eigentlich ein eep-File erzeugen, welches die Daten enthält die in den Eeprom gehören. Dieses musst Du extra in den AVR-Eeprom brennen, nachdem Du das hex-File in den AVR-Flash gebrannt hast.

Für mich trifft das nicht zu, ich will nur Parameter aus dem Programm abspeichern. Da reicht mir der Zugriff während des Programms. Da ich die gespeicherten Parameter aber nach einer Programmänderung weiterverwenden möchte, um sie nicht jedesmal neu speichern zu müssen, wollte ich ihnen feste Adressen im Eeprom geben.

*) Mit Ponyprog konnte man auch Hexfiles schreiben, die größer als der Flash waren, die Daten landeten dann automatisch im Eeprom. Damit konnte man sich das getrennte Brennen sparen. Moderne Programmer prüfen das aber vorher. Elegant brennt man Flash und Eeprom gemeinsam mit elf-Files, das können aber nicht alle Brennprogramme.
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon Mathias » 13. Mär 2018, 21:03 Re: Feste Adresse für Variable im EEPROM?

Mit section '.eeprom' teilst Du dem Compiler mit, dass diese Variable oder Konstante im Eeprom und nicht im Sram liegt.
Und was bringt das einem ?
Sram sparen ?

Für mich trifft das nicht zu, ich will nur Parameter aus dem Programm abspeichern. Da reicht mir der Zugriff während des Programms. Da ich die gespeicherten Parameter aber nach einer Programmänderung weiterverwenden möchte, um sie nicht jedesmal neu speichern zu müssen, wollte ich ihnen feste Adressen im Eeprom geben.
Für das sollte die speicher/lese-Variante vom Tutorial reichen.
Und das sind die Daten immer am gleichen Ort abgespeichert, auch wen man zwischendurch ein ganz anderes Programm auf den AVR lädt, ausser dieser überschreibt den EEPROM.

So wie Du mit section '.progmem' mitteilst, dass die Konstante oder der String im Flash liegt.
Ist irgendwo dokumentiert, welche sectionen es gibt ?
In ASM heisen die anders. Dort heist zB. .eeprom, .eseg .
Mit Lazarus sehe ich gün
Mit Java und C/C++ sehe ich rot
Mathias
 
Beiträge: 3855
Registriert: 2. Jan 2014, 17:21
Wohnort: Schweiz
OS, Lazarus, FPC: Linux (die neusten Trunc) | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 13. Mär 2018, 21:29 Re: Feste Adresse für Variable im EEPROM?

Mathias hat geschrieben:Und was bringt das einem ? Sram sparen ?


Du willst jetzt aber nicht wissen, warum man Eeprom verwendet, oder?

Mathias hat geschrieben:Und das sind die Daten immer am gleichen Ort abgespeichert, auch wen man zwischendurch ein ganz anderes Programm auf den AVR lädt, ausser dieser überschreibt den EEPROM.


Ähm nein. Wenn Du eine Variable dazwischen einfügst oder den Datentyp änderst, verschieben sich auch die Adressen der folgenden Variablen, die nicht geändert wurden. Was dazu führt, dass die Daten falsch zugeordnet sind.

Auch kann das Ändern der Compilereinstellungen, zum Beispiel der Adressoptimierung, dazu führen, dass byte- und word-Variablen mit 4 Byte Sprüngen gespeichert werden, wenn der Compiler meint dass die Adressberechnung dadurch vereinfacht wird.
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

Beitragvon Mathias » 13. Mär 2018, 21:40 Re: Feste Adresse für Variable im EEPROM?

Du willst jetzt aber nicht wissen, warum man Eeprom verwendet, oder?

Für was man einen EEPROM braucht, weis ich schon, zB. um Parameter zu speichern, so das sie nach einem Stromausfall nicht verloren gehen.
Bei der Frage ging es um die Verwendung ".eeprom" und für eine Paramterspecherung, würde das Erite und read vom Tutorial reichen.
Oder wird das ".eeprom" gebraucht, das man die Konstanten nicht ins Flash mit dem Programmcode speichern muss ?

Ähm nein. Wenn Du eine Variable dazwischen einfügst oder den Datentyp änderst, verschieben sich auch die Adressen der folgenden Variablen, die nicht geändert wurden. Was dazu führt, dass die Daten falsch zugeordnet sind.
Ich dachte, ein EEPROM fängt physikalisch immer an der gleichen Adressen an.
Mit Lazarus sehe ich gün
Mit Java und C/C++ sehe ich rot
Mathias
 
Beiträge: 3855
Registriert: 2. Jan 2014, 17:21
Wohnort: Schweiz
OS, Lazarus, FPC: Linux (die neusten Trunc) | 
CPU-Target: 64Bit
Nach oben

Beitragvon Timm Thaler » 13. Mär 2018, 22:12 Re: Feste Adresse für Variable im EEPROM?

Mathias hat geschrieben:Ich dachte, ein EEPROM fängt physikalisch immer an der gleichen Adressen an.


Wenn Du die Variablen als section: .eeprom deklarierst, übernimmt der Compiler die Verwaltung der Variablenadressen für Dich. Dann berechnet der auch alles für Dich, zum Beispiel die Adresse eines zu lesenden Wertes in einem Array. Und kann auch entsprechend optimieren. Beginnt zum Beispiel ein Array mit [1..], und die Datengröße ist Word, beginnt der Compiler bei der Berechnung 2 Bytes vor Beginn des Arrays.

Wenn Du die Adresse festlegst, musst Du Dich selbst um die Berechnung kümmern, was entsprechend fehleranfällig ist. Habe ich jahrelang in Assembler gemacht, aber einer der Gründe für Pascal ist ja, das dem Compiler zu überlassen, und das funktioniert auch meistens.
Timm Thaler
 
Beiträge: 575
Registriert: 20. Mär 2016, 22:14
OS, Lazarus, FPC: Win7-64bit Laz1.64 FPC3.0.4, Raspbian Stretch Laz1.62 FPC3.0.2 | 
CPU-Target: Raspberry Pi 3
Nach oben

» Weitere Beiträge siehe nächste Seite »
Nächste

Zurück zu Komponenten und Packages



Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 3 Gäste

porpoises-institution
accuracy-worried