I2c: Acknowledge Polling mag nicht

[Michael Z. (incunabulum)]

Moin!

ich versuche gerade, einen AD5251 (digitales Potentiometer, 2 Kanäle, 
I2c Interface) zum leben zu erwecken. Im großen und ganzen funktioniert 
das auch. Mit einem Problem:

Der AD5251 hat neben der Potentiometer ein kleines EEPROM an Bord. 
Sollen dort Werte geschrieben werden, so ist laut Dokumentation 
Acknowledge Polling anzuwenden um so herauszufinden wann die 
Schreiboperation abgeschlossen ist. Im Datenblatt steht dies so:

To determine if the internal write cycle is complete and the i2c interface
is enabled, interface polling can be executed. I2c interface polling can be
conducted by sending a start condition followed by the slave address and the
write bit. If the I2c interface responds with an ACK, the write cycle is 
complete and the interface is ready to proceed with further operations.

Die entsprechende Schreibfunktion sieht bei mir so aus:

void Ad5251::setEEMEM(u08 channel, u08 value) {
  i2cWriteStartWait(m_i2cAddr + I2C_WRITE);
  i2cWriteDataByte(B8(00100000) + channel);
  i2cWriteDataByte(value);
  i2cWriteStop();

  // TODO: acknowledge polling not working!
  i2cWriteStartWait(m_i2cAddr + I2C_WRITE); // wait for acknowledge
  i2cWriteStop();
}

Der eigentliche Schreibvorgang funktioniert einwandfrei. Schreibe ich 
allerdings mehrere Werte hintereinander, so wird nur jeder 2. 
geschrieben, da anscheinend der AD5251 noch nicht aufnahmebereit ist. 
Mit einem kleinen Delay klappt es. Ergo mein Schluss, dass das 
Acknowledge Polling irgendwie faul ist.

Die relevante i2cWriteStartWrite() Funktion sieht bei mir wie folgt aus. 
Ist bereits mehrfach getestet und letztlich von den Atmel App Notes 
(oder Fleury?) nahezu 1:1 übernommen:

void i2cWriteStartWait(u08 addr) {
  // Send start condition; send address, transfer direction
  // If device busy, use ack polling to wait for ready
    u08   twst;
    while ( 1 ) {
      TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN);  // send START condition
    while(!(TWCR & (1<<TWINT)));        // wait until transmission completed
      twst = TW_STATUS & 0xF8;            // check value of TWI Status Register.
                            // Mask prescaler bits.
    if ( (twst != TW_START) && (twst != TW_REP_START))
      continue;                 // failed; retry

      TWDR = addr;                  // send device address
      TWCR = (1<<TWINT) | (1<<TWEN);
      while(!(TWCR & (1<<TWINT)));         // wail until transmission completed
      twst = TW_STATUS & 0xF8;            // check value of TWI Status Register.
                            // Mask prescaler bits.
      if ( (twst == TW_MT_SLA_NACK )||(twst ==TW_MR_DATA_NACK) ) {
          TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWSTO);  // device busy, send stop condition to
                                // terminate write operation //
          while(TWCR & (1<<TWSTO));              // wait until stop condition is executed and bus released
          continue;
      }
      break;                        //if( twst != TW_MT_SLA_ACK) return 1;
     }
}

Mach ich das richtig? Oder wieso funktioniert das nicht wie gewünscht?

[Stephan W. (sir_wedeck)]

Morgen
>Mach ich das richtig?
Nicht ganz, denn nach dem Schreiben der Daten ist das Interface 
deaktiviert und du bekommst keiner Antwort.

In deiner Funktion wird aber nur auf ein Nack reagiert und nicht auf Ack 
bzw keine Antwort. Also schreibe deine Funktion so um, das sie nach dem 
Schreiben der Daten so lange wartet bis sie ein Ack erhält. Dann ist der 
Schreibvorgang beendet.

Stephan.

Von der Geschwindigkeit her würde ich es umgekehrt machen, erst beim 
erneuten schreiben warten bis ein Ack kommt. Meine Meinung. :-)

[Michael Z. (incunabulum)]

Stephan W. schrieb:
> In deiner Funktion wird aber nur auf ein Nack reagiert und nicht auf Ack
> bzw keine Antwort. Also schreibe deine Funktion so um, das sie nach dem
> Schreiben der Daten so lange wartet bis sie ein Ack erhält.

Duhh... ich wusste, dass es etwas triviales ist. Da ich die I2c 
Funktionen jetzt schon lange verwende habe ich deren Funktion für 
"gottgegeben" angenommen und hier nicht weiter intensiv nachgeforscht. 
Hät ich aber auch selber draufkommen können!

> Von der Geschwindigkeit her würde ich es umgekehrt machen, erst beim
> erneuten schreiben warten bis ein Ack kommt. Meine Meinung. :-)

Und noch ein gute Idee! Damit spare ich mir zumindest das Delay beim 
letzten Byte und kann den AVR sich mit anderen Dingen beschäftigen 
lassen.

Danke!