wie Daten an MSP430F1611 seriell einlesen?

Temp_celsius = ((float)temperatur / 2047 * 200) - 50;

int main (void) {

  uint16_t temperatur;  // 11-bit temperature value

  uint8_t returnvalue;  // return value of getTSicTemp(*temp);

  uint8_t Temp_celsius; // converted temperature in °C

  TSIC_INIT();          // set data direction of IO-Pins

  while(1){

    returnvalue = getTSicTemp(&temperatur);  // pull the TSIC-Sensor

    // conversion equation from TSic's data sheet

    Temp_celsius = ((float)temperatur / 2047 * 200) - 50;

// Definitionen

// lcd-anschlussbelegung

#define LCD_PORT  PORTC

#define LCD_DDR    DDRC

#define LCD_DB    PC0

#define LCD_E    PC4

#define LCD_RS    PC5

// INCLUDE

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include <stdint.h>

#include "lcd_steuerung.h"

#include "tempsensor_ansteuerung.h"

// MAIN

void main (void)

  {

      lcd_init();

    // Temperturmessung mit TSIC ausführen und Daten auf dem LCD ausgeben

      while(1)

      {

      unsigned char parity = 0; // referenz für 2. übergabewert

      uint16_t wert = 0;

      lcd_string("WERT:;");

      wert = temp_messung(&parity);  //temp_byte = übergabe

      lcd_zahl_16(wert);

      lcd_cursor(0,2);

      lcd_string("parity:;");

      lcd_zahl_8(parity);

      _delay_ms(500);

      lcd_befehl(1);

      //ende while

      //33246 bei 20°C      

      }

    while(1){};

  }

// LCD_FUNKTIONEN

/* ansteuerung eines LC-Displays im 4bit modus.

   Wartezeiten nach Datenblatt, Pinbelegung einsellbar. 

// Definitionen

// lcd-anschlussbelegung

#define LCD_PORT  PORTC

#define LCD_DDR    DDRC

#define LCD_DB    PC0

#define LCD_E    PC4

#define LCD_RS    PC5

*/

// lcd-Befehle

// clear display----------------0b00000001

#define lcd_display_löschen    0x01

// cursor bewegen

#define LCD_CURSOR_HOME      0x02

// DDRAM - Adresse festelgen

#define LCD_DDRAM        0x80

/* lcd-adressen für die Zeilen

   angaben sind für ein 4x20 Zeichen lcd.

   bei anderen auflösungen müssen die werte angepasst werden.

*/

#define lcd_cursor_1zeile    0x00

#define lcd_cursor_2zeile    0x40

#define lcd_cursor_3zeile    0x14

#define lcd_cursor_4zeile    0x54

///////////////////////////////////////////

// LCD-INITIALISIEREN

void lcd_init(void)

  {

    unsigned char zaehler = 1;

    LCD_DDR = 0xff;        // PORTC = ausgang

    _delay_ms(15);         // 15 ms warten

    LCD_PORT = 0x3;        // PORTC = 0x03

    while(zaehler <= 3)      // 3-mal enable

      {

        lcd_enable();    //enable 

        zaehler++;      //Zähl-Variable +1

      }

    // 4-bit modus

    LCD_PORT = 0x2;

    lcd_enable();

    // 4-bit, 2-Zeilig, 5x8 matrix 

    lcd_befehl(0x28);

    // display ein, cursor aus, blinken aus

    lcd_befehl(0x0f);

    //cursor inkrement, kein scrollen

    lcd_befehl(0x06);

    //lcd löschen

    lcd_befehl(0x01);

  }

///////////////////////////////////////////

// LCD_ENABLE

void lcd_enable(void)

  {

      LCD_PORT |= ( 1 << LCD_E );    //E-Setzen

      _delay_us(50);          //50µS warten

      LCD_PORT &= ~( 1 << LCD_E );  //E-rücksetzen

      _delay_ms(5);          //5ms warten

  }  

///////////////////////////////////////////

// LCD DATEN senden

void lcd_daten(uint8_t data)

  {

      LCD_PORT |= (1 << LCD_RS);      //RS setzen

      uint8_t u_nibble = data & 0x0f;    //unteres nibble

      data &= 0xf0;            //nur die obersten 4 bit maskieren

      LCD_PORT &= ~(0xf0 >> (4-LCD_DB));  //untere 4 bits löschen

      LCD_PORT |= (data >> (4-LCD_DB));  //obere 4 bits ausgeben

      lcd_enable();            //enable

      LCD_PORT &= ~(0xf0 >> (4-LCD_DB));  //untere 4 bits löschen

      LCD_PORT |= u_nibble;        //untere 4 bit ausgeben

      lcd_enable();            //enable

  }

///////////////////////////////////////////

// LCD BEFEHL senden

void lcd_befehl(uint8_t data)

  {

      LCD_PORT &= ~( 1 << LCD_RS);    //RS löschen

      uint8_t u_nibble = data & 0x0f;    //unteres nibble

      data &= 0xf0;            //nur die obersten 4 bit maskieren

      LCD_PORT &= ~(0xf0 >> (4-LCD_DB));  //untere 4 bits löschen

      LCD_PORT |= (data >> (4-LCD_DB));  //obere 4 bits ausgeben

      lcd_enable();            //enable

      LCD_PORT &= ~(0xf0 >> (4-LCD_DB));  //untere 4 bits löschen

      LCD_PORT |= u_nibble;        //untere 4 bit ausgeben

      lcd_enable();

  }

///////////////////////////////////////////

// LCD_STRING ausgeben

void lcd_string(const char *data)

  {

      while( *data != ';' )

         lcd_daten( *data++ );  

  }

///////////////////////////////////////////

// lcd-cursor postition; x = zeile/horizont, y = spalte/vertikal

void lcd_cursor(uint8_t x, uint8_t y)

  {

      uint8_t zeile;

      switch(y)

        {

          case 1:    // 1 Zeile

            lcd_befehl(LCD_CURSOR_HOME);

            zeile = LCD_DDRAM + lcd_cursor_1zeile + x;

            lcd_befehl(zeile);

            break;

          case 2:    // 2 Zeile

            lcd_befehl(LCD_CURSOR_HOME);

            zeile = LCD_DDRAM + lcd_cursor_2zeile + x;

            lcd_befehl(zeile);

            break;

          case 3:   // 3 Zeile

            lcd_befehl(LCD_CURSOR_HOME);

            zeile = LCD_DDRAM + lcd_cursor_3zeile + x;

            lcd_befehl(zeile);

            break;

          case 4:    // 4 Zeile

            lcd_befehl(LCD_CURSOR_HOME);

            zeile = LCD_DDRAM + lcd_cursor_4zeile + x;

            lcd_befehl(zeile);

            break;

          default:  // eine falsche angabe.

            return;

        }

  }

///////////////////////////////////////////

// 8-bit Zahl in ASCII umwandel und gleich auf dem LCD ausgeben

void lcd_zahl_8(uint8_t zahl)

  {

  if(zahl < 0)

  {

  uint8_t zaehler;

  //100er

  while( zahl > -99)

    { 

      zahl += 100;

      zaehler++;

    }

      if(zaehler != 0)

      {  

        zaehler += 0x30;

        lcd_daten(zaehler);

      }

      zaehler = 0;

    //10er

    while( zahl > -9)

      { 

        zahl += 10;

        zaehler++;

      }

        if(zaehler != 0)

        {

          zaehler += 0x30;

          lcd_daten(zaehler);

        }

      //einer

      zahl += 0x30;

      lcd_daten(zahl);

  }

  uint8_t zaehler;

  //100er

  while( zahl > 99)

    { 

    zahl -= 100;

    zaehler++;

    }

    if(zaehler != 0)

    {  

      zaehler += 0x30;

      lcd_daten(zaehler);

    }

    zaehler = 0;

    //10er

    while( zahl > 9)

      { 

      zahl -= 10;

      zaehler++;

      }

      if(zaehler != 0)

      {

        zaehler += 0x30;

        lcd_daten(zaehler);

      }

      //einer

      zahl += 0x30;

      lcd_daten(zahl);

  }

///////////////////////////////////////////

// 16-bit Zahl in ASCII umwandel und gleich auf dem LCD ausgeben

void lcd_zahl_16(uint16_t zahl)

  {

  uint8_t zaehler;

  //10000er

  while( zahl > 9999)

    { 

    zahl -= 10000;

    zaehler++;

    }

    if(zaehler != 0)

    {

      zaehler += 0x30;

      lcd_daten(zaehler);

    }

    zaehler = 0;

    //1000er

    while( zahl > 999)

      { 

      zahl -= 1000;

      zaehler++;

      }

      if(zaehler != 0)

      {

        zaehler += 0x30;

        lcd_daten(zaehler);

      }

      zaehler = 0;

      //100er

      while( zahl > 99)

        { 

        zahl -= 100;

        zaehler++;

        }

        if(zaehler != 0)

        {  

          zaehler += 0x30;

          lcd_daten(zaehler);

        }

        zaehler = 0;

        //10er

        while( zahl > 9)

          { 

          zahl -= 10;

          zaehler++;

          }

          if(zaehler != 0)

          {

            zaehler += 0x30;

            lcd_daten(zaehler);

          }

          //einer

          zahl += 0x30;

          lcd_daten(zahl);

  }

// TSIC 306

#define steigende_flanke  (PINB & (1 << PB2))    // steigende Flanke bzw. high

#define fallende_flanke    !(PINB & (1 << PB2))  // fallende Flanke bzw. low

#define tsic_on        PORTB |= (1 << PB1)    // Sensor einschalten

#define tsic_off      PORTB &= ~(1 << PB1)  // Sensor ausschalten

#define tsic_delay_us    1            // Flankenzeit des TSIC

unsigned int temp_messung(unsigned char *parity_byte)

{

      uint16_t temp_byte = 0;

      //tempsensor ansteuerung

      //Sensor starten und auf fallende flanke warten

      DDRB = ((1 << PB1) | (1 << PB0));    // PB0, PB1 = eingang

      tsic_on;

      _delay_ms(40);              // Sensor einschalten

      while (fallende_flanke);        // warte auf fallende Flanke

      while (steigende_flanke);        // auf steigende Flanke warten

      for (uint8_t i = 0; i < 8; i++)      // hier nun Bits auswerten

        {

          while (fallende_flanke);    // warten bis zum ersten bit.

          _delay_us(tsic_delay_us);    // 60µSekunden warten

          if (steigende_flanke)      // wenn eingang 1, 

            temp_byte |= 1 << (15-i);  // dann bit schreiben

            else               // wenn nicht,

              while (steigende_flanke);  // dann warten bis flanke wieder steigt, bzw. immernoch eingang = 1.

        }

      // parity auswerten bzw. erstmal abwarten

      while (fallende_flanke);        // Parity_bit

      _delay_us(tsic_delay_us);        // 60µs warten

      if (steigende_flanke)

        *parity_byte |= 1 << 1;        // wenn parity = 1, dann eine 1. eine stelle nach links schieben

        else while (steigende_flanke);    // wenn parity_byte = 0, dann warten bis flanke wieder steigt

      // stoppbit absitzen

      while (fallende_flanke);        // stop bit

      // startbit absitzen

      while (steigende_flanke);        // start bit

      // 2 byte LSB

      for (uint8_t i = 0; i < 8; i++)      // hier nun Bits auswerten

        {

          while (fallende_flanke);    // warten bis zum ersten bit.

          _delay_us(tsic_delay_us);    // 60µSekunden warten

          if (steigende_flanke)      // wenn eingang 0, 

            temp_byte |= 1 << (7-i);  // dann bit schreiben

            else               // wenn nicht,

              while (steigende_flanke);  // dann warten bis flanke wieder steigt, bzw. immernoch eingang = 1.

        }

      // parity auswerten bzw. erstmal abwarten

      while (fallende_flanke);        // Parity_bit

      _delay_us(tsic_delay_us);        // 60µs warten

      if (steigende_flanke)

        *parity_byte |= 1 << 0;        // wenn parity = 1, dann eine 1. 0 stellen nach links schieben

      tsic_off;                // Sensor ausschalten

      return temp_byte;            // gemessenen Wert zurückgeben          

}