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!

    • EEPROM beschreiben

      Hallo Zusammen,
      zum neuen Jahr erstmal alles Gute; vor allem Gesundheit
      Mein Problem ist wie folgt: ich versuche bei einem Mega 328P das EEPROM zu lesen und zu beschreiben. Ich habe sowas vorher noch nie gemacht. (programmiert)
      Also erstmal Google befragt und das Forum hier, und die diversen Bücher, die man so hat. Einiges ist mir klar geworden, aber längst nicht alles.

      Ich bin mal vorsichtig mit einem keinen Prgrämmchen angefangen, bei dem ich das Lesen + schreiben von aussen über Taten steuern kann. Ich möchte gerne die Werte auf die Positionen 1 , 2 , 3 ,4 schreiben Wenn ich 1 auf Pos. 1 oder auf Pos 2 schreibe ist das Erg.beim lesen was ganz anderes, aber immer das Gleiche.
      Frage ist auch : wo findet man ein gutes / aktuelles Bascom Tutorial zu dem Thema.

      Damit ich ich die Materie reinfinde, wer kann mir bitte mal helfen. Mein Programm ( mit allen auskommentierten Zeilen) hab ich mal angehängt.

      Danke + Gruss
      Theo

      Quellcode

      1. Schreiben und lesen bei EEPROM (Version 1)
      2. MCU : Mega 328P im Dil Gehäuse
      3. Clock : 16 Mhz
      4. Bascom Version : 2.0.8.1
      5. erstellt am :15.01.19
      6. Der hier verwendete Mega 328P hat lt. Datenblatt 1 KB Speicher = 1024 Bit =512 Byte
      7. Version 0
      8. Dieses Programm liest die Pos 1 im EEPROM; der Wert Ist 255 ; weil : das Eprom wurde noch nie beschrieben
      9. an diesem Plaz
      10. Version 1
      11. Schreiben auf Pos 1 mit "1" e5rgibt beim lesen "96" ; da stimmt was nicht
      12. ')
      13. $regfile = "m328pdef.dat" ' Prozessor AVR Mega 328P
      14. $crystal = 16000000 '16Mhz ext. Quartz
      15. $swstack = 40
      16. $hwstack = 40
      17. $framesize = 60
      18. $eeprom
      19. Declare Sub Eeprom_schreiben()
      20. Declare Sub Eeprom_lesen()
      21. Config Pinc.5 = Input
      22. Taster_schreiben Alias Pinc.5
      23. Portc.5 = 1
      24. Config Pinc.4 = Input
      25. Taster_lesen Alias Pinc.4
      26. Portc.4 = 1
      27. Dim Array_werte(5) As Byte
      28. Array_werte(1) = 10
      29. Array_werte(2) = 15
      30. Array_werte(3) = 20
      31. Array_werte(4) = 25
      32. Array_werte(5) = 30
      33. Dim Wert As Byte
      34. Dim B As Byte
      35. Dim Zaehl_lesen As Byte , Zaehl_schreiben As Byte
      36. Zaehl_lesen = 0 : Zaehl_schreiben = 0
      37. Dim Durchl_lesen As Byte , Durchl_schreiben As Byte
      38. Durchl_lesen = 0 : Durchl_schreiben = 0
      39. Dim E_wert_schreiben As Eram Byte
      40. Dim E_wert_lesen As Eram Byte
      41. Dim A As Eram Byte
      42. Dim Pos As Byte
      43. Pos = 2
      44. Do
      45. Debounce Taster_schreiben , 0 , Schreiben , Sub
      46. Debounce Taster_lesen , 0 , Lesen , Sub
      47. If Zaehl_lesen = 1 Then
      48. Eeprom_lesen
      49. Zaehl_lesen = 0
      50. End If
      51. If Zaehl_schreiben = 1 Then
      52. Eeprom_schreiben
      53. End If
      54. Loop
      55. End
      56. Sub Eeprom_lesen()
      57. 'Readeeprom E_wert_lesen , Pos
      58. 'Pos = 1
      59. 'Readeeprom E_wert_lesen , Pos
      60. 'Readeeprom A , Pos
      61. Readeeprom B , Pos 'hier kann man offensichtlich eine ganz normale Byte - Variable nehmen
      62. Wert = B
      63. Print "Platz " ; Pos ; " im Eeprom: " ; Wert
      64. End Sub
      65. Sub Eeprom_schreiben()
      66. E_wert_schreiben = 1
      67. Writeeeprom E_wert_schreiben , Pos
      68. Print "habe Platz " ; Pos ; " beschrieben"
      69. Zaehl_schreiben = 0
      70. End Sub
      71. Schreiben:
      72. Incr Zaehl_schreiben
      73. Return
      74. Lesen:
      75. Incr Zaehl_lesen
      76. Return
      Alles anzeigen
    • Theo schrieb:

      wer kann mir bitte mal helfen.
      Wenn du das Programm so laufen lässt wird das auch nichts, da deine Variable Pos sich nie ändert.

      Readeeprom Daten , Adresse
      Writeeeprom Daten , Adresse

      Heisst also, wenn du immer an der selben Adresse etwas ins EEProm schreibst kommt am Ende auch immer wieder das Selbe raus.
      Du zählst die Variable Zaehl_lesen und Zaehl_schreiben hoch die keinen Einfluss auf die Adresse (Pos) vom EEProm hat.


      Besser ist:

      BASCOM-Quellcode

      1. Schreiben:
      2. Incr Pos
      3. Return
      4. Lesen:
      5. Pos = Pos - 1
      6. Return
      Um Daten aus dem EEProm zu Lesen wären AUF AB Tasten besser. Und die letzte Position im EEProm solltest du auch zwischenspeichern, damit du nichts überschreibst.
      Und noch etwas: fang mit dem Schreiben nie bei Adresse NULL an.

      PS: Deine Werte E_wert_schreiben ändern sich leider auch nicht. :)
      Eine Lösung habe ich nicht, aber mir gefällt Ihr Problem.
    • In Zeile 53 bis 55 definierst du:

      Theo schrieb:

      Dim E_wert_schreiben As Eram Byte
      Dim E_wert_lesen As Eram Byte
      Dim A As Eram Byte
      Damit hast du 3 Variablen, die ihre Werte direkt im EEProm ablegen. An Adresse 0 ist E_Wert_schreiben, an Adresse 1 ist E_wert_lesen und an Adresse 2 ist A.

      Wenn du eine Zuweisung machst wie E_Wert_schreiben=5, dann wird der Bytewert 5 im EEProm an Adresse 0 abgelegt.
      Wenn du das mit A machst, also A=100, dann wird im EEProm an Adresse 2 der Bytewert 100 abgelegt.

      Lesen geht gleich.
      Das liest den Wert aus EEProm-Adresse 0 und legt den Wert ab in testVar.


      BASCOM-Quellcode

      1. Dim testVar as Byte
      2. testVar=E_Wert_schreiben
      In deiner Sub EEProm_schreiben()
      schreibst du zum einen: E_Wert_schreiben=1, damit steht eine 1 an EEProm-Adresse 0.

      Dann schreibst du: Writeeeprom E_Wert_schreiben, Pos

      Damit legst du den Wert aus Adresse 0 zum Schreiben für den Wert Pos fest.
      Der Wert Pos wird also an Adresse 1 abgelegt.
      Da überschreibst du wieder den Wert von E_Wert_lesen, der ja an Adresse 1 liegt.


      Theo schrieb:

      Sub Eeprom_schreiben()
      E_wert_schreiben = 1
      Writeeeprom E_wert_schreiben , Pos
      Print "habe Platz " ; Pos ; " beschrieben"
      Zaehl_schreiben = 0
      End Sub

      Wenn du mit Adressen hantierst in der Form
      Readeeprom Adresse, var
      Writeeeprom Adresse, var

      dann solltest du wissen, wie deine Werte im EEProm abgelegt werden.

      Die Verwendung von Variablen, die als ERAM Byte dimensioniert werden ist anfangs einfacher, da du dich nicht um die Adressen kümmern musst.

      Variablen, die als ERAM definiert werden, werden in der Reihenfolge im EEProm abgelegt, in der sie dimensioniert werden.
      Variablen haben aber auch unterschiedliche längen, das muss man berücksichtigen, wenn man die Adresse berechnen will.
    • Ergänzend kann man noch erwähnen: Variablen, die man als eram-Variablen dimensioniert hat, kann man nicht zum 'Rechnen' verwenden. Man kann nur einen Wert zuweisen, bzw lesen. Bei dim a as eram byte kann man zB b=a +5 nicht schreiben. In diesem Fall braucht man eine Hilfsvariable, dim aa as byte und dann aa=a, b=aa+5.

      ERAM
      For ERAM variables, it is important to understand that these are not normal variables. ERAM variables serve as a way to simple read and write the EEPROM memory. You can use READEEPROM and WRITEEEPROM for that purpose too.
      To write to an ERAM variable you have to use an SRAM variable as the source : eramVAR= sramVAR
      To read from an ERAM variable you have to use an SRAM variable as the targer : sramVAR=eramVAR
      Both variables need to be of the same data type. So when writing to an ERAM double, the source variable need to be of the double type too.
      ERAM can be assigned with a numeric value too : eramVAR= 123
      You can not use an ERAM variable as you would use a normal variable.
      Also keep in mind that when you write to ERAM, you write to EEPROM, and that after 100.000 times, the EEPROM will not erase properly.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Hallo zusammen,
      @Mitch 64 und @djmsc , vielen Dank für Eure Kommentare. Diese haben aber leider nicht zur „Erhellung meines Wissens“beigetragen.
      Ich schreibe mal, was ich bisher verstanden habe :
      • Nie die Adresse0 beschreiben
      • Die Anweisung readeeprom Wert , Adresse beinhaltet unter der Variablen Wert den Wert den man an die Adresse (=Position) lesen bzw. schreiben will.
      • Man darf ein EEPROM nur ca. 10.000 mal beschreiben, danach ist es „kaputt“
      • Lesen einer Zelle ist in der Häufigkeit unbegrenzt
      • Die mit Dim Var as Eram Byte dimensionierten Variablen, sind nur zum schreiben / lesen in das ERAM geeignet, und können im „normalen Programm“ so nicht weiterverwendet werden. (müssen also einer „normal dimensionierten“ Variablen zugewiesen werden).
      Auf dieser Basis ist erstmal mein kleines Progrämmchen aufgebaut. Mit den 2 Tastern bestimme ich ob gelesen oder geschrieben werden soll.Ich schreibe also auf dieAdresse (bei mir Variable Pos = Adresse) und lese hinterher diesen Wert wieder aus, indem ich den 2. Taster betätige. Wenn ich eine andere Adresse beschreiben will muss ich Pos ändern ( + neu compilieren + flaschen). Die Variablen „zaehl_lesen“ und „zaehl_schreiben“ dienen auch dazu zu gewährleisten, dass der Lese- bzw. Schreibvorgang nur 1x ausgeführt wird nach einer Tastenbetätigung, und nicht unendlich oft,wegen der begrenzten Anzahl Schreibvogänge.Ich stelle mir so ein ERAM pysikalisch vor wie eine Spalte in einer Excel Tabelle, nur das die Zeilenzahl auf 512 Zeilen begrenzt ist. In jede Zelle kann man ein Byte schreiben. Also in toto 512 Byte Werte oder 256 Integer - Werte.
      Frage : wie muss kann denn die Adresse angeben ? kann man hier eine Dezimalzahl verwenden, oder muss das in Hex vorliegen. (in Hex angegeben werden)
      Ich sehe auch den Zusammenhang nicht zwischen der Reihenfolge wie man die zu schreibenden Werte dimmt mit Dim E-variable as Eram Byte und der Position im ERAM. Wenn das so ist , wie Mitch 64 schreibt, wie muss man es den dann formulieren, wenn man z.Bsp. in einer Schleife dir Werte eines Arrays auf individuelle Adressen schreiben will?
      @tschoeatsch : Danke für Deinen Beitrag; das die E-ram Variable nicht zum allg. verrechnen ist, war mir bewusst.
      Wie Ihr seht, es ist bei mir noch vieles unklar; wer kann mir mal „beistehen“, ggf. mit einigen aussagekräftigen Beispielen ?
      Die Korrekturen von Mitch64 und djmsc werde ich heute mal ausprobieren.
      Gruss
      Theo
    • Du kannst direkt Variablen Speicherplätzen des EERam definieren.
      Weist du einer EERam Variable einen Wert zu, wird der ins EERam geschrieben!

      BASCOM-Quellcode

      1. $regfile = "m328pdef.dat" ' Prozessor AVR Mega 328P
      2. $crystal = 16000000 '16Mhz ext. Quartz
      3. $swstack = 40
      4. $hwstack = 40
      5. $framesize = 60
      6. Dim myEEDummyByte as eram byte 'Dummy auf EERam Byte 0
      7. Dim myEEVarByte as eram byte ' Byte Variable auf Pos 1 im ERam
      8. Dim myEEVarWord as eram word ' Word Variable auf Pos 2 im ERam -> nächste Pos wäre dann 4. Das Word belegt 2 Byte!
      9. Dim myVarByte as byte
      10. ' Hole Wert aus EERam
      11. myVarByte = myEEVarByte
      12. ' Schreibe neuen Wert in EERam
      13. myVarByte = 12
      14. myEEVarByte= myVarByte
      Alles anzeigen
      Code first, think later - Natural programmer :D
    • Theo schrieb:

      Man darf ein EEPROM nur ca. 10.000 mal beschreiben, danach ist es „kaputt“
      Nein, dies ist die garantierte Schreibanzahl. Wenn du sehr viele schreibzugriffe nötig hast ist ein externes eeprom(I2C) besser.
      Aber immer dran denken EEPROM-Aktinen sind vergleichsweise laaaangsam.

      Theo schrieb:

      Die mit Dim Var as Eram Byte dimensionierten Variablen, sind nur zum schreiben / lesen in das ERAM geeignet, und können im „normalen Programm“ so nicht weiterverwendet werden. (müssen also einer „normal dimensionierten“ Variablen zugewiesen werden).
      Ich spiegle diese Variablen daher immer:
      Dim Var as byte
      Dim eVar as eram byte

      vor rechnerei mit der Var:
      Var = eVar

      Nicht vergessen dies auch zu speichern:
      eVar = var


      Theo schrieb:

      Nie die Adresse0 beschreiben
      Das hält sich hartnäckig, ist aber schon lange nicht mehr notwendig. Habe damit noch nie Probleme gehabt. Kann vielleicht bei uralten AVR-Serien aufgetreten seien, man könnte ja die ERRATA-Anhänge in den Datenblättern deswegen durchfosten.
    • @Theo

      Es gibt 2 verschiedene Arten den Eeram zu beschreiben.

      1. Indirekte Adressierung
      Dim E_ramvariable_1 as Eram byte
      ...
      Dim E_ramvariable_n as Eram Word
      Dim Ramvariable_1 as byte
      ...
      Dim Ramvariable_n as Word

      E_ramvariable_1 = ramvariable_1 ' schreibt den Wert der ramvariable ins EEram (1 Speicherzelle weil Byte)
      ...
      E_ramvariable_n = ramvariable_n ' schreibt den Wert der ramvariable ins EEram (2 Speicherzellen weil Word)

      Die Adressierung erfolgt über den Namen der EEram-Variablen, es müssen keine direkten Adressen ermittelt werden.

      2. Direkte Adressierung
      Dim variable_1 as Eram byte at &H00 ' 1 Speicherzelle erforderlich
      Dim mvariable_2 as Eram long at &H01 ' 4 Speicherzellen erforderlich
      Dimvariable_3 as EramWord at &H05 ' 2 Speicherzellen erforerlich

      writeeeprom variable_1, Pos ' Pos muß &H00 beeinhalten
      writeeeprom variable_3, Pos ' Pos muß &H05 beeinhalten

      Die Adressierung erfolgt über die Hex-Adresse des Speicherplatzes, also direkt. Du mußt Dir also einen Plan deiner Speicherplätze anlegen um damit vernünftig arbeiten zu können. Das Format der Variablen nachträglich zu ändern ist schwierig weil eine z.B. von Byte nach Word geänderte Variable dann eine eventuell bereits verwendete Zelle einer anderen Variablen überschreibt.
      Wem ich nicht ausdrücklich widerspreche, der darf das bis auf Widerruf als "Gefällt mir" verstehen.
    • Theo schrieb:

      Frage : wie muss kann denn die Adresse angeben ? kann man hier eine Dezimalzahl verwenden, oder muss das in Hex vorliegen. (in Hex angegeben werden)
      Der Adressraum ist linear von 0...1023 (beim 328p), egal ob du das dezimal oder hexadezimal angiebst. Diese Adresse wird vor dem EEpromzugriff in Register EEAR gespeichert. Die Daten welche gelesen oder geschrieben werden sind im Register EEDR, das EEPROM arbeitet also bytweise. Das Register EECR ist das für EEprom-aktionen zuständige Steuerregister. Diese 3 Register brauchst du aber als Bascom-AVR-Nutzer nicht unbedingt kennen,das erledigt alles Bascom für dich. Du musst dich nur trennen von der Vorstellung dass du direkten Zugriff auf die Speicherzellen hast. Übrigens dauert ein schreibvorgang ca 1,8 /3,3ms ist also sehr langsam. Was schwebt dir eigentlich vor? Willst du Daten im EEPROM sammeln? Dafür ist der weniger gut geeignet. Dafür sind externe Flash-speicher besser (z.B. SD-Card). Der EEPROM ist gedacht als Konfigurationsspeicher, damit diese Konfiguration im stromlosem Zustand erhalten bleiben, also Werte die nur selten geändert werden.
    • @Theo wenn du mit bascom deinen Kontroller auch flasht, dann kannst du das eram auch gut anzeigen lassen.
      Dieses Programm

      BASCOM-Quellcode

      1. $regfile = "m168pdef.dat"
      2. $Crystal=16000000
      3. $hwstack = 64
      4. $swstack=32
      5. $framesize=30
      6. Dim A As Eram Byte
      7. Dim B As Eram Byte
      8. Dim C As Eram Byte
      9. Dim D As Eram Byte
      10. Dim E As Eram Byte
      11. Dim F(4) As Eram Byte
      12. Dim Fh(4) As Byte
      13. Dim N As Byte
      14. A = 1
      15. B = 2
      16. C = 3
      17. D = 4
      18. E = 5
      19. For N = 1 To 4
      20. Fh(n) = N + 10
      21. F(n) = Fh(n)
      22. Next N
      23. End
      Alles anzeigen
      hab' ich compiliert, geflasht und laufen lassen. Danach hab' ich wieder 'program chip (F4)' aufgerufen, auf den Reiter EEPROM geklickt und dann 'read code from chip into buffer' geklickt. Dann sieht man den Inhalt
      read eram.PNG
      Beachte auch die möglichen fuses, was das Löschen des EEPROMs beim flashen angeht
      erase.PNGpreserve.PNG
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Theo schrieb:

      Wie Ihr seht, es ist bei mir noch vieles unklar; wer kann mir mal „beistehen“, ggf. mit einigen aussagekräftigen Beispielen ?


      Sende dir, wenn gewünscht, ein Beispielcode. Daten sind ungleichlange Strings.

      eine Taste für schreiben, als Speicheranhang drücken. Ist Eeprom voll kommt Signal Tastelesen drücken. Der Inhalt kann als z.B. CSV verschickt werden und Eeprom wird unverzüglich von vorn neubeschrieben. Also der komplette Speicherbereich wird beim schreiben gleich“belastet“ nicht nur bestimmte Zellen.

      Ist aber nur für 8Bit wie es alle AVR internenSpeicher sind. Wen gewünscht sende ich auch noch Lösung für externe I2C 16Bit Eeproms

      Mit freundlichen Grüßen
    • Hallo Zusammen,
      ganz herzlichen Dank für die vielen Tipps / Anleitungen! Da muss ich jetzt mich erst mal "durchwühlen".
      Melde mich dann wieder, wenn die nächsten Fragen auftauchen.

      Zum Zweck der "Übung":
      in einem anderen Projekt habe ich in den letzten Wochen eine Zeitschaltuhr programmiert. Funktioniert auch soweit wie gewünscht ( zu98% jedenfalls) Einige Kleinigkeiten müssen noch verbessert / vereinfacht werden, aber sonst geht's.
      Was mir noch fehlt ist die ausfallsichere Speicherung der Ein- und Ausschaltzeiten am Tag. Da dache ich dies mit dem ERAM zu machen, das bereits im Prozessor ist. ( nicht mit einem ext. Speicherbaustein)
      Das beschreiben/ lesen findet so oft auch nicht statt. Ist ja kein Datarecorder, und es sind erst mal nur 4 Byte - Werte
      2. ist es aber auch so, dass ich das immer schon mal verstehen wollte, und jetzt ist halt der richtige Zeitpunkt für diese "Sub". I
      Ich betreibe Bascom als Rentner im Selbststudium, da geht's hat nicht so fix. Dazu bin ich nicht gelernter "Programmierer" sondern komme aus dem Masch.-bau.
      Vielen Dank nochmal!
      Gruss
      Theo
    • Theo schrieb:

      Was mir noch fehlt ist die ausfallsichere Speicherung der Ein- und Ausschaltzeiten am Tag. Da dache ich dies mit dem ERAM zu machen, das bereits im Prozessor ist.
      Das ist auch richtig so, dazu ist der ja da.

      Theo schrieb:

      Ich betreibe Bascom als Rentner im Selbststudium, da geht's hat nicht so fix. Dazu bin ich nicht gelernter "Programmierer" sondern komme aus dem Masch.-bau.
      Kein Problem. Die Meisten von uns sind Hobbyprogrammierer und haben das nicht gelernt sondern sich angeeignet.
      P.S.: Bin auch Rentner
    • Theo schrieb:

      ausfallsichere Speicherung der Ein- und Ausschaltzeiten am Tag
      Dafür reicht das allemal.
      Eine Frage wie wird die Uhr programmiert über Tasten wie eine Theben oder Seriell mit PC Oder einmal mit Festzeiten durch brennen?
      Mir persönlich sind die eram-bytes nicht sysmphatisch .
      Ich schreibe immer direkt z.B. writeeprom start,16. Dann weiß ich wo was ist. Das erleichtert die Übersicht im Simulator und das Erstellen von größeren eep Dateien per PC.
      Selbst wenn man mehrmals täglich die Zeiten ändert lebt man nicht lange genug den EEpromtod zu erfahren. Ich glaube Ceperiga? hatte einen EEprom-zerstörer programmiert. Das hielt weit über 100000
      schreibvorgänge bevor die Zelle defect war.
    • Michael schrieb:

      Du hast also Grund zur Annahme, dass dein Beitrag nicht zum Thema passt?
      Nein nicht passt aber falsch ausgelegt.


      Bitte nicht jetzt und hier über Annahme oder Beweise diskutieren(oder wer als Lügner bezeichnet werden darf) und nur weil der Er soviel Anstand besitzt die Menge an Unschuldsbeweise nicht zu veröffentlichen um Tritte zu schädigen oder beschäftig ist.


      Bin momentan Beschäftig meine große AVRBascomsammlung platt zu machen. Ist schon erstaunlich was man alles vergessen hat. Schick mal noch einen kleinen DCF-Beitrag. Inhalt ist bestimmt so alt wie Win XP also nicht lesenswert, wenn nicht sogar gefährlich.
      fand da auch die Eepromcode.

      Wie du siehst ich lass mir den Humor nicht nehmen
    • Hallo Zusammen,
      so, die "indirekte Adressierung" habe ich jetzt wohl verstanden. man muss ja nur wissen, dass durch die Reihenfolge In den Dim Anweisungen schon die Adressen der Speicherplätze vergeben werden. (Das steht auch nirgendwo , oder….

      @ Pluto: Die Zeitschaltuhr Kurz: DCF77 als Zeitgeber;Drehencoder mit Schalter (Taster) 4-zeiliges LCD Display Zeile 1 +2 Uhrzeit und Datum; zeile 3+4 T-Ein und T-Aus in HH:MM; über den Taster steuert man dann welche Zeit man einstellen will; diese Einheit blinkt solange mit 300ms Takt bis man mit dem Taster "weitertaktet". Mit dem letzten (5.) Tastertakt ist die Uhr scharf gestellt.

      Ich hänge mal hier mein erstes Programm an, für alle die später die EEPROM- Problematik mal gebrauchen / üben / verstehen wollen. Dann wende ich mich jetzt mal der "direkten Adressierung" zu; das ist mir glaub ich auch lieber, weil besser im Programm lesbar ( stell ich mir vor)

      BASCOM-Quellcode

      1. '(
      2. Schreiben und lesen bei EEPROM (Version 3)
      3. MCU : Mega 328P im Dil Gehäuse
      4. Clock : 16 Mhz
      5. Bascom Version : 2.0.8.1
      6. erstellt am :17.01.19
      7. Der hier verwendete Mega 328P hat lt. Datenblatt 1 KB Speicher = 1024 Bit =512 Byte
      8. Hier wird das Eeram beschrieben mit indirekter Adressierung der Speicherplätze .
      9. Mit den 2 Tastern wird jeweils 1 (ein) Lesevorgang / Schreibvorgang ausgelöst.
      10. ')
      11. $regfile = "m328pdef.dat" ' Prozessor AVR Mega 328P
      12. $crystal = 16000000 '16Mhz ext. Quartz
      13. $swstack = 40
      14. $hwstack = 40
      15. $framesize = 60
      16. '$eeprom 'diese Zuweisung ist offensichtlich nicht nötig (Widerspruch zu Bascom Hilfe)
      17. Declare Sub Eeprom_schreiben()
      18. Declare Sub Eeprom_lesen()
      19. Config Pinc.5 = Input
      20. Taster_schreiben Alias Pinc.5
      21. Portc.5 = 1
      22. Config Pinc.4 = Input
      23. Taster_lesen Alias Pinc.4
      24. Portc.4 = 1
      25. Dim Array_werte(5) As Byte
      26. Array_werte(1) = 60
      27. Array_werte(2) = 65
      28. Array_werte(3) = 70
      29. Array_werte(4) = 75
      30. Array_werte(5) = 80
      31. Dim Wert As Byte
      32. Dim Pos_zeiger As Integer
      33. Pos_zeiger = -1 'Weil Integer und vwird im ersten Durchlauf bereits zu Anfang auf 0 gesetzt
      34. Dim Zaehl_lesen As Byte , Zaehl_schreiben As Byte
      35. Zaehl_lesen = 0 : Zaehl_schreiben = 0
      36. '##### indirekte Adressierung der ERam Speicherplätze ##########
      37. 'Durch die Reihenfolge der Dim - Anweisungen wird auch der Speicherort im ERam festgelegt
      38. Dim E_wert0 As Eram Byte 'diese Dim Anweisung legt auch gleichzeitig die Adresse (den Speicherplatz) im ERam fest (Hier Platz 0)
      39. Dim E_wert1 As Eram Byte 'dito Platz 1
      40. Dim E_wert2 As Eram Byte ' dito Platz 2
      41. '###### das könnte jetzt beliegig fortgeführt werden bis zum Ende des Speicherbereiches
      42. Do
      43. Debounce Taster_schreiben , 0 , Schreiben , Sub 'Taster um schreiben auszulösen
      44. Debounce Taster_lesen , 0 , Lesen , Sub 'Taster um lesen auszulösen
      45. If Zaehl_lesen = 1 Then
      46. Eeprom_lesen
      47. Zaehl_lesen = 0
      48. If Pos_zeiger = 2 Then
      49. Print "alle Werte gelesen!"
      50. Pos_zeiger = -1
      51. End If
      52. End If
      53. If Zaehl_schreiben = 1 Then
      54. Eeprom_schreiben
      55. Zaehl_schreiben = 0
      56. If Pos_zeiger = 2then
      57. Print "alle Werte gechrieben!"
      58. Pos_zeiger = -1
      59. End If
      60. End If
      61. Loop
      62. End
      63. Sub Eeprom_lesen()
      64. Select Case Pos_zeiger
      65. Case 0
      66. Wert = E_wert0 ' dieser Befehl reicht, um aus dem Eeprom zu lesen (siehe oben bei den Dim Anweisungen)
      67. Case 1
      68. Wert = E_wert1 'dito
      69. Case 2
      70. Wert = E_wert2 'dito
      71. End Select
      72. Print "Platz " ; Pos_zeiger ; " im Eeprom: " ; Wert
      73. Zaehl_lesen = 0
      74. End Sub
      75. Sub Eeprom_schreiben()
      76. Select Case Pos_zeiger
      77. Case 0
      78. E_wert0 = Array_werte(1) 'dieser Befehl reicht um ins's Eeprom zu schreiben (siehe oben bei den Dim - Anweisungen)
      79. Case 1
      80. E_wert1 = Array_werte(2) 'dito
      81. Case 2
      82. E_wert2 = Array_werte(3) 'dito
      83. End Select
      84. Print "habe Platz " ; Pos_zeiger ; " beschrieben"
      85. Zaehl_schreiben = 0
      86. End Sub
      87. Schreiben:
      88. Incr Zaehl_schreiben
      89. Incr Pos_zeiger
      90. Return
      91. Lesen:
      92. Incr Zaehl_lesen
      93. Incr Pos_zeiger
      94. Return
      Alles anzeigen
      Ich hatte heute Mittag einen Betrag 2x aus versehen ins Forum gestellt, bekam den 2. dann aber nicht mehr gelöscht.
      Eine Bitte dann die Admins: kann einer bitte mal einen der 2 gleichen Beiträge löschen; sieht nämlich doof aus meine ich.
      Herzlichen Dank!

      Gruss
      Theo