I2C Eeprom ST 24C64

[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.

$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 = &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

[Searcher]

Hallo 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 Das zu berichtigen ist mir ehrlich gesagt zuviel . Angefangen schon ganz oben bei der "Const 24c64r", da fehlt das letzte Bit.

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

[fredred]

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

[Searcher]

Hallo 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?

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

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

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

‚??? 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

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)

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.

‘??? 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.

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.

'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

[fredred]

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.

$regfile "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40
$baud = 19200                                               '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
'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

[Searcher]

Hallo,

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.

Ja, weil beim "Lesen:" die Mem_addr zu spät auf den richtigen Wert gesetzt wird.
Habe in grün meine Änderungen geschrieben und blau, daß was ich rausgenommen habe.

Vor dem Aufruf von "Schreiben" sollte auch die Variable "Aktionen" auf 0 gesetzt werden (Aber nicht innerhalb des jetzigen Unterprogramms). Wenn der µC nicht zurückgesetzt wird und Du die Funktion nochmal aufrufst, hat "Aktionen" irgendeinen Wert von vorher.

Würde auch empfehlen, das DEBOUNCE Kommando zum Entprellen und Aufruf der Unterprogramme zu nutzen.

Hoffe hab auf die Schnelle nichts übersehen.
Gruß
Searcher

  '### BEGINN ext. EEPROM lesen (random address read method) ###
Lesen:
For L = 0 To 236 Step 4                                     'hier mein Versuch 10 Aktionen lesen
   Mem_addr = L                                  '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
    Mem_addr = Mem_addr + 1                            'Leseadresse mit jedem Schleifendurchlauf erhöhen
   Next J                                                               
                                                                     'Mem_addr_first_store_loc = L (auskommentiert) 
 '### BEGINN SW UART Ausgabe ###
   Print
   Print "Adressbereich ab " ; Mem_addr      'Mem_addr zeigt hier schon auf den Anfang der nächsten Single
   Print "Number read from ext. EEPROM :  " ; Four_byte_var_read     'Single paßt nicht zu vorher geprinteten Mem_addr
 Next L
 Return 
  '########ENDE ext. EEPROM lesen (random address read method) 

[fredred]

Hallo,

kann alles nicht ausprobieren. Meine Liebe Frau schreit schon wieder, es ist Sonntag und du sitzt schon wieder ab 5:30 Uhr an deinen "Komposter".
Melde mich Morgen.
Gruß
fredred

[fredred]

Hallo Searcher
Hallo Forum,

nun bin trotz Hilfe am Ende.
Nochmals mein letzter Versuch gekürzt nur mal die 6 Single schreiben und lesen ohne Fortschreibung.
In der Hoffnung mein Code ist nun besser lesbar. Stelle ich diesen noch mal ab

$regfile "m32def.dat"
$crystal = 16000000
$hwstack = 32
$swstack = 32
$framesize = 40
$baud = 19200                                               '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
'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 J As Byte                                               'Laufvariable für for-next Schleife Single
Dim Mem_addr_first_store_loc As Word
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 Z As Byte                                               'Anzahl der Single_Variablen schreiben
Dim Number_from_rs232(6) As Single                          'Array der 6 Schreib-Variablen
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 L As Byte                                               'alle Single_Variablen auslesen
Dim Number_from_rl232(6) As Single
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 Aktionen As Byte                                        'nächsten Schreibzyklus vortschreiben

'!!!!! 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:
  Print "Byte der 6 Single-Variablen schreiben"
  Print
  Mem_addr_first_store_loc = Aktionen * 1                   '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
            Print "Single-Variable   " ; Z ; " =  Adresse " ; J ; "  Bytewert  " ; Byte_var_write(j)
    Next J
         Print "!!  Ausgabe  !!  " ; Four_byte_var_write
         Print
  Next Z
   Incr Aktionen                                            'nächsten Schreibzyklus anstoßen
'### ENDE ext. EEPROM schreiben (byte write method) ###
Return
 ' Eergebnis: sieht doch Gut aus.
'(
 Byte der 6 Single-Variablen schreiben
Single-Variable   0 =  Adresse 0  Bytewert  51
Single-Variable   0 =  Adresse 1  Bytewert  51
Single-Variable   0 =  Adresse 2  Bytewert  200
Single-Variable   0 =  Adresse 3  Bytewert  66
!!  Ausgabe  !!  100.10
Single-Variable   1 =  Adresse 0  Bytewert  51
Single-Variable   1 =  Adresse 1  Bytewert  51
Single-Variable   1 =  Adresse 2  Bytewert  72
Single-Variable   1 =  Adresse 3  Bytewert  67
!!  Ausgabe  !!  200.20
Single-Variable   2 =  Adresse 0  Bytewert  102
Single-Variable   2 =  Adresse 1  Bytewert  38
Single-Variable   2 =  Adresse 2  Bytewert  150
Single-Variable   2 =  Adresse 3  Bytewert  67
!!  Ausgabe  !!  300.30
Single-Variable   3 =  Adresse 0  Bytewert  51
Single-Variable   3 =  Adresse 1  Bytewert  51
Single-Variable   3 =  Adresse 2  Bytewert  200
Single-Variable   3 =  Adresse 3  Bytewert  67
!!  Ausgabe  !!  400.40
Single-Variable   4 =  Adresse 0  Bytewert  205
Single-Variable   4 =  Adresse 1  Bytewert  76
Single-Variable   4 =  Adresse 2  Bytewert  250
Single-Variable   4 =  Adresse 3  Bytewert  67
!!  Ausgabe  !!  500.60
Single-Variable   5 =  Adresse 0  Bytewert  102
Single-Variable   5 =  Adresse 1  Bytewert  38
Single-Variable   5 =  Adresse 2  Bytewert  22
Single-Variable   5 =  Adresse 3  Bytewert  68
!!  Ausgabe  !!  600.60
')
 
 '### BEGINN ext. EEPROM lesen (random address read method) ###
Lesen:
Print "Byte der 6 Single-Variablen lesen"
Print
 For L = 0 To 5                                             'Step 4                                    'hier mein Versuch 10 Aktionen lesen
    Mem_addr = L                                            '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
    Mem_addr = Mem_addr + 1                                 'Leseadresse mit jedem Schleifendurchlauf erhöhen
    Waitms 10
       Print "Single_Variable  " ; L ; "  = Adresse " ; J ; "  Bytewert  " ; Byte_var_read(j)
  Next J
                                                                     'Mem_addr_first_store_loc = L (auskommentiert)
 '### BEGINN SW UART Ausgabe ###
     Print "!!  Ausgabe  !!  " ; Four_byte_var_read         'Single paßt nicht zu vorher geprinteten Mem_addr
     Print
 Next L
 'zurück setzen
   Aktionen = 0                                             'alle Aktionen wurden ausgelesen.
 Return
  '########ENDE ext. EEPROM lesen (random address read method)
' Eergebnis: Ist doch Müll
'(
Byte der 6 Single-Variablen lesen
Single_Variable  0  = Adresse 0  Bytewert  102
Single_Variable  0  = Adresse 1  Bytewert  38
Single_Variable  0  = Adresse 2  Bytewert  22
Single_Variable  0  = Adresse 3  Bytewert  68
!!  Ausgabe  !!  600.60 [ist die letze Variable aber weningsten schon mal ein Wert]
Single_Variable  1  = Adresse 0  Bytewert  38
Single_Variable  1  = Adresse 1  Bytewert  22
Single_Variable  1  = Adresse 2  Bytewert  68
Single_Variable  1  = Adresse 3  Bytewert  0
!!  Ausgabe  !!  0.0
Single_Variable  2  = Adresse 0  Bytewert  22
Single_Variable  2  = Adresse 1  Bytewert  68
Single_Variable  2  = Adresse 2  Bytewert  0
Single_Variable  2  = Adresse 3  Bytewert  0
!!  Ausgabe  !!  0.0
Single_Variable  3  = Adresse 0  Bytewert  68
Single_Variable  3  = Adresse 1  Bytewert  0
Single_Variable  3  = Adresse 2  Bytewert  0
Single_Variable  3  = Adresse 3  Bytewert  0
!!  Ausgabe  !!  0.0
Single_Variable  4  = Adresse 0  Bytewert  0
Single_Variable  4  = Adresse 1  Bytewert  0
Single_Variable  4  = Adresse 2  Bytewert  0
Single_Variable  4  = Adresse 3  Bytewert  7
!!  Ausgabe  !!  96.30E-36
Single_Variable  5  = Adresse 0  Bytewert  0
Single_Variable  5  = Adresse 1  Bytewert  0
Single_Variable  5  = Adresse 2  Bytewert  7
Single_Variable  5  = Adresse 3  Bytewert  134
!!  Ausgabe  !!  -25.39E-36
')

Vielen Dank für die aufwendigen Hilfeleistungen.
Nehme nach wie vor an der IC ST24C64 will mich narren.

Mit freundlichen Grüßen
fredred