Text im I2C EEPROM speichern und wieder auslesen

Hallo und nen guten Abend!

Ich möchte über ein GLCD einen Text ausgeben der aus einen I2C EEPROM stammt. Der Text soll über einen Menüpunkt als eine Art "Hifetext" auswählbar sein.
1. wie bekomme ich einen Text in das Eprom, wie kann ich das Eprom über eine PC beschreiben.
2. welcher Weg wäre der beste das Eprom wieder auszulesen?

Hat das schon mal jemand gemacht?

Gruß MAT

Hallo MAT,

Zu 1) Der Text kann mit den I2C-Schreibbefehlen in das EEPROM geschrieben werden. Wenn der PC (z.B. über RS232 oder USB) an deine uC-Platine angeschlossen ist, müßtest du ein uC-Prog schreiben, dass die Zeichen vom PC einliest und per I2C ins EEPROM schreibt.

Zu 2) Über die I2C-Lesebefehle

Gruß Dirk

Hallo Dirk,

danke für den Gedanken!
Ich habe gestern etwas gegoogelt und man kann über PonyProg und einen Adapter ein EEPROM ext. flashen.
Jetzt muss ich mir nur noch Gedanken über die Abfrage/Adressierung der Daten im EEPROM machen. Hast Du eine Idee wie ich den Text anlege?
Die Abfrage mit hilfe der I2C Befehle kenne ich, mein Problem ist nur, dass ich noch kein Plan habe, wie ich einzelne Textelemente im EEPROM anlege und diese wieder raushole.
Gruß MAT

Zitat:

---

... man kann über PonyProg und einen Adapter ein EEPROM ext. flashen.

---

Ja, klar. Wenn der Text sehr lang wird, ist das wohl eine Option.
Sonst könnte man den Text einfacher als String(s) in Bascom anlegen und in das EEPROM schreiben.

Zitat:

---

Hast Du eine Idee wie ich den Text anlege?

---

Naja, man könnte erstens eine feste Zeilenlänge (des GLCDs) nehmen und den Text in diesen Blöcken speichern.
Eine 2. Möglichkeit wäre, den Text als Bild zu speichern und die Bilder nacheinander ins GLCD zu laden.

Gruß Dirk

Hallo Dirk,

die Idee mit der Anzeige über ein Bild habe ich ausprobiert und funst soweit auch => guter Tip! ABER! diese Bilder werden ja im Programm und dadurch im RAM gespeichert, was mir ja wieder Programmspeicher weg nimmt. Gibt es ne Möglichkeit die .bgf im internen EEPROM zu speichern und sie daraus wieder zurück zu holen?

Gruß MAT

Zitat:

---

ABER! diese Bilder werden ja im Programm und dadurch im RAM gespeichert, was mir ja wieder Programmspeicher weg nimmt.

---

Ja, die Bilder nehmen Programmplatz weg. Das ist kein Problem, solange dein Programm genug Platz hat. RAM nehmen die Bilder dadurch aber nicht weg, weil Programm (und Bild) im Flash und nicht im RAM sind. Du sprichst jetzt ja auch wohl vom internen Speicher eines uC (Flash und EEPROM)? Anfangs hattest du ein I2C-EEPROM erwähnt, das dann ja extern wäre ...

Zitat:

---

Gibt es ne Möglichkeit die .bgf im internen EEPROM zu speichern und sie daraus wieder zurück zu holen?

---

Ja, klar. Allerdings ist das interne EEPROM meist nicht sehr goß.
Man kann das Bild anlegen mit:
$eeprom
Bild:
$bgf "Bild.bgf"
$data

... und Einlesen mit Showpice

Gruß Dirk

Moin Dirk,
ich komme immer wieder durcheinander mit flash,ram....
Ich meinte, und wie Du auch schon sagtest, den flashspeicher.
Als Controller nehme ich einen mega644p und da die Hilfedaten etwas mehr werden, sind das schon einige Bilder, die ich einbinden muss.
Ich habe in meinem Layout 2 externe EEPROM vorgesehen, von den ich eins für solche Anwendungen benutzen wollte und da mir die Idee mit den .bgf gefallen hat, würde ich diese entweder (vorrangig) im externen und wenn das nicht geht im internen EEPROM ablegen.

Aber vielleicht finde ich noch einen Weg den Hilfetext als hex im externen EEPROM abzulegen.

Gruß MAT

Ich komme meiner Idee der Ausführung immer näher, nur jetzt hänge ich mal wieder fest.
1. über PonyProg fülle ich ein I2C EEPROM mit meinem Text. Der Text liegt in
Hex-Form vor.
Das Eprom lese ich so aus:

Code:

---

For E_addr = &H0 To &H0D
          Call E_read(e_addr , E_dat)
          E_str1 = String(1 , E_dat)
          Print Hex(e_dat) ; " " ; Spc(10) ; E_str1 ; " "
          Next E_addr
end if
'///////////////////////////////////////////////////////////////////////////////
' Routine to read the 24C65

Sub E_read(byval E_addr As Word , E_dat_r As Byte)
    E_ah = High(e_addr)
    E_al = Low(e_addr)
    I2cstart
    I2cwbyte E_prom_w
    I2cwbyte E_ah
    I2cwbyte E_al
    I2cstart
    I2cwbyte E_prom_r
    I2crbyte E_dat_r , Nack
    I2cstop                                                                    '
End Sub

---

So kann ich mir schon mal die Hexwerte als Ascii ausgeben lassen, untereinander sehe ich die Buchstaben.

Wie kann ich diese jetzt in einen String, also hintereinander und mit einer Printanweisung, mir ausgeben lassen???

Zitat:

---

Wie kann ich diese jetzt in einen String, also hintereinander und mit einer Printanweisung, mir ausgeben lassen???

---

Du könntest die empfangenen Bytes nacheinander in Byte-Variablen ablegen, die so definiert sind:
Dim Bytevar1 As Byte
Dim Bytevar2 As Byte
...

und einen String passender Länge da drüber legen:
Dim S As String * 15 At Bytevar1 Overlay

Dann kannst du S ausgeben, wenn der String gefüllt ist.

Anstelle mehrere Byte-Variablen kannst du evtl. besser ein Byte-Array nehmen.

Gruß Dirk

hi Dirk,
"Anstelle mehrere Byte-Variablen kannst du evtl. besser ein Byte-Array nehmen. "
Das habe ich den ganzen Abend überlegt, aber wie? Daran verzweifle ich gerade. Dann könnte ich eine String über das Bytearray legen....
Hast Du nen Vorschlag wie ich die einzelnen Byte in ein Array bekomme?

Danke & Gruß

MAT

Nicht ausprobiert, daher keine Garantie:

Code:

---

Dim E_byte(14) As Byte
Dim E_str As String * 14 At E_byte(1) Overlay


For E_addr = &H0 To &H0D
          Call E_read(e_addr , E_dat)
          E_byte(E_addr + 1) = E_dat
          E_str1 = String(1 , E_dat)
          Print Hex(e_dat) ; " " ; Spc(10) ; E_str1 ; " "
          Next E_addr
end if

Print E_str

---

Gruß Dirk

Hallo Dirk,

habe es jetzt so gemacht, natürlich auch mit Hilfe ;) :

Code:

---

Dim E_dat As Byte
Dim E_str1 As String * 16
Dim E_str(20) As Byte At E_str1 Overlay
Dim Idx1 As Byte

'---------------------------------------------------------------------------
 Taster3:
  If Pina.5 = 1 Then
  Idx1 = 1
  Print "Testing I2C Eeprom"
      For E_addr = &H0 To &H0D
          Call E_read(e_addr , E_dat)
          E_str(idx1) = E_dat
          Incr Idx1
          Print = String(1 , E_dat)
          Print "Idx1 " ; Spc(10) ;  Idx1
          'Print Hex(e_dat) ; " " ; Spc(10) ; E_str1 ; " "

          Next E_addr
          Print "E_str(idx1)" ; Spc(10) ; String(1 , E_str(1))
          Print "E_str(idx2)" ; Spc(10) ; String(1 , E_str(2))
          Print "E_str(idx3)" ; Spc(10) ; String(1 , E_str(3))
          Print "E_str(idx4)" ; Spc(10) ; String(1 , E_str(4))
          Print "E_str(idx5)" ; Spc(10) ; String(1 , E_str(5))
          Print "E_str(idx6)" ; Spc(10) ; String(1 , E_str(6))
          Print "E_str(idx7)" ; Spc(10) ; String(1 , E_str(7))
          'E_str(idx1) = 0
          Print "TEXT aus Eram:" ; E_str1                                      '; String(1 , E_str1)

    End If

---

und jetzt funst es :D

Danke für Deine Hilfe!!!
Gruß MAT

Problem gelöst \:D/

1. Text in ein EEPROM brennen:

* EEPROM-Adapter bauen:

http://www.mikrocontroller.net/artic...n_am_COM1-Port

* Hexeditor besorgen:

http://mh-nexus.de/de/
Ich verwende HxD - Hexeditor, da dort direkt der Text/Daten eingegeben werden kann und dazu die Adressbelegung der Daten leicht zu verfolgen ist.
Daten ausdenken, im Hexeditor eingeben und als Hex-Datei abspeichern. Danach die Datei mit PonyProg öffnen und in den EEPROM schreiben.

2. EEPROM wieder auslesen:

Code:

---

'**********************************************************

'Programm            : Text aus EEPROM, aus bestimmter Adresse, holen und auf GLCD anzeigen
'By                  : mat-sche
'Compiler            : BASCOM-AVR  1.11.9.3
'Hardware            : GLCD 128x64 KS108
'
'
'                      EEprom 24c65 (64kBit) an Hardware TWI
'Chip type          : MEGAm644p
'Date                : 29.10.2009
'**********************************************************

$regfile = "m644pdef.dat"                                                      ' specify the used micro
$crystal = 10000000                                                            ' used crystal frequency
$baud = 19200                                                                  ' use baud rate
$hwstack = 32                                                                  ' default use 32 for the hardware stack
$swstack = 10                                                                  ' default use 10 for the SW stack
$framesize = 40                                                                ' default use 40 for the frame space


'some routines to control the display are in the glcdKS108.lib file
$lib "glcdKS108.lib"
$lib "i2c_TWI.lib"                                                              ' Lib bei Verwendung von Hardware TWI

'First we define that we use a graphic LCD
Config Graphlcd = 128 * 64sed , Dataport = Portb , Controlport = Portd , Ce = 6 , Ce2 = 5 , Cd = 4 , Rd = 3 , Reset = 7 , Enable = 2
'------------------------------------------------------------------------------- Config TWI
Config Twi = 400000                                                            ' Init TWBR und TWSR
' TWI gleich einschalten, das macht Bascom ansonsten erst beim I2CStart !
Twcr = &B00000100                                                              ' nur TWEN setzen

Config Sda = Portc.1                                                            'SDA und SCL als Hardware-TWI definieren
Config Scl = Portc.0

Const E_prom_w = &HAE                                                          'Epromadresse 160 (A1/2/3 auf GND) schreiben
Const E_prom_r = &HAF                                                          'Epromadresse 160+1 für schreiben der Daten

'EEprom 24C32,24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.
'Weil grösserer Speicherbereich im EEprom vorhanden ist Darum muss man den Adressbereich in High und Low Adressbereich
'trennen. (Zuerst High-Adressbereich schreiben und dann Low-Adressbereich)

Dim E_dat As Byte                                                              'Zwischenspeicher der TWI-Daten
Dim E_str1 As String * 25                                                      'String-Daten gefüllt als Adressüberlage beginnend bei E_str(1)
Dim E_str(25) As Byte At E_str1 Overlay                                        'Bytearray für die Daten aus dem EEPROM
Dim Idx1 As Byte , Str_z As Byte                                                'Zähler

Dim E_ah As Byte                                                                'höherwertiges Byte der SpeicherAdresse (Adresse=Word)
Dim E_al As Byte                                                                'niederwertiges Byte der SpeicherAdresse (Adresse=Word)
Dim E_addr As Word , Adr_1 As Word , Adr_2 As Word                              'SpeicherAdresse EEprom
Dim E_dat_r As Byte                                                            'Daten der zu lesenen Daten aus EEprom
Dim E_dat_w As Byte

Declare Sub E_write(byval E_addr As Word , E_dat_w As Byte)                    'Sub zum schreiben in EEprom mit Übergabe einer Kopie der Variable (Eaddr/E_dat_w)
Declare Sub E_read(byval E_addr As Word , E_dat_r As Byte)                      'Sub zum lesen aus EEprom
Declare Sub E_red_hilfe(byval Adr_1 As Word , Byval Adr_2 As Word , Byval Line_x As Byte , Byval Line_y As Byte )      'Sub zum Auslesen des EEPROM:
'                        Begin Adressbereich  , Ende Adressbereich  , Anzeigeort für X auf dem LCD, - Y-Ort


Speaker Alias Portc.3
'Dim variables (y not used)
Dim X As Byte , Y As Byte

Do
'specify the font we want to use
Setfont Font8x8

Call E_red_hilfe(&H50 , &H67 , 2 , 3 )                                          ' Daten aus dem EEPROM ab Adresse &H50 bis &H67 holen und auf Linie X 2, Linie Y 3 schreiben
Call E_red_hilfe(&H68 , &H7F , 3 , 3 )
Call E_red_hilfe(&H80 , &H97 , 4 , 3 )
Call E_red_hilfe(&H98 , &HAF , 5 , 3 )
Call E_red_hilfe(&Hb0 , &HC7 , 6 , 3 )

Wait 1
Print "Cls"
Cls

Wait 1

'specify the font we want to use
Setfont Font8x8

Sound Speaker , 200 , 200
'You can use locate but the columns have a range from 1-128
'When you want to show somthing on the LCD, use the LDAT command
'LCDAT Y , COL, value
Lcdat 1 , 1 , "123"

'lcdat accepts an additional param for inversing the text
Lcdat 2 , 1 , "123" , 1                                                        ' will inverse the text

'Now use a different font
'Setfont Font8x8
'since the 16*16 font uses 2 rows, show on row 3
'Lcdat 1 , 1 , "2345"
'Lcdat 2 , 56 , "2345656"
Wait 1
Line(0 , 0) -(127 , 64) , 1                                                    'make line
Wait 2
Line(0 , 0) -(127 , 64) , 0                                                    'remove line

For Y = 1 To 20
  Circle(30 , 30) , Y , 1
  Waitms 100
Next

Wait 1
Glcdcmd &H3E , 1 : Glcdcmd &H3E , 2                                            ' both displays off
Wait 1
Glcdcmd &H3F , 1 : Glcdcmd &H3F , 2                                            'both on
'GLCDCMD accepts an additional param to select the chip
'With multiple, GLCDCMD statements, it is best to specify the chip only the first time


                                                      'show a comnpressed picture
Loop

End                                                                            'end program
'////////////////// Subroutinen ////////////////////////////////////////////////
'///////////////////////////////////////////////////////////////////////////////
'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Routine to write the 24C65

Sub E_write(byval E_addr As Word , E_dat_w As Byte )
    E_ah = High(e_addr)                                                        'E_ah = EEprom high Adressbyte der jeweiligen Word-Adresse (H&10)
    E_al = Low(e_addr)                                                          'E_ah = EEprom low Adressbyte der jeweiligen Word-Adresse (H&10)
    I2cstart                                                                    'Start I2C
    I2cwbyte E_prom_w                                                          'Sende Slave Adresse
    I2cwbyte E_ah                                                              'Sende Speicheradresse High
    I2cwbyte E_al                                                              'Sende Speicheradresse Low
    I2cwbyte E_dat_w                                                            'Sende Daten Werte
    I2cstop                                                                    'Stop I2C
    Waitms 10
End Sub

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
' Routine to read the 24C65

Sub E_read(byval E_addr As Word , E_dat_r As Byte)
    E_ah = High(e_addr)
    E_al = Low(e_addr)
    I2cstart
    I2cwbyte E_prom_w
    I2cwbyte E_ah
    I2cwbyte E_al
    I2cstart
    I2cwbyte E_prom_r
    I2crbyte E_dat_r , Nack
    I2cstop                                                                    '
End Sub

'+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
'Routine to read a String from EEPROM and send to the GLCD
Sub E_red_hilfe(byval Adr_1 As Word , Byval Adr_2 As Word , Byval Line_x As Byte , Byval Line_y As Byte )
Idx1 = 1
For E_addr = Adr_1 To Adr_2                                                    ' Adresse &H.. bis &H..
    Call E_read(e_addr , E_dat)                                                ' Daten aus Sub E_READ(BYVAL E_ADDR AS WORD , E_DAT_R AS BYTE) holen
    E_str(idx1) = E_dat                                                        'Daten in ein Bytearray schreiben
    Incr Idx1                                                                  'Bytearray Speicherstelle erhöhen
    Next E_addr                                                                'nächste Adresse holen
    Incr Str_z                                                                  'etwas zählen
    Lcdat Line_x , Line_y , E_str1                                              'Daten auf bestimmten Ort vom GLCD anzeigen lassen
End Sub


'we need to include the font files
'Notice that this is a testfont with only numbers defined !
'$include "smallfont8x8.font"
$include "font8x8.font"
'$include "font16x16.font"

---

Meine Dienste werden damit gut bedient, vielleicht braucht dies ja mal jemand ;)

Gruß MAT

Hallo,

dank Deines Codes ,dachte ich die Lösung gefunden zu haben wie Strings, in ein I²C Eeprom ST 24c64 Wp geschrieben und gelesen werden können.
Lesen nur als Print ausgegeben .
Hier ist mein letzter Versuch Dein Code anzupassen und hoffe die Kommentare sind ausreichend für Hilfe.
In Echt wird Taste1 durch Ereignis ersetzt, wie es auch mit meinen Code für int. Eeprom, problemlos mit [Eram] funktioniert. Aber hier habe ich ein totales OUT im Kopf.

Vorab vielen Dank
Mit freundlichen Grüßen
fredred

'****************** Test-Platine *************************
'* ist ein Testmodul für Data extern EEprom als Speicher *
'* am I²C Bus ein ST24c64 angeschlossen zum speichern *
'* und lesen der Variablen *
'* kleine Platine nur an Klemme I²C anschließen *
'* *
'* alle Auswertungen für Test nur über Terminal anzeigen *
'************************************************* ********

$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 aus
Print "Erstellt am " ; Version(1)
Print
Waitms 100



'------------------------------------------------------------------------------- Config TWI
$lib "i2c_TWI.lib"
Config Twi = 100000


'Const E_prom_w = &HAE 'Epromadresse 160 (A1/2/3 auf GND) schreiben
'Const E_prom_r = &HAF 'Epromadresse 160+1 für schreiben der Daten

Const E_prom_w = &B10100000
Const E_prom_r = &B10100001


'EEprom 24C32,24C128, 24C256 haben im Gegensatz zu den 24C16'er einen Adressraum von zwei Byte.
'Weil grösserer Speicherbereich im EEprom vorhanden ist Darum muss man den Adressbereich in High und Low Adressbereich
'trennen. (Zuerst High-Adressbereich schreiben und dann Low-Adressbereich)


Dim E_dat As Byte 'Zwischenspeicher der TWI-Daten
Dim E_str1 As String * 31 'String-Daten gefüllt als Adressüberlage beginnend bei E_str(1)
Dim E_str(31) As Byte At E_str1 Overlay 'Bytearray für die Daten aus dem EEPROM
Dim Idx1 As Byte , Str_z As Byte 'Zähler

Dim E_ah As Byte 'höherwertiges Byte der SpeicherAdresse (Adresse=Word)
Dim E_al As Byte 'niederwertiges Byte der SpeicherAdresse (Adresse=Word)
Dim E_addr As Word , Adr_1 As Word , Adr_2 As Word 'SpeicherAdresse EEprom
Dim E_dat_r As Byte 'Daten der zu lesenen Daten aus EEprom
Dim E_dat_w As Byte

Dim Tagzl(10)as Byte 'soll Tastendruck zählen

Declare Sub E_write(byval E_addr As Word , E_dat_w As Byte) 'Sub zum schreiben in EEprom mit Übergabe einer Kopie der Variable (Eaddr/E_dat_w)
Declare Sub E_read(byval E_addr As Word , E_dat_r As Byte) 'Sub zum lesen aus EEprom

'Sub zum Auslesen des EEPROM: Begin Adressbereich , Ende Adressbereich
Declare Sub E_red_hilfe(byval Adr_1 As Word , Byval Adr_2 As Word)

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



'### hier werden die Variablen für EEprom-Test festgelegt ##########

Dim Var1 As String * 5
Dim Var2 As String * 5
Dim Var3 As String * 5
Dim Var4 As String * 5
Dim Var5 As String * 5
Dim Var6 As String * 5

Var1 = "Test"
Var2 = "1000"
Var3 = "2000"
Var4 = "3000"
Var5 = "4000"
Var6 = "5000"



Do

Waitms 200
'sind die Variablen die als String geschrieben/ gelesen werden sollen
E_str1 = Var1 + ";" + Var2 + ";" + Var3 + ";" + Var4 + ";" + Var5 + ";" + Var6


'(
'Begin Adressbereich , Ende Adressbereich , Anzeigeort für X auf dem LCD, - Y-Ort

Call E_red_hilfe(&H50 , &H67 , 2 , 3 ) ' Daten aus dem EEPROM ab Adresse &H50 bis &H67 holen und auf Linie X 2, Linie Y 3 schreiben
Call E_red_hilfe(&H68 , &H7F , 3 , 3 )
Call E_red_hilfe(&H80 , &H97 , 4 , 3 )
Call E_red_hilfe(&H98 , &HAF , 5 , 3 )
Call E_red_hilfe(&Hb0 , &HC7 , 6 , 3 )
')

'########## schreiben ###############################
' nach jedem Tastendruck String als Block anhängen
If Taster_s = 0 Then
' hier sollen die Blöcke angehangen werden aber wie???
'Incr Tagzl 'ist Tageszähler lesen
'???
E_dat_w = E_str1
Call E_write(e_addr , E_dat_w)
'???

'nach 10x von vorn überschreiben
'If Tagzl >= 10 Then Tagzl = 0
End If
'################################################# #####



'########## lesen ###############################
'wenn Taste gedrückt lesen
If Taster_l = 0 Then
Call E_read(e_addr , E_dat_r)

'jeden Block in eine neue Zeile printen aber wie???
' Print " gelesen " ; E_dat_r

End If
'#################################################
Loop

End


'////////////////// Subroutinen ////////////////////////////////////////////////
'///////////////////////////////////////////////////////////////////////////////
'+++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++
' Routine to write the 24C65

Sub E_write(byval E_addr As Word , E_dat_w As Byte )
E_ah = High(e_addr) 'E_ah = EEprom high Adressbyte der jeweiligen Word-Adresse (H&10)
E_al = Low(e_addr) 'E_ah = EEprom low Adressbyte der jeweiligen Word-Adresse (H&10)
I2cstart 'Start I2C
I2cwbyte E_prom_w 'Sende Slave Adresse
I2cwbyte E_ah 'Sende Speicheradresse High
I2cwbyte E_al 'Sende Speicheradresse Low
I2cwbyte E_dat_w 'Sende Daten Werte
I2cstop 'Stop I2C
Waitms 10
Print "schreiben ";
Print "Addr " ; E_addr ; " Daten " ; Asc(e_dat_w) 'test

End Sub


'+++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++
' Routine to read the 24C65

Sub E_read(byval E_addr As Word , E_dat_r As Byte)
E_ah = High(e_addr)
E_al = Low(e_addr)
I2cstart
I2cwbyte E_prom_w
I2cwbyte E_ah
I2cwbyte E_al
I2cstart
I2cwbyte E_prom_r
I2crbyte E_dat_r , Nack
I2cstop
Print "lesen ";
Print "Addr " ; E_addr ; " Daten " ; Asc(e_dat_r) 'test

End Sub

'+++++++++++++++++++++++++++++++++++++++++++++++++ ++++++++++++++++++++++++++++++
'Routine to read a String from EEPROM and send to the GLCD
Sub E_red_hilfe(byval Adr_1 As Word , Byval Adr_2 As Word , Byval Line_x As Byte , Byval Line_y As Byte )
Idx1 = 1
For E_addr = Adr_1 To Adr_2 ' Adresse &H.. bis &H..
Call E_read(e_addr , E_dat) ' Daten aus Sub E_READ(BYVAL E_ADDR AS WORD , E_DAT_R AS BYTE) holen
E_str(idx1) = E_dat 'Daten in ein Bytearray schreiben
Incr Idx1 'Bytearray Speicherstelle erhöhen
Next E_addr 'nächste Adresse holen
Incr Str_z 'etwas zählen
'Lcdat Line_x , Line_y , E_str1 'Daten auf bestimmten Ort vom GLCD anzeigen lassen
End Sub


'####### I2C-Bus testen ################################################## #####
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 = E_prom_w Then
Print "gefunden " ; "h " ; Hex(chipaddress) ; " b " ; Bin(chipaddress)
End If
If Err = 1 Then
Print " Addresse- oder Hardware- Fehler"
End If
End If
Next
Waitms 200
I2cstop
Return