2 Atmega8 über I²C / TWI verbinden

[Markus Schmitz (Gast)]

Schönen guten Abend miteinander,

bin total der Anfänger und freue mich schon auf den Shit-Storm, der auf 
diesen Beitrag folgt. Habe aber folgendes Problem:

ich möchte 2 myAVR Boards mit je einem Atmega8A  über I²C (oder auch TWI 
genannt ?) miteinander verbinden.
Dabei soll das eine Board als Master arbeiten und das andere als Slave.
Habe jetzt schon mehrer Beispielprogramme probiert, doch keins 
funktioniert so auf Anhieb.

Hat irgendwer ein lauffähiges C-Programm, welches die Kommunikation 
zwischen Master und Slave aufbaut?


Vielen Dank und Gruß Markus

[Pepe (Gast)]

Hi.
Programm hab ich keins, aber einige Tipps.

Erstmal vorab: Wenn Du totaler Anfänger bist, warum benutzt dann I2C? 
Ich würde mich dann lieber mit SPI beschäftigen. Braucht eine Verbindung 
mehr.
Kann aber wesentlich leichter debugged werden (elektrisch und in 
Firmware).
Und ist auch nur eine serielle Übertragung, aber ohne Adressierung, 
Half-Duplex, Open-Drain, etc...

I2C hat einige Fallstricke:
- Hast Du die PullUps auf beiden Leistungen? Sonst funktioniert zwar 
irgendwas aber sicherlich kein stabile Kommunikation.
- Fange mit möglichst kleiner Übertragungsfrequenz an.
- Hat der Slave die richtige Adresse ? Schickt der Master die richtige 
Adresse ?
- Bekommt Dein Master ein Ack am Ende des Pakets? Wenn nein, stimmt 
wahrscheinlich auf Slave-Seite was nicht.

So. Mehr gibt meine Glaskugel gerade nicht her. Mit so wenig Infos.

Vielleicht hilft es ja trotzdem. Kannst ja mal Deinen besten Source 
posten. Dann man dir sicher konkreter helfen.

Pepe.

[Matze (Gast)]

Finde I2C hierfür auch eher aufwendig.

Hatte sowas schonmal, würde den UART nutzen.
Controller A (Master) schickte Controller B (PWM-IO-Erweiterung) PWM 
Tastverhältnisse.

[Markus Schmitz (Gast)]

Pepe schrieb:
> Hi.
> Programm hab ich keins, aber einige Tipps.
>
> Erstmal vorab: Wenn Du totaler Anfänger bist, warum benutzt dann I2C?
> Ich würde mich dann lieber mit SPI beschäftigen. Braucht eine Verbindung
> mehr.
> Kann aber wesentlich leichter debugged werden (elektrisch und in
> Firmware).
> Und ist auch nur eine serielle Übertragung, aber ohne Adressierung,
> Half-Duplex, Open-Drain, etc...
>
> I2C hat einige Fallstricke:
> - Hast Du die PullUps auf beiden Leistungen? Sonst funktioniert zwar
> irgendwas aber sicherlich kein stabile Kommunikation.
> - Fange mit möglichst kleiner Übertragungsfrequenz an.
> - Hat der Slave die richtige Adresse ? Schickt der Master die richtige
> Adresse ?
> - Bekommt Dein Master ein Ack am Ende des Pakets? Wenn nein, stimmt
> wahrscheinlich auf Slave-Seite was nicht.
>
> So. Mehr gibt meine Glaskugel gerade nicht her. Mit so wenig Infos.
>
> Vielleicht hilft es ja trotzdem. Kannst ja mal Deinen besten Source
> posten. Dann man dir sicher konkreter helfen.
>
> Pepe.


Ja vielen Dank für die schnelle Rückmeldung. Würde mir gerne eine in 
euren Augen einfachere Kommunikationsschnittstelle aussuchen, aber i²C 
wurde mir von meiner LEERKraft so vorgegeben.

- Übertragungsfrequenz wurde auf 100kHz gesetzt bei einer F_CPU von 
3686,400 kHz. (3686400 Hz)

- Pull-Ups habe ich am Slave auf SDA und SCL gezogen.

- Slave hat die Adresse 0x50

Habe euch mal die Quelltexte vom Master und Slave angehangen.

Vielen Dank schonmal für eure Hilfe

Gruß Markus

// Master 
#include <avr/io.h>
#include "i2cmaster.h"
#define SLAVE_ADRESSE 0x50

uint8_t Taster; 

int main(void)
{
  DDRB  = 0b00000000;    //Alles Eingänge
  PORTB = 0b00000001;    //Pull-Up an PINB.1 setzen
  
  while (1)
  {
    i2c_init();         // init I2C interface

    if (bit_is_clear (PINB, 0))
    {
      Taster = 0b00000001;
    }
    else
    {
      Taster = 0b00000000; 
    }
    
    if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum schreiben?
    {
      i2c_write(0x00);  // Buffer Startadresse setzen
      i2c_write(Taster);  // Ein Bytes schreiben...
      i2c_stop();      // Zugriff beenden
    }
  }
}

##############################################################
SLAVE

#include <util/twi.h>       //enthält z.B. die Bezeichnungen für die Statuscodes in TWSR
#include <stdint.h>       //definiert den Datentyp uint8_t
#include "twislave.h"

#define SLAVE_ADRESSE 0x50 //Die Slave-Adresse

int main (void)
{
  DDRB  = 0b00000001;    //PB0 = Ausgang
  PORTB = 0b00000000;    // LED aus !
  PORTC = 0b00110000;    // Pull-Up für TWI an PORTC4 und 5
  
  //TWI als Slave mit Adresse slaveadr starten
  
  
  while(1)
  {
    init_twi_slave(SLAVE_ADRESSE);
    //i2cdatamit Werten füllen
    for(uint8_t i=0;i<i2c_buffer_size;i++)
    {
      i2cdata[i]=10+i;
    }
  
    if (i2cdata[0] = 0b00000001)
    {
      PORTB |= 0b00000001;  //setze die LED    
    }
    else
    {
      PORTB |= 0b00000000;    // rücksetze die LED  
    }        
  } 
} //end.main

[Pepe (Gast)]

Als Basis doch ganz gut.

Beim Slave fehlt aber noch das komplette Empfangen der Daten.
Also kann das ja nicht gehen.

Um es einfach aufzubauen, musst Du prüfen, ob beim Slave ein Paket 
angekommen ist und dann einlesen. Und der Slave muss ein ACK 
zurückgeben, sonst bleibt die Kommunikation hängen.
Und ich gehe mal davon aus, dass in i2c_write im Master auch das ACK 
überprüft wird.

[Thomas W. (Gast)]

Markus Schmitz schrieb:
> - Slave hat die Adresse 0x50

> if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum
> schreiben?

Guck dir mal den Aufbau des Adressierungsbytes an. Slave Adresse und 
Adressbyte sind zwei verschiedene Dinge. Die Adresse hat 7 Bit, die 
Datenrichtungssteuerung (R/W) ein weiteres.

[Mitlesa (Gast)]

- Zeige deine vollständigen Programme. Wir müssen sonst hellsehen
ob deine Initialisierungen richtig sind.

- Nimm die Init-Aufrufe aus der Schleife heraus, jedesmal
neu zu initialisieren ist Käse, das braucht nur einmal.

[Wolfgang (Gast)]

Pepe schrieb:
> Vielleicht hilft es ja trotzdem. Kannst ja mal Deinen besten Source
> posten.

Und vielleicht auch mal ein Bild der Signalverläufe von SDA und SCL ...
(DSO oder LA)

Markus Schmitz schrieb:
> Würde mir gerne eine in
> euren Augen einfachere Kommunikationsschnittstelle aussuchen, aber i²C
> wurde mir von meiner LEERKraft so vorgegeben.

Ist dir schon mal die Idee gekommen, dass diese Vorgabe vielleicht 
didaktische Gründe haben könnte. Beim Lernen kommt es oft nicht auf 
schnell und billig drauf an.

Du sollst dich wahrscheinlich mit dem Kommunikationsprotokoll, sowohl 
aus Sicht des Masters als auch der des Slaves auseinandersetzen und wie 
man sieht, gibt es da noch deutliche Verständnislücken, sowohl beim 
I²C-Protokoll als auch bei Fehleranalysemethoden.

[Narkus Schlitz (Gast)]

Markus Schmitz schrieb:
> 3686,400 kHz. (3686400 Hz)

Ich rechne Dir das mal in Megaherz um:

3,68640 * 10^0 MHz

Mitlesa schrieb:
> neu zu initialisieren ist Käse,

Da ich gerne Käse esse, kommt mir das mit dem vielen Käse ganz gelegen.

Wolfgang schrieb:
> Beim Lernen kommt es oft nicht auf
> schnell und billig drauf an.

auf billig schon, denn die Schulen haben in der Regel wenig Geld.

Wolfgang schrieb:
> Du sollst dich wahrscheinlich mit dem Kommunikationsprotokoll, sowohl
> aus Sicht des Masters als auch der des Slaves auseinandersetzen

Ich weis nicht, was eine Lehrkraft damit bezwecken möchte. Aber ich 
bleibe beim Käse, denn Käse esse ich gerne.

[Mitlesa (Gast)]

Narkus Schlitz schrieb:
> .............

Wenn das so weiter geht, dann wird das nichts, lieber
Knarkus Schwitz

[Markus S. (markusschmitz)]

Mitlesa schrieb:
> - Zeige deine vollständigen Programme. Wir müssen sonst hellsehen
> ob deine Initialisierungen richtig sind.
>
> - Nimm die Init-Aufrufe aus der Schleife heraus, jedesmal
> neu zu initialisieren ist Käse, das braucht nur einmal.


Hallo zusammen,

schonmal vielen Dank für eure Hilfe.

Hier mal der komplette Code vom Master:

 // Master 
#include <avr/io.h>
#include "i2cmaster.h"
#define SLAVE_ADRESSE 0x50  // Die Slave Adresse

uint8_t Taster; 

int main(void)
{
  DDRB  = 0b00000000;    //Alles Eingänge
  PORTB = 0b00000001;    //Pull-Up an PINB.1 für Taster setzen
  DDRC  = 0b11111111;  
  PORTC = 0b00110000; // Pull-Up von SDA und SCL am MAster
   
  i2c_init();         // init I2C interface
  
  while (1)
  {
    if (bit_is_clear (PINB, 0)) // wenn Taster 1 gedrückt wird
    {
      Taster = 0b00000001;    // schreibe Bit-Folge in Var_Taser uint8_t
    }
          
        else                        // wenn Taster 1 NICHT gedrückt
        {
          Taster = 0b00000000;  //schreibe Nullen in Var_Taster
        }
    
    
    if (!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) //Slave bereit zum schreiben?
    {
      i2c_write(0x00);  // Buffer Startadresse setzen
      i2c_write(Taster);  // Ein Bytes schreiben...
      i2c_stop();      // Zugriff beenden
    }
  }
}

Zur i2c_init()

#include <inttypes.h>
#include <compat/twi.h>

#include "i2cmaster.h"


/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 3686400
#endif

/* I2C clock in Hz */
#define SCL_CLOCK  100000 //76800 // Durch diese Busfrequenz ergibt sich ein Wert von 16 an TWBR ! und nicht 10,432 !


/*************************************************************************
 Initialization of the I2C bus interface. Need to be called only once
*************************************************************************/
void i2c_init(void)
{
  /* initialize TWI clock: 100 kHz clock, TWPS = 0 => prescaler = 1 */
  
  TWSR = 0 ;  // Prescaler auf 1 gestellt ...00 und das Statusregister für Fehler auf 00000... gesetzt !
  TWBR = ((F_CPU/SCL_CLOCK)-16)/2;  // wie oben erwähnt wird der Wert 16 in TWBR  geschrieben
                  // um eine Busfrequenz von 76800 Hz zu erhalten

}/* i2c_init */

Zur i2c_start und I2c_write

/*************************************************************************  
  Issues a start condition and sends address and transfer direction.
  return 0 = device accessible, 1= failed to access device
*************************************************************************/
unsigned char i2c_start(unsigned char address)
{
    uint8_t   twst;

  // send START condition
  TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);

  // wait until transmission completed
  while(!(TWCR & (1<<TWINT)));

  // check value of TWI Status Register. Mask prescaler bits.
  twst = TW_STATUS & 0xF8;
  if ( (twst != TW_START) && (twst != TW_REP_START)) return 1;

  // send device address
  TWDR = address; // 80 dez 
  TWCR = (1<<TWINT) | (1<<TWEN);

  // wail until transmission completed and ACK/NACK has been received
  while(!(TWCR & (1<<TWINT)));

  // check value of TWI Status Register. Mask prescaler bits.
  twst = TW_STATUS & 0xF8;
  if ( (twst != TW_MT_SLA_ACK) && (twst != TW_MR_SLA_ACK) ) return 1;

  return 0;

}/* i2c_start */

############################## i2c_write = setzt eigentlich nur eine 0!
/** defines the data direction (writing to I2C device) in i2c_start(),i2c_rep_start() */
#define I2C_WRITE   0

i2c_write = hier werden die Daten gesendet

/
unsigned char i2c_write( unsigned char data )
{  
    uint8_t   twst;
    
  // send data to the previously addressed device
  TWDR = data;
  TWCR = (1<<TWINT) | (1<<TWEN);

  // wait until transmission completed
  while(!(TWCR & (1<<TWINT)));

  // check value of TWI Status Register. Mask prescaler bits
  twst = TW_STATUS & 0xF8;
  if( twst != TW_MT_DATA_ACK) return 1;
  return 0;

}/* i2c_write */

Und noch den i2c_Stop

rief Terminates the data transfer and releases the I2C bus 
 @param void
 @return none
 */
extern void i2c_stop(void);

void i2c_stop(void)
{
    /* send stop condition */
  TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
  
  // wait until stop condition is executed and bus released
  while(TWCR & (1<<TWSTO));

}/* i2c_stop */

Soweit ist das mein Master-Programm. In diesem sehe ich soweit keine 
großen Probleme. Seht ihr noch Fehler ?

Muss der errechnete Wert von SCL_Frequenz ein gerader Wert sein ? Wenn 
ich als SCL_Clock 100000hz deklariere kommt ja ein errechneter Wert von 
10,432 raus, der ja in TWBR geschrieben wird um den SCL_Takt zu 
definieren. Der Wert sollte ja laut Atmel größer 10 sein um eine stabile 
Kommunikation zu erhalten. Rundet Atmel(C) dann auf auf 11 oder ab auf 
10 ? oder geht das wegen der Kommazahl nicht ?

Habe mir dann für TWBR einen Wert von 16 eingetragen und ausgerechnet 
welche SCL_Clock Frequenz eingestellt werden muss. In diesem Fall ist 
TWBR ja gerade und als SCL_Clock muss dann 76800Hz eingegeben werden, 
damit die 16 als Wert für TWBR herrauskommt. !

Verstehe ich das so richtig ? Könnt ihr mir bitte helfen ?!

Vielen Dank und Gruß Markus

[Thomas W. (Gast)]

Markus Schmitz schrieb:
> Hier mal der komplette Code vom Master:

Das mit der Adresse ist immer noch Unfug oder die 0x50 ist nicht die 
I2C-Adresse des Slaves. In jedem Fall solltest du deinen Variablen und 
Konstanten Namen geben, die nicht zu Verwirrung führen.

[Markus Schmitz (Gast)]

Hallo zusammen,

habe es zum Laufen bekommen.

"Musterlösung" folgt später.....

Vielen Dank für eure Hilfe!

[Markus Schmitz (Gast)]

Hier das fertige Programm für Master und Slave !!

Fehler war das nur ein = benutzt wurde und nicht wie es richtig ist ==
!!
if (i2cdata[0] = 0b00000001)

Jetzt läuft alles mit 2 Atmega 8 !