MSP430f23x0 + SHT21 und I2C

#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

}