ATMEGA32; 2 AD Wandlungen gleichzeitig laufen lassen

[Eeeeee (Gast)]

Hallo zusammen, ich möchte bei einem ATMEGA32 einen Joystick 
anschließen, der ein Kettenfahrzeug antreiben soll. Allerdings scheitere 
ich gerade dabei, zwei analoge Signale gleichzeitig mit den AD Eingängen 
auszuwerten. Einen Eingang kann ich auswerten, das funktioniert, sobald 
ich aber den zweiten Eingang danach auch auslesen möchte, funktioniert 
nichts mehr. Bitte um Hilfe. Der zweite Teil der AD- Wandung der 
auskommentiert ist, funktioniert nicht. Hier die C Datei:

#ifndef  F_CPU
#define F_CPU 16000000  // Taktfrequenz = 16 MHz

#endif
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>


float adwertx=0, adwerty=0;



int main (void)
{
  
  DDRB=0xff;      //alle portb´s sind ausgänge  
  DDRD=0xF0;      
  DDRA=0x00;      //alle PORTA´s sind eingänge
  
  ADCSRA=0b11111111;
  while(1)
{
  
  
//------------AD Wandlung--------
  
  
  ADMUX=0x04;
  
  adwertx=ADCL;
  adwertx+=(ADCH<<8);

  if (adwertx<=0x1c2)          // wert=450
  {
    PORTD=0x40;          //Motor1 linkslauf ; PORTD6=1
    PORTB=0x02;
  }

  if (adwertx>0x1c2&&adwertx<0x28a)
  {
    PORTD=0x00;
    PORTB=0x00;
  }

  if (adwertx>=0x28a)          //wert=650
  {
    PORTD=0x80;            //Motor1 rechtslauf; PORTD7=1
    PORTB=0x04;
  }




/*
ADMUX=0x05;

adwerty=ADCL;
adwerty+=(ADCH<<8);

if (adwerty<=0x1c2)          // wert=450
{
OCR1A=0x78;    
}

if (adwerty>0x1c2&&adwerty<0x28a)
{
  PORTB=0x00;
  PORTD=0x00;  
}


if (adwerty>=0x28a)          //wert=650
{
OCR1B=0x78;        
}

*/
}
}

[spess53 (Gast)]

Hi

>Einen Eingang kann ich auswerten, das funktioniert, sobald
>ich aber den zweiten Eingang danach auch auslesen möchte, funktioniert
>nichts mehr.

Dann zeig mal die Stellen im Programm, wo die einzelnen AD-Wandlungen 
gestartet werden und auf das Ende der Wandlungen gewartet wird.

MfG Spess

[Karl H. (kbuchegg)]

Warum tust du dir nicht selbst einen Gefallen und benutzt die Routinen 
aus dem AVR-GCC-Tutorial?
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe
Die würden funktionieren.
Mit so etwas

  ADCSRA=0b11111111;

tust du dir keinen Gefallen. Das ist nicht mehr durchschaubar, was du da 
eigentlich alles einschaltest bzw. aktivierst.

Nach Einbindung der ADC Routinen aus dem Tutorial (und Anpassung der 
Einstellung für die Referenzspannung), könnte dein Code so einfach sein 
wie

....

int main()
{
  uint16_t value_x, value_y;

  ADC_Init();

  while( 1 ) {
    value_x = ADC_Read( 4 );
    value_y = ADC_Read( 5 );

    if( value_x < 200 ..... werte die Werte aus

  }
}

[H.Joachim S. (crazyhorse)]

"Gleichzeitig" geht sowieso nicht, da es nur einen Wandler gibt :-).
Du meinst wahrscheinlich kurz nacheinander.
Vor dem Auslesen musst du wartennnnnnnnnnnnn, bis der Wandler fertig 
ist.

// Read the AD conversion result
unsigned int read_adc(unsigned char adc_input)
{
ADMUX=(adc_input & 0x0f) | ADC_VREF_TYPE;
// Delay needed for the stabilization of the ADC input voltage
delay_us(10);
// Start the AD conversion
ADCSRA|=0x40;
// Wait for the AD conversion to complete
while ((ADCSRA & 0x10)==0);
ADCSRA|=0x10;
return ADCW;
}

[Karl H. (kbuchegg)]

Noch ein Hinweis.

So etwas

  if (adwertx<=0x1c2)          // wert=450

ist Unsinn. Wenn du wissen willst, ob der WErt kleiner/gleich 450 ist, 
dann schreib das auch so hin

  if( adcwertx <= 450 )

wo liegt der Sinn, im C Code die Zahlenwerte als Hex-Werte anzuschreiben 
und dann im Kommentar den Dezimalwert dazu anzugeben?
Ob du eine Hex-Schreibweise benutzt oder die Zahlen als Dezimalzahl 
anschreibst, ist eine reine Frage der Schreibweise. In der Bedeutung 
sind beide aber gleich: beides sind Zahlen und 0x1c2 bzw. dezimal 450 
sind dieselbe Zahl.

[Felix P. (fixxl)]

Solche Geschichten sind auch immer fehlerträchtig:

ADMUX=0x04;

...

ADMUX=0x05;

Das mag in deinem speziellen Fall gut gehen, wenn du mit der internen 
Referenzspannung und rechtsbündigem Ergebnis (Niedrigste 8 bit in ADCL, 
obere zwei Bit in ADCH) messen willst, ansonsten sind derartige 
Holzhammerzuweisungen eher zu vermeiden.

Würde dir eher zu folgender Vorgehensweise raten:

ADMUX &= 0xE0; // Oberste drei Bit bleiben bestehen, MUX4:0 werden 0
ADMUX |= 0x04; // Kanal 4 einstellen

Und das gleiche für Kanal 5:

ADMUX &= 0xE0; // Oberste drei Bit bleiben bestehen, MUX4:0 werden 0
ADMUX |= 0x05; // Kanal 5 einstellen

[Eeeeee (Gast)]

Ich danke euch für die Antworten, ich habe alle Kommentare beachtet und 
das Programm neu überschreiben, indem ich Funktionen aus dem Tutorial 
was mir empfohlen wurde benutzt habe und die main Funktion daraufhin neu 
geschrieben habe. Allerdings Funktioniert immer nur ein Teil der 
Funktion, entweder die value_x ODER die value_y, beides leider nicht. 
Könnt ihr mir weiterhelfen?

#ifndef  F_CPU
#define F_CPU 16000000  // Taktfrequenz = 16 MHz

#endif
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>




uint16_t ADC_Read ( uint8_t channel );
void ADC_Init (void);
int main (void)
{
  
  DDRB=0xff;      //alle portb´s sind ausgänge  
  DDRD=0xF0;      
  DDRA=0x00;      //alle PORTA´s sind eingänge
  
  TCCR1B=0x03;    
  OCR1B=0xF0;
  TCCR1A=0xA1;    
  OCR1A=0xF0;

  while(1)
{
  
  
    uint16_t value_x, value_y;

    ADC_Init();

      value_x = ADC_Read( 4 );
      
        if ( value_x <= 450 )
        {
          PORTD=0x40;            //Motor1 linkslauf ; PORTD6=1
          PORTB=0x02;
        }


        if ( value_x >= 650 )
        {
          PORTD=0x80;            //Motor1 rechtslauf; PORTD7=1
          PORTB=0x04;
        }
            
        if ( value_x <= 650 && value_x >= 450 )
        {
          PORTD=0x00;            //Motor1 rechtslauf; PORTD7=1
          PORTB=0x00;
        }


  value_y = ADC_Read( 5 );

      
        if ( value_y <= 450 )
        {
          PORTD=0x80;            //Motor1 linkslauf ; PORTD6=1
          
        }

        if ( value_y >= 650 )
        {
          
          PORTB=0x04;
        }
            
        if ( value_y <= 650 && value_y >= 450 )
        {
          PORTD=0x00;            //Motor1 rechtslauf; PORTD7=1
          PORTB=0x00;
        }
    
    
}
  
}

void ADC_Init(void) 
{
 
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);    
  // oder interne Referenzspannung als Referenz für den ADC wählen:
  // ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // 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. */
  (void) 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
}

[Karl H. (kbuchegg)]

Und noch ein guter Rat.

Lerne mit Einzelbitoperationen umzugehen!
Das ist eigentlich so ziemlich das wichtigste, wenn man seine 
µC-Karriere beginnt.

Denn hier

         PORTD=0x00;            //Motor1 rechtslauf; PORTD7=1
          PORTB=0x00;

setzt du alle 8 Bits vom Port auf 0. Auch die die für deinen Motor gar 
nicht zuständig sind!

Bit setzen

   Register |= ( 1 << Bitnummer );

Bit löschen

   Register &= ~( 1 << Bitnummer );

und wenn du dann noch mittels einem #define dem Bit einen schönen 
'Namen' gibts, dann wird das ganze auch noch übersichtlich und leicht zu 
lesen.

[Falk B. (falk)]

Siehe Bitmanipulation. Mehr gibt es da nicht zu sagen oder 
diskutieren.

[Eeeeee (Gast)]

Danke erstmal für eure Hilfe, habe jetzt nocheinmal alles umgeschrieben, 
indem ich die Bits der Ports jetzt einzeln setzte und lösche. Allerdings 
ist irgendetwas noch falsch, vielleicht die schreibweise mit dem value_x 
oder value_y ? Wenn ich value_x auskommentiere, funktioniert value_y 
einwandfrei, andersrum genauso, beides zusammen immernoch nicht. Woran 
liegt das?

while(1)
{
  
  
    uint16_t value_x, value_y;

    ADC_Init();
value_x = ADC_Read( 4 );
      
        if ( value_x <= 450 )
        {
          PORTD |= ( 1 << 6 );      //PORTD=0x40;  Motor1 linkslauf ; 
          PORTB |= ( 1 << 1 );      //PORTB=0x02;  
          PORTD &= ~( 1 << 7 );
          PORTB &= ~( 1 << 2 );
        }


        if ( value_x >= 650 )
        {
          //PORTD=0x80;            //Motor1 rechtslauf; PORTD7=1
          //PORTB=0x04;
          PORTD |= ( 1 << 7 );      
          PORTB |= ( 1 << 2 );
          PORTD &= ~( 1 << 6 );
          PORTB &= ~( 1 << 1 );
        }
            
        if ( value_x <= 650 && value_x >= 450 )
        {
          PORTD &= ~( 1 << 7 );
          PORTB &= ~( 1 << 1 );
          PORTD &= ~( 1 << 6 );
          PORTB &= ~( 1 << 2 );
          //PORTD=0x00;            //Motor1 rechtslauf; PORTD7=1
          //PORTB=0x00;
        }
  _delay_ms(10);

  value_y = ADC_Read( 5 );

      
        if ( value_y <= 450 )
        {
          PORTD |= ( 1 << 7 );      //PORTD=0x80;  Motor1 linkslauf 
          PORTD &= ~( 1 << 6);
        }

        if ( value_y >= 650 )
        {
          
          PORTB |= ( 1 << 2 );                //PORTB=0x04;
          PORTB &= ~( 1 << 1);
        }
            
        if ( value_y <= 650 && value_y >= 450 )
        {
          PORTD &= ~( 1 << 7 );
          PORTB &= ~( 1 << 1 );
          PORTD &= ~( 1 << 6 );
          PORTB &= ~( 1 << 2 );

          //PORTD=0x00;            //Motor1 rechtslauf; PORTD7=1
          //PORTB=0x00;
        }
    
    _delay_ms(10);

}

[Karl H. (kbuchegg)]

Wieviele Motoren hast du eigentlich?
Und warum setzt du da manchmal 4 Bits, manchmal nur 2?

Ich denke, dein Hauptproblem ist, dass dir eigentlich nicht wirklich 
klar ist, wie die beiden Knüppel auf den/die Motor(en) einwirken sollen.
IN deinem Code macht der Y Knüppel jeweils das rückgängig, was der X 
Knüppel eingestellt hat und umgekehrt.

[Felix P. (fixxl)]

Die ADC_Init() solltest du aus der Endlosschleife herausnehmen. Es ist 
nicht nötig, den ADC bei jedem Schleifendurchlauf neu zu initialisieren, 
das reicht einmal.