Verarbeitung/Weitergabe dreier gewandelter Messwerte

#include <avr/io.h>

#include <stdlib.h>

#ifndef F_CPU

#define F_CPU 8000000

#endif

#define UART_UBRR_CALC(BAUD_,FREQ_) ((FREQ_)/((BAUD_)*16L)-1)       //Definition der Frequnz des Baudratenregisters

#define UART_BAUD_RATE 9600                         //Baudrate einstellen

//Definieren der Variablen

//uint8_t  data  = 0;//

uint8_t  h  = 0;  

uint8_t  i  = 0;

uint16_t z  = 0; 

uint16_t  sensor_X = 0;

uint16_t  sensor_Y=  0;

uint16_t  sensor_Z=  0;

char ident_sensor;

//USART initalisieren nach Handbuch Atmega8, S.138ff

#define FOSC 1843200    

// Clock Speed

//Wie auch in der Systemsteuerung

#define BAUD 9600  

#define MYUBRR FOSC/16/BAUD - 1

void USART_Init ( unsigned int ubrr )

  {

  // Setzen der Baud-Rate

  UBRRH = (unsigned char) (ubrr>>8);

  UBRRL = (unsigned char)  ubrr;

  //"Anschalten" von Reciever und Transmitter

  UCSRB = (1<<RXEN)|(1<<TXEN);

  //"FRAME_FOMAT" : 8data, 2 stop - bits

  UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);

  }

void main (void) 

{   

    //*ADC ~Wandlung~*

    //Handbuch: "In single conversion mode, always select the channel, before starting the conversion  !"

    //ADMUX-Register "Analog Channel Selection Bits": The Value of these bits selects which analog inputs are connected to the ADC..." Handbuch S. 206

    //Sensoren an:  1.(Sensor_X) MUX: 0001  ->  ADC1  ->  (PC1)  

    //        2.(Sensor_Y) MUX: 0010   ->  ADC2  ->  (PC2)      

    //        3.(Sensor_Z) MUX: 0011   ->  ADC3  ->  (PC3)

    //Pinbelegung der AD -Eingänge an PC1 ... PC3

    //Setzen von allen PCx auf EINGANG

    DDRC=0x00;

    //ADC einschalten und Dummyreadout machen:  

    uint16_t ReadChannel (uint8_t mux)

    {

      uint8_t i;

      ADCSRA = (1<<ADEN) | ( 1<<ADPS1) | (1<<ADPS0);

      ADMUX=mux;                                      //gilt das mux nur für den Dummyreadout?

      //Als Referenzspannung die interne Referenzspannung nutzen

      ADMUX |=(1<<REFS1) | (1<<REFS0);   

      //Nun Dummyreadout zum "Warmlaufen":

      ADCSRA |= (1<<ADSC);

      //Warten, bis die Konvertierung fertig ist...

        while (ADCSRA & (1<<ADSC) )

          {

            ;;

          }

    //Die eigentliche Messung beginnt:

    //Mittelwert bilden und die Sensoren " nacheinander " abarbeiten....

    /// ENLOSSCHEIFE:

  while(1)

  {

//////////////////////////////////////////////////Sensor_X //////////////////////////////////////////////////////////////

      ///Kanal wählen:

    ADMUX |= (1<<MUX0);

      for (i=0;i<4;i++)

        {

          ADCSRA |= (1<<ADSC);

          while (ADCSRA & (1<<ADSC)) 

              { 

              ;

              }

          sensor_X=sensor_X+ADCW;

        }

      //ADC deaktivieren

      //ADCSRA &= ~(1<<ADEN);

      sensor_X = sensor_X / 4;

      return sensor_X;

      //Daten senden:

      int uart_putc_X (unsigned char sensor_X)                ///unsigned char

        {

          while (!(UCSRA & (1<<UDRE)))

                                    ///da fehlt noch etwas!

          UDR = sensor_X;  

          return 0;

      void uart_puts (char *s)

        {

          while (*s)

        {

        uart_putc_X(*s);

        s++;

        }

    }

    ///Das Empfängerprogramm muss erkennen, welcher der (X,Y,Z) - Messdaten er im Moment empfängt; also "Erkennungszeichen" 

    ///gleich hinterhersenden ('x' bzw. 'y' oder 'z')

    ident_sensor =  'x' ;

    ///Senden der Kontrollvariablen:

    int uart_putc (unsigned char ident_sensor)

      {    

          while (!(UCSRA & (1<<UDRE)));

          UDR = ident_sensor;

          ///Blinken einer entsprechenen LED zum Programmtest:

          ///Setzten von PBx als Ausgang (Bei X - Signal sollen Leuchten: LED 0 und 1) :

          ///Aktivieren der Ports

          DDRB = (1<<DDB0) | (1<<DDB1) ;

          PORTD = (1<<PD0) | (1<<PD1)  ;

          ///LEDs wieder aus:

          PORTD = 0x00;

          return 0;

        }

    ///gesetzte MUX wieder löschen

    ADMUX = 0x00;

//////////////////////////////////////////////////Sensor Y //////////////////////////////////////////////////////////////

    ADMUX |= (1<<MUX1) | (1<<MUX0);

    for (i=0;i<4;i++)

      {

        ADCSRA |= (1<<ADSC);

        while (ADCSRA & (1<<ADSC)) 

        { 

        ;

        }

      sensor_Y=sensor_Y+ADCW;

      }

    //ADC deaktivieren

    //ADCSRA &= ~(1<<ADEN);

    sensor_Y = sensor_Y / 4;

    return sensor_Y;

    //Daten senden:

    int uart_putc_Y (unsigned char sensor_Y)                  ///unsigned char

    {

      while (!(UCSRA & (1<<UDRE)))

                                    ///da fehlt noch etwas!

      UDR = sensor_Y;  

      return 0;

    void uart_puts (char *s)

    {

      while (*s)

      {

        uart_putc(*s);

        s++;

      }

    }

  ///Das Empfängerprogramm muss erkennen, welcher der (X,Y,Z) - Messdaten er im Moment empfängt; also "Erkennungszeichen" 

  ///gleich hinterhersenden ('x' bzw. 'y' oder 'z')

  ident_sensor =  'y' ;

  ///Senden der Kontrollvariablen:

  int uart_putc (unsigned char ident_sensor)

  {

    while (!(UCSRA & (1<<UDRE)));

      {

        UDR = ident_sensor;

        ///Blinken einer entsprechenen LED zum Programmtest:

        ///Setzten von PBx als Ausgang (Bei X - Signal sollen Leuchten: LED 2 und 3) :

        ///Aktivieren der Ports

        DDRB = (2<<DDB0) | (3<<DDB1) ;

        PORTD = (2<<PD0) | (3<<PD1)  ;

        ///LEDs wieder aus:

        PORTD = 0x00;

      return 0;

      }      

  }

    ///gesetzte MUX wieder löschen

    ADMUX = 0x00;

//////////////////////////////////////////////////Sensor Z //////////////////////////////////////////////////////////////

    ADMUX |= (1<<MUX1) | (1<<MUX0);

    for (i=0;i<4;i++)

      {

        ADCSRA |= (1<<ADSC);

        while (ADCSRA & (1<<ADSC)) 

        { 

        ;

        }

      sensor_Z=sensor_Z+ADCW;

      }

    //ADC deaktivieren

    //ADCSRA &= ~(1<<ADEN);

    sensor_Z = sensor_Z / 4;

    return sensor_Z;

    //Daten senden:

    int uart_putc_Z (unsigned char sensor_Z)                

    {

      while (!(UCSRA & (1<<UDRE)))

      UDR = sensor_Z;  

      return 0;

    }

    void uart_puts (char *s)

    {

      while (*s)

      {

        uart_putc(*s);

        s++;

      }

    }

    ///Das Empfängerprogramm muss erkennen, welcher der (X,Y,Z) - Messdaten er im Moment empfängt; also "Erkennungszeichen" 

    ///gleich hinterhersenden ('x' bzw. 'y' oder 'z')

    ident_sensor =  'z' ;

    ///Senden der Kontrollvariablen:

    int uart_putc (unsigned char ident_sensor)

      {

        while (!(UCSRA & (1<<UDRE)));

        UDR = ident_sensor;

        ///Blinken einer entsprechenen LED zum Programmtest:

        ///Setzten von PBx als Ausgang (Bei X - Signal sollen Leuchten: LED 4 und 5) :

        ///Aktivieren der Ports

        DDRB = (1<<DDB0) | (1<<DDB1) ;

        PORTD = (1<<PD0) | (1<<PD1)  ;

        ///LEDs wieder aus:

        PORTD = 0x00;

        return 0;

      }

    ///gesetzte MUX wieder löschen

    ADMUX = 0x00;

      }

    for (i=0;i<4;i++)

      {

        ADCSRA |= (1<<ADSC);

        while (ADCSRA & (1<<ADSC)) 

          { 

            ;

          }

      sensor_Z=sensor_Z+ADCW;

      }

      //ADC deaktivieren

      //ADCSRA &= ~(1<<ADEN);

      sensor_Z = sensor_Z / 4;

      return sensor_Z;

      //Daten senden

    int uart_putc3 (unsigned char sensor_Z)                      //geht das??????//

    {    

      while (!(UCSRA & (1<<UDRE)))

      UDR = sensor_Z;

      ///Das Empfängerprogramm muss erkennen, welcher der (X,Y,Z) - Messdaten er im Moment empfängt; also "Erkennungszeichen" 

      ///gleich hinterhersenden ('x' bzw. 'y' oder 'z')

      ident_sensor =  'z' ;