I2C-Verbindung zwischen zwei MSP430 Mikrocontrollern

[Thiemo B. (thiemo87)]

Hallo,

wir sollen für das Mikrocontroller-Labor an der Hochschule eine 
Kommunikation zwischen zwei Controllern (MSP430F5438) über I2C 
herstellen.
Da ich sehr wenig Erfahrung mit der Pogrammierung eines Mikrocontrollers 
habe, möchte ich erst einmal ein Zeichen von Slave zu Master senden.
Dazu habe ich mir die TI-Examples msp430x54xA_uscib0_i2c_04 und _05.c 
angeschaut und vereinfacht.

Die Initialisierung habe ich soweit verstanden.
Bei den Start- / Stoppbedingungen innerhalb der for-Schleifen bin ich 
mir ziemlich unsicher. Wie genau verwendet man diese?
Kann die Übertragung mit den beiden Codes so funktionieren?

Danke schonmal!

Viele Grüße
Thiemo

// *******************
//     MASTER-CODE
// *******************

#include <msp430.h>

unsigned char EmpfZeichen;

int main(void)
{
  WDTCTL = WDTPW + WDTHOLD;              // Watchdog aus
  P3SEL |= 0x06;                         // P3.1 und P3.2 für I2C
  UCB0CTL1 |= UCSWRST;                   // en Softwarerese zur
                                         // Initialisierung
  UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC;  // Master, synchrone Übertragung
  UCB0CTL1 = UCSSEL_2 + UCSWRST;         // Taktquelle: SMCLK
  UCB0BR0 = 0x12;                        // Einstellungen zur Übertragung
  UCB0BR1 = 0x00;
  UCB0I2CSA = 0x48;                      // Slave-Adresse = 0x48
  UCB0CTL1 &= ~UCSWRST;                  // clr Softwarerest, da Init.
                                         //  fertig
  UCB0IE |= UCRXIE;                      // en empf. Interrupt

  for(;;)
  {
    while (UCB0CTL1 & UCTXSTP);          // Stopp-Bed. gesendet?
    UCB0CTL1 |= UCTXSTT;                 // Start-Bed.

    while (UCB0CTL1 & UCTXSTP);          // Start-Bed. gesendet?
    UCB0CTL1 |= UCTXSTP;                 // Stopp-Bed.

    EmpfZeichen = UCB0RXBUF;             // Empfangenes Zeichen in
                                         // EmpfZeichen ablegen
  }
}

// *******************
//     SLAVE-CODE
// *******************

#include <msp430.h>

unsigned char GesZeichen;

int main(void)
{
  WDTCTL = WDTPW + WDTHOLD;              // Watchdog aus
  P3SEL |= 0x06;                         // P3.1 und P3.2 für I2C
  UCB0CTL1 |= UCSWRST;                   // en Softwarerese zur 
                                         // Initialisierung
  UCB0CTL0 = UCMODE_3 + UCSYNC;          // Slave, synchrone Übertragung
  UCB0I2COA = 0x48;                      // eigene Adresse des Slave (0x48)
  UCB0CTL1 &= ~UCSWRST;                  // clr Softwarerest, da
                                         // Init. fertig
  UCB0IE |= UCTXIE+UCSTTIE+UCSTPIE;      // en send. Interrupt 

  GesZeichen = 'A';

  for(;;)
  {
    UCB0IFG &= ~UCSTTIFG;     // Start-Bed.    

    UCB0TXBUF = GesZeichen;   // Sende 'A' an Master

    UCB0IFG &= ~UCSTPIFG;     // Stopp-Bed
  }
}

[Rufus Τ. F. (rufus)]

Thiemo B. schrieb:
> for(;;)
>   {
>     UCB0IFG &= ~UCSTTIFG;     // Start-Bed.
>
>     UCB0TXBUF = GesZeichen;   // Sende 'A' an Master
>
>     UCB0IFG &= ~UCSTPIFG;     // Stopp-Bed
>   }

Das wird so sicher nicht funktionieren. Überlege mal, wie schnell diese 
Schleife durchlaufen wird, und überlege, wie lange es dauert, ein 
einzelnes Byte per I2C zu übertragen. Du stopfst also ständig neue 
Zeichen in die USCI, ohne darauf zu warten, daß sie mit dem Übertragen 
fertig wird.

Sieh Dir also nochmal genau den Code im TI-Beispiel an.

[Peter D. (peda)]

Ich würde vermeiden, 2 Baustellen gleichzeitig zu öffnen.

Daher zuerst mal den Master machen und nen PCF8574 lesen und schreiben.
Und dann einen Slave, der den PCF8574 emuliert.


Peter

[Thiemo B. (thiemo87)]

Rufus Τ. Firefly schrieb:
> Sieh Dir also nochmal genau den Code im TI-Beispiel an.

Danke für die schnelle Antwort!
Habe es mir noch einmal angeschaut und wie folgt verbessert:

  for(;;)
  {
    if (UCB0IV == 0x06)    // Start-Bed. erhalten?
       UCB0IFG &= ~UCSTTIFG;  // dann clr Start-Bed. Int-Flag

    if (UCB0IV == 0x08)    // Stopp-Bed. erhalten?
       UCB0IFG &= ~UCSTPIFG;  // dann clr Stopp-Bed. Int-Flag

    if (UCB0IV == 0x0C)    // Sende-Puffer leer?
       UCB0TXBUF = GesZeichen;  // dann sende Zeichen
  }

Habe auch den Master-Code so korrigiert, dass das Zeichen nur dann in 
'EmpfZeichen' geschrieben wird, wenn wirklich Daten empfangen wurden:

    if (UCB0IV == 0x0A)            // wenn Daten empfangen, dann lege
      EmpfZeichen = UCB0RXBUF;     // Empfangenes Zeichen in EmpfZeichen ab

Ist das richtig so oder habe ich noch etwas übersehen oder vergessen?

Grüße
Thiemo

[Thiemo B. (thiemo87)]

@ Peter
Das hatte ich auch vor. Habe allerdings nur zur "Labor-Zeit" Zugang zu 
den Controllern und die Kommunikation soll bis Dienstag laufen...