I2C mal wieder

[Rene H. (ballibou77)]

Hallo,

ich müsste 5 AVRs miteinander verbinden.

Als Master dient ein ATMega128A mit 16Mhz externem Quarz

Als Slaves gibt es

1 ATMega8 mit 1 Mhz interner Quarz
2 ATMega32 mit 1Mhz interner Quarz

Hinzu kommt ein eDIPTFT70-ATP was 400khz I2C ebenfalls beherscht. In 
diesem ist auch ein ATMega128 verbaut.

Eine kommunikation zwischen dem Master und Display habe ich schon. Wenn 
das Display Daten hat legt es einen PIN auf LOW und man liest die Daten 
aus zerlegt den String und hat seine Daten :)

Wie aber funktioniert nun die Kommunikation? Das Display hat $DE (lesen) 
$Df (schreiben) als feste adressen.

Die adressierung ist nicht das problem, vielmehr wie man die 
kommunikation aufbaut.

Sagen wir Daten von Slave 1 müssen an Slave 2. Bisher habe ich immer nur 
daten vom Master an den Slave geschrieben, nie gelesen.

Was ich nicht verstehe, wie lese ich die Daten vom Slave?

Der Slave muss diese ja bereitstellen etc. und da verstehe ich es nicht 
mehr.

Muss der master erst an den slave schreiben (ich brauche die daten xyz) 
dann arbeitet der Slave diesen befehl ab, tut die Daten "irgendwo" hin 
und dann redet der Master nochmal mit dem Slave mit "gib jetzt her die 
daten"?

Wie sieht das dann in C aus?

Ich danke euch schonmal.

[Sascha (Gast)]

Hallo,
also ersteinmal die Grundlagen vom I2C-BUS Philips bzw. NXP genau lesen, 
wenns geht auch noch verstehen.

Focus: Start-Bit ... Stop-Bit Re-Start und für Multimaster 
BUS-Arbitration.


Immer der, der von anderen lesen oder schreiben will wird sozusagen der 
Master.
Es ist ein multimaster system.
Alle Devices die nicht gerade Master sein wollen sind Slaves und die 
Adresse, also Device-Adresse wird auf der Hardware ins Register 
geschrieben.
Bei gleicher Adresse kommt dan ein Interrupt und das entsprechende Slave 
Device muss ganz schnell die Kommunikation mit einem ACK bestätigen.
Danach können die Daten vom Master gelesen werden.
Nun kann der Master über ein Stopbit die Kommunikation oder über ein 
NACK oder auch der Slave über ein NACK die Kommunikation beenden.
Beim Master unterscheidet sich das ob er gerade lesen oder schreiben 
tut.
Den wenn der Master ließt muss er ja das ACK oder NACK ausgeben.

So weit mal nur das ganz Grobe.
Weiteres Thema SCL erzwungene Clock Phase Verlängerung durch Slave.

Gruß Sascha

[Rene H. (ballibou77)]

Hi,

danke schonmal.

Also eine I2C Kommunikation mit dem Display habe ich schon hinbekommen.

Auch habe ich es hinbekommen auf einem ATMega8 eine PWM mittels I2C zu 
steuern. Also der Master hat dem Slave gesagt PWM auf 100 und dann ging 
daa.

Jedoch war es so das ich mit dem Master an den Slave eine "zahl" 
geschrieben habe und das war dann eben der PWM Wert. Das klappte 
perfekt.

Nun ist aber der Fall das der Slave 3 PWMs hat. Dort muss ich dem Slave 
ja auch mitteilen welche PWM auf den Wert eingestellt wird der nun vom 
Master kommt.

Nun könnte ich folgendes machen.

1001 oder 1100 senden und diese Zahl auf dem Slave zerlegen 1001 in 1 
und 001 das wäre dann 1 für die PWM Nummer 001 der PWM Wert gleiches mit 
2090 oder 1050 oder 3100 usw.

Ok.

Jetzt kommt aber noch dazu das der Slave einen DS18S20 und einen 
Fotowiderstand auswertet. Die Daten stehen dann im Slave in einer 
Variable.

Wie nun komme ich vom Master da dran? Also wie sage ich dem Slave mit 
welche Daten der Master nun haben will?

Danke euch.

[Carl D. (jcw2)]

Schau dir einfach mal das *Protokoll einer RTC oder eines kleinen 
EEProms an. Da werden Sklaven ausgelesen.

*im Datenblatt

[Oliver S. (oliverso)]

TWI mit einem AVR ist für alles außer einfachem 
Master-Slave-Verbindungen zu anderen Bausteinen problematisch.

Nimm lieber SPI.

Oliver

[Karl H. (kbuchegg)]

Rene H. schrieb:

> 1001 oder 1100 senden und diese Zahl auf dem Slave zerlegen 1001 in 1
> und 001 das wäre dann 1 für die PWM Nummer 001 der PWM Wert gleiches mit
> 2090 oder 1050 oder 3100 usw.

Wenn du mir jetzt noch erklärst, wie du mit 1 Byte eine 16 Bit Zahl 
übertragen willst, dann sind wir fast dort.

Ja. In dem Fall schreibst du eben 2 Bytes nacheinander zum Slave. Das 
erste Byte kann man als Kommando auffassen, das zweite als der zu 
schreibende Wert. Genausogut kann man eine Kommunikation nach dem Muster 
aufbauen: Erst mal schreibt der Master wovon oder wohin er 
lesen/schreiben will und dann kommt ein Reead oder Write hinten nach, 
mit dem dann der Wert übermittelt wird.
Genauso wie du es im täglichen Leben auch machst.

Wenn ein Slave nur einen Wert verwalten muss (1 Byte) dann ist alles 
klar. Denn dann gibt es keine Unterscheidungen. Mit dem Lesen ist alles 
klar was gelesen oder geschrieben werden soll. Gibt es mehrere Werte, 
dann muss halt mal irgendwer mitteilen welcher der 5 es sein soll.

[Rene H. (ballibou77)]

Also für das Display habe ich folgenden Code:

unsigned char SendDisplayData(char *buf)
{
    unsigned int len = strlen(buf);
    unsigned char i, bcc, ret;
  int daten = 0;
    ret = i2c_start(DISPLAY_I2C_ADDR+I2C_WRITE);       // set device address and write mode
    if ( ret ) {
        /* failed to issue start condition, possibly no device found */
        i2c_stop();
        /* do some error reporting.. led or whatever */
    } else {
        /* issuing start condition ok, device accessible */
        i2c_write(0x11);                            // send DC1
        bcc = 0x11;
        i2c_write(len);
        bcc = bcc + len;
        for(i=0; i < len; i++) // Send buf
        {
            i2c_write(buf[i]);
            bcc = bcc + buf[i];
        }
        i2c_write(bcc); // Send checksum                      
        i2c_start(DISPLAY_I2C_ADDR+I2C_READ);       // set device address and read mode
        ret = i2c_readNak();                        // read one byte
        if (ret == DISPLAY_I2C_ACK)
        {
            daten = 1;
        } else {
            daten = 0;
        }
        i2c_stop();
    }
  return daten;
}



    unsigned char ReadDisplayData(void)
    {
        unsigned char bcc, ret, rettemp;
        unsigned char len = 2;
        ret = i2c_start(DISPLAY_I2C_ADDR+I2C_WRITE);      // set device address and write mode
        if ( ret ) {
            /* failed to issue start condition, possibly no device found */
            i2c_stop();
            /* do some error reporting.. led or whatever */
        } else {
            /* issuing start condition ok, device accessible */
            i2c_write(DISPLAY_I2C_DC2); // send DC2
            i2c_write(0x01);            // send 1
            i2c_write(0x53);            // send S
            bcc = DISPLAY_I2C_DC2 + 0x01 + 0x53;                // Set checksum
            i2c_write(bcc);            // Send checksum 
            bcc = 0;
            i2c_start(DISPLAY_I2C_ADDR+I2C_READ);      // set device address and read mode
            ret = i2c_readAck();                        // read ack byte
            if (ret == DISPLAY_I2C_ACK)
            {
                rettemp = i2c_readAck();
                bcc = bcc + rettemp;
                ret = i2c_readAck();            // read len
                bcc = bcc+ret;
                unsigned char *buf = malloc(ret * sizeof(char));
                len += ret;
                for (int i = 0; i < ret; i++)
                {
                    buf[i] = i2c_readAck(); // read data bytes
                    bcc = bcc + buf[i];
                }
                ret = i2c_readNak();    // read len
                if (ret != len) {
                    // Checksum not matching
                }
                return buf;
            } else {
                // No Ack
            }
            i2c_stop();
           
        }
        return 0;
    }

void DisplayReset(void)
  {
    PORTD &= ~(1<<PD3);
    PORTD &= ~(1<<PD3);
    PORTD &= ~(1<<PD3);
    PORTD |= (1<<PD3);
    
  }

unsigned char ReadDisplayBufferStatus(void)
  {
    int DisplayBufferStatus;
    if ( !(PIND & (1<<PIND2)) )
      {
        DisplayBufferStatus = 1;
      }
      else
      {
        DisplayBufferStatus = 0;
      }
      
    return DisplayBufferStatus;
  }

Und damit kann ich ganze Strings senden.

So in der Art aber auch zum lesen zwischen zwei ATMegas wäre schön.

[Rene H. (ballibou77)]

So,

ich habe mich dann mal am I2C versucht. Und was passiert? Nichts 
passiert.

Es soll eigentlich nur was von Master zum Slave geschrieben werden, also 
ein recht kurzer Code. Jedoch passiert nichts. Laut Oszi bleibt der I2C 
Bus auch dauerhaft auf High. Den Bus ziehe ich mit 4,7k PullUps und 5V 
auf High.

Ich habe die Codes mal angehangen.

ATMega8 und ATMega32 sind Slaves

ATMega128 ist der Master

Ich hoffe mir kann einer weiter helfen.

[Rene H. (ballibou77)]

Achso, was vielleicht noch wichtig ist,

der ATMega8 sowie der ATMega32 laufen mit dem internen Oszilator mit 
1Mhz.

Der ATMega128 läuft mit einem 16Mhz externem Quarz.

[Rene H. (ballibou77)]

Jetzt hab ich viel gelesen und keinen Schritt weiter -.- Also manchmal 
steht was von Pullups zu klein. Größere verwenden. Dann wieder, ne, 4,7k 
sind gut.

Dann wieder was von Kapazitiver BUS und je nach Anzahl der devices muss 
der Pullup größer / kleiner. -.-

Ich habe dann mal die PINS mit einem µC selber auf LOW gezogen und ich 
habe immernoch knapp 2V auf dem Bus. Ist der Pullup hier wirklich zu 
klein und ich muss diesen erhöhen?

[Dennis R. (dennis_r93)]

Dein ic muss die Spannung gegen den pullup auf einen niedrigen 
spannungslevel ziehen.
Wenn bei einem pullup auf 5v mit 4.7 kohm dann noch 2V übrig bleiben 
wird vermutlich ein anderer busteilnehmer den bus auf high ziehen.
Prüfe ob alle anderen Teilnehmer den Port als tristate konfiguriert 
haben.