atmega32 i2c master transimitter/slave receiver problem

[Jürgen S. (jsachs)]

Hallo,

ich habe ein "Netzwerk" aus mehreren atmega32.
Diese Kommunizieren über i2c. Es wird nur gesendet im Master Transmitter 
Modus und Empfangen im Slave Receiver. Alle atmega sind sowohl Slave und 
Master.
Das Funktioniert soweit prima, jedoch bekomme ich ein Problem wenn ich 
versuche zu senden (Master Transmitter) und etwas Empfange.

Als Test lasse ich einfach beide atmegas Texte hin und her schicken. Was 
klappt bis ich senden will während ein Empfang läuft.

Irgendwie habe ich noch keine Möglichkeit gefunden festzustellen, ob der 
i2c/TWI frei ist.

Ich dachte ich kann "jederzeit" sagen sende ein Startcondition und 
sobald es geht wird dies ausgeführt und ein Interrupt ausgelöst. Das 
geht nicht.

Bin das PDF des atmega nun mehrfach durch.
Habe ich etwas übersehen ?

Der i2c Code ist so alleine nicht Lauffähig, daher bringt das Posten 
hier vermutlich nichts. Ich hoffe es hat trotzdem noch jemand einen 
Tipp.

Ich dachte ein Flag setzen sobald ich etwas Empfange sollte reichen, 
aber scheinbar deckt das nicht alle Sonderfälle ab.

Gruss
Juergen

[Tim (Gast)]

>Als Test lasse ich einfach beide atmegas Texte hin und her schicken. Was
>klappt bis ich senden will während ein Empfang läuft.

Solange die TWI Hardware arbeitet darfst du nicht daran rumfummeln.
Also laufende Übertragung abschließen und dann Start anfordern.

>Irgendwie habe ich noch keine Möglichkeit gefunden festzustellen, ob der
>i2c/TWI frei ist.

Brauch dich ja auch nicht zu interessieren.

>Der i2c Code ist so alleine nicht Lauffähig, daher bringt das Posten
>hier vermutlich nichts. Ich hoffe es hat trotzdem noch jemand einen
>Tipp.

Poste deinen Code!
Solange keiner sieht was du mit TWI anstellst kann dir keiner helfen.

>Ich dachte ein Flag setzen sobald ich etwas Empfange sollte reichen,
>aber scheinbar deckt das nicht alle Sonderfälle ab.

Von wo bis wo setzt du das Flag?
Code??

[Klaus2m5 (Gast)]

Alle Master müssen den I2C-Bus auf Startbedingung überwachen und eigene 
Starts unterdrücken, bis wieder ein Stop empfangen wird.

Für die seltenen Fälle, bei denen mehr als ein Master gleichzeitig Start 
signalisiert, muss eine Bus-Arbitration durchgeführt werden. Dabei 
müssen alle Master sofort ihre Übertragung abbrechen, wenn sie selbst 
SDA=1 gesetzt haben, aber tatsächlich SDA=0 ist.

Bei I2C-Teilnehmern, die gleichzeitig Master und Slave sein können, 
gibts dabei noch ein spezielles Problem. Wenn bei einer Bus-Arbitration 
ein Slave adressiert werden sollte, der aber selbst gerade als Master an 
der Bus-Arbitration beteiligt ist, kann auf die Adressierung dieses 
Teilnehmers kein ACK erfolgen.

All diese Probleme, die in einem Single-Master Sytem gar nicht erst 
auftreten würden, müssen von der Software abgefangen werden.

[Jürgen S. (jsachs)]

Das Flag was ich weiter oben erwähnt habe, ist schon wieder drausen. Es 
hat ja nicht funktioniert :-(

Ich kann den Code auf die schnelle nur hier "inline" posten.
Ach ja, das Makro "_BVC()" ist "((0<<x))" und für mich einfacher mal ein 
Flag zu löschen und dazu zu nehmen.

Wie gesagt der Code ist nur auf MT und SR ausgelegt.

/*
 * 
 * 
 * 
 */

#include "i2c.h"
#include <util/atomic.h>
#include <avr/interrupt.h>
#include <util/twi.h> 
#include "avr_helper.h"
#include "uart.h"

//#define IC2_DEBUG

enum 
{
  i2c_unknown = 0,
  i2c_Idle,
  i2c_send_start,
  i2c_send_addr,
  i2c_send_data,
  i2c_send_stop
};

struct _sI2cStatus
{
  uint8_t status;
  uint8_t txBuffer[20];
  uint8_t txPos;
  uint8_t toSendPos;
  uint8_t isMaster:1;
};

volatile struct _sI2cStatus i2cStatus;

#define getTWIstatus (TWSR & TW_STATUS_MASK)

void setI2CAddr(uint8_t addr)
{
  TWAR = (addr & 0x7F)<<1;
}

void initI2C(uint8_t isMaster, uint16_t baud, uint8_t myAddr)
{
  if (isMaster)
    i2cStatus.isMaster = 1;
  else
    i2cStatus.isMaster = 0;
  
  i2cStatus.status = i2c_Idle;
  
  uint8_t scl = (F_CPU/baud -16) / 2;  
  
  TWBR = scl;
  setI2CAddr(myAddr);
  
  PORTC = _BV(PC0)|_BV(PC1);  // Pullup an
  
  
  //last enable interrupt
  TWCR = _BVC(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
  //TWCR |= _BV(TWIE) | _BV(TWEN);
  
}

void sendI2CStart(void)
{
#ifdef I2C_DEBUG
  char buffer[10];
  uint8_t twcr;
  uartPut('t');
  twcr = TWCR;
  uartPuts(uint8ToAh(buffer, twcr));
  uartPut(',');
  uartPuts(uint8ToAh(buffer, getTWIstatus));
  uartPut(':');
#endif
  ATOMIC_BLOCK ( ATOMIC_RESTORESTATE )
  {
    TWCR = _BV(TWINT)|_BV(TWEA)|_BV(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
    i2cStatus.status = i2c_send_start;
  }
#ifdef I2C_DEBUG
  //twcr = TWCR;
  uartPuts(uint8ToAh(buffer, twcr));
  uartPut(',');
  uartPuts(uint8ToAh(buffer, getTWIstatus));
  uartPut('\r');
#endif
}

void sendI2CStop(void)
{
  ATOMIC_BLOCK ( ATOMIC_RESTORESTATE )
  {
#ifdef I2C_DEBUG
    uartPut('e');
#endif
    TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BV(TWSTO)|_BV(TWEN)|_BV(TWIE);  
    i2cStatus.status = i2c_send_stop;
  }
}

void sendI2C(uint8_t addr, uint8_t *data, uint8_t len)
{
  // wait to get last packet send
  // currently we do not support multiple commands in buffer
  while (i2cStatus.txPos > 0)
  {
//#ifdef I2C_DEBUG
    uartPut('-');
//#endif
    nop();
  }
  /*
  while(!(getTWIstatus & _BV(TWINT)))
  {
      uartPut('.');
  }
  */
  ATOMIC_BLOCK ( ATOMIC_RESTORESTATE )
  {
    if (len < sizeof(i2cStatus.txBuffer))
    {
#ifdef I2C_DEBUG
      uartPut('+');
#endif
      i2cStatus.txBuffer[0] = (addr<<1)|TW_WRITE; // 0 = WRITE, 0x01 = READ
      
      uint8_t i;
      for(i=0;i<len;i++)
      {
  i2cStatus.txBuffer[i+1] = data[i];
      }
      
      //memcpy(&(i2cStatus.txBuffer)+1, data, len);
      //uartPut('2');
      
      i2cStatus.txPos = len+1; //add addressbyte
      i2cStatus.toSendPos = 0;
      sendI2CStart();
    }
  }
}

ISR(TWI_vect)
{
#ifdef I2C_DEBUG
  char buffer[10];
  uartPut('i');
#endif
  switch(getTWIstatus)
  {
    case TW_START:  // START send
    {
#ifdef I2C_DEBUG
      uartPuts("TWI_TW_START,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      TWDR = i2cStatus.txBuffer[0];
      i2cStatus.toSendPos++;
      i2cStatus.status = i2c_send_addr;
      TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
      break;
    }
    case TW_MT_SLA_ACK :
    case TW_MT_DATA_ACK:
    {
#ifdef I2C_DEBUG
      uartPuts("TW_MT_SLA/DATA_ACK,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif      
      if (i2cStatus.toSendPos < i2cStatus.txPos)
      {
  TWDR = i2cStatus.txBuffer[i2cStatus.toSendPos];
  i2cStatus.toSendPos++;
  i2cStatus.status = i2c_send_data;
  TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
      }
      else
      {
  i2cStatus.txPos = 0;
  sendI2CStop();
      }
      break;
    }
    case TW_MT_DATA_NACK:
    {
#ifdef I2C_DEBUG
      uartPuts("TW_MT_DATA_NACK,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      i2cStatus.txPos = 0;
      sendI2CStop();
      break;
    }
    case TW_MT_ARB_LOST:
    {
#ifdef I2C_DEBUG
      uartPuts("TW_MT_ARB_LOST,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      //TODO we need to support this
      // ups we lost bus control
      break;
    }
    case TW_MT_SLA_NACK:  // addr not used, abbort
    {
#ifdef I2C_DEBUG
      uartPuts("TWI_MT_SLA_NACK,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      i2cStatus.txPos = 0;
      //TWCR = _BV(TWINT)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
      sendI2CStop();
      break;
    }
    case TW_SR_SLA_ACK :
    {
#ifdef I2C_DEBUG
      uartPuts("TW_SR_SLA_ACK,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      char c = TWDR;
      uartPut(c);
      uartPut('\r');
      TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);
      break;
    }
    case TW_SR_DATA_ACK:
    {
#ifdef I2C_DEBUG
      uartPuts("TW_SR_DATA_ACK,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      char c = TWDR;
      uartPut(c);
      TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);
      break;
    }
    case TW_SR_STOP:
    {
#ifdef I2C_DEBUG
      uartPuts("TW_SR_STOP,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      char c = TWDR;
      uartPut('\r');
      TWCR = _BV(TWINT)|_BV(TWEA)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);
      i2cStatus.status = i2c_Idle;
      break;
    }
    default:
    {
#ifdef I2C_DEBUG
      uartPuts("TWI int default,");
      uartPuts(uint8ToAh(buffer, getTWIstatus));
      uartPut('\r');
#endif
      i2cStatus.txPos = 0;
      //TWCR = _BV(TWINT)|_BVC(TWSTA)|_BVC(TWSTO)|_BV(TWEN)|_BV(TWIE);  
      sendI2CStop();
      break;
    }
    
  }
  
  
  // last clear interrupt so we free TWI
  //TWCR |= _BV(TWINT);
}

[Tim (Gast)]

Hier ein parr Sachen die mir aufgefallen sind:
Wofür i2cStatus.status? Wird nur geschrieben.
sendI2C prüft anhand von i2cStatus.txPos ob TWI arbeitslos ist,
kann so aber NIE erkennen ob das TWI gerade im SR Modus ist.

Wenn du also gerade Daten empfängst und sendI2C aufrufst geht das
garantiert schief.

Vorschlag:
Definiere für i2cStatus.status ein i2c_rvc_data und setzt das in
TW_SR_SLA_ACK.
sendI2C darf nur noch senden wenn i2cStatus.status == i2c_Idle.

Beachte auch das es diverse Möglichkeiten gibt den Master Status zu 
verlieren: 0x38, 0x68, 0x78.
Du fängst aber im Moment nur 0x38 ab.

[Jürgen S. (jsachs)]

Hallo,

i2cStatus.txPos dient dazu wie voll der Sendespeicher ist. Im Moment 
Unterstütze ich nur 1 Packet in der Queue. Daher schicke ich den avr in 
eine while bis das letzte Packet verschickt wurde. Will ich mal 
ausbauen, aber Schritt für Schritt :-)

Die noch nicht abgefangenen Sonderfälle sind in Arbeit. Ich will mich da 
erst mal rein arbeiten.

Mit dem Vorschlag für den i2cStatus.status. So hat ich das auch 
umgesetzt, nur in einer extra Variablen. Nur kam es trotzdem noch vor. 
Das ich ein Start senden will und ein Empfang anfängt.
Aber ich versuche das gleich nochmal, vielleicht habe ich mich gestern 
auch vertan.

Ich werde berichten :-)

Gruss
Juergen

[Jsachs (Gast)]

Ich habe gestern das och modifiziert und es scheint doch zu gehen.
Ich lasse zwei master sich gegenseitig Meldungen schicken, die dann auf 
die Serielle ausgegeben werden. Und das ganze mir richtig speed :-)
Nun habe ich noch folgendes Problem:
Wird der "Bus Master" während der Übertragung resetet, bleibt der Bus 
natürlich belegt und ist bis zu einem Reset beider Master nicht nutzbar.
Der "Salve Receiver" denkt der Bus ist noch belegt. Der MT der neu 
gestartet wurde fängt aber auch keine Übertragung an. Ich nehme an das 
passiert nur wärend der Übertragung eines bytes.
Starte ich beide CPUs neu läuft alles wieder prima.

Wie kann man so etwas sinnvoll handhaben ?
Wenn für eine gewisse Zeit nichts passiert, einfach mal ein Stop senden 
???

Für Tipps wäre ich dankbar.

Gruss
Juergen

[Tim (Gast)]

Freut mich das es jetzt klappt.

Ich habe hier einen timeout Zähler in jedem µC laufen.
Der wird bei jedem TWI-IRQ zurückgesetzt.
Wenn sich für eine gewisse Zeit nichts auf dem Bus tut
gibt es einen Init des TWI und der Bus ist wieder frei.

Und noch so als Tipp: Bau eine CRC ein.
Wenn du dann nach der CRC noch ein Dummy Byte sendest kann
der Slave durch ACK/NACK dem Master mitteilen ob die CRC gepasst hat.

[Jürgen S. (jsachs)]

Hallo,

wenn ich einen Fehler feststelle. Sagen wir der Bus ist für eine gewisse 
Zeit still und der Verdacht da ist was faul.

Nun möchte ich das TWI in einen definierten Zustand bringen. Was muss 
ich dann machen ?

Ist folgendes ausreichend ?

/*
 * get us in a known state
 */
void reinitI2C(void)
{
  i2cStatus.status = i2c_Idle;
  TWCR |= _BV(TWSTO);
  TWCR &= ~_BV(TWEA);
  TWCR |= _BV(TWEA);
}

Nachdem TWEA ja auch die Hardware freigibt, bin ich mir da unsicher.
Ich möchte aus einem Fehler, egal ob Master oder Slave in einen 
definierten Zustand (Idle) wechseln.

Natürlich nur bei Fehler die Fatal sind, also zu Busausfällen führen, 
weil ein Slave hängt oder nicht mehr reagiert oder der Master während 
dem Transfer resetet/abgeschaltet wurde.

Gruss
Juergen