ADC - Dehnungsmesstreifen

#define F_CPU 8000000UL   

#include <stdlib.h>

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include <string.h>

#include <stdio.h>

#define UART_BAUDRATE  9600

#define UART_SETTING  ((F_CPU/16L/UART_BAUDRATE)-1)

#define PRESCALER      64

#define PRESCALER_BITS (1<<CS22) 

#define MILLISEC_BASE  ( F_CPU / PRESCALER / 1000 )

#define CENTER         ( MILLISEC_BASE / 2 ) 

#define debounce( port, pin )            \

({                  \

  static uint8_t flag = 0;  \

  uint8_t i = 0;              \

                  \

  if( flag ){   \

    for(;;){       \

      if( !(port & 1<<pin) ){   \

  i = 0;      \

  break;                \

      }                  \

      _delay_us( 98 );     \

      if( --i == 0 ){    /* ... until key >25ms released */  \

  flag = 0;    /* clear press flag */      \

  i = 0;      /* 0 = key release debounced */    \

  break;                \

      }                  \

    }                  \

  }else{      /* else check for key press: */    \

    for(;;){      /* loop ... */        \

      if( (port & 1<<pin) ){  /* ... until key released or ... */  \

  i = 0;      /* 0 = bounce */      \

  break;                \

      }                  \

      _delay_us( 98 );    /* * 256 = 25ms */      \

      if( --i == 0 ){    /* ... until key >25ms pressed */  \

  flag = 1;    /* set press flag */      \

  i = 1;      /* 1 = key press debounced */    \

  break;                \

      }                  \

    }                  \

  }                  \

  i;        /* return value of Macro */    \

})

//

// Konfiguration der Servoleitungen

//

#define NR_SERVOS      3

#define SERVO_DDR      DDRD

#define SERVO_PORT     PORTD

uint8_t ServoPuls[NR_SERVOS] = { 1<<PD6, 1<<PD5, 1<<PD4, 0,

                 0,      0, 0, 0};

// uint8_t ServoPuls[NR_SERVOS] = { 1<<PD6, 1<<PD5 };

//

// Werte für die Servoposition

// Gültige Werte laufen von 0 bis 2 * CENTER

// 0           ... ganz links

// CENTER      ... Mittelstellung

// 2 * CENTER  ... ganz rechts

//

volatile uint8_t ServoValue[NR_SERVOS]; 

volatile uint16_t sekunden, msekunden;

ISR (TIMER2_COMP_vect) 

{

  static uint8_t ServoId = 0;

  //

  // den Puls des aktuellen Servos beenden

  //

  SERVO_PORT &= ~ServoPuls[ServoId];

  //

  // welches ist das nächste aktuelle Servo?

  //

  if( ++ServoId >= NR_SERVOS )

    ServoId = 0;

  //

  // die Ausgangsleitung fuer dieses Servo auf 1; den Puls beginnen

  //

  SERVO_PORT |= ServoPuls[ServoId];

  //

  // den Timer so einstellen, dass bei Pulsende, die ISR erneut aufgerufen wird

  //

  OCR2 = MILLISEC_BASE + ServoValue[ServoId];

}

ISR(TIMER0_COMP_vect)

{

  static int count, count_sek;

  count_sek++;

  if(count_sek == 10)

  {

    msekunden++;

    count_sek = 0;

    if(msekunden == 1000)

    {

      sekunden++;

      msekunden = 0;

    }

  }

}

void init_time()

{

  TIMSK|=(1<<OCIE0);

  TCCR0 |= (1<<WGM01) | (1<<CS01);  

  OCR0 = F_CPU/8/10000;      

}

/* ADC initialisieren */

void ADC_Init(void) {

  uint16_t result;

  ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen

  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten

  // schon auf 0, also single conversion

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler

  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest

     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 

  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten

  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten

     Wandlung nicht übernommen. */

  result = ADCW;

}

/* ADC Einzelmessung */

uint16_t ADC_Read( uint8_t channel )

{

  // Kanal waehlen, ohne andere Bits zu beeinflußen

  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten

  return ADCW;                    // ADC auslesen und zurückgeben

}

/* ADC Mehrfachmessung mit Mittelwertbbildung */

uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average )

{

  uint32_t ergebnis = 0;

  for (uint8_t i = 0; i < average; ++i )

    ergebnis += ADC_Read( channel );

  return (uint16_t)( ergebnis / average );

}

void setup_uart()

{

  UBRRH = (char) (UART_SETTING >> 8);

  UBRRL = (char) (UART_SETTING);

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

  UCSRC = (1<<URSEL) | (1<<UCSZ1) | (1<<UCSZ0);

}

void uart_putchar(char c)

{

  // Warten bis Buffer bereit ...

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

    ;

  // Senden...

  UDR = c;

}

void uart_putstring(char *str)

{

  unsigned char i;

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

  {

    if (str[i] != 0)

      uart_putchar(str[i]);

    else

      break; // Ende des Strings erreicht

  }

}

char uart_getchar()

{

  // Ist schon ein Zeichen im Buffer?

  if (bit_is_set(UCSRA, RXC))

    return UDR;

  else 

    return -1;

}

void uart_readline(char *str)

{

  char c;

  unsigned char index;

  index = 0;

  while (1)

  {

    c = uart_getchar();

    if (c != -1)

    {

      if (c == 13) 

      {

        str[index] = 0;

        return;

      }

      else 

      {

        str[index] = c;

        index++;

      }

    }

  }

}

void InitServo()

{

  uint8_t i;

  //

  // Die Servoleitungen auf Ausgang stellen

  //

  SERVO_DDR = ServoPuls[0] | ServoPuls[1];

  //

  // Alle Servos in Mittelstellung

  //

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

    ServoValue[i] = (CENTER + (CENTER/2));

  //

  // Timer auf CTC Modus konfigurieren

  //

  OCR2 = MILLISEC_BASE + ServoValue[0];

  TIMSK |= (1<<OCIE2);

  TCCR2 = (1<<WGM21) | PRESCALER_BITS;  // CTC mode

}

int main()

{

  uint16_t adcval;

  uint16_t remember;

  int last_sek;

  char Buffer[25];

  ADC_Init();

  DDRC=0x00;

  PORTC=0xff;

  DDRB=0xff;

  PORTB=0x00;

  InitServo();

  sei();                                // Interrupts global an

  last_sek = 0;

  sekunden = 0;

  msekunden = 0;

  remember = 0;

  init_time();

  setup_uart();

  uart_putstring("Setup UART: check\r\n");

  ServoValue[0] = (CENTER + (CENTER/2));

  uart_putstring("Setup Servo \r\n");  

  uart_putstring("check\r\n");

  while( 1 ) 

  {

  if(debounce(PINC, PC0))

  {

  if(ServoValue[0] == 0)

    ServoValue[0] = 2*CENTER;

  else

    ServoValue[0] = 0;          

  }

    if(sekunden>last_sek)

        {

  last_sek = sekunden;

  adcval = ADC_Read_Avg(0,200);

        sprintf( Buffer, "Wert: %d", adcval );

  uart_putstring(Buffer);

  }

  }

}