I2C Eeprom ST 24C64

Hallo Forum,
es gibt schon viele Beispiele und Hinweise diese mit Byte zu beschreiben und lesen.
Ist ja auch kein Problem aber ich finde keine vernünftige Lösung für Single –Variablen.
Dieses Thema ist nach meiner persönlichen Meinung schon sehr unübersichtlich geworden. Somit ein Neustart.
Nun bitte ich um Hilfe.

Vielen Dank vorab
Mit freundlichen Grüßen
fredred


Zum Verständnis mein Terminal- Ausdruck für Byte-Variablen.
Funktioniert prima. Aber wie mit Single-Variablen ????
-------------------------------------

Code:

---

I2C Scan start
gefunden h A0 b 10100000

EEPROM beschreiben...
Adresse >1< wurde mit >0 beschrieben!
Adresse >2< wurde mit >110 beschrieben!
Adresse >3< wurde mit >120 beschrieben!
Adresse >4< wurde mit >130 beschrieben!
Adresse >5< wurde mit >140 beschrieben!
Adresse >6< wurde mit >150 beschrieben!

EEPROM auslesen...
Adresse >1< wurde mit >0 gelesen!
Adresse >2< wurde mit >110 gelesen!
Adresse >3< wurde mit >120 gelesen!
Adresse >4< wurde mit >130 gelesen!
Adresse >5< wurde mit >140 gelesen!
Adresse >6< wurde mit >150 gelesen!

Hier mein letzter Code
'****************** Test-Platine *************************
'* ist ein Testmodul für Data extern EEprom als Speicher *
'* am I²C Bus ein 24c64 angeschlossen zum speichern *
'* und lesen der Variablen *
'* *
'* alle Auswertungen für Test nur über Terminal anzeigen *
'* *
'*************! fredred@arcor.de !************************

$regfile "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40
$baud = 19200

'gibt den Erstellungszeitpunkt im europäischen Format DD-MM-YY hh:nn:ss
'und die Code-Version aus.
Print " "
Print "erstallt am : " ; Version(1)
Print "Version Code : " ; Version(3)
Print " "
Waitms 100

$lib "i2c_TWI.lib" 'Hardware I²C einbinden
Config Twi = 100000 ' Takt 100kHz

Const 24c64w = &B10100000
Const 24c64r = &B10100001

Dim Adresse As Word 'ist Adresszähler für Eeprom
Dim Adresse_l As Byte At Adresse Overlay
Dim Adresse_h As Byte At Adresse + 1 Overlay


Dim Wert(6) As Word 'ist Schreibwerte Array
Dim Wertalt As Word 'ist Lesewert
Dim Aktionen As Byte 'ist Status für Aktionen

'war nur ein erfolgloser Versuch

'Dim Wert As Single
'Dim Werts As Byte At Wert(4) Overlay
'Dim Wertalt As Single
'Dim Wertl(4) As Byte At Wertalt Overlay


'!!!!! ist nur für Test mit Taster also anpassen !!!!
Config Pinc.3 = Input 'Taster für EEprom schreiben
Portc.3 = 1 'Port auf H schalten
Taster_s Alias Pinc.3 'Taster ein Namen geben

Config Pinc.2 = Input 'Taster für EEprom lesen
Portc.2 = 1 'Port auf H schalten
Taster_l Alias Pinc.2 'Taster ein Namen geben

'Config Portc.4 = Output
'Eepvoll Alias Portc.4 'LED-Warnung für EEprom voll

'+++ zu Test ob I²C Hardware OK ist +++
Gosub I2c_test
'++++++++++++++++++++++++++++++++++++++

'------- nach Reset lesen -------------
Gosub Lesen
'--------------------------------------

Do

'!!! Testwerte !!!
Wert(1) = Aktionen
Wert(2) = 110
Wert(3) = 120
Wert(4) = 130
Wert(5) = 140
Wert(6) = 150
'!!!!!!!!!!!!!!!!!!

'--- hier zum Daten schrieben --------
If Taster_s = 0 Then 'wenn Taste gedrückt schreiben
Waitms 100 'nur für Test
Incr Aktionen 'nur für Test
Gosub Schreiben
End If
'--- hier zum Daten lesen ------------
If Taster_l = 0 Then 'wenn Taste gedrückt lesen
Waitms 100 'nur für Test
Gosub Lesen
End If
Loop
End


'###################################################################
Lesen:
Print ""
Print "EEPROM auslesen..."

For Adresse = 1 To 6
I2cstart
I2cwbyte 24c64w
I2cwbyte Adresse_h
I2cwbyte Adresse_l
I2cstart
I2cwbyte 24c64r
I2crbyte Wertalt , Nack
I2cstop
Print "Adresse >" ; Adresse ; "< wurde mit >" ; Wertalt ; " gelesen!"
Next
Return

'#############################################################################
Schreiben:
Print ""
Print "EEPROM beschreiben..."

For Adresse = 1 To 6
I2cstart
Adresse_h = High(adresse)
Adresse_l = Low(adresse)
I2cwbyte 24c64w
I2cwbyte Adresse_h
I2cwbyte Adresse_l
I2cwbyte Wert(adresse)
I2cstop
Print "Adresse >" ; Adresse ; "< wurde mit >" ; Wert(adresse) ; " beschrieben!"
Next
Return

'#############################################################################

I2c_test:

Dim Busaddress As Byte
Dim Busaddress_read As Byte
Dim Chipaddress As Byte

Print "I2C Scan start"

'I²C Porterweiterung testen
'Alle Adresen suche und Anzeigen
'Step 2 soll nur IC Adresse aufrufen für lesen
For Chipaddress = 0 To 254 Step 2 ' IC's am I²C-Bus erkennen
I2cstart 'send start
I2cwbyte Chipaddress 'sende Addresse auf Bus
If Err = 0 Then 'Chip gefunden
If Chipaddress = 24c64w Then
Print "gefunden " ; "h " ; Hex(chipaddress) ; " b " ; Bin(chipaddress)
End If
End If
Next
Waitms 200
I2cstop
Return

---

'---------------------------------------------------------

So sieht das mit Code-Fenster aus - Manf

Bitte schließe den Terminalausdruck in [CODE] -Tags ein, damit der Thread besser lesbar wird. Danke.

Guten Tag,

bin noch nicht so firm im Forum.
War der Meinung mein Ergebnis sollte in der Erklärung stehen wie weit ich gekommen bin.
Um somit eventuelle Anfragen ob Hartware usw. OK ist zu vermeiden.
Auch dein Hinweis gehören in eine gutes Forum.
Somit vielen Dank.

Mit freundlichen Grüßen
fredred

Zitat:

---

Zitat von fredred

es gibt schon viele Beispiele und Hinweise diese mit Byte zu beschreiben und lesen.
Ist ja auch kein Problem aber ich finde keine vernünftige Lösung für Single –Variablen.

---

Hallo,
nach Deinem Code hast Du ja schon Bytes geschrieben und zurückgelesen. Den Kommentaren zufolge hast Du es beim Typ Single auch schon mit Overlays versucht. Die Overlay Verwendung scheint mir bei Dir falsch gewesen zu sein.

Hier ein Codefragment um eine Single-Variable zu schreiben und zu lesen. Wichtig hierbei eben die richtige Deklaration der Overlays. Übertragen in Deinen Code mit Ergänzungen und den den richtigen EEPROM Adressen "darfst" Du machen ;) Wenn das klappt, kann man zum Speichern mehrerer Single übergehen.

Code:

---

Dim I As Byte                          'Laufvariable für for-next Schleife

Dim Four_byte_var_wr As Single                                  'Single Variable für Write belegt vier Byte
Dim Byte_var_write(4) As Byte At Four_byte_var_wr Overlay      'Array mit vier mal ein Byte liegt über der Write-Single

Dim Four_byte_var_rd As Single                                  'Single Variable für Read belegt vier Byte
Dim Byte_var_read(4) As Byte At Four_byte_var_rd Overlay        'Array mit vier mal ein Byte liegt über der Read-Single

Four_byte_var_wr = &H1A2B3C4D          'dezimal = 439041101 (irgendeine Zahl)

For I = 1 To 4                          'die vier Bytes der Single Variablen zum EEPROM schreiben
  .
  I2cwbyte Byte_var_write(i) ,(ack , Nack)
  .
Next
  .
For I = 1 To 4                          'die vier Bytes der Single Variablen vom EEPROM lesen
  .
  I2crbyte Byte_var_read(i) ,(ack , Nack)
  .
Next

Print Four_byte_var_wr
Print Four_byte_var_rd

End                                    'end program

---

Gruß
Searcher

PS. Die [ CODE][ /CODE] Tags (ohne die Leerzeichen in den eckigen Klammern) erreicht man auch mit dem "Erweitert" Button und dann mit dem # Zeichen. Posts kann man auch nachträglich noch editieren.

Hallo Searcher,

sieht auf dem ersten Blick schon mal sehr Gut aus.
Werde es Morgen mal versuchen im mein Code einzubinden.
Vorab schon mal vielen Dank.

Gruß
fredred

Guten Tag,

komme nicht zum Erfolg. Nun bin ich langsam ans aufgeben.
Vermute ich verstehe Overlay nicht richtig oder der IC Eeprom (ST24c64) ist eigenwillig mit Adressierung der Speicherzuordnung.
Nochmals kurz meine Endvision. 6 Single-Variablen speichern dann nach nächster Aktion die nächsten 6 Single-Variablen anhängen usw. und dann auf Befehl kompletten Speicherbereich printen lassen.

Nur zum Verständnis vorab ein Printauszug dank Hilfe.
Gleichen String hintereinander speichern dann auslesen.

'ist Test Single-Variable
Four_byte_var_wr = 500.1
Siehe Code

Byte-Wert 205
Byte-Wert 12
Byte-Wert 250
Byte-Wert 67
geschrieben 500.10
gelesen 23.69E-39
gelesen 6.25E-36

Nun der Code.

Code:

---

$regfile "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40
$baud = 19200

---

Code:

---

'gibt den Erstellungszeitpunkt im europäischen Format DD-MM-YY hh:nn:ss
'und die Code-Version aus.
Print " "
Print "erstallt am      : " ; Version(1)
Print "Version Code : " ; Version(3)
Print " "
Waitms 100
$lib "i2c_TWI.lib"                                          'hardware I²C einbinden
Config Twi = 100000                                        ' Takt 100kHz
Const 24c64w = &B10100000
Const 24c64r = &B1010000
'Format für Single zwei Nachkommastellen
Config Single = Scientific , Digits = 2

Dim Adresse As Word                                        'ist Adresszähler für Eeprom
Dim Adresse_l As Byte At Adresse Overlay
Dim Adresse_h As Byte At Adresse + 1 Overlay
Dim I As Byte                                              'Laufvariable für for-next Schleife
Dim Four_byte_var_wr As Single                              'Single Variable für Write belegt vier Byte
Dim Byte_var_write(4) As Byte At Four_byte_var_wr Overlay  'Array mit vier mal ein Byte liegt über der Write-Single
Dim Four_byte_var_rd As Single                              'Single Variable für Read belegt vier Byte
Dim Byte_var_read(4) As Byte At Four_byte_var_rd Overlay    'Array mit vier mal ein Byte liegt über der Read-Single
'ist Test Single-Variable
Four_byte_var_wr = 500.1                                    '&H1A2B3C4D 'dezimal = 439041101 (irgendeine Zahl)
Do
'********* schreiben **************
For Adresse = 1 To 8 Step 4                                'Adressbereich festlegen
  I2cstart
    Adresse_h = High(adresse)
    Adresse_l = Low(adresse)
  I2cwbyte 24c64w
  I2cwbyte Adresse
  I2cwbyte Adresse_h
  I2cwbyte Adresse_l
  I2cstop
  I2cstart
    For I = 1 To 4                                        'die vier Bytes der Single Variablen zum EEPROM schreiben
      I2cwbyte Byte_var_write(i)                            ',(ack , Nack)
      Waitms 10                                            'etwas Zeit geben
      Print "Byte-Wert  " ; Byte_var_write(i)              'Byte anzeigen ist OK
    Next I
  I2cstop
'++++ ausgeben +++++++++
'!!dieses Print macht kein Sinn Variable ist vor Do schon festgelegt!!
    Print "geschrieben  " ; Four_byte_var_wr
'+++++++++++++++++++++++
Next Adresse

Wait 2                                                      ' nur für Test

'********** lesen ****************
For Adresse = 1 To 8 Step 4                                'Adressbereich festlegen
  I2cstart
    Adresse_h = High(adresse)
    Adresse_l = Low(adresse)
  I2cwbyte 24c64w
  I2cwbyte Adresse_h
  I2cwbyte Adresse_l
  I2cstop
  I2cstart
    For I = 1 To 4
      I2crbyte Byte_var_read(i) , Nack                      'die vier Bytes der Single Variablen vom EEPROM lesen
        Waitms 10                                          'etwas Zeit geben
    Next I
  I2cstop
'++++ ausgeben ++++
    Print "gelesen        " ; Four_byte_var_rd
'++++++++++++++++++
Next Adresse

Loop
End                   
   

---

Danke an alle Helfer und besonders an Markus Fulde.
fredred

Hallo fredred,

Zitat:

---

Zitat von fredred

komme nicht zum Erfolg. Nun bin ich langsam ans aufgeben.
Vermute ich verstehe Overlay nicht richtig oder der IC Eeprom (ST24c64) ist eigenwillig mit Adressierung der Speicherzuordnung.

---

Dranbleiben! Das wird schon. Liegt jetzt erstmal nicht den Overlays sondern hauptsächlich an der Reihenfolge der I2C Kommandos und der Berechnung der Adressen - denke ich:confused: Das zu berichtigen ist mir ehrlich gesagt zuviel :( . Angefangen schon ganz oben bei der "Const 24c64r", da fehlt das letzte Bit.

Zitat:

---

Nochmals kurz meine Endvision. 6 Single-Variablen speichern dann nach nächster Aktion die nächsten 6 Single-Variablen anhängen usw. und dann auf Befehl kompletten Speicherbereich printen lassen.

---

Hast Du es schon geschafft nur eine Single zu schreiben und zu lesen?

Wenn nicht, dann hier ein Programm in Anhang, daß das macht. Es liest über die UART (zB vom PC Hyperterminal) eine Zahl ein, schreibt sie in das ext. EEPROM und liest sie danach wieder aus und gibt die geschriebene und gelesene Zahl wieder am Terminal aus.

Das Programm ist getestet, allerdings auf einem Tiny44. Du müsstest es auf den Mega32 anpassen. Die Anpassungen sollten aber nur Header, die SW-UART und SW-I2C betreffen.

Falls Du es bei Dir zum Laufen bekommst, poste es nochmal und mal schaun, wie wir mehrere Singles bearbeiten können.

Gruß
Searcher

Hallo Forum Mitglieder und Gäste
Guten Tag Herr Searcher,

dank der Hilfe, gibt es mich wieder Mut, weiter zu mache.
Dumm war nur das "Const 24c64r", da fehlt das letzte Bit. War nur ein Copyfehler.
Bitte um Entschuldigung. Natürlich muss da noch eine 1 dran sein.

Aktuelle Hilfe:
Single- Variable wird geschrieben und so wie es sein soll gelesen.
Konnte diese zwar nicht über Hyperterminal eingeben(mag sein da ich nicht den von BASCOM nutze)
[mein genutztes Terminal zeigt Strings/Hex und Binär an] ist oft sehr Hilfreich.
Ist aber gegenstandslos.
Lasse die Variable einfach hoch zählen. Nach Erfolgreichen Test und Beendigung meiner Freudensprünge gleich mal versucht den Adressbereich für die nächsten Single-Variablen anzuhängen. Oh Oh Oh schon wieder Erfolglos.
Vermute die vielen Sprünge haben nicht nur meine Knochen belastet sonder auch mein Gehirn noch mehr geschädigt.

Der hilfreiche Code für eine Single Variable kann mit Deklarationen belassen bleiben.
Anpassungen für mein Projekt bekomme ich hin(hoffe ich)

‚??? Dies kann ich nicht nachvollziehen ???
Mem_addr = Mem_addr_first_store_loc 'Speicheradresse für ext. EEPROM initialisieren
Config Base = 0 'Array Indexe beginnen mit 0
‚???????????????????????????????????????

HIER MEIN VERSUCH (erst mal schreiben)
6 Single pro Aktion hintereinander schreiben und nach nächster Aktion die 6 Single anhängen bis Eeprom voll.

‘!!! Als Array geändert Number_from_rs232 !!!
Dim Number_from_rs232(7) As Single
Dim Aktionen As Byte

Do
Wait 2
Incr Aktionen
If Mem_addr = 4 Then Mem_addr = Mem_addr_low_byte * Aktionen

For Z = 1 To 6
If Z = 1 Then Number_from_rs232(1) = 100.10
If Z = 2 Then Number_from_rs232(2) = 200.20
If Z = 3 Then Number_from_rs232(3) = 300.30
If Z = 4 Then Number_from_rs232(4) = 400.40
If Z = 5 Then Number_from_rs232(5) = 500.60
If Z = 6 Then Number_from_rs232(6) = 600.60

Four_byte_var_write = Number_from_rs232(z) 'Single Variable mit irgendeiner Zahl belegen
‘habe ich mit [Number_from_rs232(7) As Single] gemacht


‘??? Weis auch hier nicht warum ???
Four_byte_var_read = 0 'Zurückgelesene Single "löschen"

'### BEGINN ext. EEPROM schreiben (byte write method) ###
Mem_addr = Mem_addr_first_store_loc 'Speicheradresse für ext. EEPROM initialisieren
For J = 0 To 3 'Laufschleife um 4 Bytes zu schreiben
I2cstart
I2cwbyte Dev_addr_write 'Sendet ext. EEPROM Adresse zum Schreiben
I2cwbyte Mem_addr_high_byte 'Sendet Speicher-Schreibadresse
I2cwbyte Mem_addr_low_byte 'Sendet Speicher-Schreibadresse
I2cwbyte Byte_var_write(j) 'Sendet Datenbyte
I2cstop
Mem_addr = Mem_addr + 1 'Schreibadresse mit jedem Schleifendurchlauf erhöhen
Waitms 10 'Warten auf ext. EEPROM
Next J
Next Z
'### ENDE ext. EEPROM schreiben (byte write method) ###
Print "Number written to ext. EEPROM: " ; Four_byte_var_write

Loop
‘-----------------------------------------------------------------------------------------------------------------

ERGEBNIS:
Schreibt alle Single auf Adresse 1 bis 4 somit wird auch nur [Number_from_rs232(6)] gelesen. Ist ja auch der letzte Inhalt.
Wie geschrieben habe ist schon ein Erfolgserlebnis. Dumm für mich ist nur, dass die Vermutung aufkommen könnte ich möchte ein fertigen Code. Aber nach 525 Test- .BAS und 1889 Progmmed
(nur für diesen I²C Eeprom), ohne Endergebnis, benötigt man schon Hilfe.
Dachte anfangs dies mache ich in 10 Minuten. Aber, Aber.

Nun genug des Geschwätz und helft mich weiter.
Danke
fredred

Hallo fredred,

Zitat:

---

Zitat von fredred

Guten Tag Herr Searcher,

---

:-) Komisch so angesprochen zu werden. Ich duze jeden außer er verlangt explizit das siezen. Ist allgemeiner Gebrauch im Roboternetz. Also einfach Searcher und das Du, oder?

Zitat:

---

Dumm war nur das "Const 24c64r", da fehlt das letzte Bit. War nur ein Copyfehler.
Bitte um Entschuldigung. Natürlich muss da noch eine 1 dran sein.

---

Brauchst Dich nicht entschuldigen; passiert doch jedem mal. Aber die CODE Tags könntest Du mal nutzen ;)

Zitat:

---

Lasse die Variable einfach hoch zählen. Nach Erfolgreichen Test und Beendigung meiner Freudensprünge gleich mal versucht den Adressbereich für die nächsten Single-Variablen anzuhängen. Oh Oh Oh schon wieder Erfolglos.
Vermute die vielen Sprünge haben nicht nur meine Knochen belastet sonder auch mein Gehirn noch mehr geschädigt

---

:lol: Habe versucht Deinen Code hinzubiegen und ihn in CODETAGS unten eingefügt. Besser lesbar als Deiner, oder? ;) Hoffe die Kommentare sagen genug, sonst nachfragen.

Zitat:

---

‚??? Dies kann ich nicht nachvollziehen ???
Mem_addr = Mem_addr_first_store_loc 'Speicheradresse für ext. EEPROM initialisieren

---

Mem_addr ist "overlayed" von Mem_addr_low_byte und Mem_addr_high_byte, die beim Schreiben und Lesen immer auf die aktuelle Speicheradresse im EEPROM zeigen müssen. Mem_addr wird also ständig verändert und muß deshalb vor dem Schreiben bzw vor dem Lesen einer Single auf einen sinnvollen Wert gebracht werden. War das die Frage:confused:

Zitat:

---

Config Base = 0 'Array Indexe beginnen mit 0
‚???????????????????????????????????????

---

Defaultmäßig beginnen die Arrayindexe mit 1. Wenn sie mit 0 beginnen erleichtert es einige Dinge besonders bei Adressrechnungen, da zB EEPROM Speicheradressen bei 0 beginnen.
DIM AR(2) as Byte hat MIT dem Kommando 3 Elemente: AR(0), AR(1), AR(2)
DIM AR(2) as Byte hat OHNE dem Kommando 2 Elemente: AR(1), AR(2)

Zitat:

---

HIER MEIN VERSUCH (erst mal schreiben)
6 Single pro Aktion hintereinander schreiben und nach nächster Aktion die 6 Single anhängen bis Eeprom voll.

---

Code sollte nun die 6 Singles schreiben - jedoch nicht getestet. Die Variable "Aktionen" wird zur Berechnung der Speicheradresse weiterverwendet aber nun erst zum Ende der Hauptschleife erhöht. Abbruchbedingung habe ich keine gefunden. EEPROMS sind nicht unendlich beschreibbar. Zu oft in einer schnellen Schleife zerstört sie.

Zitat:

---

‘??? Weis auch hier nicht warum ???
Four_byte_var_read = 0 'Zurückgelesene Single "löschen"

---

Diente einer Kontrolle. Wenn im Programm beim Print eine 0 rauskam, wußte ich, das nicht vom EEPROM gelesen wurde. Nicht wichtig für die Funktion.

Zitat:

---

Wie geschrieben habe ist schon ein Erfolgserlebnis. Dumm für mich ist nur, dass die Vermutung aufkommen könnte ich möchte ein fertigen Code. Aber nach 525 Test- .BAS und 1889 Progmmed
(nur für diesen I²C Eeprom), ohne Endergebnis, benötigt man schon Hilfe.

---

Kein Problem solange man merkt, daß sich jemand Mühe gibt und das meine ich bei Dir zu erkennen. Ich selbst bin auch kein Profi und lerne auch gleich mit.

Code:

---

'HIER MEIN VERSUCH (erst mal schreiben)
'6 Single pro Aktion hintereinander schreiben und nach nächster Aktion die 6 Single anhängen bis Eeprom voll.

'!!! Als Array geändert Number_from_rs232 !!!

Dim Mem_addr_first_store_loc As Word    'nicht mehr als Const sondern Variable, ist defaultmäßig auf 0

Dim Number_from_rs232(7) As Single
Dim Aktionen As Byte
Aktionen = 0                            'ist sowieso defaultmäßig auf 0
Do
  Wait 2

                                  'If Mem_addr = 4 Then Mem_addr = Mem_addr_low_byte * Aktionen
  Mem_addr_first_store_loc = Aktionen * 24      '24 = 6 Singles * 4 Byte (ein Single belegt 4 Byte)

  For Z = 0 To 5                        'for-next mit 0 beginnen lassen
    If Z = 0 Then Number_from_rs232(0) = 100.10
    If Z = 1 Then Number_from_rs232(1) = 200.20
    If Z = 2 Then Number_from_rs232(2) = 300.30
    If Z = 3 Then Number_from_rs232(3) = 400.40
    If Z = 4 Then Number_from_rs232(4) = 500.60
    If Z = 5 Then Number_from_rs232(5) = 600.60

    Four_byte_var_write = Number_from_rs232(z)      'Single Variable mit irgendeiner Zahl belegen
                                                  'habe ich mit [Number_from_rs232(7) As Single] gemacht

    '??? Weis auch hier nicht warum ???
    'Four_byte_var_read = 0              'Zurückgelesene Single "löschen"

    '### BEGINN ext. EEPROM schreiben (byte write method) ###
    Mem_addr = Mem_addr_first_store_loc 'Speicheradresse für ext. EEPROM initialisieren
    For J = 0 To 3                      'Laufschleife um 4 Bytes zu schreiben
      I2cstart
      I2cwbyte Dev_addr_write          'Sendet ext. EEPROM Adresse zum Schreiben
      I2cwbyte Mem_addr_high_byte      'Sendet Speicher-Schreibadresse
      I2cwbyte Mem_addr_low_byte        'Sendet Speicher-Schreibadresse
      I2cwbyte Byte_var_write(j)        'Sendet Datenbyte
      I2cstop
      Mem_addr = Mem_addr + 1          'Schreibadresse mit jedem Schleifendurchlauf erhöhen
      Waitms 10                        'Warten auf ext. EEPROM
    Next J
  Next Z
  '### ENDE ext. EEPROM schreiben (byte write method) ###
  Print "Number written to ext. EEPROM: " ; Four_byte_var_write

  Incr Aktionen                        'Aktionen erst am Ende der Loop erhöhen

Loop

---

Gruß
Searcher

Guten Tag Searcher,

wie es aussieht wird der Eeprom dank deiner Hilfe, nach meinen Vorstellungen, beschrieben.
Aber das Entresultat sieht man nur beim auslesen(nach Reset). Ist meine persönliche Erfahrung. Dachte vor langer Zeit, alles im Griff zu haben aber die Auslesung kam nicht vom Eeprom sondern vom RAM.

So nun in der Hoffnung wir machen weiter bis zum Ziel.
Kommt schon wieder die nächste Aufgabe für dich.
Eeprom auslesen und meinen Code „hinzubiegen“.
In meinen Versuch wird zwar der Eeprom gelesen aber die Werte sind Expotential.
Somit nehme ich an die Ausleseadressen sind verschoben.
Im Code sollt somit für dich nur meine Dim’s und die Gosub lesen für Hilfe betrachtet werden.
Wie schon geschrieben benötige Hilfe zum lernen wie Single sauber in Adressbereiche des Eeproms geschrieben/gelesen werden können.

Code:

---

$regfile "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40
$baud = 19200                                              '19200

---

Code:

---


'gibt den Erstellungszeitpunkt im europäischen Format DD-MM-YY hh:nn:ss
'und die Code-Version aus.
Print
Print "erstallt am      : " ; Version(1)
Print "Version Code : " ; Version(3)
Print
Waitms 100
$lib "i2c_TWI.lib"                                          'hardware I²C einbinden
Config Twi = 100000                                        ' Takt 100kHz
'Format für Single zwei Nachkommastellen
Config Single = Scientific , Digits = 2
'###############################################################################
Config Base = 0                                            'Array Indexe beginnen mit 0
Const Dev_addr_write = &B10100000                          'EEPROM Schreibadresse
Const Dev_addr_read = &B10100001                            'EEPROM Leseadresse
'Const Mem_addr_first_store_loc = 0                          'Auf EEPROM Seitenanfang legen, im folgenden PRG keinen roll over produzieren!
Dim Mem_addr_first_store_loc As Word
Dim J As Byte                                              'Laufvariable für for-next Schleife Single
Dim Z As Byte                                              'Anzahl der Single_Variablen schreiben
Dim L As Byte                                              'alle Single_Variablen auslesen
Dim Aktionen As Byte                                        'nächsten Schreibzyklus vortschreiben
Dim Four_byte_var_write As Single
Dim Byte_var_write(3) As Byte At Four_byte_var_write Overlay      '4 Elemente, Arrayindex von 0 bis 3
Dim Four_byte_var_read As Single
Dim Byte_var_read(3) As Byte At Four_byte_var_read Overlay  '4 Elemente, Arrayindex von 0 bis 3
Dim Mem_addr As Word
Dim Mem_addr_low_byte As Byte At Mem_addr Overlay
Dim Mem_addr_high_byte As Byte At Mem_addr + 1 Overlay
Dim Number_from_rs232(6) As Single                          'Array der 6 Schreib-Variablen

'!!!!! ist nur für Test mit Taster also anpassen !!!!
Config Pinc.3 = Input                                      'Taster für EEprom schreiben
Portc.3 = 1                                                'Port auf H schalten
Taster_s Alias Pinc.3                                      'Taster ein Namen geben
Config Pinc.2 = Input                                      'Taster für EEprom lesen
Portc.2 = 1                                                'Port auf H schalten
Taster_l Alias Pinc.2                                      'Taster ein Namen geben
Gosub Lesen                                                'nach Reset erstmal lesen
Do
 '--- hier zum Daten schrieben --------
  If Taster_s = 0 Then                                      'wenn Taste gedrückt schreiben
      Waitms 100                                          'nur für Test
    Gosub Schreiben
  End If
'--- hier zum Daten lesen ------------
  If Taster_l = 0 Then                                      'wenn Taste gedrückt lesen
      Waitms 100                                          'nur für Test
    Gosub Lesen
  End If
Loop

'### BEGINN ext. EEPROM schreiben (byte write method) ###
Schreiben:
Mem_addr_first_store_loc = Aktionen * 24                  '24 = 6 Singles * 4 Byte (ein Single belegt 4 Byte)
For Z = 0 To 5                                            'for-next mit 0 beginnen lassen
    If Z = 0 Then Number_from_rs232(0) = 100.10
    If Z = 1 Then Number_from_rs232(1) = 200.20
    If Z = 2 Then Number_from_rs232(2) = 300.30
    If Z = 3 Then Number_from_rs232(3) = 400.40
    If Z = 4 Then Number_from_rs232(4) = 500.60
    If Z = 5 Then Number_from_rs232(5) = 600.60
  Four_byte_var_write = Number_from_rs232(z)              'Single Variable Z schreiben
  Mem_addr = Mem_addr_first_store_loc                      'Speicheradresse für ext. EEPROM initialisieren
    For J = 0 To 3                                          'Laufschleife um 4 Bytes zu schreiben
      I2cstart
      I2cwbyte Dev_addr_write                              'Sendet ext. EEPROM Adresse zum Schreiben
      I2cwbyte Mem_addr_high_byte                          'Sendet Speicher-Schreibadresse
      I2cwbyte Mem_addr_low_byte                            'Sendet Speicher-Schreibadresse
      I2cwbyte Byte_var_write(j)                            'Sendet Datenbyte
      I2cstop
      Mem_addr = Mem_addr + 1                              'Schreibadresse mit jedem Schleifendurchlauf erhöhen
      Waitms 10                                            'Warten auf ext. EEPROM
    Next J
  '!!! nüt für Test !!!
      Print
      Print "Aktionen  " ; Aktionen
      Print "Adressbereich ab " ; Mem_addr_first_store_loc
      Print "Number written to ext. EEPROM: " ; Four_byte_var_write
    '!!!!!!!!!!!!!!!!!!!!
Next Z
  Incr Aktionen                                            'nächsten Schreibzyklus anstoßen
'### ENDE ext. EEPROM schreiben (byte write method) ###
Return

 '### BEGINN ext. EEPROM lesen (random address read method) ###
Lesen:
For L = 0 To 240 Step 4                                    'hier mein Versuch 10 Aktionen lesen
  Mem_addr = Mem_addr_first_store_loc                      'Leseadresse für ext. EEPROM initialisieren
  For J = 0 To 3                                            'Laufschleife um 4 Bytes zu schreiben
    I2cstart
    I2cwbyte Dev_addr_write                                'Sendet ext. EEPROM Adresse zum Schreiben
    I2cwbyte Mem_addr_high_byte                            'Sendet Speicher-Leseadresse
    I2cwbyte Mem_addr_low_byte                              'Sendet Speicher-Leseadresse
    I2cstart                                                'zweites Start ohne vorheriges Stop (siehe Datenblatt "random address read")
    I2cwbyte Dev_addr_read                                  'Sendet ext. EEPROM Adresse zum Lesen
    I2crbyte Byte_var_read(j) , Nack                        'Liest Datenbyte
    I2cstop
  Next J Mem_addr = Mem_addr + 1                            'Leseadresse mit jedem Schleifendurchlauf erhöhen
    Mem_addr_first_store_loc = L
'### BEGINN SW UART Ausgabe ###
  Print
  Print "Adressbereich ab " ; Mem_addr
  Print "Number read from ext. EEPROM :  " ; Four_byte_var_read
 Next L
ENDE ext. EEPROM lesen (random address read method) Return


---

Bin schon wieder gespannt wo mein Denkfehler liegt.

Vorab vielen Dank
fredred