I2C Verbindung fehlerhaft

[Thomas M. (Gast)]

Hallo zusammen,

ich möchte gerne zwei ATMEGA(32/64) miteinander über I2C kommunizieren 
lassen. Dazu habe ich auch schon Probeaufbauten gemäß des I2C Standards 
aufgebaut und mit der Programmierung angefangen. Weil der Code gut 
geschrieben ist, habe ich ihn u.a. von [[AVR TWI Master und Slave 
Funtionen in C
]] übernommen. Ein IC fungiert als Master, der andere als Slave.

Stecke ich z.B. einen DS1307 (i2c fähige RealTimeClock) alleine an den 
Bus, funktioniert die Verbindung problemlos. Stecke ich aber alleine 
oder zusätzlich zur DS1307 den als Slave fungierenden ATMEGA auf die I2C 
Leitung, bleibt der Master in der unten markierten Stelle hängen. Jetzt 
kann ich mir leider nicht genau erklären warum er gerade dort hängen 
bleibt, obwohl meines Erachtens nach alles korrekt eingestellt wurde.

Leider habe ich hier und auf jeglichen Suchmaschinen keine mögliche 
Antwort auf mein Problem gefunden.


Mein zusammengefasster Code aus der Library:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/twi.h>

///////////////////////////////////////////////////////////////////////////////////////
//////////////////////////    MASTER Chain    ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////
_Bool TWIM_Init(uint32_t bitrate) {
  TWBR = ((F_CPU / bitrate) - 16) / 2;
  if (TWBR < 11)
    return false;
  return true;
}

_Bool TWIM_Start(uint8_t adress, uint8_t RW) {
  uint8_t twst;

  // Sende Startbefehl
  TWCR = (1 << TWINT) | (1 << TWSTA) | (1 << TWEN);
  // Warten bis fertig
// BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG BUG
  // BUG: sobald ATMEGA Slave angeschlossen wird bleibt er in der while schleife
  while (!(TWCR & (1 << TWINT))) {
 // Ausgabe, ob der IC hier bleibt
    PORTB ^= (1 << PB3);
    _delay_ms(100);
  }
  // Statusregister checken
  twst = TWSR & 0xf8;
  if ((twst != TWI_START) && (twst != TWI_REP_START))
    return false;
  // sende ansprechadresse
  TWDR = (adress << 1) + RW;
  TWCR = (1 << TWINT) | (1 << TWEN);
  // Warte bis Befehl zuende und ACK/NACK empfangen
  while (!(TWCR & (1 << TWINT)))
    ;
  // Statusregister checken
  twst = TWSR & 0xf8;
  if ((twst != TWI_MTX_ADR_ACK) && (twst != TWI_MRX_ADR_ACK))
    return false;
  return true;
}

void TWIM_Stop(void) {
  // Sende Stop Befehl
  TWCR = (1 << TWINT) | (1 << TWSTO) | (1 << TWEN);
  // Warte bis Befehl fertig
  while (TWCR & (1 << TWSTO)) {

  }
}

_Bool TWIM_Write(uint8_t byte) {
  uint8_t twst;
  // Sende Daten an die vorher eingestellte Adresse
  TWDR = byte;
  TWCR = (1 << TWINT) | (1 << TWEN);
  // Warte bis die Übertragung fertig ist
  while (!(TWCR & (1 << TWINT))) {
    PORTB ^= (1 << PB3);
    _delay_ms(100);
  }
  // Statusregister checken
  twst = TWSR & 0xf8;
  if (twst != TWI_MTX_DATA_ACK)
    return true;
  return false;
}

uint8_t TWIM_ReadAck(void) {
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
  while (!(TWCR & (1 << TWINT)))
    ;
  return TWDR;
}

uint8_t TWIM_ReadNack(void) {
  TWCR = (1 << TWINT) | (1 << TWEN);
  while (!(TWCR & (1 << TWINT)))
    ;
  return TWDR;
}

///////////////////////////////////////////////////////////////////////////////////////
////////////////////////////    SLAVE Chain    ///////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////

_Bool TWIS_Init(uint8_t adress, uint32_t bitrate) {
  TWBR = ((F_CPU / bitrate) - 16) / 2;
  if (TWBR << 11)
    return false;
  // Setze die Slave Adresse, geshiftet, denn TWGCE
  TWAR = adress * 2;
  // Aktiviere das TWI Interface
  TWCR = (1 << TWEN) | (1 << TWEA);
  return true;
}

void TWIS_Stop(void) {
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWSTO) | (1 << TWEA);
}

void TWIS_Write(uint8_t byte) {
  TWDR = byte;
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
  while (!(TWCR & (1 << TWINT)))
    ;
}

uint8_t TWIS_ReadAck(void) {
  TWCR = (1 << TWINT) | (1 << TWEN) | (1 << TWEA);
  while (!(TWCR & (1 << TWINT))) {
    PORTB ^= (1 << PB0);
    _delay_ms(100);
  }
  return TWDR;
}

uint8_t TWIS_ReadNack(void) {
  TWCR = (1 << TWINT) | (1 << TWEN);
  while (!(TWCR & (1 << TWINT))) {
    PORTB ^= (1 << PB0) | (1 << PB1);
    _delay_ms(100);
  }
  return TWDR;
}

_Bool TWIS_ResponseRequired(uint8_t *typ) {
  *typ = TWSR;
  return (TWCR & (1 << TWINT));
}

Jetzt habe ich in meiner main folgendes (da ich gerade kein Display 
habe, lasse ich mir die Zustände auf dem PortB in Form von LEDs 
ausgeben:

#define ADRESSE 15
#define TWI_BITRATE 100000

int main(void) {
  init();

  DDRB = 0xff;
  PORTB = 0xff;

  uint8_t TWI_Response = 0;
  uint8_t data[8];

  cli();

  if (MASTER) {
    _delay_ms(1000);
    _delay_ms(1000);
    if (!TWIM_Init(TWI_BITRATE))
      while (1) {
        PORTB ^= (1 << PB0) | (1 << PB1);
        _delay_ms(100);
      }
    //else
    //  PORTB &= (1 << PB0);
  } else {
    _delay_ms(500);
    if (!TWIS_Init(ADRESSE, TWI_BITRATE))
      while (1) {
        PORTB ^= (1 << PB0) | (1 << PB2);
        _delay_ms(100);
      }
    //else
    //  PORTB &= ~ ((1 << PB1) | (1 << PB0));
  }

  sei();

  while (1) {

    if (MASTER) {
      if(!i2c_start((52 * 2))) {
      //if (TWIM_Start(52, TWI_READ)) {
        PORTB &= ~(1 << PB5);
        for(int i = 0; i < 7; i++)
          data[i] = TWIM_ReadAck();
        data[7] = TWIM_ReadNack();
        TWIM_Stop();
        //PORTB |= (1 << PB5);
        PORTB = ~data[4];
      } else {
        PORTB ^= (1 << PB3);
        TWIM_Stop();
      }
    } else {
      if (TWIS_ResponseRequired(&TWI_Response)) {
        switch (TWI_Response) {
        case TWI_SRX_ADR_ACK:
          PORTB = ~(TWIS_ReadNack());
          TWIS_Stop();
          break;
        case TWI_STX_ADR_ACK:
          for (int i = 0; i < 8; i++) {
            TWIS_Write(PIND);
          }
          TWIS_Stop();
          break;
        default:
          while (1) {
            PORTB = ~(TWI_Response);
          }
          break;
        }
      }
    }

    PORTB ^= (1 << PB7);
    _delay_ms(100);
  }

  // Never reached
  return 0;
}

Lieben Dank,
Thomas