Speicherstellen im EEprom werden überschrieben ?!

**Roberto** · 04.12.2006, 10:10

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!!

Code:

$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** · 04.12.2006, 10:44

Zitat von Roberto

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** · 04.12.2006, 13:11

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** · 04.12.2006, 13:17

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** · 04.12.2006, 13:29

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** · 04.12.2006, 13:42

Zitat von Roberto

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** · 04.12.2006, 14:01

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

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

**Rage_Empire** · 04.12.2006, 14:13

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** · 04.12.2006, 14:49

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

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** · 04.12.2006, 15:31

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 )