Speicherstellen im EEprom werden überschrieben ?!

[Roberto]

Hallo Leute
Habe wieder so ein blödes Problem, wo ich schon eine ganze Woche dabei sitze und einfach nicht den Fehler finde ](*,)

Im Prinzip geht es um eine Speicherung in einem 24C256er EEprom (I2C)

Ich schreibe da Daten ab Adresse 192 rein und nach ein paar Einträgen löscht es mir den Wert in Adresse 192

Irgendwie muss es wohl mit der Adresse zusammenhängen, den es schein sich ab Adresse 255 zu verändern.

Ein Datenblock = 26 Byte lang und besteht aus Long und Byte Variablen.
Nach dem dritten Datenblock, habe ich in Adresse 192, keine 31 mehr drinnen, sondern nur mehr ein 0 ! ](*,)

Wenn ich z.B. 50 Datenblöcke reinschreibe, werden auch an anderen Stellen, Daten verändert.
Z.B. dann in Block: 8,18,23,28,33,35,40,50 u.s.w.
Das Muster bleibt so ca. gleich, wo die Daten verändert wurden..


Habe den Code von 12Kb mal geschrumpft:
Ab der dritten Schleife, löscht es mir die daten in Adresse 192!!





$regfile = "m32def.dat"
$crystal = 10000000

$hwstack = 250
$swstack = 250
$framesize = 250




'##################### Config für Grafik-LCD ################################################## ##
' (Config LCD muss vor Config Portb stehen , sonst blockiert er das Port!)
Config Graphlcd = 240 * 128 , Dataport = Portc , Controlport = Portb , Ce = 6 , Cd = 7 , Wr = 4 , Rd = 5 , Reset = 3 , Fs = 2 , Mode = 8
Cursor Off
Cls



'############################ Config I2C Bus ###################################
Config Scl = Portb.2 ' I2C-Port festlegen
Config Sda = Portb.1 ' I2C-Port festlegen



'################## Config Port's ##############################################
'-----config Port A
Config Porta = Input

'-----config Port B
Config Portb = &B11111001

'-----config Port D
'Pin 3-7 Ausgabe (Takt/Richtungen
'Pin 2 Int0 (Auf Eingabe)
'Pin 1 Ausgabe (TXD)
'Pin 0 Eingabe und Pin2 Interrupt Eingang
Config Portd = &B11111010
Portd.2 = 1 'Auf Pull up


'################## Variablen ################################################## '

'------------ EEprom lesen/schreiben -----------
' Adessen
Dim Adresse As Word At $101 ' EEprom Adresse (Long)
Dim Low_adresse As Byte At $101 Overlay
Dim High_adresse As Byte At $102 Overlay

'Byte-EEprom-Wert
Dim B_wert As Byte 'Byte-Wert zum Daten lesen vom EEprom

'Word-EEprom-Wert
Dim W_wert As Word At $111 'Word-Wert zum Daten lesen vom EEprom
Dim W_wert1 As Byte At $111 Overlay 'Teil1 der Word Variable (Byte)
Dim W_wert2 As Byte At $112 Overlay 'Teil2 der Word Variable (Byte)

'Long-EEprom-Wert
Dim L_wert As Long At $123 'Long-Wert zum Daten lesen vom EEprom
Dim L_wert1 As Byte At $123 Overlay 'Teil1 der Long Variable (Byte)
Dim L_wert2 As Byte At $124 Overlay 'Teil2 der Long Variable (Byte)
Dim L_wert3 As Byte At $125 Overlay 'Teil3 der Long Variable (Byte)
Dim L_wert4 As Byte At $126 Overlay 'Teil4 der Long Variable (Byte)

'---------I2C --------------------------------
Dim I2c_wert As Byte 'I2C Wert schreiben/lesen
Dim Int0_schalter As Byte ' Schalter für INT0 Auslösung

Dim Datenblock_anfang As Word 'Adresse vom Anfang vom Datenblock (bei Datensatz)

'------------
'Sonstiges
Dim X As Word ' zum rechnen
Dim I As Word


Cls

Do



Datenblock_anfang = 192

For X = 1 To 4


Locate 2 , 1 : Lcd "Anfangsadresse =" ; Datenblock_anfang

'-- Daten für Achse 1 schreiben --
Adresse = Datenblock_anfang
L_wert = 31
Gosub Eeprom_long_schreiben
Adresse = Datenblock_anfang + 4
B_wert = 91
Gosub Eeprom_byte_schreiben
'-----


'-- Daten für Achse 2 schreiben --
Adresse = Datenblock_anfang + 5
L_wert = 32
Gosub Eeprom_long_schreiben
Adresse = Datenblock_anfang + 9
B_wert = 92
Gosub Eeprom_byte_schreiben
'---


'-- Daten für Achse 3 schreiben --
Adresse = Datenblock_anfang + 10
L_wert = 33
Gosub Eeprom_long_schreiben
Adresse = Datenblock_anfang + 14
B_wert = 93
Gosub Eeprom_byte_schreiben
'---


'-- Daten für Achse 4 schreiben --
Adresse = Datenblock_anfang + 15
L_wert = 34
Gosub Eeprom_long_schreiben
Adresse = Datenblock_anfang + 19
B_wert = 94
Gosub Eeprom_byte_schreiben
'---


'-- Daten für Achse 5 schreiben --
Adresse = Datenblock_anfang + 20
L_wert = 35
Gosub Eeprom_long_schreiben
Adresse = Datenblock_anfang + 24
B_wert = 95
Gosub Eeprom_byte_schreiben
'---

'-- Daten: Ausgang schreiben --
Adresse = Datenblock_anfang + 25
B_wert = 96
Gosub Eeprom_byte_schreiben

'---
'Datensatzstück bis hier = 26 Byte!!!!

Datenblock_anfang = Datenblock_anfang + 26

Locate 4 , 1
For I = 192 To 260
Adresse = I
Gosub Eeprom_byte_lesen
Lcd B_wert;
Next I

Locate 14 , 1 : Lcd "Durchgang =" ; X
Wait 1
Next X






Loop
End


'========== Speicherstruktur vom EEprom ========================
'
'--------------------------------
'erste Datensatznummer (1) 1 Byte
'Bezeichnung 11 Byte
'Anfangsadresse von dem Datensatz 2 Byte (Word)
'Endadresse vom Datensatz 2 Byte (Word)
'
'zweite Datensatznummer(2)
'
'
' (max 12 Datensatz Einträge)
'-----------------------------
'
'
'-----------------------------
'==Datensatzanfang! (= 192)
'Schritt n 26Byte |
' |Achse1 Koordinate 4 Byte (Long)
' |Achse1 Geschwindigkeit 1 Byte
'
' |Achse2 Koordinate 4 Byte (Long)
' |Achse2 Geschwindigkeit 1 Byte'
'
' |Achse3 Koordinate 4 Byte (Long)
' |Achse3 Geschwindigkeit 1 Byte'
'
' |Achse4 Koordinate 4 Byte (Long)
' |Achse4 Geschwindigkeit 1 Byte'
'
' |Achse5 Koordinate 4 Byte (Long)
' |Achse5 Geschwindigkeit 1 Byte'
' |
' | Ausgang 1 Byte
'-----------------------------
'Schritt n+1 (26 Byte)
'Schritt n+1 (26 Byte)
'.
'==Datensatzende!
'-------------------------------

'================= EEprom Byte schreiben =======================================
Eeprom_byte_schreiben:
Disable Interrupts
'Adresse ist die Variable die dann in High_adress und Low_adresse per Overlay geteilt wird (für EEprom)
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse LOW

I2cwbyte B_wert 'Sende Wert
I2cstop 'stop

Waitms 20
Enable Interrupts
Return
'-------------------------------------------------------------------------------

'================= EEprom Byte lesen ===========================================
Eeprom_byte_lesen:
Disable Interrupts
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse Low

I2cstart 'Start
I2cwbyte &B10100001 'Sende Slavadresse +1 für Schreiben
I2crbyte B_wert , Nack 'Lese Adresse vom EEprom
I2cstop
Enable Interrupts
Return
'-------------------------------------------------------------------------------



'================= EEprom Word schreiben =======================================
Eeprom_word_schreiben:
Disable Interrupts
' Adresse ist die Variable die dann in High_adress und Low_adresse per Overlay geteilt wird (für EEprom)
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse LOW

I2cwbyte W_wert1 'Sende Wert
I2cwbyte W_wert2 'Sende Wert
I2cstop 'stop
Waitms 20
Enable Interrupts
Return
'-------------------------------------------------------------------------------

'================= EEprom Word lesen ===========================================
Eeprom_word_lesen:
Disable Interrupts
'---lesen----
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse Low

I2cstart 'Start
I2cwbyte &B10100001 'Sende Slavadresse +1 für Schreiben
I2crbyte W_wert1 , Ack 'Lese Adresse vom EEprom
I2crbyte W_wert2 , Nack 'Lese Adresse vom EEprom
I2cstop 'Stop
Enable Interrupts
Return
'-------------------------------------------------------------------------------



'================= EEprom Long schreiben =======================================
Eeprom_long_schreiben:
Disable Interrupts
' Adresse ist die Variable die dann in High_adress und Low_adresse per Overlay geteilt wird (für EEprom)
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse LOW

I2cwbyte L_wert1 'Sende Wert
I2cwbyte L_wert2 'Sende Wert
I2cwbyte L_wert3 'Sende Wert
I2cwbyte L_wert4 'Sende Wert
I2cstop 'stop
Waitms 20
Enable Interrupts
Return
'-------------------------------------------------------------------------------

'================= EEprom Long lesen ===========================================
Eeprom_long_lesen:
Disable Interrupts
'---lesen----
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse Low

I2cstart 'Start
I2cwbyte &B10100001 'Sende Slavadresse +1 für Schreiben
I2crbyte L_wert1 , Ack 'Lese Adresse vom EEprom
I2crbyte L_wert2 , Ack 'Lese Adresse vom EEprom
I2crbyte L_wert3 , Ack 'Lese Adresse vom EEprom
I2crbyte L_wert4 , Nack 'Lese Adresse vom EEprom
I2cstop 'Stop
Enable Interrupts
Return
'-------------------------------------------------------------------------------





'================= I2C Bus schreiben ===========================================
I2c_bus_schreiben:
Disable Interrupts
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse LOW

I2cwbyte I2c_wert 'Sende I2c_wert
I2cstop
Waitms 20
Enable Interrupts
Return
'-------------------------------------------------------------------------------


'================= I2C Bus lesen ===============================================
I2c_bus_lesen:
Disable Interrupts
I2cstart 'Start
I2cwbyte &B10100000 'Sende Slavadresse
I2cwbyte High_adresse 'Sende Speicheradresse High
I2cwbyte Low_adresse 'Sende Speicheradresse Low

I2cstart 'Start
I2cwbyte &B10100001 'Sende Slavadresse +1 für Schreiben
I2crbyte I2c_wert , Nack 'Lese I2C_wert
I2cstop
Enable Interrupts
Return
'-------------------------------------------------------------------------------




Hat jemand einen Tipp, was das sein könnte ?
Habe schon EEprom getausch, Overlaw-Adressen geändert u.s.w...


Hiiilllfffeeee ..

l.G. Roberto

[Rage_Empire]

Hat jemand einen Tipp, was das sein könnte ?

Habs jetzt nur mal so überflogen, aber es könnte sein, daß du im Page-write-Modus arbeitest. Wenn die Page zuende ist, fängt das eeprom wieder am Anfang der Page an, überschreibt somit also den Anfang.

Dieser Mist hat mich auch schon Wochen an Verzweiflung gekostet. Weiß bis heute nicht, wofür dieser schrott-Modus gut ist. Und je nach Hersteller kann die Page-Größe variieren.

[Roberto]

Hallo

Kann mich errinnern, dass du da mal was geschrieben hast.
Ich hatte das aber so aufgefasst, dass das nur ist, wenn man alles in einer Wurst schreibt...

Bei mir schreibe ich aber einmal eine Long variable einmal eine Byte-variable und alle sind mit Stop und Start eigene Schreibvorgänge..

Oder sehe ich da was falsch ?




l.G. Roberto

[Rage_Empire]

Du mußt alles Byte per Byte übertragen, und nach jedem Byte Stop und Startbedingung. Sonst rutscht du automatisch in den Pagewritemodus. Also nach jedem Wert sozusagen stop und dann wieder start......


Wie gesagt, bin selber auch darauf reingefallen ;-)

Also, immer schön Byte per Byte, dann klappts auch.

[Roberto]

mmhhhh..
byte per byte...

Nach jedem schreiben noch 10ms warten...
Klingt nicht so gut...

Startet nicht nach jedem "START" der Pagewritemodus " neu ?

(Danke für die schnellen Antworten :-) )

[Rage_Empire]

Startet nicht nach jedem "START" der Pagewritemodus " neu ?

wenn du nicht mehr als 1 byte schreibst, dann nicht. Brauchst auch nicht unbedingt 10ms, 5 reichen vollkommen, wenn nicht sogar nur 2ms (ausprobieren ;-) )

...und wenn du dein Systemtakt mit bis zu 400Khz betreibst, ist es nicht unbedingt tragisch, daß du einige ms warten musst. Wenn deine Anwendung jedoch so zeitkritisch sein sollte würde ich dir ein RAM empfehlen, welches mit Batterie(oder Goldcap) gepuffert wird.

Wie gesagt, die EEproms sind leider ziemlich herstellerabhängig, da empfiehlt es sich ins datenblatt zu schauen, wieviel wartezeit der kleine benötigt.

Jedenfalls gibts auch noch eine alternative über SPI, ist jedoch teurer.

[Roberto]

Nochmal zurück:

wenn du nicht mehr als 1 byte schreibst,

Stimmt das jetzt nicht, dass mit jedem:
I2cstart
I2cwbyte &B10100000
I2cwbyte High_adresse
I2cwbyte Low_adresse

u.s.w.

Der Page-write-Block neu anfängt. ??

Wenn nicht, dann könnte man ja nie eine Long-Variable schreiben, weil irgendwann kommt man vielleicht in diesen Überlauf... :-k

Habe mir jetzt auch den Thread :
https://www.roboternetz.de/phpBB2/viewtopic.php?t=19051
durchgelesen.
Aber ganz klar sehe ich da noch nicht...

:-k

[Rage_Empire]

Nein, die Pages sind fest vorgegeben. Das erste BYte, welches du schreibst ist fest deffiniert durch die adresse, die du mitschickst. Wenn du nun keine "Stopbedingung" schickst und einfach weiterschreibst, schreibst du in die Page weiter. Wenn du die Page "Überrennst" (dabei über dessen Adressbereich fährst) fängst du nicht bei der nächsten an, sondrer bei der gleichen ganz von vorn (springst also zurück!). Wenn du jedesmal Start und Stopbedingungen fährst wird dein Byte bei jedem Start durch die Adresse, welche du mitschickst deffiniert. Also befindest du dich dann im Byte-Write Modus.

Du Kannst auch Pages beschreiben, dazu mußt du aber im Datenblatt schauen, wo diese Anfangen und aufhören. Dann mußt du bei jeder "neuen Page" die Start-Stopbedingung einhalten (wie ein Heft, welches du umblätterst).

Ich hoffe, ich konnte es dir etwas näher bringen, ist a bissl komplex das ganze ;-)

[Roberto]

Hallo

Das erste BYte, welches du schreibst ist fest deffiniert durch die adresse
ahaaaa.....
Beim Datenblatt steht was von 64byte page-write mode aviable (24C256)
(bin aber nicht so gut in englisch :-( )

Dann kann man eigentlich nie blind eine Word oder Long-Variable in das EEprom schreiben ](*,)
Mann müsste die Pages im Avr praktisch mitberechnen und dann immer ab der richtigen Adresse erst reinschreiben :-k
Schön blöd...

Dann werde ich wohl alles auf Byte-schreiben umstellen.
Lessen kann man ja dann Word und Long trotzdem .. ?! (stimmt das ?)

[albundy]

Nein, die Pages sind fest vorgegeben.

Naja, die max. Größe einer Page ist vorgegeben.
Ganz einfach deshalb, weil der interne Adresscounter nur mir 6 Bit arbeitet und somit nur 64 Byte adressieren kann.


Dann werde ich wohl alles auf Byte-schreiben umstellen.


Das würde ich nicht machen.
Wenn dein Datensatz immer 26 Byte ist, bietet sich der Page Write Modus doch an. Dann ist in deinem Fall eine Page=26 Byte.
Du müsstest deinen Datensatz z.B. in ein Array packen und dann in einem Rutsch in den Eeprom schreiben. Zwischen den Bytes benötigt es dann keine Wartezeit, da der EEprom die Daten aus einem internen Pagebuffer in den Speicher schreibt.
Den nächsten Datensatz schreibst du dann an Adresse + 26.


Dann kann man eigentlich nie blind eine Word oder Long-Variable in das EEprom schreiben

Natürlich kannst du auch gezielt an irgendeine Adresse ein Word oder ähnliches schreiben. Du musst dabei nur beachten, das immer nur 1 Byte geschrieben wird und dann ein Stop kommen muss.
Der Nachteil bei dieser Methode ist die Wartezeit nach jedem geschriebenen Byte. (siehe Datenblatt unter Writecycle Time )

[Roberto]

Hallo Albundy


Den nächsten Datensatz schreibst du dann an Adresse + 26.

Aber nur wenn der Block in die Page passt.
Wenn ich jetzt zweimal 26Byte (=ein Block) hintereinander geschrieben habe geht es sich mit +26 dann nicht mehr aus. :-k
Dann dürfte ich die nächsten 26byte erst wieder in die nächste Page schreiben..
Dann geht mir ja relativ viel Platz imm EEprom verloren. :-k
Sehe ich das richtig ?

[albundy]

Wenn ich jetzt zweimal 26Byte (=ein Block) hintereinander geschrieben habe geht es sich mit +26 dann nicht mehr aus.


Sorry, dass habe ich jetzt nicht verstanden.
Aber egal. Klammer dich nicht so an den Begriff Page. Diese muss ja nicht 64 Byte groß sein.
Bei dir wäre z.B.
Page 1 von Speicherstelle 0 bis 25
Page 2 von 26 bis 52
Page 3 von 53 bis 79
u.s.w.
Also adressierst du den 1. Datensatz an Adresse 0, den 2. Datensatz an Adresse 26 und den 3. Datensatz an Adresse 53.
Da du nach jedem Datensatz (26 Byte) ein Stop sendest, ist für den Eeprom die Page beendet und eine neue kannst du an jeder beliebigen Speicherstelle anfangen lassen. Es gibt nur die Beschränkung (64 Byte) nach oben.

[Roberto]

Hallo
War jetzt doch am Holzweg.

Durch die Aussage:

Nein, die Pages sind fest vorgegeben.
Dachte ich mir jetzt, dass die EEprom Pages fix an Adressen vom EEprom gebunden sind.
Aber durch nachlesen von:

Das erste BYte, welches du schreibst ist fest deffiniert durch die adresse, die du mitschickst.
Scheint das doch nicht so zu sein.

Zusammenfassung:
Die "64byte page-write" sind praktisch ein zwischenspeicher im Eeprom für den Datenempfang.
Das Stop Kommando veranlasst das EEprom dann, diesen Buffer
von max 64Byte, nachhaltig dann in den EEprom-Speicher zu schreiben.
(nacher ca. 10ms warten)

Wenn ich mehr als 64 Byte in den Buffer schreibe, überschreibt er den Buffer , bei Null beginnend.

Liege ich da jetzt richtig ?8-[

Aber durch nochmaliges durchlesen, hat mich jezt wieder dieser Satz verunsichert:

Natürlich kannst du auch gezielt an irgendeine Adresse ein Word oder ähnliches schreiben. Du musst dabei nur beachten, das immer nur 1 Byte geschrieben wird und dann ein Stop kommen muss.
Der Nachteil bei dieser Methode ist die Wartezeit nach jedem geschriebenen Byte. (siehe Datenblatt unter Writecycle Time )


Muss ich den Page-Modus extra aktivieren, oder ist der immer aktiviert und schliesst einfach mit dem Stop Befehl ?

Wenn das unter Zusammenfassung jetzt stimmt: müsste mein Code ja eigentlich funktionieren :-k , weil ich ja nach jedem Word, Long oder Byte, ein Stop habe !

l.G. Roberto (schwere Geburt 8-[ )

[albundy]

Zusammenfassung:
Die "64byte page-write" sind praktisch ein zwischenspeicher im Eeprom für den Datenempfang.
Das Stop Kommando veranlasst das EEprom dann, diesen Buffer
von max 64Byte, nachhaltig dann in den EEprom-Speicher zu schreiben.
(nacher ca. 10ms warten)

Wenn ich mehr als 64 Byte in den Buffer schreibe, überschreibt er den Buffer , bei Null beginnend.

Das ist korrekt.

Muss ich den Page-Modus extra aktivieren, oder ist der immer aktiviert und schliesst einfach mit dem Stop Befehl ?

Der wird aktiviert, sobald du mehr als 1 Byte ohne Stop schreibst.

Wenn das unter Zusammenfassung jetzt stimmt: müsste mein Code ja eigentlich funktionieren , weil ich ja nach jedem Word, Long oder Byte, ein Stop habe !

Siehe Eeprom_Word_schreiben oder Eeprom_Long_schreiben.
Was fällt dir auf ?
Das habe ich aber schon mal erwähnt.

Natürlich kannst du auch gezielt an irgendeine Adresse ein Word oder ähnliches schreiben. Du musst dabei nur beachten, das immer nur 1 Byte geschrieben wird und dann ein Stop kommen muss.

[Roberto]

Hallo Albundy


Das ist korrekt.
Gut :-)

Siehe Eeprom_Word_schreiben oder Eeprom_Long_schreiben.
Was fällt dir auf ?
mmhh.. :-k
Wie meinst Du das ?

Ich sehe das bei meinem Code dann praktisch so, dass das schreiben "einer" Long-Variable als schreiben eines Pages (aus sicht des EEproms)
gesehen wird.
Wird mit Stop geschlossen und ist unter 64 Byte.
Müsste also passen ?!

Warum funktioniert dann das Speichern nicht richtig ?

l.G.

[albundy]

Hallo Roberto,

ich habe mir jetzt einmal andere I2C Eeprom Datenblätter angesehen, da beim 24LC256 nicht sonderlich viel über den Page Write Modus steht.
In einem stand, dass die Pageadresse ein vielfaches des Pagebuffers sein muss.
Wenn das beim 24LC256 auch so ist, sind die Pageadressen doch fest vorgegeben.
Sorry, das habe ich in dem Datenblatt, auch jetzt nach gezielter Suche nicht gefunden.
Damit wäre dann aber klar, warum nach dem 3.Datensatz der Inhalt überschrieben wird.
Der 1.Datensatz auf Speicherstelle 192 (Page 3) wird korrekt geschrieben.
Der 3.Datensatz passt aber nicht mehr komplett in die Page und überschreibt mit den überzähligen Bytes den Anfang.

[Roberto]

Hallo Albundy

Dann stimmt meine zusammenfassung doch nicht :-(


In einem stand, dass die Pageadresse ein vielfaches des Pagebuffers sein muss.

Würde sich mit der Aussage von Rage_empire decken.

Nein, die Pages sind fest vorgegeben. Das erste BYte, welches du schreibst ist fest deffiniert durch die adresse, die du mitschickst. Wenn du nun keine "Stopbedingung" schickst und einfach weiterschreibst, schreibst du in die Page weiter. Wenn du die Page "Überrennst" (dabei über dessen Adressbereich fährst) fängst du nicht bei der nächsten an, sondrer bei der gleichen ganz von vorn (springst also zurück!)

Könnte man sich das dann so wie ein Buch mit Seiten vorstellen?!
Wenn ich nur Byte schreibe, blättert das EEprom die Seiten (Pages) selber um. Wenn ich aber längere Daten schreibe, muss ich selber schauen, dass umgeblättert wird ?!
Ich selber kann aber nicht umblättern. Ausser wen zu Ende der Seite(Page) hin, Byte's geschrieben werden, die dann überlaufen und das EEprom umblättert ?

Stimmt das so ?

Was sagst Du Rage_Empire?

L.G.

[Roberto]

Hallo

Habe jetzt mal im Internet geschaut.
Leider findet man sehr wenig darüber:

Hierbie bekomme ich den EE_Page-Write nicht hin. In allen Applikationen von Atmel sind nur Byteweise Schreib- und Lesezugriffe aufgefuehrt. Im Datenblatt ist alles theoretisch gut beschrieben. Die Page-Write-Applikation hierzu fehlt aber ganz.
von hier:http://www.c51.de/c51.de/Kommunik/Forumlesen.php

und hier was in Deutsch:
http://www.eseo.de/i2c.htm

Der seitenweise Zugriff ist identisch mit dem zuvor beschriebenen byteweisen Zugriff. Hier wird jedoch anstelle von nur einem Datenbyte gleich mehrere Datenbytes gesendet. EEPROM's unterstützen meist zwischen 8 und 16 Bytes pro seitenweiser Zugriff. Das EEPROM inkrementiert automatisch seinen internen Speicherzeiger zwischen den Schreibzyklen. Wird die höchste Adresse erreicht, so findet automatisch ein Umbruch statt und der Zeiger springt auf die erste Adresse zurück. Der große Vorteil des seitenweise Zugriffs ist das Senden von mehreren Bytes innerhalb nur eines Schreibzyklus.

Da frage ich mich, für was ich den Pages-Modus überhaupt verwenden kann, wenn ich den Rest dann nur mehr mit Bytes vollschreiben kann,
damit das Eeprom auf die nächste Seite springt. ?!

Ich glaube ich werde dann doch besser bei dem Byte-schreiben bleiben :-(

Danke Euch zwei für die Mühe und die Zeit O:)

L.G. Roberto

[Rage_Empire]

Könnte man sich das dann so wie ein Buch mit Seiten vorstellen?!
Wenn ich nur Byte schreibe, blättert das EEprom die Seiten (Pages) selber um. Wenn ich aber längere Daten schreibe, muss ich selber schauen, dass umgeblättert wird ?!

Genau so würde ich das auch sehen! :-)

Jedenfalls hab ich meine Routinen alle auf Byte für Byte umgeschrieben und habe seit dem nie wieder Probleme gehabt.

[Roberto]

Hallo

Es hat mich jetzt doch keine ruhe gelassen ;-)
Probiere gerade 35 mal ein Word in das Eeprom zu speichern.
(Adresse 0-70)
Dann wieder auslesen.
Die Werte sind dann von 0-70 wieder da. ?!
Jetzt werde ich mal eine Page von 65 Länge probieren..

[Roberto]

mmmmhhh.. komisch :-k

Schreiben ab Adresse 0 (Eeprom 24C256)

Eine Page von 64 Byte Schreiben = ok

Eine Page von 66 Byte schreiben, fängt dann mit den 2 Byte mehr, wieder bei Adresse 0 an zu schreiben.

Zwei Pages mit z.B. 40 Byte hintereinander schreiben, schaft nicht die Grenze über die 64 Byte (Page-Grenze)
Fang mit dem Rest wieder bei Adresse 0 an zu schreiben.

Aber jetzt:

40mal Word schreiben(2 Byte), überwindet die Page Grenze
20mal Long schreiben (4Byte), überwindet auch die Page Grenze :-k

komisch , komisch.
Da dürften die Longs und Words ja auch nicht über die 64Byte Grenze kommen und mein Code (vom Anfang) müsste eigentlich funktionieren ?!

l.G.

[Roberto]

Ps.:
Habe jetzt die Word und Long in meinem Programm durch Byte Schreibroutinen umgeschrieben.
Funktioniert jetzt ! \:D/ \:D/ \:D/
War wirklich der Fehler

l.G. Roberto

[Rage_Empire]

Wunderbar...siehste, ist alles ganz einfach......
wenn man weiß, wie mans machen muß! ;-) ;-)