ATmega EEPROM Schreiben

[arser (Gast)]

Hallo,

wie kann ich einen Wert im EEPROM beim allerersten Programmlauf ablegen?
Also vorbelegen quasi und beim nächsten Programmlauf wird die 
Speicherzelle mit dem zur Laufzeit entstandenem Wert überschrieben?

Kann ich das auch im AVR Studio machen?

Gruß Artur

PS. die Befehle zu Schreiben/Lesen des EEPROMs sind mir bekannt, mir 
geht es nur um den Trick.

[Eumel (Gast)]

Du kannst das EEPROM direkt aus dem Programmierdialog des AVR Studio 
heraus beschreiben. Mit einer von dir ausgewählten Datei. Ebenso kannst 
du es auch auslesen.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

So etwas hier erzeugt zum Beispiel eine *.eep Datei mit vorbesetzten 
Werten im Sourcecode:

// EEPROM values
uint16_t ee_address1 __attribute__((section(".eeprom"))) = TimeStamp; 
uint8_t ee_address2  __attribute__((section(".eeprom")))= MYCONSTANT;
uint8_t ee_address3  __attribute__((section(".eeprom"))) = 0b10001000;
uint8_t ee_address4 __attribute__((section(".eeprom"))) = 0xAA;

Ansprechen kannst du sie dann mit ihren ee_xxxxx Adressen.

[DIL EMMA (Gast)]

Jungfräuliche AVRs haben im EEPROM FF an allen Stellen. Beim allerersten 
Programmstart kannst du ein zusätzliches Byte != FF setzen. Beim 
nächsten Programmstart testest du dieses zusätzliche Byte und weißt 
dann, das es bereits einen Programmstart gegeben hat. Von der Benutzung 
der Speicherstelle bei 0x00 ist aus anderen Gründen abzuraten.

[arser (Gast)]

Hallo,
Danke Euch. Ich werde es mal probieren.
@DIL EMMA:
An sowas dachte ich, aber ich habe keine Vorstellung mit welcher 
Sicherheit die Zellen den beschriebenen Zustand haben.

Es hat sich nun folgendes, neues Problem ergeben:

void main()
{
...
  Kardan_Faktor = eeprom_read_float(&KF);
  Umfang_Faktor = eeprom_read_float(&UF);

  sei();                          //Interrupts an

  //Hauptschleife
  while(1) 
  {
    
  switch(main_state)
  {
    case state_Tacho:

      zahl = f_Welle * Kardan_Faktor*Umfang_Faktor * 3.6;;
      Zahlenart = GANZ;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_OelTemp;
      if( get_key_short( 1<<KEY2 ))
        main_state = state_U_Bat;
    break;

    case state_U_Bat:

      zahl = delta_V*MESSFAKTOR*ADC_result;
      Zahlenart = DEZIMAL1;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Tacho;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Tages_km;
    break;

    case state_Tages_km:

      zahl = 222;
      Zahlenart = GANZ;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_U_Bat;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Gesamt_km1;
    break;

    case state_Gesamt_km1:

      zahl = km_Stand/1000;
      Zahlenart = GANZ;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Tages_km;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Gesamt_km2;
    break;

    case state_Gesamt_km2:

      km_int = km_Stand/1000;
      zahl = (uint16_t)km_Stand - km_int*1000;
      Zahlenart = GANZ;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Gesamt_km1;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Kardan;
    break;

    case state_Kardan:
      
      zahl = Kardan_Faktor;
      Zahlenart = DEZIMAL2;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Gesamt_km2;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Umfang;

      if( get_key_long( 1<<KEY1 ))
        Kardan_Faktor -= 0.01;

      if( get_key_long( 1<<KEY2 ))
        Kardan_Faktor += 0.01;
    break;

    case state_Umfang:
      
      zahl = Umfang_Faktor;
      Zahlenart = DEZIMAL2;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Kardan;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_OelTemp;

      if( get_key_long( 1<<KEY1 ))
        Umfang_Faktor -= 0.01;

      if( get_key_long( 1<<KEY2 ))
      {
        PORTC ^= (1<<PC1);    //LED toggle
        Umfang_Faktor += 0.01;
      }
    break;

    case state_OelTemp:

      zahl = 777;
      Zahlenart = GANZ;

      if( get_key_short( 1<<KEY1 ))
        main_state = state_Umfang;

      if( get_key_short( 1<<KEY2 ))
        main_state = state_Tacho;

      if( get_key_long( 1<<KEY2 ))
      {
        cli();                          //Interrupts aus
        eeprom_write_float(&KF, Kardan_Faktor);
        eeprom_write_float(&UF, Umfang_Faktor);
        sei();                          //Interrupts an
      }
    break;

    default:

      zahl = 999;
      Zahlenart = GANZ;

    break;
  }
...

Wenn ich die Zeilen
  Kardan_Faktor = eeprom_read_float(&KF);
  Umfang_Faktor = eeprom_read_float(&UF);
einfüge lassen sich die Variablen Kardan_Faktor und Umfang_Faktor im 
state_Kardan und state_Umfang nicht per Tastendruck verändern.
So habe ich es deklariert (Ausserhalb von main()):

float Kardan_Faktor = 0;
float KF EEMEM;

float Umfang_Faktor = 0;
float UF EEMEM;

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

arser schrieb:
> state_Umfang nicht per Tastendruck verändern

Sind das denn richtig deklarierte Variablen? Die globale Deklaration 
hast du ja nicht mitgepostet. Die 2te Frage ist, ob deine 'get_key_long' 
Routine über jeden Verdacht erhaben ist. Toggelt denn die Test LED?

arser schrieb:
> cli();                          //Interrupts aus
>         eeprom_write_float(&KF, Kardan_Faktor);
>         eeprom_write_float(&UF, Umfang_Faktor);
>         sei();                          //Interrupts an

Und du solltest da unbedingt noch

eeprom_busy_wait();

dazwischen machen. Beim Lesen braucht mans nicht, beim Schreiben aber 
schon.

[Arser (Gast)]

Hallo Mathias,

die Deklaration ist global, vor main().
Die Test LED toggelt.

Ich habe es auch versucht, dass ich die Variablen in andere zwei 
kopiere, wahrscheinlich unsinnig, aber es hat nicht funktioniert.

Gruß Artur

[Karl H. (kbuchegg)]

arser schrieb:
> Hallo,
> Danke Euch. Ich werde es mal probieren.
> @DIL EMMA:
> An sowas dachte ich, aber ich habe keine Vorstellung mit welcher
> Sicherheit die Zellen den beschriebenen Zustand haben.

Den haben sie, keine Sorge.

So ähnlich mach ichs auch, allerdings einfacher.

....

int main()
{
  eeprom_write_float(&KF, 0.5);
  eeprom_write_float(&UF, 0.5);


  .... dein restlicher Code

und hab dann die Werte im EEPROM, ehe das eigentliche Programm loslegt. 
:-)
Wenn dann der Rest funktioniert, kommentiere ich einfach die beiden 
Zeilen aus und fertig.

[Karl H. (kbuchegg)]

Arser schrieb:
> Hallo Mathias,
>
> die Deklaration ist global, vor main().

Arser.
Bitte mach ed dir zur Regel, deinen Code einfach in Form eines C-Files 
an das Psoting anzuhängen.
Beschreib nicht deinen Code, zeig ihn nicht in Auszügen, sondern häng 
einfach den Code direkt an. Das ist für dich einfacher, das ist für uns 
einfacher, viele Nachfragen nach Details entfallen und nicht zu letzt 
zeigt sich immer wieder, dass das eigentliche Problem gar nicht in dem 
Codestück sitzt, welches du in Ausschnitten gezeigt hast.

[arser (Gast)]

Hallo Karl Heinz,

hast recht, hätte ich gleich machen sollen. Wollte Euch einfach nicht 
mit zuviel Code belasten.

Die entsprechende Stelle liegt auf Zeile 164/165 und ist kommentiert.
Wie gesagt, wenn ich die zwei Zeilen weglasse kann ich die Variablen 
Kardan_Faktor und Umfang_Faktor zur Laufzeit per Tastendruck ändern, 
sonst nicht.

Gruß Artur

[arser (Gast)]

...ach ja, falls es sonst etwas am Code, genauer am Stil zu bemängeln 
gibt, ist mein Ohr offen.

Gruß Artur

[Viktor N. (Gast)]

Uiiiiiii, Tasten & Interrupts .... keine Spur von Entprellen.

Regel 1 mit Tasten :
Keine Interrupts. Es kommt ganz sicher nicht auf die Mikrosekunde an.

Regel 2 mit Tasten :
Ueber einen Timer-Tick, aber im Main, Entprellen.

[Viktor N. (Gast)]

Float ... sollte man vermeiden. Die bringen in 99% aller Faelle nichts.
Delays sollte man vermeiden, die machen das Programm schwer zu debuggen, 
denn man weiss nicht genau wo es steht. Und kann es auch nicht 
herausfinden

[Karl H. (kbuchegg)]

Viktor N. schrieb:
> Uiiiiiii, Tasten & Interrupts .... keine Spur von Entprellen.

Red keinen Quatsch. Er benutzt die PeDa Entprellung. Das Beste was man 
benutzen kann.

[arser (Gast)]

Den INT1_vect löst ein Hall-Sensor aus. Durch die Beschaltung ist 
mehrmaliges Auslösen eigentlich nicht möglich. Ist auch getestet worden.

Die Entprellung der zwei Taster ist wie hier beschrieben realisiert:
http://www.mikrocontroller.net/articles/Entprellung#Timer-Verfahren_.28nach_Peter_Dannegger.29

Die Qualität meines Guzzi-Tachos wäre um einiges schlechter ohne diese 
Enprell-Lösung))

[Karl H. (kbuchegg)]

arser schrieb:

> Die Entprellung der zwei Taster ist wie hier beschrieben realisiert:
> 
http://www.mikrocontroller.net/articles/Entprellung#Timer-Verfahren_.28nach_Peter_Dannegger.29



Dein Entprellen ist schon ok.
Allerdings hab ich mit den short bzw. long Funktionen auch keine 
Erfahrung. Hab ich noch nie benutzt.

Ich seh allerdings auch keinen Zusammenhang, wie das jetzt mit den 
EEPROM Funktionen zusammen hängen könnte.

OK, dass deine Multiplex-Anzeige verbesserungswürdig ist, darüber kann 
man reden. Allerdings ist das jetzt erst mal nicht das Problem.



Den einzigen Zusammenhang den ich vielleicht herstellen könnte ist, dass 
es einen Reset gibt und daher immer wieder derselbe Wert aus dem EEPROM 
geholt wird. Aber ansonsten seh ich da nicht wirklich, wie das zusammen 
hängen könnte.

Im übrigen würde ich den Wert sofort nach der Manipulation im EEPROM 
ablegen und nicht erst auf einen Tastendruck vom Benutzer warten um das 
Speichern anzustossen. Du kannst eine EEPROM Zelle mindestens 10000 mal 
beschreiben, ehe sie kaputt geht. So oft stellst du diese Faktoren nicht 
um! Oder fummelst du im Minutentakt, 24 Stunden am Tag, 2 Monate lang an 
dieser Einstellung rum?

[arser (Gast)]

Natürlich nicht. Die Speicherung würde in den gleichen State verlegt 
werden. Es würde dann abgespeichert werden wenn man zum 
naächsten/vorherigen State umschaltet.
Zur Problemlösung wurde das Speichern "ausgelagert".

Ei Reset ist auszuschliesen, denn das Programm beginnt beim State Tach. 
Oder ich habe Deine Vermutung falsch verstanden.

Was Multiplexen angeht bin ich natürlich auch gelehrig, funzt auch nicht 
optimal. Die Anzeigen haben unterschiedliche Leuchtkraft, die dritte ist 
die hellste, denn die ist am längsten an, da nach ih vermutlich mehr 
Code abgearbeitet wird.

[arser (Gast)]

Das Problem ist scheinbar unabhängig davon, ob ich die Entprellfunktion 
benutze.
Auch bei einfachster Pinabfrage lässt sich die Variable nicht verändern.

[arser (Gast)]

Karl Heinz Buchegger schrieb:
> arser schrieb:
>> Hallo,
>> Danke Euch. Ich werde es mal probieren.
>> @DIL EMMA:
>> An sowas dachte ich, aber ich habe keine Vorstellung mit welcher
>> Sicherheit die Zellen den beschriebenen Zustand haben.
>
> Den haben sie, keine Sorge.
>
> So ähnlich mach ichs auch, allerdings einfacher.
> ....
>
> int main()
> {
>   eeprom_write_float(&KF, 0.5);
>   eeprom_write_float(&UF, 0.5);
>
>
>   .... dein restlicher Code
>
> und hab dann die Werte im EEPROM, ehe das eigentliche Programm loslegt.
> :-)
> Wenn dann der Rest funktioniert, kommentiere ich einfach die beiden
> Zeilen aus und fertig.

Man könnte ja den Speicher vorher auslesen und dann wie Du einen 
konstanten Wert schreiben, aber vorher abfragen ob der ausgelesene Wert 
EXAKT dem entspricht was reingeschrieben wurde. Wurde der Inhalt der 
EEPROM-Zelle zur Laufzeit bereits verändert, findet beim nächsten Mal 
das Beschreiben nicht mehr statt. Und sollte der Wert EXAKT dem 
entsprechen womit initialisiert wurde ist ja nicht schlimm.

Ich habe die EEPROM-Funktionen ausgetauscht: float gegen word. mit der 
byte Lese-/Schreibfunktion funktioniert es auch.

Leider bleibt das Problem für mich ungeloöst, mit einem Workaround durch 
Umrechnung verkraftbar))

Vielen Dank an alle!

Gruß Artur

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

arser schrieb:
> Leider bleibt das Problem für mich ungeloöst, mit einem Workaround durch
> Umrechnung verkraftbar))

Es ist sicher sinnvoll, die Software generell auf Integermathmatik 
umzubauen und lediglich für die Anzeige dann Dezimalzahlen zu verwenden. 
Du wirst dich wundern, wieviel Platz plötzlich im Flash verfügbar ist 
und kannst dann noch andere spassige Sachen mit einbauen.
http://www.mikrocontroller.net/articles/Festkommaarithmetik

[a. l. (artur78)]

Interssanter Link. Man lernt nie aus.
Danke!

[Peter D. (peda)]

Matthias Sch. schrieb:
> Du wirst dich wundern, wieviel Platz plötzlich im Flash verfügbar ist

Die float Grundrechenarten belegen einmalig 1kB Flash (AVR-GCC).
Könnte beim ATtiny2313 ne Rolle spielen.
Ab ATmega168 würde ich mir aber keinen Kopp darum machen.


Den EEPROM benutze ich nie direkt, sondern ne Struct im SRAM.
Beim Reset wird im EEPROM ne CRC geprüft und bei Erfolg die Struct 
geladen.
Bei falscher CRC bleibt die Vorbelegung der Struct gültig.

Erfolgt eine Bedienung, wird nur die Struct geändert. Nach Abschluß 
erfolgt dann das Berechnen der CRC und Update des EEPROM.
Update schreibt nur geänderte Bytes, man macht es daher immer über die 
gesamte Struct.