mehrere ADC und UART

[Kluski (Gast)]

hy zusammen,

Ich wollte ein kleines Programm schreiben das herere adc-Kannele nutzt, 
aber nach abfrage per UART, der Code Läuft nur "halb".
Was es soll:
per Terminal wird 1, 2 oder 3 eingetippt und dann per ATMega8 der 
ADC-Kannal gemessen. (z.b: 1 => 1 = 123)
nach jeder neuen abfrage soll es messen und aus dem switch raus und 
warten bis etwas neues kommt

was es macht:
die abfrage der adc-Knäle funktioniert aber nur einmal.
wenn ich beim ersten mal 1 eingebe ist der Wert richtig und bei der 
zweiten Abfrage kommt sofort der maximale wert raus (1023).

Hier mal den Code
(habe die Funktionen für READ_ADC1 usw. sogewählt, weil ich den Die 
funktion aus dem Tutorial nicht gefunden habe)

#ifndef F_CPU
#warning "F_CPU war noch nicht definiert, wird nun nachgeholt mit 20000000"
#define F_CPU 20000000UL
#endif
#define BAUD 9600UL      // Baudrate

// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) // Fehler in Promille, 1000 = kein Fehler.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))
  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch!
#endif

#include <avr/io.h>
#include <string.h>
#include <stdio.h>

#define Ausgang DDRC      //Datenrichtung bestimmen
#define Sensorspannung PORTC  //Datenregister für PORTC 
#define ON |= (1<<PC0)      //Pin C0 High setzten
#define OFF &= ~(1<<PC0)    //Pin C0 Low setzten

/*Analog-Digital-Wandler-Initalisierung*/
void ADC_Init(void)
{

Sensorspannung ON;
uint16_t result;//Hilfsvariable für Dummy wert

//Referenzspannung AVcc 
ADMUX  = (1<<REFS0);

//ADC enable| Frequenzvorteiler F_CPU/64
ADCSRA = (1<<ADEN)|(1<<ADSC)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);

/*Dummy wert lesen*/
ADCSRA |= (1<<ADSC);             // eine ADC-Wandlung
while (ADCSRA & (1<<ADSC) ) {}

 result = ADCW;

Sensorspannung OFF;
}

void UART_Init(void)
{
//Schreibt die Baudrate in das Register
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  
// UART TX einschalten
UCSRB |= (1<<TXEN)|(1<<RXEN); 
//Asynchrone Übertragung | 8 bit Modus | 1 Stopbit  
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  
}

uint8_t uart_getc(void)
{
    while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
        ;
    return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

void send_string (char *s)
{  
  // Schleife solange bis s versendet ist
  while(*s)
    {   
    //Warte bis senden möglich
        while (!(UCSRA & (1<<UDRE))) 
      {
      }
    //Sende einzelne Zeichen
      UDR = *s;   
        //Nächtes Zeichen
    s++;
    }
}

int Read_ADC1()
{
Sensorspannung ON;
 ADMUX = (1<<MUX0);
//Start der Wandlung
  ADCSRA |= (1<<ADSC);
              
// Warte bis Wandlung Ageschlossen
  while (ADCSRA & (1<<ADSC) ) {}  

Sensorspannung OFF;

//Ausgabe der Wandlung
  return ADCW;                    
}

int Read_ADC2()
{
Sensorspannung ON;

  ADMUX = (1<<MUX1);
//Start der Wandlung
  ADCSRA |= (1<<ADSC);
              
// Warte bis Wandlung Ageschlossen
  while (ADCSRA & (1<<ADSC) ) {}  

Sensorspannung OFF;

//Ausgabe der Wandlung
  return ADCW;                    
}

int Read_ADC3()
{
Sensorspannung ON;
  ADMUX = (1<<MUX1)|(1<<MUX0);
//Start der Wandlung
  ADCSRA |= (1<<ADSC);
              
// Warte bis Wandlung Ageschlossen
  while (ADCSRA & (1<<ADSC) ) {}  

Sensorspannung OFF;

//Ausgabe der Wandlung
  return ADCW;                    
}


int main()
{

Ausgang ON;
Sensorspannung OFF;

//Einbinden der Initialisierungen 
ADC_Init();
UART_Init();
uint8_t c;
uint16_t adc_Value;
char     Buffer[6];

    //Endlosschleife
    while( 1 ) 
    {

  

  if((UCSRA & (1<<RXC)))
  {  PORTB &= ~(1<<PB0);
    c = uart_getc();
    
    switch(c)
    {  
      /*ASCII = 1*/
      case 49:  c= 1;
      adc_Value = Read_ADC1();//Channel 0;
      break;
      
      /*ASCII = 2*/
      case 50:   c= 2;
      adc_Value = Read_ADC2();//Channel 2;
      break;
      
      /*ASCII = 3*/
      case 51:   c= 3;
      adc_Value = Read_ADC3();//Channel 3;
      break;
      
      default: adc_Value = 0;
                   
       
    }//Ende switch
    
  

      
      sprintf( Buffer, "%d=%4d\r\n",c,adc_Value );
      ADCW = 0;
      send_string( Buffer );
      
      //adc_Value = 0;
  
      
  
  }//ende if

  else 
  {
      
  }
  
  


    }//Ende while

return 0;

}//Ende main

Hoffe Ihr Könnt mir bei dem Problem weiter Helfen.
MFG
Kluski

[Stefan E. (sternst)]

void ADC_Init(void)
{
...
ADMUX  = (1<<REFS0);

int Read_ADC1()
{
...
 ADMUX = (1<<MUX0);

x = 1;
x = 2;
Welchen Wert hat x nach diesen beiden Zeilen?

[Kluski (Gast)]

eigendlich x=3
hatte aber auch schon dran gedacht und READ_ADCX() jedes mal
ADCW = 0;
und nach dem senden
adc_value = 0;
zusetzten aber hatt auch kein erfolg.

[Cyblord -. (cyblord)]

Kluski schrieb:
> eigendlich x=3

Dicht drann. x=2 ist aber richtig. ;-)
Ein ADMUX=xxx überschreibt dir ADMUX jedesmal komplett neu.
Der vorherige Zustand wird so niemals irgendwie übernommen. Egal was da 
vorher drinstand, es ist nun weg.

Um das zu verhindern musst du so vorgehen:
Mit
ADMUX |= Bits setzen und
ADMUX &= ~ bits löschen. Dann klappts.

Nachzulesen hier: 
http://www.mikrocontroller.net/articles/Bitmanipulation

Und wenn du meherere ADCs auslesen willst, dann mach um Himmels Willen 
nur EINE Auslesefunktion und parametriere die mit dem gewünschten ADC 
Kanal. Für jeden Kanal eine eigene Funktion ist doch humbug hoch 10.

gruß cyblord

[Kluski (Gast)]

ja ok da gebe ich mal geschlagen mit der x=2 :D
klar klinkt einleuchtend, aber wenn ich jedes mal nur channel 1 nutzt, 
überschreibe ich es doch jedes mal mit der 1 oder nicht?

Danke das Problem mit den ADC hat sich erledigt.
MFG Kluski

[Karl H. (kbuchegg)]

Kluski schrieb:
> eigendlich x=3

????
echt.
Das wär aber fatal. Da würden 100% aller C-Programme nicht mehr 
funktionieren, wenn das so wäre.

  x = 1;
  x = 2;
  // an dieser Stelle hat x den Wert 2
  // Eine Zuweisung ist immer noch eine Zuweisung und gibt einer
  // Variablen einen neuen Wert unabhängig davon, was vorher
  // drinn gestanden hat

[Karl H. (kbuchegg)]

Kluski schrieb:
> ja ok da gebe ich mal geschlagen mit der x=2 :D
> klar klinkt einleuchtend, aber wenn ich jedes mal nur channel 1 nutzt,
> überschreibe ich es doch jedes mal mit der 1 oder nicht?

Darum gehts aber nicht.
Was passiert mit dem Bit, welches die Referenzspannung einstellt und im 
selben Register beheimatet ist?

[Karl H. (kbuchegg)]

Karl Heinz Buchegger schrieb:
> Kluski schrieb:
>> ja ok da gebe ich mal geschlagen mit der x=2 :D
>> klar klinkt einleuchtend, aber wenn ich jedes mal nur channel 1 nutzt,
>> überschreibe ich es doch jedes mal mit der 1 oder nicht?
>
> Darum gehts aber nicht.
> Was passiert mit dem Bit, welches die Referenzspannung einstellt und im
> selben Register beheimatet ist?


Oder anders gefragt:
Warum denkst du fängt die ADC Routine aus dem Tutorial
AVR-GCC-Tutorial/Analoge Ein- und Ausgabe
genau so an:

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ...

und weist nicht einfach nur den Channel an ADMUX zu?




PS:
Das hier

    switch(c)
    {  
      /*ASCII = 1*/
      case 49:  c= 1;
      adc_Value = Read_ADC1();//Channel 0;
      break;
      
      /*ASCII = 2*/
      case 50:   c= 2;
      adc_Value = Read_ADC2();//Channel 2;
      break;
      
      /*ASCII = 3*/
      case 51:   c= 3;
      adc_Value = Read_ADC3();//Channel 3;
      break;
      
      default: adc_Value = 0;
                   
       
    }//Ende switch

schreibst du besser so (die Zeichen selber anstatt ihrem Code

    switch(c)
    {  
      case '1':  c= 1;
      adc_Value = Read_ADC1();//Channel 0;
      break;
      
      case '2':   c= 2;
      adc_Value = Read_ADC2();//Channel 2;
      break;
      
      case '3':   c= 3;
      adc_Value = Read_ADC3();//Channel 3;
      break;
      
      default: adc_Value = 0;
    }//Ende switch

erstens brauchst du dir dann die ASCII Codes nicht merken (die kennt der 
Compiler auswendig) und zweitens brauchst du dann auch die Kommentare 
nicht (die im Extremfall sowieso einfach nur falsch sind)