-
        

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 20

Thema: I2C Eeprom ST 24C64

  1. #1
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211

    I2C Eeprom ST 24C64

    Anzeige

    Hallo Forum,
    es gibt schon viele Beispiele und Hinweise diese mit Byte zu beschreiben und lesen.
    Ist ja auch kein Problem aber ich finde keine vernünftige Lösung für Single –Variablen.
    Dieses Thema ist nach meiner persönlichen Meinung schon sehr unübersichtlich geworden. Somit ein Neustart.
    Nun bitte ich um Hilfe.

    Vielen Dank vorab
    Mit freundlichen Grüßen
    fredred


    Zum Verständnis mein Terminal- Ausdruck für Byte-Variablen.
    Funktioniert prima. Aber wie mit Single-Variablen ????
    -------------------------------------
    Code:
    I2C Scan start
    gefunden h A0 b 10100000
    
    EEPROM beschreiben...
    Adresse >1< wurde mit >0 beschrieben!
    Adresse >2< wurde mit >110 beschrieben!
    Adresse >3< wurde mit >120 beschrieben!
    Adresse >4< wurde mit >130 beschrieben!
    Adresse >5< wurde mit >140 beschrieben!
    Adresse >6< wurde mit >150 beschrieben!
    
    EEPROM auslesen...
    Adresse >1< wurde mit >0 gelesen!
    Adresse >2< wurde mit >110 gelesen!
    Adresse >3< wurde mit >120 gelesen!
    Adresse >4< wurde mit >130 gelesen!
    Adresse >5< wurde mit >140 gelesen!
    Adresse >6< wurde mit >150 gelesen!
    
    Hier mein letzter Code
    '****************** Test-Platine *************************
    '* ist ein Testmodul für Data extern EEprom als Speicher *
    '* am I²C Bus ein 24c64 angeschlossen zum speichern *
    '* und lesen der Variablen *
    '* *
    '* alle Auswertungen für Test nur über Terminal anzeigen *
    '* *
    '*************! fredred@arcor.de !************************
    
    $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 = &B10100001
    
    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 Wert(6) As Word 'ist Schreibwerte Array
    Dim Wertalt As Word 'ist Lesewert
    Dim Aktionen As Byte 'ist Status für Aktionen
    
    'war nur ein erfolgloser Versuch
    
    'Dim Wert As Single
    'Dim Werts As Byte At Wert(4) Overlay
    'Dim Wertalt As Single
    'Dim Wertl(4) As Byte At Wertalt Overlay
    
    
    '!!!!! 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
    '++++++++++++++++++++++++++++++++++++++
    
    '------- nach Reset lesen -------------
    Gosub Lesen
    '--------------------------------------
    
    Do
    
    '!!! Testwerte !!!
    Wert(1) = Aktionen
    Wert(2) = 110
    Wert(3) = 120
    Wert(4) = 130
    Wert(5) = 140
    Wert(6) = 150
    '!!!!!!!!!!!!!!!!!!
    
    '--- hier zum Daten schrieben --------
    If Taster_s = 0 Then 'wenn Taste gedrückt schreiben
    Waitms 100 'nur für Test
    Incr Aktionen '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 
    
    
    '###################################################################
    Lesen:
    Print ""
    Print "EEPROM auslesen..."
    
    For Adresse = 1 To 6
    I2cstart
    I2cwbyte 24c64w
    I2cwbyte Adresse_h
    I2cwbyte Adresse_l
    I2cstart
    I2cwbyte 24c64r
    I2crbyte Wertalt , Nack
    I2cstop
    Print "Adresse >" ; Adresse ; "< wurde mit >" ; Wertalt ; " gelesen!"
    Next
    Return
    
    '#############################################################################
    Schreiben:
    Print ""
    Print "EEPROM beschreiben..."
    
    For Adresse = 1 To 6
    I2cstart
    Adresse_h = High(adresse)
    Adresse_l = Low(adresse)
    I2cwbyte 24c64w
    I2cwbyte Adresse_h
    I2cwbyte Adresse_l
    I2cwbyte Wert(adresse)
    I2cstop
    Print "Adresse >" ; Adresse ; "< wurde mit >" ; Wert(adresse) ; " beschrieben!"
    Next
    Return
    
    '#############################################################################
    
    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 = 24c64w Then
    Print "gefunden " ; "h " ; Hex(chipaddress) ; " b " ; Bin(chipaddress)
    End If
    End If
    Next
    Waitms 200
    I2cstop
    Return
    '---------------------------------------------------------

    So sieht das mit Code-Fenster aus - Manf
    Geändert von Manf (11.02.2014 um 19:48 Uhr)

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    03.09.2009
    Ort
    Berlin (Mariendorf)
    Beiträge
    938
    Bitte schließe den Terminalausdruck in [CODE] -Tags ein, damit der Thread besser lesbar wird. Danke.

  3. #3
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211
    Guten Tag,

    bin noch nicht so firm im Forum.
    War der Meinung mein Ergebnis sollte in der Erklärung stehen wie weit ich gekommen bin.
    Um somit eventuelle Anfragen ob Hartware usw. OK ist zu vermeiden.
    Auch dein Hinweis gehören in eine gutes Forum.
    Somit vielen Dank.

    Mit freundlichen Grüßen
    fredred

  4. #4
    Erfahrener Benutzer Roboter Genie Avatar von Searcher
    Registriert seit
    07.06.2009
    Ort
    NRW
    Beiträge
    1.410
    Blog-Einträge
    101
    Zitat Zitat von fredred Beitrag anzeigen
    es gibt schon viele Beispiele und Hinweise diese mit Byte zu beschreiben und lesen.
    Ist ja auch kein Problem aber ich finde keine vernünftige Lösung für Single –Variablen.
    Hallo,
    nach Deinem Code hast Du ja schon Bytes geschrieben und zurückgelesen. Den Kommentaren zufolge hast Du es beim Typ Single auch schon mit Overlays versucht. Die Overlay Verwendung scheint mir bei Dir falsch gewesen zu sein.

    Hier ein Codefragment um eine Single-Variable zu schreiben und zu lesen. Wichtig hierbei eben die richtige Deklaration der Overlays. Übertragen in Deinen Code mit Ergänzungen und den den richtigen EEPROM Adressen "darfst" Du machen Wenn das klappt, kann man zum Speichern mehrerer Single übergehen.
    Code:
    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
    
    Four_byte_var_wr = &H1A2B3C4D           'dezimal = 439041101 (irgendeine Zahl)
    
    For I = 1 To 4                          'die vier Bytes der Single Variablen zum EEPROM schreiben
      .
      I2cwbyte Byte_var_write(i) ,(ack , Nack)
      .
    Next
      .
    For I = 1 To 4                          'die vier Bytes der Single Variablen vom EEPROM lesen
      .
      I2crbyte Byte_var_read(i) ,(ack , Nack)
      .
    Next
    
    Print Four_byte_var_wr
    Print Four_byte_var_rd
    
    End                                     'end program
    Gruß
    Searcher

    PS. Die [ CODE][ /CODE] Tags (ohne die Leerzeichen in den eckigen Klammern) erreicht man auch mit dem "Erweitert" Button und dann mit dem # Zeichen. Posts kann man auch nachträglich noch editieren.
    Geändert von Searcher (15.01.2014 um 17:55 Uhr) Grund: Variablennamen berichtigt die Zweite :(
    Hoffentlich liegt das Ziel auch am Weg
    ..................................................................Der Weg zu einigen meiner Konstruktionen

  5. #5
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211
    Hallo Searcher,

    sieht auf dem ersten Blick schon mal sehr Gut aus.
    Werde es Morgen mal versuchen im mein Code einzubinden.
    Vorab schon mal vielen Dank.

    Gruß
    fredred

  6. #6
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211

    Frage

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


  7. #7
    Erfahrener Benutzer Roboter Genie Avatar von Searcher
    Registriert seit
    07.06.2009
    Ort
    NRW
    Beiträge
    1.410
    Blog-Einträge
    101
    Hallo fredred,
    Zitat Zitat von fredred Beitrag anzeigen
    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
    Angehängte Dateien Angehängte Dateien
    Geändert von Searcher (18.01.2014 um 05:47 Uhr)
    Hoffentlich liegt das Ziel auch am Weg
    ..................................................................Der Weg zu einigen meiner Konstruktionen

  8. #8
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211
    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

  9. #9
    Erfahrener Benutzer Roboter Genie Avatar von Searcher
    Registriert seit
    07.06.2009
    Ort
    NRW
    Beiträge
    1.410
    Blog-Einträge
    101
    Hallo fredred,
    Zitat Zitat von fredred Beitrag anzeigen
    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.

    Code:
    '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
    Hoffentlich liegt das Ziel auch am Weg
    ..................................................................Der Weg zu einigen meiner Konstruktionen

  10. #10
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    14.11.2013
    Ort
    SA
    Alter
    64
    Beiträge
    211

    I2C Eeprom ST 24C64

    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.

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

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Smartcard - FUN2 mit AT90S8515 und 24C64 EEPROM - Wie jetzt?
    Von Lovebongo im Forum Microcontroller allgemeine Fragen/Andere Microcontroller
    Antworten: 7
    Letzter Beitrag: 24.01.2008, 12:58
  2. 24c64 Eeprom Problem
    Von Rohbotiker im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 0
    Letzter Beitrag: 20.01.2008, 14:15
  3. PIC18F4550 und 24C64 über I2C
    Von TheScientist im Forum PIC Controller
    Antworten: 0
    Letzter Beitrag: 23.07.2007, 17:29
  4. Erledigt: EEPROM 24C64 Probleme
    Von N8Surfer im Forum C - Programmierung (GCC u.a.)
    Antworten: 0
    Letzter Beitrag: 11.12.2006, 15:34
  5. Wiedermal Problem mit 24C64 EEPROM
    Von basil_05 im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 1
    Letzter Beitrag: 20.06.2006, 02:15

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •