EEPROM beschreiben

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Da du noch nicht erfahren bist, solltest du auf die Variante mit der Dimensionierung von ERam-Variablen aufbauen.
      Das hat den Vorteil, dass du dich nicht um Adressen kümmern musst.

      Du liest oder schreibst die Variable wie jede andere (aber nicht rechnen).

      Ich empfehle vor diesen Variablentyp das Prefix 'EE'
      Dim EEWert1 as ERam Byte
      Dim EEWert1 as ERam Integer
      etc.

      Ich schreibe meine Programme oft so, dass ich die 1. Speicherzelle
      benutze um festzustellen, ob das EEProm schon mit meinen Werten beschrieben ist. Wenn das EEProm neu ist steht immer &hFF (Byte) drin.
      Nach dem beschreiben schreibe ich da einen Wert rein z.B. 1.

      Bei der Abfrage, ob das EEProm beschrieben ist, wird die erste Zelle gelesen und mit 1 verglichen. Wenn unterschiedlich, muss das EEProm initialisiert werden.

      Ab der 2. Zelle speichere ich dann die eigentlichen Werte, die ich gerne im EEProm haben möchte.

      Im Programm sieht es dann etwa wie folgt aus:

      BASCOM-Quellcode

      1. ' EEProm-Variablen definieren
      2. Dim EEProgrammed as ERam Byte ' Dient zur Feststellung, ob EEProm unbeschrieben ist
      3. ' Benutzerwerte
      4. Dim EEWert1 as ERam Byte
      5. Dim EEWert2 as ERam Integer
      6. Dim EEWert3 as ERam Long


      Ich verfahre dann immer so, dass ich mir 2 Routinen erstelle.
      Mit der einen lese ich die EEProm-Werte in Variablen ein, mit denen ich dann im Programm arbeite.
      Mit der anderen, um die Werte aus den Variablen ins EEProm abzulegen.

      Die Routinen nenne ich gerne
      • SaveSetting() und
      • LoadSetting()


      Eine 3. Routine ist noch hilfreich, die das EEProm mit Defaultwerten Initialisiert.
      • InitSettings()
      Die Routinen sehen dann etwa so aus:

      Quellcode

      1. ' ----------------------------------------------
      2. ' Settings im EEProm sichern
      3. ' ----------------------------------------------
      4. Sub SaveSettings()
      5. ' Variablen im EEProm sichern
      6. EEWert1 = Wert1
      7. EEWert2 = Wert2
      8. EEWert3 = Wert3
      9. End Sub
      10. ' ----------------------------------------------
      11. ' Settings aus EEProm lesen
      12. ' ----------------------------------------------
      13. Sub LoadSettings()
      14. ' prüfen, ob Werte im EEProm gültig sind
      15. If EEProgrammed <> 1 then ' EEProm muss initialisiert werden
      16. Call InitSettings() ' EEProm initialisieren
      17. End If
      18. ' EEProm Werte in Variablen kopieren
      19. Wert1 = EEWert1
      20. Wert2 = EEWert2
      21. Wert3 = EEWert3
      22. End Sub
      23. ' ----------------------------------------------
      24. ' EEProm mit defaultwerten initialisieren
      25. ' ----------------------------------------------
      26. Sub InitSettings()
      27. EEWert1 = 15 ' Byte
      28. EEWert2 = -2953 ' Integer
      29. EEWert3 = 2001234 ' Long
      30. ' nicht vergessen im EEProm die 1 abzulegen, denn jetzt ist EEProm initialisiert
      31. EEProgrammed = 1
      32. End Sub
      Alles anzeigen

      Du brauchst dann nur noch bevor das Programm in die Mainloop geht, die Routine LoadSettings() aufrufen.
      Das EEprom wird initialisiert, falls nicht schon passiert, und dann die Settings geladen.

      Das fertige Code-Beispiel könnte dann so aussehen:

      BASCOM-Quellcode

      1. ' Bitmanipulation
      2. $regfile = "m328pdef.dat" ' Prozessor AVR Mega 328P
      3. $crystal = 16000000 '16Mhz ext. Quartz
      4. $swstack = 40
      5. $hwstack = 40
      6. $framesize = 60
      7. TasteSave Alias PinB.0 : PortB.0 = 1 ' Taste Save
      8. ' ----------------------------------------------
      9. ' EEProm-Variablen definieren
      10. ' ----------------------------------------------
      11. Dim EEProgrammed as ERam Byte ' Dient zur Feststellung, ob EEProm neu initialisiert werden muss
      12. ' Hier deine Werte mit Prefix 'EE'
      13. Dim EEWert1 as ERam Byte
      14. Dim EEWert2 as ERam Integer
      15. Dim EEWert3 as ERam Long
      16. ' ----------------------------------------------
      17. ' Normale-Variablen mit Inhalt der EEProm-Werte
      18. ' ----------------------------------------------
      19. ' Hier deine Werte ohne Prefix 'EE' (normale Variablen)
      20. Dim Wert1 as Byte
      21. Dim Wert2 as Integer
      22. Dim Wert3 as Long
      23. ' ----------------------------------------------
      24. ' Deklarationen der EEProm-Routinen
      25. ' ----------------------------------------------
      26. Declare Sub SaveSettings() ' Werte aus RAM-Variablen ins EEProm kopieren
      27. Declare Sub LoadSettings() ' Werte aus EEProm in RAM-Variablen kopieren
      28. Declare Sub InitSettings() ' EEProm-Werte vorinitialisieren (Standard-Werte)
      29. ' ------------------------------------------------------------------------------------------------
      30. ' Hauptschleife
      31. ' ------------------------------------------------------------------------------------------------
      32. Call LoadSettings() ' Prüft EEProm, initialisiert es gegebenenfalls und lädt Setting in Variablen
      33. Do
      34. ' Hier dein Code
      35. Debounce TasteSave , 0 , SaveSettings , Sub ' Bei Tastendruck werte ins EEProm
      36. Loop
      37. ' ------------------------------------------------------------------------------------------------
      38. ' Routinen
      39. ' ------------------------------------------------------------------------------------------------
      40. ' ----------------------------------------------
      41. ' Settings im EEProm sichern
      42. ' ----------------------------------------------
      43. Sub SaveSettings()
      44. ' Variablen im EEProm sichern
      45. EEWert1 = Wert1
      46. EEWert2 = Wert2
      47. EEWert3 = Wert3
      48. End Sub
      49. ' ----------------------------------------------
      50. ' Settings aus EEProm lesen
      51. ' ----------------------------------------------
      52. Sub LoadSettings()
      53. ' prüfen, ob Werte im EEProm gültig sind
      54. If EEProgrammed <> 1 then ' EEProm muss initialisiert werden
      55. Call InitSettings() ' EEProm initialisieren
      56. End If
      57. ' EEProm Werte in Variablen kopieren
      58. Wert1 = EEWert1
      59. Wert2 = EEWert2
      60. Wert3 = EEWert3
      61. End Sub
      62. ' ----------------------------------------------
      63. ' EEProm mit defaultwerten initialisieren
      64. ' ----------------------------------------------
      65. Sub InitSettings()
      66. EEWert1 = 15 ' Byte
      67. EEWert2 = -2953 ' Integer
      68. EEWert3 = 2001234 ' Long
      69. ' nicht vergessen im EEProm die 1 abzulegen, denn jetzt ist EEProm initialisiert
      70. EEProgrammed = 1
      71. End Sub
      Alles anzeigen
      Du must lediglich die Variablennamen und Typen an deine Anforderung anpassen.
      Ansonsten ist das ein problemloser Code und funktioniert zuverlässig. Und wie du siehst ohne dass Adressen angegeben werden.

      Gutes Gelingen! a_170_58e0202d
    • Der Code funktioniert.
      Platz 0 ist instabil. Deswegen sollte wenn mit Eram Byte gearbeitet wird als erstes ein unnützes Byte gedimmt werden.
      Zitat:
      diese Dim Anweisung legt auch gleichzeitig die Adresse (den Speicherplatz) im ERam fest (Hier Platz 0)

      Platz 0 weil es zuerst genannt wird , nicht weil eine 0 im Namen steckt . :D

      Als schreibfauler hätte ich die anstelle der Eeprom_schreiben Sub
      writeeprom Arraywerte(pos_zeiger) , pos-zeiger

      oder in der Eram variante:
      Dim E_wert(3) as Eram Byte
      E_wert(pos_zeiger) = Arraywerte(pos-zeiger)
    • djmsc schrieb:

      Es scheint aber häufig Probleme damit zu geben.
      Nein, ich hatte diese Probleme noch nie. Es ist so wie ich schon vermutete das es "ältere AVR-Generationen" betreffen kann. Wäre nett wenn die das konkret benannt hätten.So ist die Aussage mehr als vage.

      "
      In AVRs älterer Generationen wird das EEPROM-Adressregister (EEAR) beim Zurücksetzen auf Null gesetzt, sei es von Brown Out Detect, Watchdog oder dem Reset Pin. Wenn ein EEPROM-Schreiben zum Zeitpunkt des Zurücksetzens gerade erst begonnen hat, wird das Schreiben abgeschlossen, nun aber bei Adresse Null anstelle der angeforderten Adresse. Wenn der Reset später im Schreibvorgang erfolgt, können sowohl die angeforderte Adresse als auch der Adressnullwert beschädigt sein."


      Übersetzt mit DeepL.com/Translator

      Bezieht sich das auf bestimmte AVR,bis zu welchem Produktionszeitraum usw ???
      Der Ängstliche kann ja zuerst eine Dummy-EE-Variable anlegen.
      Es liegt alsonicht an den EEPROM-Zellen sondern an den Zugriffs-Registern, bzw. deren Handling.
      Ich verwende ja auch keinen AVR-Schrott. :D

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von oscar ()

    • Hallo zusammen,
      @daja, Ihr braucht nicht zu sammeln, um mir das Buch von Stefan H. zu schenken, das hab ich schon seit ca.4 Jahren. Aber, das fängt bei diesem Thema sehr "ambitioniert" an. Da hat man (zumindest ich) nach 100 Wörtern den Überblick verloren. Wenn mir ein Thema gänzlich unbekannt ist, und ich niemanden fragen kann, dann muss es gaaanz unten losgehen. Ansonsten ist das Buch prima, und hat mir schon des Öfteren gut geholfen (so zerlesen siehts auch aus)!

      Pluto25 schrieb:

      Platz 0 weil es zuerst genannt wird , nicht weil eine 0 im Namen steckt .
      Das war mir schon klar, nur um die Doku sauber zu habe, hab ich den ersten Wert "Wert0" genannt.

      @Mitch64, deine Routinen sind wohl überlegt. Wenn man das öfters braucht, kommt man halt auf sowas.

      Vielen Dank für Eure Hilfen und Mühe!
      Gruss
      Theo
    • Hallo Admins,

      können die Beiträge im Anhang nur registrierte Mitglieder öffnen?

      Frage ist wieder mal nicht bösartig gemeint.

      Da ich meist nur praktisch erprobtes an Freunde weitergeben möchte sind es oft Projektbestandteile mit Informationen die ich nicht bei google lesen möchte. Oft wie in den Code sind auch vielmehr interessante Sachen als gefragt wurden enthalten.
      Nun kommt nicht mit kannst du doch alles vorab löschen.
      1. wird vieles aus dem Zusammenhang gerissen und viel überflüssige Erklärungen folgen denn wer denkt er kann was gebrauchen kann sich ja das herauspicken und dann im öffentlichen Forumteil dies einstellen und Fragen stellen.
      2. warum soll ich mir diese Löscharbeit machen(und danach mich entschuldigen wenn zuviel gelöscht), alle Mitglieder können doch den Anhang lesen und wie gehabt nur um das Wesentliche dasThema fortsetzen.
      Würde mal 2 Projekte in Anhang stellen. Mit Eeprom Vergleich 8Bit oder größer würde sogar die Frage 0 Adresse bei den Experten ein Haaa kommen. Naklar habe ich auch mal gesagt.
      Stichwort: EEPROM- Memmery der verschiedenen Typen

      Keine Antwort ist auch eine Antwort

      Mit freundlichen Grüßen
    • @fredred
      Ich habe mal deinen Code zum Getränkeautomat angeschaut.

      Die Funktion, also wie der Getränkeautomat funktioniert, kann ich aus dem Code nicht rauslesen.
      Das Programm ist zum Nachvollziehen zudem schlecht kommentiert.
      Kommentare wie Reset(für mich reicht es) bringen da nicht wirklich Hilfe.

      Die Tasten sind nur von Taster0 bis Taster4 bezeichnet. Bei Taster3 und Taster4 ist keine Angabe, wozu die Schalter dienen.
      Man könnte die Taster z.B. Taster_Select, Taster_Minus, Taster_Plus etc. bezeichnen. Das würde den Code schon mal lesbarer machen.

      Auch über die Funktion der Variablen kann man nur rätseln bei solchen Bezeichnungen:
      Dim Summeta As Single
      Dim Summetar As Word
      Dim Summett As Single
      Dim Summeta1 As Integer

      Warum Variablen nicht ordentlich benennen wie z.B. SummeTarif etc.

      Der Code ist insgesamt sehr undurchsichtig und ich steige da ehrlich gesagt nicht durch, ohne viel Zeit in die Analyse zu stecken.
      Müsste ich den Code weiterpflegen, hätte ich also meine Mühe damit. Man kann anstelle von Labels, die mit Return enden und mit Gosub angesprungen werden, auch Subs verwenden. Labels verwende ich nur da, wo man darauf nicht verzichten kann. Das macht den Code auch lesbarer.

      Ich möchte deine Programmierkünste nicht kritisieren, aber man könnte das alles (aus meiner Sicht) besser gestalten.
      Betrachte das also als Vorschlag, deinen Programmierstiel zu verbessern.

      Das Programm wäre übrigens sehr gut geeignet, um es als Zustandsautomat auszulegen. Das hätte verschiedene Vorteile.
      Auch hättest du keine Problem mit dem geflacker des LCD, müsstest da nicht rumtrixen.

      Schau mal im Lexikon nach Statemachine.

      Vielleicht möchtest du deinen Code noch etwas besser erklären, damit man versteht, wie der Getränkeautomat funktioniert.
      Welche Tasten haben welche Funktion. Sinnvoll ist auch eine Erklärung, an welchen Pins was dran hängt.
      Bei den Tastern ist es mit Abstrichen rel. klar, aber bei den Relais und und den 20cent, 50cent, Fachon eher nicht.

      Also bitte die Kritik nicht persönlich nehmen, sondern als Tipps, um das Coden zu verbessern. Denn in 3 Jahren weist zu zwar, wie das Bas-Programm heißt, weist aber vielleicht selbst nicht mehr, was die Variablen oder Pins bedeuten. Für Variable und Taster, Ausgänge sollte man immer aussagekräftige Namen verwenden.

      Man kann z.B anstatt Rf1, Rf2 usw. Bezeichnungen verwenden wie Relais_Fach1, Relais_Fach2 usw.

      Wenn du Fragen hast zur Statemachine helfe ich dir gerne weiter.
    • Mitch64 schrieb:

      Die Funktion, also wie der Getränkeautomat funktioniert, kann ich aus dem Code nicht rauslesen.
      Das Programm ist zum Nachvollziehen zudem schlecht kommentiert.


      Hallöchen,

      danke für Nachfrage hatte aber angekündigt das der Thradwoker sich die benötigten Eeprom- Bereiche sich selber ausschneiten kann und die sind ausreichend kommentiert um zu erkennen Was, Wie und Wann.
      Ich verstehe jede Zeile im Code und muss diese nicht für Dritte erklären. Warum auch? Sind doch für Thema uninteressant.
      War nie meine Absicht zu erklären wie Geträngeautomat funktioniert
      Es Scheint wohl doch falsch zu sein ein Projektbezogenen Code einzustellen. Sind aber die meisten die ich noch habe.

      P.S.
      Die komplette Elektronik eines„alten“ sehr teuren Getränkeautomat war defekt. Es gab keinerlei Unterlagen mehr.
      Das war ein Anreiz für mich (AVRBASCommer) nicht nur eine nachzubauen sondern noch eleganter für Bediener und auch sicherer. Mit Sicherer meine ich die eingegebenen Preise und der Umsatz sind im Eeprom festgeschrieben. Hatte die Bestätigung das der defekt(Totalausfall) erst nach mehrmaligen Stromausfall kam und somit alle Daten immer fort waren.

      Hoffe du hast Verständnis das ich nicht die Bedienungsanleitung und Kurzbeschreibungauch noch in diesen Themenbereich abgestellt habe. Hast du ähnliches vor dann werde ich dich natürlich alle deine Fragen beantworten. Freud mich wenn jemand kreativ ist. Werden leider immer weniger.

      Mit freundlichen Grüßen
    • Ja und korrekt funktionieren tut es auch nicht.
      Zum einen werden die PullUps nicht aktiviert,
      sofern auf seiner Hardware keine externen PullUps drauf sind, kann ich mir nicht vorstellen, dass die Tastenabfrage korrekt funktioniert.

      BASCOM-Quellcode

      1. '****************Prog-Tasten *******************
      2. Config Pinc.7 = Input
      3. Config Pinc.6 = Input
      4. Config Pinc.5 = Input
      5. Config Pinc.4 = Input
      6. Config Pinc.3 = Input
      7. Pinc.7 = 1
      8. Pinc.6 = 1
      9. Pinc.5 = 1
      10. Pinc.4 = 1
      11. Pinc.3 = 1
      12. Taster0 Alias Pinc.7 ' Select
      13. Taster1 Alias Pinc.6 ' minus
      14. Taster2 Alias Pinc.5 ' plus
      15. Taster3 Alias Pinc.4
      16. Taster4 Alias Pinc.3
      17. '********* System Kontakte *****************
      18. Config Pinb.1 = Input
      19. Config Pinb.2 = Input
      20. Config Pinb.3 = Input
      21. Pinb.1 = 1
      22. Pinb.2 = 1
      23. Pinb.3 = 1
      24. 20cent Alias Pinb.1
      25. 50cent Alias Pinb.2
      26. Fachon Alias Pinb.3
      Alles anzeigen




      Und zum anderen frage ich mich, warum @fredred 4 Single-Werte (Preise für Getränke der 4 Ausgabefächer) aufwendig in String wandelt und diese dann 10x im EEProm ablegt.

      Hier, wie die Werte aus dem EEProm gelesen werden, vor der Hauptschleife. Augenmerk auf Schleife um Zeile 6. Im Original-Code Zeile 145)

      BASCOM-Quellcode

      1. ' Auszug
      2. Const Mess_eeprom_max = 10 ' Abhängig vom verwendeten µC (Mess_eeprom_max = EEPROM / 200)
      3. ' Daten aus Eeprom Einlesen und in Temp_str schreiben
      4. For C = 1 To Mess_eeprom_max
      5. Temp_str = Mess_eeprom(c)
      6. Next C

      Beim Schreiben umgekehrt. 10x die gleichen String-Werte schreiben. Augenmerk auf Schleife um Zeile 3. Im Original-Code Zeile 501)

      BASCOM-Quellcode

      1. If Taster3 = 0 Then
      2. For C = 1 To Mess_eeprom_max
      3. Mess_eeprom(c) = Temp_str
      4. Print Temp_str
      5. Next C
      6. Locate 1 , 1
      7. Lcd "Tarif gesichert "
      8. Locate 2 , 1
      9. Lcd ">weiter mit Ta0<"
      10. End If
      Alles anzeigen
      Original-Code im Post #32 (Getränkeautomat)

      Hat sich da der Fehlerteufel eingeschlichen?

      Ich frage mich warum der Aufwand, um 4 Singelwerte (Preise für 4 Ausgabeluken) zu aufwendig in Strings gewandelt werden und diese 10x im EEProm angelegt werden.

      Da dieser Beitrag ja um das Ablegen von Werten im EEProm geht, wollte ich das hier nochmal klarstellen.

      Im Post 22 hatte ich ja schon beschrieben, wie man die Werte ablegen und auslesen kann.