Internes EEPROM und externes EEPROM 24C512 mit ATmega128 unter BASCOM-AVR

[Markus]

Hallo AVR-Freunde!

Habe folgendes Thema als Lösung anzubieten:
Internes EEPROM und externes EEPROM 24C512 mit ATmega128 unter BASCOM-AVR

Bei der Bearbeitung meines Projektes - ich bin dabei eine Wintergartensteuerung mit allem möglichen Schnick-Schnack zu bauen - stellte ich mir folgende Aufgabenstellung:

- Für die Wintergartensteuerung erfasse ich einige Umweltgrößen wie Windgeschwindigkeit, Temperatur, Regen, Luftfeuchtigkeit, Lichthelligkeit.
- Diese Umweltdaten möchte ich zum späteren Download und Auswertung (z.B. mit Excel) in einem externen EEPROM (ausgewählt habe ich den 24C512 mit I2C (TWI) Schnittstelle) mitloggen.
- Für die internen Programmeinstellungen möchte ich das interne EEPROM des AVR verwenden.

Hierbei habe ich mir Gedanken über die folgenden Bedingungen gemacht:
- Verwendung des internen HW-I2C-Interface (TWI) des ATmega128.
- Das interne EEPROM kann nur 100.000 beschrieben werden.
- Das externe EEPROM kann 1.000.000 beschrieben werden.
- Byteweise Adressierung und Zugriff auf das EEPROM.

Dabei hat sich dann die hier vorgestellte Lösung entwickelt:
- Ich verwende die HW-TWI-Schnittstelle des ATmega mit den Signalleitungen SCL und SDA direkt am ATmega
- Entwickelt wurde der Prototyp mit dem ATMEL STK500 + STK501
- Zum Einsatz kommt ein ATmega128 der extern mit 16 MHz getacktet wird.
- Das interne EEPROM ist wegen der Begrenzung von Schreibzyklen ungeeignet.
- Die hier vorgestellte Lösung bietet einige prinzipielle Zugriffsfunktionen auf das interne und externe EEPROM.
- Zum Test ist das Ganze in eine "Debug-Testumgebung" eingebaut so dass man die einzelnen Funktionen leicht aufrufen und testen kann.
- Die Basisfunktionen lassen sich einfach extrahieren und weiterverwenden.
- Konfiguration von PullUp-Widerständen und verwendeter I2C-Adresse über Jumper.

Bemerkungen:
- Mit dem BASCOM-AVR ist die Einbindung des TWI-Interface denkbar einfach!
- Soll nicht die ATmega interne TWI-Schnittstelle verwendet werden so kann man das EEPROM ab jedem beliebigen Port anschließen. BASCOM übernimmt die Emulation der TWI Schnittstelle. Bis auf die Konfiguration kann der Code so übernommen werden.

So, genug der vielen Worte. Wenn Ihr Fragen habt bitte melden.
Ansonsten findet Ihr den kommentierten Code als Download.
Weiter habe ich den aktuellen Schaltplan und ein Bild des Prototyps mit angehängt, so wie ich das ganze selbst in Betrieb genommen habe.

Viel Spass beim EEPROMen und ausprobieren,
Grüße an die AVR-Welt,

Markus

 

[kaito]

lol

hmm gibts das auch fürn atmega 8 ?

 

[Markus]

Hallo,

prinzipiell gibts das auch für den ATmega 8 aber es gibt einige kleine aber feine Unterschieden.

1. Unterschied:
- der ATmega 8 verfügt nur über 512 Bytes internes EEPROM
- der ATmega 128 hat ganze 4K davon
- in den Schreibzyklen (100.000) unterscheiden sie sich nicht

2. Unterschied:
- wie der 128er verfügt auch der 8er über ein HW-TWI Interface
- beim 128er sind dies die PINs PD0 und PD1
- beim 8er sind das die PINs PC5 und PC4

3. Unterschied:
Mein Beispielcode verbraucht all inklusiv im 128er ca. 7% Flash das sind fast 9 kByte. Damit dürftest Du Probleme bekommen das in einem 8er zum laufen zu bekommen
Wenn Du die Traces ausschaltest (Const Eeprom_testmodus = 0) dann reduziert sich das ganze schon mal auf 4%.
Du musst also die für Dich unwichtigen Code-Teile komplett raus schmeißen und nur die Basics verwenden. Das dürfte sich dann - was die reinen Methoden für das EEPROM betrifft - auf wenige Bytes reduzieren.

Bezüglich der TWI Interfacebeschreibungen für 128er und 8er dürfte es keine Unterschiede geben.

Es gibt auch die Möglichkeit in BASCOM das TWI-HW Interface zu "emulieren". Dazu kannst Du jeden PIN für SCL und SDA verwenden den Du möchtest. Dazu müsste es reichen die Lib im Programmkopf raus zu schmeißen.
Dadurch - Du musst dann alles "von Hand" zappel lassen - erwarte ich aber nochmals eine Zunahme der Code-Größe da Du keine HW hast was Dir das ganze protokoll-Handling macht sondern das muss von BASCOM in SW nachgebildet werden.

Probiers doch einfach mal, viel Spass dabei!

Grüße,
Markus

 

[Rudi54]

Hallo Markus !
Bin gerade dabei mich mit dem EEprom 24FC512 zu beschäftigen. Datenblatt hab ich mir übersetzt,
nur mit den Address Low Byte A0 / A7 und den Address High Byte A8 - A15 sehe ich nicht durch.

Kannst Du mir das mal genau erklären und den Zusammenhang mit den Adresszeiger?
Mit freundlichen Gruß
Rudi54

 

[Cassio]

Hallo Rudi54!

Ich bin zwar nicht Markus und weiß jetzt auch nicht genau was du im Detail für ein Problem mit der Adressierung des Speichers hast, aber vielleicht hilft dir ja schon folgender Ansatz weiter (nicht eigenständig lauffähig):



CodeBox BascomAVR

Dim Adresse As Word
Dim Adresse_l As Byte At Adresse Overlay      'Adress-Low-Byte
Dim Adresse_h As Byte At Adresse + 1 Overlay      'Adress-High-Byte



'EEPROM schreiben:
I2cstart
I2cwbyte 512w              'EEPROM-Adresse senden
I2cwbyte Adresse_h      'Speicheradresse HighByte
I2cwbyte Adresse_l       'Speicheradresse Low-Byte
I2cwbyte Wert               'Bytewert zum EEPROM
I2cstop


'EEPROM lesen:
I2cstart
I2cwbyte 512w
I2cwbyte Adresse_h
I2cwbyte Adresse_l
  I2cstart
  I2cwbyte 512r
  I2crbyte Wert , Nack
  I2cstop

Vielleicht hilft es dir ja schon weiter, oder es bringt dich auf Ideen.

Grüße,
Cassio

 

[Rudi54]

Danke Cassio für die schnelle Andwort !
Nein , leider nicht .
Ich verstehe nicht ,das bei "Addresse Low Byte" nur A7 als MSB und A0 LSB im Datenblatt stehen. Also A7 = 128 und A0 = 1.
Macht bei mir, die Adressierung 0 , 1 , 128 und 129 möglich. Oder liege ich da im Denkfehler Bereich ?
Mich würde mal ein Beispiel interessieren, wo an welcher Stelle bei einer bestimmten Adressierung, im EEprom geschrieben wird.
Und, muß man immer bei "Addresse High Byte" - Adresse + 1 Overlay berechnen ?
Im Flash Speicher eines ATMega ist mir das klar. z.B. $7000 als Wordadresse fängt er dann in Flash bei &HE000 (Byteadresse)
an zu schreiben.

Freundlichst Rudi54

 

[LotadaC]

:Ist Dir klar, was ein Word und was ein Byte ist?
Das Lowbyte kann als Byte 2^8=256 Werte annehmen, das Highbyte ebenso, kombinierst Du die hintereinandergeschrieben zu einem 16bit-Word, hast Du 256*256 Werte -> 65536-> 64K (Adressen)
Und nein, müssen mußt Du das nicht so, ABER:
Wenn man in Bascom eine Variable als Word alloziiert, verwendet Bascom zwei aufeinanderfolgende Adressen im SRAM (eine fürs Highbyte, und eine fürs Lowbyte). Was ist eine Variable? Ein Zeiger, der Dir den Zugriff auf'ne bestimmte Speicherzelle erleichtert. Und mit Overlay kannst Du einen weiteren Zeiger festlegen, der abhängig von einer vorher alloziierten Zelle auf seine Zelle zeigt, ohne daß Du irgendwelche konkreten Adressen kennst.

Also sei zB X ein Word, im SRAM abgelegt. Dann befindet sich irgendwo das Lowbyte, und in der Zelle dahinter das Highbyte. Definierst Du Dir nun eine Variable A mit Overlay auf X, greift A auf dieselbe Zelle zu, in der das Lowbyte von X steht, um mit einer neuen Variable B auf das Highbyte von X zu kommen, kannst Du B mit Overlay auf die Adresse hinter A alloziieren. Also A+1. Oder auch X+1, was ja dasselbe ist.

Äh @Cassio, sollte nicht auch direkt low(Adresse) und high(Adresse) gehen?

 

[Rudi54]

Dank auch Dir für deine Andwort !
Was ein Word und ein Byte ist weis ich. Entschuldige, ich bin da nur im Datenblatt gestolpert wiel da steht :
Address High Byte : A15 A14 A13 A12 A11 A10 A9 A8 und bei Address Low Byte : A7 * * * * * * A0.
Was so aussieht als wenn Bit 1 bis Bit 6 weggelassen sind.
Das weitere was Du geschrieben hast, muß ich mir noch in Ruhe zu gemüte ziehen .
"Overlay" ist mir schon mal untergekommen (in Verbindung mit String). Muß ich noch mal nachlesen .
Freundlichst Rudi54

 

[Cassio]

Oder liege ich da im Denkfehler Bereich ?

Hallo Rudi!

Ja, ich denke schon, dass du da einen Denkfehler hast.

Wie es LotadaC schon richtig erklärt hat....
Du hast ein EEPROM mit 512k Bits!
512k / 8 = 64k Byte

Damit du nun jedes Byte adressieren kannst, musst du natürlich vorher die Speicheradresse mit angeben.
Da du aber logischer Weise mehr als 256 Adressen benötigst, reicht ein Byte nicht mehr aus.
Aus dem Grunde wird als Adresse ein Word verwendet! Damit hast du 65536 Möglichkeiten zur Adressierung.

Nun kommt das Problem, dass du mit dem TWI/I2C Bus immer nur ein Byte senden kannst....... und kein Word!
Aus dem Grunde wird das Word in zwei einzelne Bytes zerlegt (Highbyte und Lowbyte) und dann zum EEPROM gesendet.

Damit du dir aber keine weiteren Gedanken zum Zerlegen des Word in zwei Bytes machen musst, habe ich die Overlays verwendet.
Auf diese Weise benötigst du im Speicher nur ein einziges Word und die beiden Variablen (Adresse_h und Adresse_l) sind nur Zeiger auf die einzelnen Bytes des Words.


Die Ansteuerung steht auch genauso im Datenblatt!


Daher auch mein Beispielcode zur Adressierung und zum Übertragen der Daten:


CodeBox BascomAVR

I2cstart
I2cwbyte 512w
I2cwbyte Adresse_h
I2cwbyte Adresse_l
I2cwbyte Wert
I2cstop

Schreibe doch mal einen ersten Testcode und probiere es doch einfach mal aus.
Sollte es dann nicht funktionieren, stelle deinen Testcode hier ein und wir helfen dir dann bestimmt weiter.

Grüße,
Cassio

 

[LotadaC]

ich bin da nur im Datenblatt gestolpert wiel da steht :
Address High Byte : A15 A14 A13 A12 A11 A10 A9 A8 und bei Address Low Byte : A7 * * * * * * A0

Ja, das ist inkonsequent im Datenblatt (die sind auch nicht immer unfehlbar, wenn ich da zB an das USI-Buffer-Register bei diversen ATtinies und deren Datenblätter denke... aber zurück zum Thema) - auch beim Low-Byte hast Du alle 8 Bits. Da geht's ja eigentlich eher um die Chip-Select-Bits.
Konsequent wäre, wenn sie entweder auch beim High-Byte die "°"-Platzhalter verwendet hätten, oder eben im Lowbyte alles Tippen...
Alles klar jetzt?

Zu Overlay:
Wenn Du mal genau drüber nachdenkst, gibt es doch gar keine Variablen. Der AVR hat dafür nur SRAM-Speicher (jaja, Flash und Eeprom-Spitzfindigkeiten mal aussen vor). Nur Bits in Bytes.
Wenn Du in Bascom irgend'ne Variable alloziieren läßt, wird nur vereinbart, daß die und die Speicherzelle jetzt zu jener Variable gehört. Genauer: daß beim Zugriff auf eine bestimmte Variable eben auf eine oder nehrere SRAM-Speicherzellen zugegriffen wird. Insbesondere können aber auch mehrere Variablen (Zeiger) auf dieselbe SRAM-Zelle Zugreifen (in Deinem String X="blablub" stehen halt 8 Bytes im SRAM (blablub und 'ne ASCII-Null), X ist die Adresse des ersten "b". 5 Zellen später steht das ASCII-"u". Wenn Du jetzt 'ne neue Variable b overlay X+5 erzeugst, wird für b die SRAM-Adresse alloziiert, in der das "u" steht.
Setzt Du jetzt b=105 (dezimal) und liest irgendwann mal X aus dem SRAM, bekommst Du plötzlich "blablib" (105dez = ASCII-"i" = &b01101001 = 0x69)

 

[Rudi54]

Dank euch beiden für die hilfreichen Andworten !
Bin wegen dem A7.......A0 schon fast vom Glauben abgefallen. (Wie soll das denn gehen?)
Einen Testcode habe ich noch gar nicht. Bin noch bei der Platine am löten.
Nur erstmal soweit: ATMega644 mit 16 MHz Quarz, SD-Card, Schieberegister, LCD 24x2 usw.
Und weil ich bei der letzten Reichelt Bestellung noch nicht über 10€ war und noch Platz auf der
Platine ist, kam dann die Idee mit dem EEprom. Damit und mit TWI wollte ich mich auch mal
versuchen. Dazu muß ich gestehen, beschäftige mich erst seit knapp einem Jahr mit Bascom.
Wenn es soweit ist. mit dem Testcode, melde ich mich bestimmt wieder.
Freundlichst Rudi54

 

[fredred]

Hallo Rudi54,

wie im Forum schon mit Recht angeprangert, bin ich kein „Schreiberling“ somit nur ein Code-Schnipsel,
für I2C Eeprom >= 64. Hoffe du findest ein Teil, der dich Hilft. In meiner Anwendung funktioniert auch ein(ST24C512). Meine Betonung liegt auf "Teil"
Weitere Beschreibung möchte ich dem Forum nicht zumuten. Werde natürlich Fragen beantworten.

Mit freundlichen Grüßen
Fred




CodeBox BascomAVR

'---- Eeprom Konstanten festlegen ----
Const Dev_addr_write = &B10100000  'EEPROM Schreibadresse  (ST24C64)
Const Dev_addr_read = &B10100001  'EEPROM Leseadresse (ST24C64)
'hier Objekt Einstellungen
Const Stringanz = 6  'String Var Anzahl beginnt mit 0 somit 7 Var
Const Stringmax = 8  'für jedes String 8 Byte reserviert.
Const Speichervoll = 16000  'maximale Speichergröße in Byte (zB.ST24C64)
'############################################
'!!!!!!! Übergabe von Konstanden NICHT ändern !!!!!!!!!!
Const Byteschleife = Stringanz + 1  'bedingt durch String
Const Stringab = Stringmax + 1
Dim Aktschleife As Word
Aktschleife = Stringanz * Stringmax
Aktschleife = Aktschleife + 9  'ist Summe aller Byte + String Endzeichen
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
Dim Mem_addr As Word  'Adress Zähler
Dim J As Byte  'Laufvariable für Byte Schleife
Dim Mem_addr_low_byte As Byte At Mem_addr Overlay  'da Eeprom > 8kByte aufteilen
Dim Mem_addr_high_byte As Byte At Mem_addr + 1 Overlay
Dim Aktionen As Word  'Schreib-Zähler
Dim Aktionenl As Word  'Lese-Zähler
Dim S As Byte  'Laufvariable für for-next Schleife schreiben
Dim Number_from_rs(byteschleife) As String * Stringab  'Array der Schreib-Variablen
Dim Four_byte_var_write As String * Stringmax
Dim Byte_var_write(stringmax) As Byte At Four_byte_var_write Overlay  ' Elemente Arrayindex
Dim L As Word  'Zyklus fortschreiben lesen  'alle Single_Variablen auslesen
Dim Four_byte_var_read As String * Stringmax
Dim Byte_var_read(stringmax) As Byte At Four_byte_var_read Overlay  ' Elemente, Arrayindex
'!!!!! 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
'Gosub Lesen  'nach Reset erstmal lesen
'### hier werden die Variablen für Eeprom-Test festgelegt ##########
  Dim Datum As String * Stringmax
  Dim Zeit As String * Stringmax
  Dim Var2 As String * Stringmax
  Dim Var3 As String * Stringmax
  Dim Var4 As String * Stringmax
  Dim Var5 As String * Stringmax
  Dim Var6 As String * Stringmax
'(
'+++ Beispiel1 für Single ++++++
  Dim Temperatur1 As Single
  Temperatur1 = 19.55  'sind 4Byte
  Var2 = Str(temperatur1)  'Single als String übergeben
'+++++++++++++++++++++++++++++++
'+++ Beispiel2 für Single ++++++
  Dim Temperatur2 As Single
  Temperatur2 = -3.55  'sind 4Byte
  Var3 = Str(temperatur2)  'Single als String übergeben
'+++++++++++++++++++++++++++++++
')
Mem_addr = 0  ' Sicher ist Sicher
'**** Hauptschleife ****
Do
Waitms 500  'Test Zeit für Terminal-Testanzeige
'Analog Ports lesen
  Gosub Analog_dat  'Abfrage Controller AD(Lichtsensor)
  Gosub Analog_dat_bus  'Abfrage I2C-Bus AD
'Beispiel: Poti Abfrage
  Gosub Poti_ic_test
'Beispiel: I²C-Bus alle Ports als Eingang
  Gosub Eingang
'Beispiel: I²C-Bus alle Ports als Ausgang
  ' Gosub Ausgang
'Temperatursensoren lesen
  Gosub Temperaturmessung  'Abfrage Controller 1wire Bus
'für Eeprom-Test einfach mal so eingefügt
  Datum = "01.02.14"
  Zeit = "15:10:00"
  Var2 = Str(temp1)  'ist Beispiel Temperatursensor1
  Var3 = Str(temp2)  'ist Beispiel Temperatursensor2
  Var4 = Str(hell)  'ist Beispiel Helligkeit
  Var5 = "fredred"
  Var6 = "Test-OK"
'(
  'für Test Speicher löschen
  Datum = ""
  Zeit = ""
  Var2 = ""
  Var3 = ""
  Var4 = ""
  Var5 = ""
  Var6 = ""
')
'!!!alle Variablen für Test mit Hyperterminal anzeigen!!!
  Print
  Print "lese die Sensoren 1wire an Portb.0 Controller"
  Print "Temp1  " ; Var2
  Print "Temp2  " ; Var3
  Print
  Print "lese Lichtsensor von Getadc(7)"
  Print "Hell  " ; Var4
  Print
  Print "lese Port-Pins AD I2C "
  Print "A0: " ; " Wert ist " ; A0
  Print "A1: " ; " Wert ist " ; A1
  Print "A2: " ; " Wert ist " ; A2
  Print "A3: " ; " Wert ist " ; A3
  Print
Print "lese alle 8 Portpin's Expander"
  Print "Taste 1 = " ; Taste.0
  Print "Taste 2 = " ; Taste.1
  Print "Taste 3 = " ; Taste.2
  Print "Taste 4 = " ; Taste.3
  Print "Taste 5 = " ; Taste.4
  Print "Taste 6 = " ; Taste.5
  Print "Taste 7 = " ; Taste.6
  Print "Taste 8 = " ; Taste.7
  Print
  'Print "lese DigPoti" 'wird in Sub durchgeführt da für Test eine Schleife eingebaut.
  'Print "Volt-P0 =  " ; W0
  'Print "Volt-P1 =  " ; W1
  'Print
'!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
'Aktionen mit Taster in Echt durch Ereignis ersetzen zB. Timer
Debounce Taster_s , 0 , Schreiben , Sub  'Taster entprellen
Debounce Taster_l , 0 , Lesen , Sub
'(
'--- 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
'**** END Hauptsschleife ****
'### BEGINN in ext EEPROM schreiben (byte write method) ###
Schreiben:
'Config Base = 0 'Zähler mit 0 beginnen
'--- für Test ---
  Print "Byte der Var-Variablen schreiben  " ; "Aktionen  " ; Aktionen
  Print
'----------------
  Mem_addr = Aktionen * Aktschleife  'step Aktionen
'LED Anzeige wenn Eeprom gelesen werden sollte
  If Mem_addr >= 113 Then Eepvoll = 1  '113 ist nur ein Beispiel kann auch [Speichervol- xxx] sein
For S = 0 To Stringanz  'for-next mit 0 beginnen da Base = 0
  If S = 1 Then Number_from_rs(1) = Datum
  If S = 2 Then Number_from_rs(2) = Zeit
  If S = 3 Then Number_from_rs(3) = Var2
  If S = 4 Then Number_from_rs(4) = Var3
  If S = 5 Then Number_from_rs(5) = Var4
  If S = 6 Then Number_from_rs(6) = Var5
  If S = 7 Then Number_from_rs(7) = Var6
  Four_byte_var_write = Number_from_rs(s)  'String Variable S schreiben
  For J = 0 To Byteschleife  'Laufschleife 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 Rückmeldung
'--- nur für Test ---
  Print "Var-Variable  " ; S ; " =  Adresse " ; Mem_addr ; "  Bytewert  " ; Byte_var_write(j)
'--------------------
  Next J
'--- nur für Test ---
  Print "!!  Ausgabe  !!  " ; Four_byte_var_write
  Print
'---------------------
Next S
'ist Speicher am Ende dann wieder von vorn
  If Mem_addr = Speichervoll Then
'schreiben beginnt wieder ab Adr 0. Rest bleib erhalten.
  Aktionen = 0
  End If
  Incr Aktionen  'nächsten Schreibzyklus anstoßen
  'Config Base = 1  'Schleifenzähler wieder auf 1 setzen
Return
'### ENDE ext EEPROM schreiben ###
'-----------------------------------------------------------
'### BEGINN aus ext.EEPROM lesen  ###
Lesen:
'Config Base = 0  'Zähler mit 0 beginnen
  Mem_addr = 0  'da Variable auch für schreiben gesetz ist zum lesen zurück setzen.
  Aktionenl = 0  'starte Lesung bei Adr 0
For Mem_addr = Aktionenl To Speichervoll  'ist max Byte für Eeprom
'--- nur für Test ---
' Print "Byte der 6 Var-Variablen lesen " ; "Zyklus  " ; Aktionenl
' Print
'--------------------
  For L = 0 To Stringanz
  For J = 0 To Byteschleife  'Laufschleife lesen
  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
  Waitms 10
  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
'--- nur für Test ---
  ' Print "Var_Variable  " ; L ; "  = Byte " ; Mem_addr ; "  Bytewert  " ; Byte_var_read(j)
'--------------------
'wenn -NAN dann Auslesung beenden(soll nicht unbeschriebenen Speicher lesen)
  If Four_byte_var_read = "" Or Byte_var_read(j) = 255 Then
  Print Mem_addr ; "  Byte gelesen "
  Eepvoll = 0  'LED aus
  Return
  End If
  Next J
'### BEGINN Terminal_log Ausgabe für Auswertungen in Excel ###
'### CSV Trenzeichen ist [;] ###
  Print Four_byte_var_read ; ";" ;
  'Daten wurden gelesen
  Eepvoll = 0  'LED aus
'Nach Zwischenauslesung Speicherbereich fortsschreiben soll ja nicht
'immer die gleichen Zellen beschreiben("Lebensdauer")
  If Mem_addr = Speichervoll Then
'schreiben beginnt wieder ab Adr 0. Rest bleib erhalten.
  Aktionen = 0
  End If
  Next L
  Print Chr(3)  'wird benötigt für CSV(End Off Text nach Zyklus)
  Incr Aktionenl  'Lesezyklus hochzählen bis -Nan
Next Mem_addr
' Config Base = 1  'Schleifenzähler wieder auf 1 setzen
Return
'#### ENDE ext.EEPROM lesen ####

 

[fredred]

Hallo Rudi54,

solltest du ein Blick auf meinem Code geworfen haben noch ein Nachtrag.

Für mich war es wichtig Strings zu schreiben/lesen.
Also alle Variablen ob Word oder Single auf Sting setzen. Somit sind auch lange Texte möglich. Wichtig auch die Schreibzyklen der Zellen optimal auszulasten.
Auch eine LED Meldung wenn Speicherkapazität ein Punkt erreicht hat, dann auslesen, sollen ja keine Informationen überschrieben werden. Kommt Meldung lese ich Eeprom mit Terminal aus gleich mit Format zur Weiterverarbeitung für Excel.

PS. Code ist nicht mehr aktuell. In meinem Projekt hängen schon 6 (ST24C512) am Bus, reicht für ca. 3 Monate alle Inforationen zu speichern, bevor ab IC 1 überschrieben wird.

Mit freundlichen Grüßen
Fred

 

[Rudi54]

Hallo Fred !
Danke für Deine Anregungen. Komme jetzt erst dazu mich mit der EEprom-Geschichte zu befassen.
Habe mich in der letzte Zeit mit den beiden 74HC595 rumgeschlagen.
Meine 1. Variante:
Dim Var As Integer
Dim Zeiger As Word

'*Sub Shift_out*****************************************************************
Shift_out:
Var = Lookup(zeiger , Tabelle)
Shiftout PORTA.0 , PPORTA.1 , Var , 1 , 16 ' 1 MSB first, Clock gos high
Reset Le ' Latch disabled
Set Le ' Latch enabled
Incr Zeiger ' in nächste Zelle
Return

'*Tabelle***********************************************************************
Tabelle:
Data &B0110100101001111% , usw...
Kommt nur Müll raus. Hab auch % mal weg gelassen aber dann nur anderer Müll.
Hab ich bei Data was falsch ?
'*******************************************************************************
Mit:
Dim Var As Byte
Dim Zeiger As Word

'*Sub Shift_out*****************************************************************
Shift_out:
Var = Lookup(zeiger , Tabelle)
Shiftout PORTA.0 , PPORTA.1 , Var , 1 , 8 ' 1 MSB first , Clock gos high
Incr Zeiger ' in nächste Zelle
Var = Lookup(zeiger , Tabelle)
Shiftout PORTA.0 , PPORTA.1 , Var , 1 , 8 ' 1 MSB first , Clock gos high
Reset Le
Set Le
Incr Zeiger ' in nächste Zelle
Return

'*Tabelle***********************************************************************
Tabelle:
Data &B01101001 , &B01001111 , usw...
Läuft alles wunderbar .

Wegen der EEprom write / read Sache melde ich mich bestimmt wieder.
Muss auch noch raus bekommen wann "ack" oder "nack" gesetzt werden.
Gruß an alle
Rudi54

 

[Tschoeatsch]

Hi Rudi54, bis du dir mit deinen latch-leveln sicher? Vertausch mal die Reihenfolge, erst ein set und danach ein reset, sodass beim Reinschieben der Daten der latch-Eingang einen low-level hat.

 

[fredred]

Hallo Rudi54,

dein letzter Beispiel-Code ist für mich nicht nachvollziehbar im Bezug I2C Eepromm > 8k.
Bis 8k ob intern oder extern gibt es viele Beispiele.
Mein Code sollte nur vermitteln, wie auch größere (mit 16Bit Struktur)zuverlässig beschrieben/gelesen gelesen werden können.
Das größte Problem war den Zeiger für Speicherplatz im Eepromm dynamisch zu setzen.
Meine eigenwillige Lösung funktioniert prima. Nun kann ich Texte und Variablen zusammen „basteln“ und mit einem Ruck in Speicher schreiben oder Inhalt wann immer zurücklesen.
Eine meiner Option wahr auch die Zellen des Epromm gleichmäßig zu „belasten“.

Mit freundlichen Grüßen
Fred