MSP430G2232 USI I2C Slave

[fluxi (Gast)]

Hallo,

ich habe ein Problem mit meinem MSP430G2232. Und zwar habe ich von TI 
ein Code-Example verwendet und ein wenig umgebaut. Mein Ziel ist es, 
dass der MSP430 z.b. 2 Bytes empfängt (1 Kommando, 1 Wert) und die 
beiden Bytes in ein Array/Variable abspeichert um diese dann in der main 
Funktion weiter zu verarbeiten.
Ich bin noch ganz neu auf diesem Gebiet.
Die Kommunikation von I2C funktioniert. Habe das Senden und Empfangen 
mit meinem Oszi gemessen. Nur das speichern der gesendeten und 
empfangenen Werte machen mir Probleme. Wahrscheinlich habe ich irgendwo 
einen Denkfehler, vllt. könnt ihr mir auf die Sprünge helfen.

Vielen Dank!

#pragma vector = USI_VECTOR
__interrupt void USI_ISR (void)
{  
  if (USICTL1 & USISTTIFG)
  {
    I2C_State = 2;            // Enter 1st state on start
  }
  
  switch (I2C_State)
  {
    /* Idle */
    case 0:
      break;
    
    /* RX address */  
    case 2:
      USICNT = (USIIFGCC | 0x08);    // Stop auto clr USIIFG, read 8 bits
      USICTL1 &= ~USISTTIFG;      // Clear start flag
      I2C_State = 4;          // Next state: check addres
      break;
    
    /* Check address and send (N)ACK */  
    case 4:
      if (USISRL & 0x01)        // If Master read...
      {
        slv_addr = rd_addr;      // Save R/W bit
        transmit = 1;
      }
      else
      {
        slv_addr = 0x60;
        transmit = 0;
      }  
      
      USICTL0 |= USIOE;        // SDA = Output
      
      if (USISRL == slv_addr)      // Address match?
      {
        USISRL = 0x00;        // Send ACK
        
        if (transmit == 0)
        {
          I2C_State = 6;      // Next state: RX data
        }
        else
        {
          I2C_State = 10;      // Next state: TX data
        }
      }
      else
      {
        USISRL = 0xFF;        // Send NACK
        I2C_State = 8;
      }
      
      USICNT |= 0x01;          // Bit counter = 1, send (N)ACK bit
      break;
    
    /* RX data byte */  
    case 6:
      RX_Data ();
      break;
    
    /* Check data & TX (N)ACK */
    case 8:
      USICTL0 |= USIOE;        // SDA = Output
      if(ByteCtr <= NUM_BYTES)
      {
        USISRL = 0x00;        // Send ACK
        I2C_State = 6;        // RX another byte
        ByteCtr++;
        USICNT |= 0x01;        // Bit counter = 1, send (N)ACK
//        
      }
      else
      {
        USISRL = 0xFF;        // Send NACK
        USICTL0 &= ~USIOE;      // SDA = Input
        I2C_State = 0;        // Reset state machine
        ByteCtr = 0;        // Reset counter for next TX/RX
//        
      }
      break;
      
    /* TX data byte */
    case 10:
      TX_Data ();
      break;
    
    /* Receive (N)ACK */
    case 12:
      USICTL0 &= ~USIOE;        // SDA = Input
      USICNT |= 0x01;          // Bit counter = 1, receive (N)ACK
      I2C_State = 14;          // Next state: check (N)ACK
      break;
    
    /* Process Data ACK/NACK */  
    case 14:
      if (USISRL & 0x01)        // If NACK received...
      {
        USICTL0 &= ~USIOE;      // SDA = input
        slv_addr = 0x60;
        I2C_State = 0;        // Reset state machine
        ByteCtr = 0;        // Reset counter
      }
      else
      {
        TX_Data ();          // TX next byte
      }
      break;
  }
  
  USICTL1 &= ~USIIFG;            // Clear pending flags
}

/* Receive data over I2C */
static void RX_Data (void)
{
  USICTL0 &= ~USIOE;    // SDA = Input
  USICNT |= 0x08;      // Bit counter = 8
  RxBuffer[RXByteCtr] = USISRL;
  RXByteCtr++;
  I2C_State = 8;      // Test data and send (N)ACK
}

/* Transmit data over I2C */
static void TX_Data (void)
{
  USICTL0 |= USIOE;    // SDA = Output
  USISRL = TxBuffer[TXByteCtr];
  TXByteCtr++;
  USICNT |= 0x08;      // Bit counter = 8
  I2C_State = 12;      // Receive (N)ACK
}

[Krapao (Gast)]

> und die beiden Bytes in ein Array/Variable abspeichert um diese dann in
> der main Funktion weiter zu verarbeiten.

int main(void)
{
  DATENTYP1 idx = 0; // To do: gleicher DATENTYP wie RXByteCtr 
  DATENTYP2 b; // To do: gleicher DATENTYP wie ein Element von RxBuffer[]

  while(1)
  {
    if ( idx < RXByteCtr )
    {
      b = RxBuffer[idx++];
      // To do: Was mit b machen
    }
    else
    {
      // To do: IRQ USI_ISR sperren
      RXByteCtr = 0; // I2C RX Puffer zurücksetzen
      // To do: IRQ USI_ISR freigeben
      idx = 0;
    }
  }  
}

[fluxi (Gast)]

Danke für den Denkanstoß, werde ich nachher mal ausprobieren.
Sind denn die RX_Data und TX_Data Funktionen korrekt und funktioniert 
das mit

RxBuffer[RXByteCtr] = USISRL;

USISRL = TxBuffer[TXByteCtr];

 korrekt oder habe ich etwas übersehen?