MSP430f23x0 + SHT21 und I2C

[Nasenschleim (Gast)]

Hallo,

ich versuche mit Hilfe eines MSP430f2370 einen Temperatur- und 
Feuchtigkeitssensor (SHT21 von Sensirion) auszulesen.
Das komische ist das mal eine I2C-Kommunikation stattfindet und ein 
anderes mal funktionierts wieder nicht. Der Fehler lässt sich auch nicht 
reproduzieren. Nach langem hin und her rätseln/versuchen wollte ich euch 
mal fragen ob ihr durch Zufall einen Fehler im Code entdeckt.

10k Ohm PullUps sind an SDA und SCL dran.

PS: Da der Code noch in der Entwurfsphase ist, schaut er an manchen 
Stellen noch etwas komisch aus.

Ich danke schon mal für jeden kleinen Hinweis.

#include  "msp430x23x0.h"


//Funktionsdeklaration
void warte_ms(unsigned int i);
void ausgeben(unsigned char c[], unsigned char len);
void Reset();
void I2C_schreiben_byte(unsigned char cmd);
void I2C_lesen();

int main(void)
{
  
  unsigned char Ende[2]="00";
  unsigned char Test[5]="TEST-";
  int a=0;

// ---Initialisierung-Start---
  WDTCTL = WDTPW + WDTHOLD;  // Watchdog aus
  BCSCTL3 = XCAP1;      // Clock

  P4DIR = BIT5;               // P4.5 als Ausgang

// UART init
  UCA0CTL1 = UCSWRST;
  UCA0CTL1 |= UCSSEL0;                       // UCLK = ACLK
  UCA0BR0 = 0x03;                            // 32k/2400 - 13.65
  UCA0BR1 = 0x00;
  UCA0MCTL = 0x06;                           // Modulation
  P3SEL |= 0x30;  
  P3DIR |= 0x10;
  P3OUT |= 0x10;
  UCA0CTL1 &= ~(UCSWRST);                    // Initalize USART state machine

// I2C init
  P3SEL |= 0x06;                            // Assign I2C pins to USCI_B0
  UCB0CTL1 |= UCSWRST;                      // Enable SW reset
  UCB0CTL0 = UCMST + UCMODE_3 + UCSYNC;     // I2C Master, synchronous mode
  UCB0CTL1 = UCSSEL_2 + UCSWRST;            // Use SMCLK, keep SW reset  
  UCB0BR0 = 12;                             // fSCL = ACLK/12 = ~100kHz
  UCB0BR1 = 0;
  UCB0I2CSA = 0x40;                         // Set slave address
  UCB0CTL1 &= ~UCSWRST;                     // Clear SW reset, resume operation
 
// TIMER init
  TACCTL0 = CCIE;
  TACTL = TASSEL0 + ID0 + ID1;

  _BIS_SR(GIE);              // Interrupts ein
// ---Initialisierung-Ende---

for (a=0;a<20000;a++)            // Delay fuer Hardwarekonfigurierung
{;}

Ende[0] = '\r';
Ende[1] = '\n';

//ausgeben(Test,5);

//Reset();
//warte_ms(20);  
//
//ausgeben(Test,5);

  while(1)  // Hauptschleife
  {
//    ausgeben(Test,5);
    
    P4OUT &= ~BIT5;        // gelbe LED an
//    I2C_schreiben_byte(0xF3);  // Temp noHOLD-MASTER
    I2C_schreiben_byte(0xE3);  // Temp HOLD-MASTER
    I2C_lesen();
    P4OUT |= BIT5;        // gelbe LED aus
    
//    ausgeben(Test,5);
    
    warte_ms(50);
    
    P4OUT &= ~BIT5;        // gelbe LED an
//    I2C_schreiben_byte(0xF5);  // RH noHold-Master
    I2C_schreiben_byte(0xE5);  // RH Hold-Master  
    I2C_lesen();
    P4OUT |= BIT5;        // gelbe LED aus
    
    ausgeben(Ende,2);

  }

}

#pragma vector = TIMERA0_VECTOR    // ISR-TIMERA0
__interrupt void Timer_A (void)
{
  TACTL &= ~(MC0);
  TAR=0;
  TAIV = 0;
  LPM0_EXIT;                // Exit LPM0 um mit Programmausführung fortzufahren
}

//---------------------------------------------------------------------------------
// ausgelagerte Funktionen

void warte_ms(unsigned int i)
{
  if(i>=4)
  {
  TACCR0 = (i<<2);
  TACTL |= MC0;
  _BIS_SR(LPM0);
  }
  else
  {
    TACCR0 = (4<<2);
    TACTL |= MC0;
    _BIS_SR(LPM0);
  }
}

void ausgeben(unsigned char c[], unsigned char len)
{
  unsigned char i=0;
  while(i<len)
  {
    while (!(IFG2 & UCA0TXIFG));  // USART0 TX buffer ready?
      UCA0TXBUF = c[i];
    i++;
    while(UCBUSY & UCA0STAT);
  }
}

void Reset()  // Sensor Reset
{
  UCB0I2CSA = 0x40;                   // Slave Address 
  UCB0CTL1 |= UCTR + UCTXSTT;         // I2C TX, Start senden
  UCB0TXBUF = 0xFE;
  
  while((UCB0CTL1 & UCTXSTT) && !(UCB0STAT & UCNACKIFG));      // Warten bis Start und Adresse gesendet  

  UCB0CTL1 |= UCTXSTP;              // Stop senden
  while(UCB0CTL1 & UCTXSTP);          // Warten bis Stop gesendet  
}

void I2C_schreiben_byte(unsigned char cmd)
{

  UCB0I2CSA = 0x40;                   // Slave Address 
  UCB0CTL1 |= UCTR + UCTXSTT;         // I2C TX, Start senden
  UCB0TXBUF = cmd;
  
  while((UCB0CTL1 & UCTXSTT) && !(UCB0STAT & UCNACKIFG));      // Warten bis Start und Adresse gesendet  
  
  // Kein stop senden
}

// Temperatur oder RH lesen
void I2C_lesen()
{
  unsigned int i=0;
  unsigned char j=0;
  unsigned char Daten[3] = "000";
  
  UCB0I2CSA = 0x40;                    // Slave Address 
  
  UCB0CTL1 &=~UCTR;                   // I2C RX
  UCB0CTL1 |= UCTXSTT;                // Start senden
  while((UCB0CTL1 & UCTXSTT) && !(UCB0STAT & UCNACKIFG));      // Warten bis Start und Adresse gesendet  
  
  for (i=0; i<3; i++)
  {
      while (!(IFG2 & UCB0RXIFG));      // Buffer bereit?
//    Daten[i] = UCB0RXBUF;
     
      if(i==0)            // erstmal ohne Schleifenindex + Array-Index
      {Daten[0] = UCB0RXBUF;}
      if(i==1)
      {Daten[1] = UCB0RXBUF;
      UCB0CTL1 |= UCTXSTP;    // beim vorletzten Byte stop senden
      }
      if(i==2)
      {Daten[2] = UCB0RXBUF;}
   }
  
//  UCB0CTL1 |= UCTXSTP;            // Stop senden
  while(UCB0CTL1 & UCTXSTP);                    // Warten bis Stop gesendet
  
  // gleich Daten uebertragen
  while(j<3)
  {
    while (!(IFG2 & UCA0TXIFG));  // USART0 TX buffer ready?
      UCA0TXBUF = Daten[j];
    j++;
    while(UCBUSY & UCA0STAT);
  }
  
//  IFG2 &= ~UCB0RXIFG;    // Clear receive interruptflag
}

[Daniel S. (nasenschleim)]

Sorry, hätte den Code mal lieber als Anhang machen sollen.
Kommt nicht wieder vor.