I2C Modul sendet Adresse erneut anstelle von Stop-Condition (TI TMS320F28388D)

[Mductance (Gast)]

Hallo zusammen

Ich benutze gerade einen TMS320F28388D und müsste mit dem mit einem 
TLI493D-W2BW von Infineon  kommunizieren. Dazu implementiere ich die 
generische Bibliothek die von Infineon bereitgestellt wird.

Das Problem ist, dass meine I2C write Funktion nicht richtig 
funktioniert, das angehängte Bild (w2bw_debugging) zeigt das Resultat, 
wenn man zwei bytes in den Sensor schreiben möchte (also 
"w2bw_i2c_write" mit count=2).

Der uC schreibt die Adresse und die beiden bytes welche auch vom Sensor 
bestätigt werde. Danach verhält sich der uC allerdings seltsam und 
sendet die Adresse des Sensors erneut (der Protokoll-Analysator 
registriert das als einen "Re-Start", habe davon aber im Zusammenhang 
mit I2C noch nie gehört).

Das I2C Modul konfiguriere ich mittels:

void I2Cinit(){
    I2C_disableModule(I2C0_W2BW_BASE);
    I2C_initMaster(I2C0_W2BW_BASE, DEVICE_SYSCLK_FREQ, 200000, I2C_DUTYCYCLE_50);
    I2C_setConfig(I2C0_W2BW_BASE, I2C_MASTER_SEND_MODE);
    I2C_setSlaveAddress(I2C0_W2BW_BASE, 0);
    I2C_disableLoopback(I2C0_W2BW_BASE);
    I2C_setBitCount(I2C0_W2BW_BASE, I2C_BITCOUNT_8);
    I2C_setDataCount(I2C0_W2BW_BASE, 1);
    I2C_setAddressMode(I2C0_W2BW_BASE, I2C_ADDR_MODE_7BITS);
    I2C_enableFIFO(I2C0_W2BW_BASE);
    I2C_setFIFOInterruptLevel(I2C0_W2BW_BASE, I2C_FIFO_TXEMPTY, I2C_FIFO_RXEMPTY);
    I2C_setEmulationMode(I2C0_W2BW_BASE, I2C_EMULATION_FREE_RUN);
    I2C_enableModule(I2C0_W2BW_BASE);
}

Die Funktion die n bytes schreiben sollte ist definiert als:

/*! \brief Function Header: (uint8_t addr, const uint8_t* data, uint8_t count)
 *
 * I2C write command must have a header precisely of type:
 * (uint8_t addr, const uint8_t* data, uint8_t count), where:
 * \param addr Is the I2C address to read from data is the;
 * \param data is the array that the function will read to
 * \param count is the number of bytes the function will read
 *
 * \code{.c}
 * // =============== EXAMPLE ================
 * uint8_t payload[] = {5, 1, 2, 3};
 * // write 4 bytes from payload to the I2C device with address 0x23
 * error = _I2C_write(0x23, payload, 4);
 * \endcode
 * */
inline uint8_t w2bw_i2c_write(uint8_t addr,const uint8_t* data,uint8_t count){
    //set the I2C slave address to the write address
    I2C_setSlaveAddress(I2C0_W2BW_BASE,I2C_W2BW_ADDRESS_WRITE);
    //set the number of bytes to be sent
    I2C_setDataCount(I2C0_W2BW_BASE, count);
    //push the data to the I2C TX FIFO
    uint8_t i=0;
    for(i=0; i<count; i++){
        I2C_putData(I2C0_W2BW_BASE,data[i]);
    }
    //set the I2C mode to master
    I2C_setConfig(I2C0_W2BW_BASE, I2C_MASTER_SEND_MODE);
    //send the start condition
    I2C_sendStartCondition(I2C0_W2BW_BASE);
    //send the stop condition
    I2C_sendStopCondition(I2C0_W2BW_BASE);
    //wait until TX FIFO is empty
    while(I2C_getTxFIFOStatus(I2C0_W2BW_BASE)!=I2C_FIFO_TXEMPTY){
        ;
    }
    return 0;
}
#define _I2C_write w2bw_i2c_write

Das Programm scheint auch immer in der while loop stecken zu bleiben, 
e.g. die FIFO scheint nicht leer zu sein. Wenn ich mir die Register des 
I2C Moduls anschaue fällt auf, dass diese sich ändern sobald ich das 
Programm mit dem Debugger anhalte. Wenn das Programm normal läuft (also 
scheinbar in der while-loop stecken bleibt, zeigt die Register-Vorschau 
einen Transmit-FIFO status von 0 [also nichts in der Transmit-FIFO], 
wenn ich das Programm anhalte jedoch ändert sich die Register-Vorschau 
und zeigt einen Transmit-FIFO Status von 2 [also 2 bytes in der Transmit 
FIFO], zudem scheint das NACK interrupt bit gesetzt.

Weiss vielleicht jemand, was da los ist?

[PittyJ (Gast)]

Zeile 18: müßte da nicht etwas von addr enthalten sein?

[Mductance (Gast)]

PittyJ schrieb:
> Zeile 18: müßte da nicht etwas von addr enthalten sein?

Diese Zeile setzt die I2C Slave Adresse, addr ist ein pointer auf die 
Daten, die gesendet werden sollten.

[DerEinzigeBernd (Gast)]

Mductance schrieb:
> addr ist ein pointer auf die
> Daten, die gesendet werden sollten.

Nö. Der heißt "data". addr ist kein Pointer, sondern ein uint8_t, und 
wird in Deiner Funktion nirgendwo verwendet.

[Mductance (Gast)]

DerEinzigeBernd schrieb:
> Mductance schrieb:
>> addr ist ein pointer auf die
>> Daten, die gesendet werden sollten.
>
> Nö. Der heißt "data". addr ist kein Pointer, sondern ein uint8_t, und
> wird in Deiner Funktion nirgendwo verwendet.

Hmm, ok, das habe ich nun entsprechend geändert, allerdings ändert das 
nichts am Verhalten des uCs, die Adresse ist immer noch die gleiche 
under uC sendet weiterhin eine weitere Start-Condition nachdem er die 
zwei Bytes gesendet hat.

[DerEinzigeBernd (Gast)]

Mductance schrieb:
> Hmm, ok, das habe ich nun entsprechend geändert,

Wie?

[Mductance (Gast)]

So, mittlerweile konnte ich herausfinden woran das Problem lag. Nachdem 
man das Stop-Condition bit mittels I2C_sendStopCondition gesetzt hat 
muss man eine Weile warten um sicherzustellen, dass die STOP condition 
auch richtig erzeugt wird, das kann man machen indem man das BB 
(Bus-Busy) bit pollt:

inline uint8_t w2bw_i2c_write(uint8_t addr,const uint8_t* data,uint8_t count){
    //set the I2C slave address to the write address
    I2C_setSlaveAddress(I2C0_W2BW_BASE,addr);
    //set the number of bytes to be sent
    I2C_setDataCount(I2C0_W2BW_BASE, count);
    //push the data to the I2C TX FIFO
    uint8_t i=0;
    for(i=0; i<count; i++){
        I2C_putData(I2C0_W2BW_BASE,data[i]);
    }
    //set the I2C mode to master
    I2C_setConfig(I2C0_W2BW_BASE, I2C_MASTER_SEND_MODE);
    //send the start condition
    I2C_sendStartCondition(I2C0_W2BW_BASE);
    //wait until TX FIFO is empty
    while(1){
        I2C_TxFIFOLevel state=I2C_getTxFIFOStatus(I2C0_W2BW_BASE);
        if(state==I2C_FIFO_TXEMPTY)
            break;
    }
    //send the stop condition
    I2C_sendStopCondition(I2C0_W2BW_BASE);
    while(I2C_isBusBusy(I2C0_W2BW_BASE))
        ;
    return 0;
}
#define _I2C_write w2bw_i2c_write

Zuvor gab es das Problem, dass sie Sensor-Library welche die 
w2bw_i2c_write interface Funktion benutzt mehrere I2C writes 
hintereinander aufruft. Der eine w2bw_i2c_write Aufruf kam dann bevor 
die Stop-Condition des vorigen Aufruds richtig auf den Bus gesetzt 
werden konnte. Durch das zusätzliche Warten am Ende der Funktion können 
dann mehrere I2C writes hintereinander richtig aufgerufen werden: