MSP430 I2C Senden und Empfangen Problem

[MSPler (Gast)]

Hallo zusammen,

ich sitze nun seit Tagen an folgendem Problem:

-- Ich habe das I2C Modul im MSP430FR5729 konfiguriert
-- Ich kann ein Byte Senden und zwei Byte empfangen.

ABER: Das kann ich nur getrennt voneinander. Sobald ich den Code wie 
unten schreibe (erste ein Byte senden,
danach nur noch empfangen) wird vom Slave ein NACK gesendet und die 
Kommunkation bricht ab.

Ich habe schon diverse Taktraten ausprobiert, Delays eingebaut, etc. 
aber ohne Erfolg.

Hat Jemand schon mal mit einem ähnlichen Problem zu tun gehabt?

Viele Grüße,
MSPler

#include <msp430.h>
#include "init.h"

unsigned char *pTXData         = 0x0;      // Pointer to TX data
unsigned char TXByteCounter    = 0;
unsigned char *pRXData         = 0x0;      // Pointer to RX data
unsigned char RXByteCounter    = 0;
volatile unsigned int TEMP     = 0;
volatile float celsius         = 0;

void receive();
void transmit();
void i2c_master_receiver();
void i2c_master_transmitter()

int main(void)
{
  msp430fr5729_ports();
  msp430fr5729_clock();

  //Transmit
  i2c_master_transmitter();
  __enable_interrupt();
  transmit();

  //Receive
  __disable_interrupt();
  i2c_master_receiver();
  __enable_interrupt();



    while(1)
    {
      receive();
    }

}


//===================================================================================//
// ISR2: USCIB0_ISR
//===================================================================================//
#pragma vector = USCI_B0_VECTOR
__interrupt void USCIB0_ISR(void)
{
  switch(__even_in_range(UCB0IV,12))
  {
        case 0x04:
              UCB0CTLW0 |= UCTXSTT;                   // Resend start if NACK
              break;                                  // Vector 4: NACKIFG break;
        case 0x16:
               RXByteCounter--;                          // Decrement RX byte counter

               if (RXByteCounter)
               {
                 *pRXData++= UCB0RXBUF;                // Multiple bytes left to receive
               }
               else
               {
                 *pRXData= UCB0RXBUF;                  // Last byte to be received
                 __bic_SR_register_on_exit(LPM0_bits);    // Exit LPM0
                 RXFlag = FLAG_SUCCESS;          // Set Data Received RX Flag to success
               }

               if(RXByteCounter == 1)                   // Only one byte left?
                  UCB0CTL1 |= UCTXSTP;                    // Generate I2C stop condition
                                                          // If reading only 1 byte, stop condition
                                                          // should have already been sent
              // Receive and calculate temperature
               slave_temperature = i2c_Data_From_Slave[1] << 8 | i2c_Data_From_Slave[0];
               celsius = ((slave_temperature-2730)/10);
                    break;                     // Vector 24: RXIFG0 break;

        case 0x18:
              if (TXByteCounter)              // If there's something to transmit
              {
                    UCB0TXBUF = 0x08;*pTXData++;            // Load TX buffer
                    TXByteCounter--;                      // Decrement TX byte counter
                    TXFlag = FLAG_SUCCESS;
                }
                else
                {
                  UCB0CTL1 |= UCTXSTP;                    // I2C stop condition
                  UCB0IFG &= ~UCTXIFG;                    // Clear USCI_B0 TX int flag
                  __bic_SR_register_on_exit(LPM0_bits);   // Exit LPM0
                  TXFlag = FLAG_SUCCESS;
                }

              break;                                  // Vector 26: TXIFG0 break;
        default:     break;
  }
}


//===================================================================================//
// FUNCTION: i2c_MASTER_TRANSMITTER
//===================================================================================//
void i2c_master_transmitter()
{
  UCB0CTL1 |= UCSWRST;                          // Enable SW reset
  UCB0CTLW0 = UCMST + UCMODE_3 + UCSYNC;         // I2C Master, synchronous mode
  UCB0CTL1 = UCSSEL_2 + UCSWRST;                // Use SMCLK, keep SW reset
  UCB0BR0 = 0;                                 // fSCL = SMCLK/256 ~ 100kHz
  UCB0BR1 = 1;                  // Buad Rate Prescalar = UCB1BR1 * 256 + UCB1BR0
  UCB0I2CSA = i2c_BATTERY_ADDRESS;              // Assign Slave Address
  UCB0CTL1 &= ~UCSWRST;                        // Clear SW reset, resume operation
  UCB0IE |= UCTXIE + UCRXIE + UCNACKIE;         // Enable TX, RX, NACK interrupt
}

//===================================================================================//
// FUNCTION: TRANSMIT
//===================================================================================//
void transmit()
{
    __delay_cycles(1000);                     // Delay between transmissions
    TXByteCounter = 1;                          // Load TX byte counter
    while (UCB0CTLW0 & UCTXSTP);              // Ensure stop condition got sent
    UCB0CTLW0 |= UCTR + UCTXSTT;              // I2C TX, start condition

    __bis_SR_register(CPUOFF + GIE);          // Enter LPM0 w/ interrupts
}


//===================================================================================//
// FUNCTION: i2c_MASTER_TRANSMITTER
//===================================================================================//
void i2c_master_receiver()
{
    UCB0CTLW0 |= UCSWRST;                  // Software reset enabled
    UCB0CTLW0 |= UCMODE_3  + UCMST + UCSYNC;  // I2C mode, Master mode, sync
    UCB0CTLW1 |= UCASTP_2;              // Automatic stop generated
                                              // After UCB0TBCNT is reached
    UCB0BR0 = 0;                               // fSCL = SMCLK/256 ~ 100kHz
    UCB0BR1 = 1;                // Buad Rate Prescalar = UCB1BR1 * 256 + UCB1BR0
    UCB0I2CSA  = i2c_BATTERY_ADDRESS;        // Slave address
    UCB0CTL1  &=~UCSWRST;
    UCB0IE    |= UCRXIE+UCNACKIE+UCBCNTIE;
}


//===================================================================================//
// FUNCTION: RECEIVE
//===================================================================================//
void receive()
{
    __delay_cycles(2000);
    pRXData = (unsigned char *) i2c_Data_From_Slave;
    RXByteCounter = 2;                              // Load RX byte counter
    while (UCB0CTL1 & UCTXSTP);                   // Ensure stop condition got sent
    UCB0CTL1 |= UCTXSTT;                          // I2C start condition

    __bis_SR_register(CPUOFF+GIE);                // Enter LPM0 w/ interrupt
}

[Klaus R. (klara)]

Hallo,
nimm am Anfang ein simples Device wie den PCF8574 als Slave. Der ist so 
ziemlich das unkritischste Device. Wenn dann Deine Kommunikation läuft, 
gehe einen Schritt weiter. Arbeite anfangs mit kleineren Taktraten und 
kurzen Leitungslängen.
mfg klaus.