Hallo Leute,

Theorie OK und Praxis zeigt, nicht alles ist OK
Erfahrung:
Nach Einsockeln eines „jungfräulichen“ Eeprom, war eine kleine Optimierung nötig.
Eeprom lesen immer bis zum Ende des Speichers, sollt doch nicht sein.
Die [var_read] ist ja werkseitig immer 255, somit noch dies eingefügt und Abfragen höher gelegt.

If Four_byte_var_read = "" Or Byte_var_read(j) = 255 Then
Nun wird lesen beendet, wenn Speicherplatz „leer „

Auch nach Auslesung des Eeprom wieder von Adr 0 zu beschreiben, war Dumm, nun wird [Mem_Addr] schreiben erst auf 0 gesetzt, wenn [Speichervoll]. Gleiches gilt auch beim Schreiben. Somit erhalten alle Speicherplätze die gleiche „Lebensdauer“


Nun der aktuelle Code.


Code:
'******************  Test-Demo  **************************
'* ist ein Testmodul für Data extern EEprom als Speicher *
'*   am I²C Bus ein 24c64 angeschlossen zum speichern    *
'*          und lesen der Variablen                      *
'*  alle Variablen werden als Strings konvertiert.       *
'*  somit unabhänig von Daten-Typ. Auch lange Texte sind *
'*              kein Problem mehr.                       *
'*  Die Variablen können mit Hyperterminal_Log als CSV   *
'*    für Auswertungen an EXCEL übergeben werden         *
'*    oder nur auf LCD usw.                              *
'*********************************************************
Code:

$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 auf Hyperterminal 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
'Hinweis: Diese Einstellung reserviert ein paar ROM-Speicher mehr..
'nur nötig wenn eine Var den Typ Single hat. Die letzte Stelle wird gerundet.
'Format für Single zwei Nachkommastellen
Config Single = Scientific , Digits = 2                     '2 Nachkommastellen oder wie auch immer
Config Base = 0                                             'alle Zähler mit 0 beginnen
'mehrer unterschiedliche I²C IC am Bus "anzuhängen" ist mit Dev_addr Select kein Problem.
'#### Eeprom Konstanten festlegen ###########
Const Dev_addr_write = &B10100000                           'EEPROM Schreibadresse  (ST24C64)
Const Dev_addr_read = &B10100001                            'EEPROM Leseadresse (ST24C64)
Const Stringanz = 6                                         'String Var Anzahl
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
'+++ zu Test ob I²C Hardware OK ist +++
Gosub I2c_test
'++++++++++++++++++++++++++++++++++++++
'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
'für Test einfach mal so
     Datum = "01.02.14"
     Zeit = "15:10:00"
     'Var2 = "100.10"                                        'ist ausgeblendet da Beispiel aktiv
     'Var3 = "123456"                                        'ist ausgeblendet da Beispiel aktiv
     Var4 = "300.30"
     Var5 = "fredred"
     Var6 = "Test-OK"

'Aktionen mit Taster in Echt durch Ereignis ersetzen zB. Timer
Debounce Taster_s , 0 , Schreiben , Sub                     '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:
 '--- 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 >= 626 Then Eepvoll = 1                     '626 ist nur ein Beispiel kann auch [Speichervol- xxx] sein
 For S = 0 To Stringanz                                     'for-next mit 0 beginnen da Base = 0
    If S = 0 Then Number_from_rs(0) = Datum
    If S = 1 Then Number_from_rs(1) = Zeit
    If S = 2 Then Number_from_rs(2) = Var2
    If S = 3 Then Number_from_rs(3) = Var3
    If S = 4 Then Number_from_rs(4) = Var4
    If S = 5 Then Number_from_rs(5) = Var5
    If S = 6 Then Number_from_rs(6) = 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
'--- 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
Return
'### ENDE ext EEPROM schreiben ###

'-----------------------------------------------------------
'### BEGINN aus ext.EEPROM lesen  ###
Lesen:
   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
        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 besschreiben("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
Return
'#### ENDE ext.EEPROM lesen ####

'-----------------------------------------------------
I2c_test:
Dim Busaddress As Byte
Dim Busaddress_read As Byte
Dim Chipaddress As Byte
Print "I2C Scan start"
'I²C Porterweiterung testen
'Alle Adresen Suche und Anzeigen
'Step 2 soll nur IC Adresse aufrufen für lesen
For Chipaddress = 0 To 254 Step 2                           ' IC's am I²C-Bus erkennen
   I2cstart                                                 'send start
   I2cwbyte Chipaddress                                     'sende Addresse auf Bus
 If Err = 0 Then                                            'Chip gefunden
  If Chipaddress = Dev_addr_write Then
    Print "gefunden  " ; "h  " ; Hex(chipaddress) ; "   b " ; Bin(chipaddress)
    Print "ist ein ST24C64 Adr 000"
    End If
  'hier können noch weitere I²C IC Teilnehmer abgefragt werden.
'(
 If Chipaddress = xxx Then
    Print "gefunden  " ; "h  " ; Hex(chipaddress) ; "   b " ; Bin(chipaddress)
    Print "ist ein ICxxx Adr xxx"
  End If
')
  End If
 Next
    Return



Wird wohl nicht der letzte sein
PS. Bin gerate dabei 2 * ST24C512 am Bus als Massenspeicher zu „hängen“.

Mit freundlichen Grüßen
fredred