I2CEprom 24LC512 Page Write Bascom - TWI Experten gesucht

[Manfred S. (Firma: Manfred) (xfred343)]

Hi,

stehe gerade vor einem gröberen Problem und weiß nicht was richtig ist, 
einerseits gibt es in der Literatur Beispiele, wie das EPROM 24LC64 oder 
24LC512 beschrieben wird (z.B. Stefan Hoffmann: ..BASCOM)

Hier gibts ein Beispiel für einen Datenlogger (Seite 442), der immer 10 
Bytes schreibt - ich benötige soetwas in meiner Applikation und 
programmiere das in etwa so

<code>
I2cinit
I2cstart
I2cwbyte Eprom_write  '160
Err = 0
Wrd = 0
I2cwbyte AdrHigh
I2cwbyte AdrLow
I2cwbyte Lngbytes(1)
I2cwbyte Lngbytes(2)
I2cwbyte Lngbytes(3)
I2cwbyte Lngbytes(4)
I2cwbyte Lngbytes2(1)
I2cwbyte Lngbytes2(2)
I2cwbyte Lngbytes2(3)
I2cwbyte Lngbytes2(4)
I2cwbyte Byt
I2cwbyte Bytfunktion
I2cstop
</code>

Ich hab das so ähnlich für einen Datenlogger programmiert. Nun lese ich 
auf diversen Seiten, dass der page-Write nicht so einfach wäre,
z.B. hier: http://www.grzesina.de/avr/i2c/i2c.html

Es müssen die Bytes immer in der 128-Byte Seite (von null begonnen) 
liegen
Also wenn immer 10 Bytes geschrieben werden
0-10-20-30-40-50-60-70-80-90-100-110-120
gibts beim 13.Log Eintrag ab Adresse 120 ein Problem,
in diesem Fall werden die 10 Bytes auf 120-127 und 128-129 geschrieben,
das können (angeblich) die EPROMS nicht und vergessen die Bytes 128-129

Wenn das wirklich so ist, dann ist das Buch von Stefan Hoffmann und 
diverse andere Literatur deutlich zu überarbeiten...
Soll ich jetzt die Bytes einzeln schreiben oder muss ich mein Programm 
so (kompliziert) überarbeiten, dass erkannt wird, in welchem 
Paging-Bereich ich schreibe und bei Schreiben ab Adresse 120 muss ich 
dann 2x schreiben (einmal 120-127 und den 2. Schreibvorgang mit 128-129)

Aus dem Datenblatt zum 24LC512 geht das leider auch nicht so recht 
hervor, bzw. steht nicht explizit, dass der SRAM-Buffer mit 128 Bytes 
auch genau einer 128-Byte Seite im EPROM zugeordnet werden muss

[Peter D. (peda)]

Manfred S. schrieb:
> Aus dem Datenblatt zum 24LC512 geht das leider auch nicht so recht
> hervor

Also im Atmel Datenblatt steht das ganz eindeutig drin:

"The data word address lower 7 bits are internally incremented following 
the receipt of each data
word. The higher data word address bits are not incremented, retaining 
the memory page row
location. When the word address, internally generated, reaches the page 
boundary, the following
byte is placed at the beginning of the same page. If more than 128 data 
words are
transmitted to the EEPROM, the data word address will “roll over” and 
previous data will be
overwritten. The address roll over during write is from the last byte of 
the current page to the first
byte of the same page."


Manfred S. schrieb:
> in diesem Fall werden die 10 Bytes auf 120-127 und 128-129 geschrieben,
> das können (angeblich) die EPROMS nicht und vergessen die Bytes 128-129

Nö, der EEPROM schreibt Byte 128, 129 dann auf Adresse 0 und 1.
Das ist mit "The address roll over" gemeint.


Manfred S. schrieb:
> Soll ich jetzt die Bytes einzeln schreiben oder muss ich mein Programm
> so (kompliziert) überarbeiten

Das Testen ist ganz einfach möglich, indem man die nächste Adresse mit 
einer Maske für die unteren Bits undiert und dann 0 rauskommt.
In C sieht das so aus:

    do
      si2c_w( *sram++ );
    while( --len && (++eeaddr & (PAGE_SIZE-1)));  // end or next page

Anbei die komplette Routine in C (ich benutze kein Basic).


Peter

[Manfred S. (Firma: Manfred) (xfred343)]

Danke, Peter für die rasche Rückmeldung
Peter Dannegger schrieb:

> Also im Atmel Datenblatt steht das ganz eindeutig drin:
>
> "The data word address lower 7 bits are internally incremented following
> the receipt of each data
> word. The higher data word address bits are not incremented, retaining
> the memory page row
> location. When the word address, internally generated, reaches the page
> boundary, the following
> byte is placed at the beginning of the same page. If more than 128 data
> words are
> transmitted to the EEPROM, the data word address will “roll over” and
> previous data will be
> overwritten. The address roll over during write is from the last byte of
> the current page to the first
> byte of the same page."

mea culpa - tja, sollt man halt nicht einfach so überfliegen..

> Manfred S. schrieb:
>> in diesem Fall werden die 10 Bytes auf 120-127 und 128-129 geschrieben,
>> das können (angeblich) die EPROMS nicht und vergessen die Bytes 128-129
>
> Nö, der EEPROM schreibt Byte 128, 129 dann auf Adresse 0 und 1.
> Das ist mit "The address roll over" gemeint.
>
>
> Manfred S. schrieb:
>> Soll ich jetzt die Bytes einzeln schreiben oder muss ich mein Programm
>> so (kompliziert) überarbeiten
>
> Das Testen ist ganz einfach möglich, indem man die nächste Adresse mit
> einer Maske für die unteren Bits undiert und dann 0 rauskommt.
> In C sieht das so aus:
>

>     do
>       si2c_w( *sram++ );
>     while( --len && (++eeaddr & (PAGE_SIZE-1)));  // end or next page
>

>
> Anbei die komplette Routine in C (ich benutze kein Basic).
>
>
> Peter

Tja, werd den Algorithmus für Bascom wohl anpassen müssen, dazwischen 
muss ich dann noch das acknowledge polling einbauen oder ich schreib die 
10 Bytes einzeln mit acknowledge polling - werd das morgen einmal 
testen!

Vielleicht sollte Stefan Hoffmann bei der nächsten Auflage das alles 
auch noch berücksichtigen... sein Buch in Ehren, ist wirklich super für 
Anfänger - aber das mit dem Page-Writing sollte kurz erwähnt sein!

[MWS (Gast)]

Manfred S. schrieb:
> Aus dem Datenblatt zum 24LC512 geht das leider auch nicht so recht
> hervor, bzw. steht nicht explizit, dass der SRAM-Buffer mit 128 Bytes
> auch genau einer 128-Byte Seite im EPROM zugeordnet werden muss

Das steht doch sehr genau im DB, unter:

Page write operations are limited to writing bytes within a single 
physical page, regardless of the number of bytes ...

[Manfred S. (Firma: Manfred) (xfred343)]

So, geschafft: hier Variante 1 vollständig in Bascom, die die 
Eigenheiten des Page Write richtig berücksichtigt:

$regfile = "m644def.dat"
$crystal = 8000000
$swstack = 128
$hwstack = 128
$framesize = 128
Config Twi = 100000
$lib "i2c_twi.lbx"
$baud = 19200
Config Serialout = Buffered , Size = 254
'**************************** Hardware-Definitionen
Config Sda = Portc.1                                        'I2C-Pins definieren, bei Atmega 8: PortC.4
Config Scl = Portc.0                                        'PortC.5 bei Atmega 8
Const Eprom_write = 160
Const Eprom_read = 161
Dim I As Byte
Dim Byt As Byte
Const Cbytes2write = 20
Dim Arrbytes(cbytes2write) As Byte
Dim Wrdadr As Word
Dim Wrd As Word
Dim Blnok As Bit
Dim Wrdbytes(2) As Byte At Wrd Overlay
Taster Alias Pina.1
Config Porta.1 = Input
'**************************** ab jetzt betriebsbereit
Enable Interrupts
Cls
Lcd "START"
Const Cpage = 128                                           'abhängig vom 24C, hier: 24LC512
I2cinit
Do
   If Taster = 1 Then                                       'ausnahmsweise gegen VCC
      Print "*************"
      Byt = Rnd(5)
      Print "Random=" ; Byt                                 'Testdaten erzeugen
      For I = 1 To Cbytes2write
         Arrbytes(i) = I * Byt
      Next I
      Wrdadr = 120
      Wrd = Wrdadr
      Byt = Wrd Mod Cpage
      Byt = Cpage - Byt
      Print "Byt=" ; Byt
      I2cstart
      I2cwbyte Eprom_write
      I2cwbyte Wrdbytes(2)
      I2cwbyte Wrdbytes(1)
      For I = 1 To Cbytes2write
         I2cwbyte Arrbytes(i)
         If Byt = I Then
            Wrd = Wrd + Byt
            I2cstop
            Waitms 20
            I2cstart
            I2cwbyte Eprom_write
            I2cwbyte Wrdbytes(2)
            I2cwbyte Wrdbytes(1)
         End If
      Next I
      I2cstop
      Waitms 20
'      Print "Geschrieben"
'      'nach dem letzten Schreiben nicht warten
'      'gewartet wird erst beim nächsten Zugriff, kann viel später sein!
      Wrd = Wrdadr
      I2cstart
      I2cwbyte Eprom_write
      I2cwbyte Wrdbytes(2)
      I2cwbyte Wrdbytes(1)
      I2cstart
      I2cwbyte Eprom_read
      Blnok = 1
      For I = 1 To Cbytes2write
         If I < Cbytes2write Then
            I2crbyte Byt , Ack
         Else
            I2crbyte Byt , Nack
         End If
         If Byt <> Arrbytes(i) Then
            Print Wrd ; "=" ; Byt
            Blnok = 0
         End If
         Incr Wrd
      Next I
      I2cstop
      If Blnok = 1 Then
         Print "Alle Bytes ok"
      Else
         Print "Fehlerhafte Bytes"
      End If
      Waitms 100
   End If
Loop
Return

[Manfred S. (Firma: Manfred) (xfred343)]

Und für die weiter Fortgeschrittenen, hier die Variante mit Acknowledge 
Polling - vielleicht schafft es jemand, das Acknowledge Polling 
ausschließlich mit Bascom zu realisieren. Aber die I2C-Routinen sind 
sehr "eigen".

$regfile = "m644def.dat"
$crystal = 8000000
$swstack = 128
$hwstack = 128
$framesize = 128
Config Twi = 100000
$lib "i2c_twi.lbx"
$baud = 19200
Config Serialout = Buffered , Size = 254
'**************************** Hardware-Definitionen
Config Sda = Portc.1                                        'I2C-Pins definieren, bei Atmega 8: PortC.4
Config Scl = Portc.0                                        'PortC.5 bei Atmega 8
Const Eprom_write = 160
Const Eprom_read = 161
Dim I As Byte
Dim J As Byte
Dim Byt As Byte
Const Cbytes2write = 20
Dim Arrbytes(cbytes2write) As Byte
Dim Wrdadr As Word
Dim Wrd As Word
Dim Blnok As Bit
Dim Wrdbytes(2) As Byte At Wrd Overlay
Taster Alias Pina.1
Config Porta.1 = Input
Declare Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'**************************** ab jetzt betriebsbereit
Enable Interrupts
Cls
Lcd "START"
Const Cpage = 128                      'abhängig vom 24C, hier: 24LC512
'I2cinit geht nicht richtig, erst mit I2CStart, brauchen wir aber nicht
Twsr = &B00000000                                   'Prescaler=0, 1
Twbr = 32                                           'TWI=100000
Do
   If Taster = 1 Then                   'ausnahmsweise gegen VCC
      Print "*************"
      Byt = Rnd(5)
      Print "Random=" ; Byt                           'Testdaten erzeugen
      For I = 1 To Cbytes2write
         Arrbytes(i) = I * Byt
      Next I
      Wrdadr = 120
      Wrd = Wrdadr
      Byt = Wrd Mod Cpage
      Byt = Cpage - Byt
      Print "Byt=" ; Byt
      J = Fxi2cstart(eprom_write)
      If J > 255 Then
         Print "Baustein nicht verfübar"
      Else
         I2cwbyte Wrdbytes(2)
         I2cwbyte Wrdbytes(1)
         For I = 1 To Cbytes2write
            I2cwbyte Arrbytes(i)
            If Byt = I Then
               Wrd = Wrd + Byt
               I2cstop
               J = Fxi2cstart(eprom_write)
               I2cwbyte Wrdbytes(2)
               I2cwbyte Wrdbytes(1)
            End If
         Next I
         I2cstop
'      'nach dem letzten Schreiben nicht warten
'      'gewartet wird erst beim nächsten Zugriff, kann viel später sein!
         Wrd = Wrdadr
         J = Fxi2cstart(eprom_write)
         I2cwbyte Wrdbytes(2)
         I2cwbyte Wrdbytes(1)
         I2cstart
         I2cwbyte Eprom_read
         Blnok = 1
         For I = 1 To Cbytes2write
            If I < Cbytes2write Then
               I2crbyte Byt , Ack
            Else
               I2crbyte Byt , Nack
            End If
            If Byt <> Arrbytes(i) Then
               Print Wrd ; "=" ; Byt
               Blnok = 0
            End If
            Incr Wrd
         Next I
         I2cstop
         If Blnok = 1 Then
            Print "Alle Bytes ok"
         Else
            Print "Fehlerhafte Bytes"
         End If
      End If
      Waitms 100
   End If
Loop
Return

Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'Acknowledge Polling, Wert zu groß=Timeout Fehler
Local Bytzaehler As Byte
Bytzaehler = 0
Do            
    Incr Bytzaehler   'Beschäftigung, wenn kein Zähler, dann Waitus 1
    Twcr = &B10100100                     'entspricht I2CWrite_EpromWrite
    Do
    Loop Until Twcr.twint = 1                       'entspricht I2CStart
    Twdr = Byti2cadr
    Twcr = &B10000100
    Do
    Loop Until Twcr.twint = 1
Loop Until Twsr.5 = 0 Or Bytzaehler = 255                   'TWSR.5 = Bit, ob Ack empfangen wurde, wird 0 bei ACK
Fxi2cstart = Bytzaehler
End Function

[Manfred S. (Firma: Manfred) (xfred343)]

So einfach geht es, den 512kBit Baustein mit FF zu füllen, dauert nur 
wenige Sekunden:

      For Wrd = 0 To 65535 Step Cpage
         Call Si2cepromstart
         I2cwbyte Wrdbytes(2)
         I2cwbyte Wrdbytes(1)
         For Byt = 0 To 127
            I2cwbyte &HFF
         Next Byt
         I2cstop
         Print "L=" ; Wrd
      Next Wrd

[Manfred S. (Firma: Manfred) (xfred343)]

Und der ganze TWI-Bus zu Fuß codiert - wir benötigen überhaupt keine 
Bascom Library oder Bascom I2c-Befehle

So und jeztt die Frage: welche Variante ist die Beste?

$regfile = "m644def.dat"
$crystal = 8000000
$swstack = 128
$hwstack = 128
$framesize = 128
$baud = 19200
Config Serialout = Buffered , Size = 254
'**************************** Hardware-Definitionen
Config Sda = Portc.1                                        'I2C-Pins definieren, bei Atmega 8: PortC.4
Config Scl = Portc.0                                        'PortC.5 bei Atmega 8
Const Eprom_write = 160
Const Eprom_read = 161
Dim I As Byte
Dim J As Byte
Dim Byt As Byte
Const Cbytes2write = 20
Dim Arrbytes(cbytes2write) As Byte
Dim Wrdadr As Word
Dim Wrd As Word
Dim Blnok As Bit
Dim Wrdbytes(2) As Byte At Wrd Overlay
Taster Alias Pina.1
Config Porta.1 = Input
Declare Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'**************************** ab jetzt betriebsbereit
Enable Interrupts
Cls
Lcd "START"
Const Cpage = 128                                           'abhängig vom 24C, hier: 24LC512
'wir brauchen überhaupt keine Bascom TWI-Libraries
Twsr = &B00000000                                           'Prescaler=0, 1
Twbr = 32                                                   'TWI=100000
Do
   If Taster = 1 Then                                       'ausnahmsweise gegen VCC
      Print "*************"
      Byt = Rnd(5)
      Print "Random=" ; Byt                                 'Testdaten erzeugen
      For I = 1 To Cbytes2write
         Arrbytes(i) = I * Byt
      Next I
      Wrdadr = 120
      Wrd = Wrdadr
      Byt = Wrd Mod Cpage
      Byt = Cpage - Byt
      Print "Byt=" ; Byt
      J = Fxi2cstart(eprom_write)
      If J > 255 Then
         Print "Baustein nicht verfübar"
      Else
         Twdr = Wrdbytes(2)
         Twcr = &B10000100
         Do
         Loop Until Twcr.twint = 1
         Twdr = Wrdbytes(1)
         Twcr = &B10000100
         Do
         Loop Until Twcr.twint = 1
         For I = 1 To Cbytes2write
            Twdr = Arrbytes(i)
            Twcr = &B10000100
            Do
            Loop Until Twcr.twint = 1
            If Byt = I Then
               Wrd = Wrd + Byt
               Twcr = &B10010100                            'Stopp
               J = Fxi2cstart(eprom_write)
               Twdr = Wrdbytes(2)
               Twcr = &B10000100
               Do
               Loop Until Twcr.twint = 1
               Twdr = Wrdbytes(1)
               Twcr = &B10000100
               Do
               Loop Until Twcr.twint = 1
            End If
         Next I
         Twcr = &B10010100                                  'Stopp
'      'nach dem letzten Schreiben nicht warten
'      'gewartet wird erst beim nächsten Zugriff, kann viel später sein!
         Wrd = Wrdadr
         J = Fxi2cstart(eprom_write)
         Twdr = Wrdbytes(2)
         Twcr = &B10000100
         Do
         Loop Until Twcr.twint = 1
         Twdr = Wrdbytes(1)
         Twcr = &B10000100
         Do
         Loop Until Twcr.twint = 1
         J = Fxi2cstart(eprom_read)
         Blnok = 1
         For I = 1 To Cbytes2write
            If I < Cbytes2write Then
               Twcr = &B11000100                            'Ack
            Else
               Twcr = &B10000100                            'Noack
            End If
            Do
            Loop Until Twcr.twint = 1                       'I2CRead
            Byt = Twdr
            If Byt <> Arrbytes(i) Then
               Print Wrd ; "=" ; Byt
                Blnok = 0
            End If
            Incr Wrd
         Next I
         Twcr = &B10010100                                  'Stopp
         If Blnok = 1 Then
            Print "Alle Bytes ok"
         Else
            Print "Fehlerhafte Bytes"
         End If
      End If
      Waitms 100
   End If
Loop
Return

Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'Acknowledge Polling, Wert zu groß=Timeout Fehler
Local Bytzaehler As Byte
Bytzaehler = 0
Do                                                          'Beschäftigung, wenn kein Zähler, dann Waitus 1
    Incr Bytzaehler                                         'entspricht I2CWrite_EpromWrite
    Twcr = &B10100100
    Do
    Loop Until Twcr.twint = 1                               'entspricht I2CStart
    Twdr = Byti2cadr
    Twcr = &B10000100
    Do
    Loop Until Twcr.twint = 1
Loop Until Twsr.5 = 0 Or Bytzaehler = 255                   'TWSR.5 = Bit, ob Ack empfangen wurde, wird 0 bei ACK
Fxi2cstart = Bytzaehler
End Function

[MWS (Gast)]

Manfred S. schrieb:
> Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
> 'Acknowledge Polling, Wert zu groß=Timeout Fehler
> Local Bytzaehler As Byte
> Bytzaehler = 0
> Do
>     Incr Bytzaehler   'Beschäftigung, wenn kein Zähler, dann Waitus 1
>     Twcr = &B10100100                     'entspricht I2CWrite_EpromWrite
>     Do
>     Loop Until Twcr.twint = 1                       'entspricht I2CStart
>     Twdr = Byti2cadr
>     Twcr = &B10000100
>     Do
>     Loop Until Twcr.twint = 1
> Loop Until Twsr.5 = 0 Or Bytzaehler = 255                   'TWSR.5 = Bit, ob 
Ack empfangen wurde, wird 0 bei ACK
> Fxi2cstart = Bytzaehler
> End Function

Brrr, grausam. Wenn der restliche Codes auch so aufgeblasen ist und der 
vernünftig geschrieben würde, dann bliebe ja nix mehr über um den µC 
voll zu bekommen. :D

Acknowlede Polling geht so:

Do
  I2cstart
  I2cwbyte EEProm_Write_Address
Loop Until Err = 0

Manfred S. schrieb:
> Aber die I2C-Routinen sind sehr "eigen".
Übersetzung: Habe keine Ahnung.

[Weingut P. (weinbauer)]

naja, die I2C-Routinen in Bascom sind standardmäßig Soft-I2C,
es sei denn der User ruft die Lib auf.
Bei dem Befehl I2CStart macht Bascom in der Soft-I2C-Variante
einen Restart statt einen reinen Start, das kann einem schon den Tag
versauen wenn ein TWI-Slave das nicht mag ... hatt ich nämlich schon
und hab erst mit dem Oszi nach Stunden das Problem gefunden weil
ewig im Code nach Fehlern gesucht.

[MWS (Gast)]

Fhutdhb Ufzjjuz schrieb:
> Bei dem Befehl I2CStart macht Bascom in der Soft-I2C-Variante
> einen Restart statt einen reinen Start

Da hast Du auch noch in der aktuellen Version Recht.

> es sei denn der User ruft die Lib auf.

Was der TE offensichtlich macht, sonst würde er nicht selbst im TWCR 
rumwerken.

[Manfred S. (Firma: Manfred) (xfred343)]

>
> Manfred S. schrieb:
>> Aber die I2C-Routinen sind sehr "eigen".
> Übersetzung: Habe keine Ahnung.

[Manfred S. (Firma: Manfred) (xfred343)]

Wenn schon Bacom, Acknowdlege Polling geht sicherer so:

.
j=Fxi2cstart(irgendeine_I2C_Adresse) 
if j<255 then
   'ok
else
   'Baustein nicht da oder defekt
endif
.

Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'Universalroutine als Alternative zu normalem I2CStart und Adresse
Local Bytzaehler As Byte
Bytzaehler = 0
Do                                                          
    Incr Bytzaehler                                            
    i2cstart
    I2cwbyte byti2cadr
Loop Until Twsr.5 = 0 Or Bytzaehler = 255 'TWSR.5=Ack Bit 
Fxi2cstart = Bytzaehler
End Function

[MWS (Gast)]

Manfred S. schrieb:
> Acknowdlege Polling geht sicherer so:

Was ist sicherer ?
Wenn die I2C-HW zuverlässig funktioniert, dann geht die einfachste 
Version, wenn Err = 0 ist, dann wurde der Befehl erfolgreich ausgeführt.
Was soll da unsicher sein ?

Wenn die HW dagegen unzuverlässig ist, dann kann man nach Belieben immer 
noch Sicherheiten, Zähler, Timeouts, etc. dazu bauen.

War aber nicht die Frage, die war: Wie geht's mit Bascom-Mitteln ?

[Manfred S. (Firma: Manfred) (xfred343)]

MWS schrieb:
> Manfred S. schrieb:
>> Acknowdlege Polling geht sicherer so:
>
> Was ist sicherer ?
> Wenn die I2C-HW zuverlässig funktioniert, dann geht die einfachste
> Version, wenn Err = 0 ist, dann wurde der Befehl erfolgreich ausgeführt.
> Was soll da unsicher sein ?
>
> Wenn die HW dagegen unzuverlässig ist, dann kann man nach Belieben immer
> noch Sicherheiten, Zähler, Timeouts, etc. dazu bauen.
>
> War aber nicht die Frage, die war: Wie geht's mit Bascom-Mitteln ?

Naja, es sollt halt dann nicht gleich eine Endlosschleife sein - ein 
Timeout bei Hardwarefehlern muss einfach gegeben sein.

[Manfred S. (Firma: Manfred) (xfred343)]

> Manfred S. schrieb:
>> Aber die I2C-Routinen sind sehr "eigen".
> Übersetzung: Habe keine Ahnung.

Tja, hätt ich gern, da ist aber Bascom zu wenig ausführlich dokumentiert

Warum wird beim IC2INIT nicht gleich das TWI mit TWSR, TWBR richtig 
initialisiert, sondern erst beim I2CSTART - Und wo steht das in der 
Doku?

Wann wird ERR=1 gesetzt, wird dann TWSR ausgelesen oder wie genau wird 
ERR gesetzt? - manchmal ist ERR=1 nicht nachvollziehbar!

Fragen über Fragen..

Also da fühl ich mich dann auf der Registerebene einfach sicherer

[MWS (Gast)]

Manfred S. schrieb:
> Naja, es sollt halt dann nicht gleich eine Endlosschleife sein - ein
> Timeout bei Hardwarefehlern muss einfach gegeben sein.

Kommt drauf an, wenn die komplette Schaltung z.B. auf 
Konfigurationsdaten des I2C-EEProms angewiesen ist und ohne nicht 
funktioniert, dann machst Du genau was ?

Und wenn's sicherheitskritisch ist, nimmt man den WD.

Die Bascom HW-I2C Routine selbst blockiert ja nicht, die hat ein eigenes 
Timeout drin. Wenn man also aufgrund Unwägbarkeiten einen sicheren Exit 
braucht, dann zählt man die Aufrufe in denen es einen Error gab und 
bricht nach 'ner bestimmten Anzahl ab.

Aber sowas bringt doch jeder selbst zustande, das muss ich doch nicht 
extra zu meinem Beispiel dazuschreiben.

[MWS (Gast)]

Manfred S. schrieb:
> Warum wird beim IC2INIT nicht gleich das TWI mit TWSR, TWBR richtig
> initialisiert, sondern erst beim I2CSTART - Und wo steht das in der
> Doku?

Hättest Du Dir nur einmal das zugehörige Beispiel (TWI-master.bas) 
angesehen, dann wüsstest Du daß die Prescaler-Bits im TWSR und das TWBR 
von "Config TWI" gesetzt werden.
Zitat:
  Config Twi = 100000                     ' wanted clock frequency
  'will set TWBR and TWSR

So steht's auch in der Hilfe, kann Bascom doch nix dafür, daß Du weder 
die Hilfe liest, noch Dir die Beispiele anschaust.

Beim I2CStart wird im Übrigen für TWBR/TWSR auch nix initialisiert.
Wenn Du Config TWI vergisst, dann bleiben die Prescalerbits als auch das 
Bitrateregister eben leer und die I2C arbeitet mit Maxspeed.

Ob das die angeschlossenen Busteilnehmer mitmachen, ist dann 'ne andere 
Sache.

[Manfred S. (Firma: Manfred) (xfred343)]

MWS schrieb:
> Manfred S. schrieb:
>> Warum wird beim IC2INIT nicht gleich das TWI mit TWSR, TWBR richtig
>> initialisiert, sondern erst beim I2CSTART - Und wo steht das in der
>> Doku?
>
> Hättest Du Dir nur einmal das zugehörige Beispiel (TWI-master.bas)
> angesehen, dann wüsstest Du daß die Prescaler-Bits im TWSR und das TWBR
> von "Config TWI" gesetzt werden.
> Zitat:
>   Config Twi = 100000                     ' wanted clock frequency
>   'will set TWBR and TWSR
>
OK, überlesen -danke , auch gerade gelesen I2CINIT ist dann gar nicht 
notwendig, da beim Reset des Prozessors die Hardware TWI eh richtig 
gesetzt ist.

Aber eine Frage bleibt noch:
wie und wann genau wird ERR gesetzt beim Hardware TWI?

[MWS (Gast)]

Manfred S. schrieb:
> auch gerade gelesen I2CINIT ist dann gar nicht
> notwendig, da beim Reset des Prozessors die Hardware TWI eh richtig
> gesetzt ist.

I2CInit setzt das DDRx richtig und aktiviert die internen Pullups, falls 
man keine externen verwenden muss/möchte.

Manfred S. schrieb:
> wie und wann genau wird ERR gesetzt beim Hardware TWI?

Wenn vor dem Timeout kein TWINT kam, bricht I2CStart ab und es wird Bit 
2 von Err gesetzt.

[Manfred S. (Firma: Manfred) (xfred343)]

> Wenn vor dem Timeout kein TWINT kam, bricht I2CStart ab und es wird Bit
> 2 von Err gesetzt.

Ja, für I2CStart und auch die anderen I2C-Routinen, die auf TWINT warten 
stimmt da.

I2CWByte und I2CRByte können aber viel mehr. Hab mir gerade den 
Bascom-Assembler angesehen, entgegen anders lautenden Infoquellen (z.B. 
http://www.rn-wissen.de/index.php/Bascom_I2C_Master) wird bei I2CWrite 
sehr wohl das Statusregister TWSR eingehend geprüft.

Bei I2CWByte konkret:
1) TWINT Timeout (wie bei allen)
2) TWSR, Prescaler Bits maskieren
3) Timeout, solange TWSR $F8 bleibt
4) wenn TWSR nicht einen der Werte $18, $28, $40 oder $50 hat -> Fehler

Die Antwort gibt allerdings nur undifferenziert Bit2 des ERR-Registers 
zurück - wer will kann ja dann noch spezifischer testen: beim Starten 
der Kommunikation mit dem EEPROM als Slave sind nur die Stati $18 und 
$20 relevant, $18, Bit 5=0 = ACK empfangen und $20, Bit5=1 =NACK, daher 
habe ich spezifisch auf TWSR Bit5 getestet (übrigens Super Tabelle in 
den Atmega-Datenblättern, sh. "Formats and States in the Master 
Transmitter Mode"). Universeller ist natürlich die Prüfung auf ERR=1, 
weil sie alle Fehler umfasst.

[Manfred S. (Firma: Manfred) (xfred343)]

Hier nun der "finale" Bascom-Code, um EEproms mit PageWrite (gilt schon 
ab 2 Bytes !!) zu beschreiben. Bitte beim Testen aufpassen, dass das 
EEPROM nicht in einer Endlosschleife getestet wird..

$regfile = "m644def.dat"
$crystal = 8000000
$swstack = 128
$hwstack = 128
$framesize = 128
$baud = 19200
$lib "i2c_twi.lbx"
Config Serialout = Buffered , Size = 254
'**************************** Hardware-Definitionen
Config Twi = 100000
Config Sda = Portc.1                                        'I2C-Pins definieren, bei Atmega 8: PortC.4
Config Scl = Portc.0                                        'PortC.5 bei Atmega 8
Const Eprom_write = 160
Const Eprom_read = 161
Dim I As Byte
Dim J As Byte
Dim Byt As Byte                                             '
Dim Bytwrite As Byte
Dim Wrdadr As Word
Dim Wrdadrbytes(2) As Byte At Wrdadr Overlay
Declare Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
Taster Alias Pina.1
Config Porta.1 = Input
'**************************** ab jetzt betriebsbereit
Enable Interrupts
Cls
Const Cpage = 128                                           'Paging-Größe lt. Datenblatt EEPROM
Const Cbytes2write = 20                                     'max. 20 Bytes, muss <=cPage sein
Wrdadr = 110                                                'Testadresse=110, 130, 150 usw.
'I2cinit                                                     'verwende eigene Pullups-Widerstände am Busende
Do
   'Achtung nicht als Endlosschleife, sonst neues EEPROM kaufen
   If Taster = 1 Then                                       'Achtung: normalerweise =0, meiner ist "anders"
      Bytwrite = 1 + Rnd(6)                                 'Würfeln
      Print "*************"
      Byt = Wrdadr Mod Cpage
      Byt = Cpage - Byt
      If Byt >= Cbytes2write Then
         Byt = 0
      End If
      J = Fxi2cstart(eprom_write)                           'Teste auf Kommunikation
      If J > 0 Then
         I2cwbyte Wrdadrbytes(2)
         I2cwbyte Wrdadrbytes(1)
         For I = 1 To Cbytes2write
            I2cwbyte Bytwrite                               'mit select case differenzieren, z.B. 1-4=Adresse,5-6=Logwerte
            If Byt = I Then                                 'oder Bytarray schreiben
               Wrdadr = Wrdadr + Byt
               I2cstop
               J = Fxi2cstart(eprom_write)                  'hier keine Fehlerprüfung
               I2cwbyte Wrdadrbytes(2)
               I2cwbyte Wrdadrbytes(1)
            End If
         Next I
         I2cstop
         Wrdadr = Wrdadr - Byt                              'wrd-Adresse richtig erhöhen
         Wrdadr = Wrdadr + Cbytes2write
      Else
         Print "EPROM antwortet nicht"
      End If
'      Print "Geschrieben"
'      'nach dem letzten Schreiben nicht warten
'      'gewartet wird erst beim nächsten Zugriff, kann viel später sein!
      Wrdadr = Wrdadr - Cbytes2write                        'Adresse zurücksetzen
      J = Fxi2cstart(eprom_write)
      If J > 0 Then
         I2cwbyte Wrdadrbytes(2)
         I2cwbyte Wrdadrbytes(1)
         I2cstart
         I2cwbyte Eprom_read
         For I = 1 To Cbytes2write
            If I < Cbytes2write Then
               I2crbyte Byt , Ack                           'Ack
            Else
               I2crbyte Byt , Nack                          'Nack
            End If
            Print Wrdadr ; "=" ; Byt
            Incr Wrdadr
         Next I
         I2cstop
      Else
         Print "EPROM antwortet nicht"
      End If
      Waitms 500                                            'Taster könnte ja prellen..
   End If
Loop
Return


Function Fxi2cstart(byval Byti2cadr As Byte) As Byte
'Bytzahler muss kleiner 0 sein, sonst Timeout
'Universalroutine als Alternative zu normalem I2CStart
'Gibts Baustein nicht: Timeout
'Acknowledge Polling bei I2CEEPROM - wartet bis Baustein antwortet
Local Bytzaehler As Byte
Bytzaehler = 0
Do                                                          'Beschäftigung, wenn kein Zähler, dann Waitus 1
    Incr Bytzaehler                                         'entspricht I2CWrite_EpromWrite
    I2cstart
    I2cwbyte Byti2cadr
Loop Until Err = 0 Or Bytzaehler = 0                        'ERR=1 universeller als TWSR.5, ACK empfangen
Fxi2cstart = Bytzaehler
End Function