MSP430FR und I2C Master

[Daniel S. (snipod)]

Hallo,
ich bin neu auf der MSP430 Plattform und komme aktuell mit dem I2C nicht 
zurecht.

Ich habe mich durch die Doku gekämpft und zahlreiche Tutorials gelesen, 
aber komme nicht weiter.

Ich möchte mit einem MSP430FR2532 einen VL53L0X einstellen und auslesen, 
scheitere aber schon am lesen der ID, vielleicht kann mir ja jemand 
weiterhelfen :)

Vorab:
VL53L0X und MSP430FR werden mit 2V8 versorgt. SDA hängt an P1.2 
(UCB0SDA), SCL hängt an P1.3 (UCB0SCL). SDA und SCL sind über 1k6 an 
2V8. Außerdem läuft der UART auf UCA0.

Und hier mein Code:

void I2C_Init()
{
    //-- Setup I2C periphal
    UCB0CTLW0 |= UCSWRST;           // put I2C B0 into SW reset
    UCB0CTLW0 |= UCSSEL_3;          // choose SMCLK
    UCB0BRW = 20;                   // set prescaler = 20 0> 8 MHz SMCLK => 400 kHz
    UCB0CTLW0 |= UCMODE_3;          // put into I2C mode
    UCB0CTLW0 |= UCMST;             // put into Master

    //-- Setup I2C ports
    P1SEL1 &= ~BIT3;                // P1.3 = SCL
    P1SEL0 |= BIT3;

    P1SEL1 &= ~BIT2;                // P1.2 = SDA
    P1SEL0 |= BIT2;

    UCB0CTLW0 &= ~UCSWRST;          // take I2C B0 out of SW reset
}

void I2C_Read_Bytes(uint8_t slv_addr, uint8_t reg_addr, uint8_t l, char *arr)
{
    uint8_t i;

    while (UCB0STAT & UCBBUSY); // wait until UCB0 not busy

    UCB0I2CSA = slv_addr;       // set slave address

    UCB0CTL1 |= UCTR | UCTXSTT; // transmitter mode and START condition.

    while (UCB0CTL1 & UCTXSTT); // wait for start to be sent

    UCB0TXBUF = reg_addr;       // send register address

    while ((UCB0IFG & UCTXIFG));// wait for tx buffer to be empty

    UCB0CTL1 |= UCTXSTP;        // send stop bit

    UCB0CTL1 &= ~UCTR;          // receiver mode

    UCB0CTL1 |= UCTXSTT;        // START condition

    while (UCB0CTL1 & UCTXSTT); // wait for start to be sent

    for (i = 0; i < l; i++)
    {
        while (!(UCB0IFG & UCRXIFG));   // wait for a byte to arrive in Rx Buffer


        if (i == l - 1) {
            UCB0CTL1 |= UCTXSTP;        // STOP condition on last byte
        }

        char val = UCB0RXBUF;           // read byte into buffer
        arr[i] = val;
    }

    while (UCB0CTL1 & UCTXSTP);         // wait until stop is sent
}

Der Code hängt bei

while (!(UCB0IFG & UCRXIFG));

Vielen Dank schon mal an Alle vorab!

[wv (Gast)]

Hallo Daniel,

die Zeile
   while (!(UCB0IFG & UCRXIFG));
macht auch irgendwie keinen Sinn. Ich hab jetzt nicht im Family-Guide 
nachgeschaut, aber von den Bezeichnungen her sind das zwei 
Flags(Bitwerte) die Du vergleichst. Also überprüf mal welches Flag in 
welchem Register Du da prüfen willst und vergleiche dann das Register 
gegen das Flag.

Gruß wv

[Clemens L. (c_l)]

wv schrieb:
> while (!(UCB0IFG & UCRXIFG));
>
> von den Bezeichnungen her sind das zwei Flags(Bitwerte) die Du vergleichst.

Nein, UCB0IFG ist ein Register.

Daniel S. schrieb:
> //-- Setup I2C ports
>     P1SEL1 &= ~BIT3;                // P1.3 = SCL
>     P1SEL0 |= BIT3;
>     P1SEL1 &= ~BIT2;                // P1.2 = SDA
>     P1SEL0 |= BIT2;

Hast du auch LOCKLPM5 gelöscht?

> while (UCB0STAT & UCBBUSY); // wait until UCB0 not busy

UCBBUSY verrät dir nicht, ob du auf die Register zugreifen darfst. Hier 
solltest du UCTXSTP abfragen (am Ende der Funktion ist das dann nicht 
notwendig).

>     UCB0CTL1 |= UCTR | UCTXSTT; // transmitter mode and START condition.
>     while (UCB0CTL1 & UCTXSTT); // wait for start to be sent

Das Flag, das dir sagt, dass du in TXBUF schreiben kannst, ist UCTXIFG.
Und du solltest auch auf UCNACKIFG testen.

>     UCB0TXBUF = reg_addr;       // send register address
>     while ((UCB0IFG & UCTXIFG));// wait for tx buffer to be empty

Der Kommentar ist falsch. Hier brauchst du nicht zu warten, und TXIFG 
wurde durch das Schreiben eh gelöscht.

>     UCB0CTL1 |= UCTXSTP;        // send stop bit

Das Stop-Bit brauchst du hier nicht (repeated start). Und wenn du es 
trotzdem setzt, musst du wahrscheinlich warten.

>     UCB0CTL1 &= ~UCTR;          // receiver mode
>     UCB0CTL1 |= UCTXSTT;        // START condition
>     while (UCB0CTL1 & UCTXSTT); // wait for start to be sent

UCTXSTT ist auch hier sinnlos; einfach auf UCRXIFG oder UCNACKIFG 
warten.

[Daniel S. (snipod)]

Hallo,
alles klar ich bin etwas weiter gekommen...

Habe wie Ihr geschrieben habt festgestellt, dass ich bisschen Register 
und Masken Gulasch hatte :)

Das sollte soweit jetzt passen, laufen will es aber noch immer nicht 
richtig.

uint8_t I2C_Read_Byte(uint8_t address, uint8_t *value) {
    while(UCB0CTL1 & UCTXSTP);      // wait for previous transaction to complete

    UCB0CTL1 |= (UCTR | UCTXSTT);   // transmitter mode + START

    while(!(UCB0IFG & UCTXIFG));    // wait for Tx Buffer


    if(UCB0IFG & UCNACKIFG)         // check for NACK
    {
        return UCB0STAT;
    }

    UCB0TXBUF = address;            // write register address

    while(!(UCB0IFG & UCTXIFG));    // wait for Tx Buffer

    if(UCB0IFG & UCNACKIFG)         // check for NACK
    {
        return UCB0STAT;
    }

    UCB0CTL1 &= ~UCTR;              // Receiver Mode
    UCB0CTL1 |= UCTXSTT;            // send Start

    //while(UCB0CTL1 & UCTXSTT);      // wait for START signal to be sent

    while (!(UCB0IFG & UCRXIFG));   // wait for RX Buffer

    UCB0CTL1 |= UCTXSTP;            // Transmit STOP
    *value = UCB0RXBUF;             // read RX data

    return 0;
}

Leider will der Controller immer 1 byte mehr lesen als ich - und ich hab 
keinen Plan warum...



Clemens L. schrieb:
> Hast du auch LOCKLPM5 gelöscht?

Ja


Irgendwann kackt mir dann der VL54L0X ab und SCL bleibt Low

[Clemens L. (c_l)]

>     while(!(UCB0IFG & UCTXIFG));    // wait for Tx Buffer
>     if(UCB0IFG & UCNACKIFG)         // check for NACK

Wenn nur UCNACKIFG gesetzt ist, dann wird die Schleife nie beendet.

>     if(UCB0IFG & UCNACKIFG)         // check for NACK
>         return UCB0STAT;

UCB0STAT ist wahrscheinlich 0. Du solltest hier UCB0IFG oder einen 
Fehlercode zurückliefern.

>     UCB0CTL1 |= UCTXSTT;            // send Start
>     while (!(UCB0IFG & UCRXIFG));   // wait for RX Buffer
>     UCB0CTL1 |= UCTXSTP;            // Transmit STOP

UCTXSTP muss gesetzt werden, before das letzte Byte empfangen wird. 
Also:

    UCB0CTL1 |= UCTXSTT | UCTXSTP;  // send Start and Stop

[Daniel S. (snipod)]

Hi,
danke für die Antwort;

Clemens L. schrieb:
> UCTXSTP muss gesetzt werden, before das letzte Byte empfangen wird.
> Also:    UCB0CTL1 |= UCTXSTT | UCTXSTP;  // send Start and Stop

nicht nur das, man muss warte, bis START gesendet wurde und erst danach 
das STOP bit setzen.

 UCB0CTL1 |= UCTXSTT;                                        // send Repeated Start
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    UCB0CTL1 |= UCTXSTP;                                        // send STOP
    while (!((UCB0IFG & UCRXIFG)));                             // wait for RX Buffer
    *value = UCB0RXBUF;                                         // read RX data

Das hat soweit auch funktioniert, nur irgendwann hatte ich dann immer 
"alte" Daten im RxBuffer, also ich habe die Funktion I2C_Read_Byte() 
ausgefürt, habe auf dem Logic Analyzer auch gesehen, welche Bytes 
gelesen und gesendet wurden, habe aber aus dem UCB0RXBUF immer den Wert 
der jeweils vorherigen Transaktion bekommen. Ich habe das Problem jetzt 
erst mal umschifft, indem ich den eUSCIB nach jeder Transaktion resette, 
aber das ist ja eigentlich auch nicht des Rätsels Lösung... Vielleicht 
findet ja noch jemand den Fehler in meinem I2C Wrapper....

void i2cInit()
{
    UCB0CTLW0 |= UCSWRST;       // put into SW Reset
    UCB0CTLW0 |= UCSSEL_3;      // choose SMCLK
    UCB0BRW = 20;               // set prescaler = 20 => 400 kHz
    UCB0CTLW0 |= UCMODE_3;      // put into I2C Mode
    UCB0CTLW0 |= UCMST;         // put into MASTER mode
    UCB0CTLW0 |= UCSYNC;        //
    UCB0I2CSA = 0x29;           // slave addr = 0x29


    P1SEL1 &= ~BIT3;            // P1.3 = SCL
    P1SEL0 |= BIT3;

    P1SEL1 &= ~BIT2;            // P1.2 = SDA
    P1SEL0 |= BIT2;

    UCB0CTLW0 &= ~UCSWRST;      // get out of SW Reset
}

void i2cReset() {
    UCB0CTLW0 |= UCSWRST;       // put into SW Reset
    UCB0CTLW0 &= ~UCSWRST;      // get out of SW Reset
}


uint8_t I2C_Read_Byte(uint8_t address, uint8_t *value) {

    UCB0CTL1 |= UCTR | UCTXSTT;                                 // transmitter mode + START
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)                                     // check for NACK
    {
        return 1;
    }
    UCB0TXBUF = address;                                        // write register address
    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)                                     // check for NACK
    {
        return 2;
    }
    UCB0CTL1 &= ~UCTR;                                          // Receiver Mode
    UCB0CTL1 |= UCTXSTT;                                        // send Repeated Start
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    UCB0CTL1 |= UCTXSTP;                                        // send STOP
    while (!((UCB0IFG & UCRXIFG)));                             // wait for RX Buffer
    *value = UCB0RXBUF;                                         // read RX data
    while(UCB0CTL1 & UCTXSTP);                                  // wait for previous transaction to complete
    i2cReset();

    return 0;
}

uint8_t I2C_Read_Bytes(uint8_t address, uint8_t *value, uint8_t length)
{
    uint8_t i = 0;

    UCB0CTL1 |= UCTR | UCTXSTT;                                 // transmitter mode + START
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)                                     // check for NACK
    {
       return 1;
    }
    UCB0TXBUF = address;                                        // write register address
    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)                                     // check for NACK
    {
       return 2;
    }

    UCB0CTL1 &= ~UCTR;                                          // Receiver Mode
    UCB0CTL1 |= UCTXSTT;                                        // send Start
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    do
    {
        while(!(UCB0IFG & UCRXIFG));                            // wait for Rx Buffer
        value[i] = UCB0RXBUF;                                   // read RX Buffer
        i++;
    }while(i < (length - 1));

    while(!(UCB0IFG & UCRXIFG));                                // wait for Rx Buffer

    UCB0IFG &= ~UCTXIFG;
    UCB0CTL1 |= UCTXSTP;
    value[length - 1] = UCB0RXBUF;
    while(UCB0CTL1 & UCTXSTP);                                  // wait for previous transaction to complete
    i2cReset();
    return 0;
}

uint8_t I2C_Write_Byte(uint8_t address, uint8_t value)
{
    UCB0CTL1 |= (UCTR | UCTXSTT);
    while(UCB0CTL1 & UCTXSTT) ;                                 // wait for START
    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)                                     // check for NACK
    {
        return 1;
    }

    UCB0TXBUF = address;

    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)         // check for NACK
    {
        return 2;
    }

    UCB0TXBUF = value;

    while(!((UCB0IFG & UCTXIFG) || (UCB0IFG & UCNACKIFG)));     // wait for Tx Buffer
    if(UCB0IFG & UCNACKIFG)         // check for NACK
    {
        return 3;
    }
    UCB0CTL1 |= UCTXSTP;
    while(UCB0CTL1 & UCTXSTP);                                  // wait for previous transaction to complete
    i2cReset();
    return 0;
}

[Clemens L. (c_l)]

Wenn UCB0RXBUF ein noch nicht vom Code gelesenes Byte enthält, dann wird 
UCRXIFG gesetzt. Kannst du testen, wann es zuerst gesetzt wird? Schon 
vor dem Aufruf von I2C_Read_Byte, oder später?