Zwei Analokanäle abfragen ?

[Michael H. (h_m)]

Guten Morgen,

also ich habe einen Atmega88, dazu habe ich auch ein Buch in dem steht 
wie man den ADC-Konverter einstellt u.a wie man die Register für die 
Kanäle 0-5 einstellt.

allerdings ist hier nur ein Beispiel beschrieben wie man mit einem Kanal 
einen Wert einliest. Eigentlich genauso wie im AVR-Tutorial hier im 
Forum.

ich möchte aber gerne zwei Kanäle nutzen nämlich Kanal 4 und 5. Wie man 
das nutzt/konfiguriert finde ich im netz nichts, entweder suche ich 
falsch oder es geht nicht.

Um ADC 4 und 5 zu nutzen muss ich das im AMUX Register frei schalten

   ADMUX |= (1<<MUX2);                // ADC-Kanal 4 einstellen
    ADMUX |= (1<<MUX2)|(1<<MUX0);       // ADC-Kanal 5 einstellen

ich hatte jetzt keine andere Idee, so  wie unten im Code das mal zu 
versuchen, das geht natürlich nicht.

nach was muss ich da suchen um das zu realisieren, oder könnte es mir 
bitte jemand zeigen ?

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

#define FOSC 16000000                // Set clock Speed in Hz
#define BAUD 9600                   // Set baud rate
#define UBRR_Value FOSC/16/BAUD-1   // Set baud rate value in baud rate register

void USART_Init( uint16_t ubrr)
{
  UBRR0H = (uint8_t)(ubrr >> 8);        // Set baud rate in high- and low-register
  UBRR0L = (uint8_t)ubrr;             // Set low-register always after high-register
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);   // Set frame format: 8data, 1stop bit
  UCSR0B = (1<<RXEN0)|(1<<TXEN0);     // Enable receiver and transmitter
}

void USART_Transmit(uint8_t data)
{
  while ( !( UCSR0A & (1<<UDRE0)) );    // Wait for empty transmit buffer
  UDR0 = data;                        // Put data into buffer, sends the data
}

uint8_t USART_Receive(void)
{
  while ( !(UCSR0A & (1<<RXC0)) );  // Wait for data to be received
  return UDR0;                        // Get and return received data from buffer
}

/**** Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) ****/
void USART_Flush(void)
{
  uint8_t dummy;
  while (UCSR0A & (1<<RXC0))
  dummy = UDR0;
}

int main( void )
{
  uint16_t x, ergebnis,ergebnis1;
  uint8_t data;
  USART_Init(UBRR_Value);     // Init UART
  USART_Flush();              // Flush Receive-Buffer
  DDRB = 0xFF;                // alle PINs an PortB als Ausgänge
  
      //*** Init ADC ***
    ADCSRA |= (1<<ADEN);              // ADC aktivieren
    ADCSRA |= (1<<ADPS0)|(1<<ADPS1);    // Vorteiler auf 8
    ADMUX |= (1<<REFS0);              // Uref = 5V
  ADMUX |= (1<<MUX2);                // ADC-Kanal 4 einstellen
    ADMUX |= (1<<MUX2)|(1<<MUX0);       // ADC-Kanal 5 einstellen
    ADMUX |= (1<<ADLAR);              // Ausgabe linksbündig
    DIDR0 |= (1<<ADC5D);              // Dig. Input Kanal ADC5 deaktivieren (spart Strom)
     
    //*** Dummy Readout ***
    ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));            // Auf Abschluss der Konvertierung warten
    x = ADC;                            // Das Ergebnis der 1.Wandlung in x speichern
     

  while(1)
  {           // Ausgabe ADC5
            ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
            while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
            ergebnis = ADCH;                // Inhalt von ADCH in ergebnis speichern
           USART_Transmit(ergebnis);
         _delay_ms(1000);
         
         // Ausgabe ADC4
          ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
          while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
          ergebnis1 = ADCH;                // Inhalt von ADCH in ergebnis speichern
          USART_Transmit(ergebnis1);
          _delay_ms(1000);
  }
}

[HildeK (Gast)]

Michael H. schrieb:
> Um ADC 4 und 5 zu nutzen muss ich das im AMUX Register frei schalten
>     ADMUX |= (1<<MUX2);                // ADC-Kanal 4 einstellen
>     ADMUX |= (1<<MUX2)|(1<<MUX0);       // ADC-Kanal 5 einstellen
>
> ich hatte jetzt keine andere Idee, so  wie unten im Code das mal zu
> versuchen, das geht natürlich nicht.

Das geht schon, aber nicht auf ein Mal.
Du musst zunächst Kanal 4 einstellen und dann den ADC starten und das 
Ergebnis holen.
Dann musst du mit der zweiten Zeile Kanal 5 einstellen und wieder den 
ADC starten und das zweite Ergebnis ermitteln.
Also nacheinander, nicht gleichzeitig!

[HildeK (Gast)]

... also so:

 while(1)
 {           // Ausgabe ADC5
    ADMUX |= (1<<MUX2)|(1<<MUX0); // Kanal 5
    ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
    ergebnis = ADCH;                // Inhalt von ADCH in ergebnis speichern
    USART_Transmit(ergebnis);
    _delay_ms(1000);
 
    // Ausgabe ADC4                 
    ADMUX &= ~(1<<MUX0);   // Kanal 4 (nur MUX2=1)
    ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
    ergebnis1 = ADCH;                // Inhalt von ADCH in ergebnis speichern
    USART_Transmit(ergebnis1);
   _delay_ms(1000);

[Michael H. (h_m)]

@Hildek

also Danke schon einmal für die Antwort, da es nicht so ganz bei 
funkioniert. Ich bekomme im H-term nur einen wert angezeit der von dem 
anderen etwas beeinflusst wird, wenn ich am Poti des anderen Kanal 
drehe. Muss ich hier noch bei den Registern vor der while schleife dann 
was ausklammern ?

aktuell sieht es jetzt so  aus .:

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

#define FOSC 16000000                // Set clock Speed in Hz
#define BAUD 9600                   // Set baud rate
#define UBRR_Value FOSC/16/BAUD-1   // Set baud rate value in baud rate register

void USART_Init( uint16_t ubrr)
{
  UBRR0H = (uint8_t)(ubrr >> 8);        // Set baud rate in high- and low-register
  UBRR0L = (uint8_t)ubrr;             // Set low-register always after high-register
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);   // Set frame format: 8data, 1stop bit
  UCSR0B = (1<<RXEN0)|(1<<TXEN0);     // Enable receiver and transmitter
}

void USART_Transmit(uint8_t data)
{
  while ( !( UCSR0A & (1<<UDRE0)) );    // Wait for empty transmit buffer
  UDR0 = data;                        // Put data into buffer, sends the data
}

uint8_t USART_Receive(void)
{
  while ( !(UCSR0A & (1<<RXC0)) );  // Wait for data to be received
  return UDR0;                        // Get and return received data from buffer
}

/**** Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) ****/
void USART_Flush(void)
{
  uint8_t dummy;
  while (UCSR0A & (1<<RXC0))
  dummy = UDR0;
}

int main( void )
{
  uint16_t x, ergebnis,ergebnis1;
  uint8_t data;
  USART_Init(UBRR_Value);     // Init UART
  USART_Flush();              // Flush Receive-Buffer
  DDRB = 0xFF;                // alle PINs an PortB als Ausgänge
  
      //*** Init ADC ***
    ADCSRA |= (1<<ADEN);              // ADC aktivieren
    ADCSRA |= (1<<ADPS0)|(1<<ADPS1);    // Vorteiler auf 8
    ADMUX |= (1<<REFS0);              // Uref = 5V
  ADMUX |= (1<<MUX2);                // ADC-Kanal 4 einstellen
    ADMUX |= (1<<MUX2)|(1<<MUX0);       // ADC-Kanal 5 einstellen
    ADMUX |= (1<<ADLAR);              // Ausgabe linksbündig
    DIDR0 |= (1<<ADC5D);              // Dig. Input Kanal ADC5 deaktivieren (spart Strom)
     
    //*** Dummy Readout ***
    ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));            // Auf Abschluss der Konvertierung warten
    x = ADC;                            // Das Ergebnis der 1.Wandlung in x speichern
     

  while(1)
  {           // Ausgabe ADC5
            ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
            while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
            ergebnis = ADCH;                // Inhalt von ADCH in ergebnis speichern
           USART_Transmit(ergebnis);
         _delay_ms(1000);
         
         // Ausgabe ADC4
         ADMUX &= ~(1<<MUX0);   // Kanal 4 (nur MUX2=1)
         ADCSRA |= (1<<ADSC);          // Start ADC-Wandlung
         while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
         ergebnis1 = ADCH;                // Inhalt von ADCH in ergebnis speichern
         USART_Transmit(ergebnis1);
         _delay_ms(1000);

  }
}

Simplex schrieb im Beitrag #5328761:
> Analo?
> Haha, is fürn Arsch?

 Was soll jetzt das heissen, ich bin gerade am testen, und so richtig 
funktioniert es auch nicht, ich bekomme im H-term nur einen wert 
angezeit der von dem anderen etwas beeinflusst wird, wenn ich am Poti 
des anderen Kanal drehe

[MWS (Gast)]

Beim erstmaligen Beschreiben von Konfigurationsregistern nicht verodern.
In der while() fehlt die Rückkonfiguration des ADMUX für den zweiten 
Kanal.

[HildeK (Gast)]

Michael H. schrieb:
> da es nicht so ganz bei funkioniert.

Du hast noch immer vergessen, am Anfang der while-Schleife für Kanal 5 
den Mux wieder auf 5 zu stellen. da, wo du "// Ausgabe ADC5" kommentiert 
hast.
Die hier:
    ADMUX |= (1<<MUX2)|(1<<MUX0); // Kanal 5

Ich muss aber zugeben, dass ich nicht alle Settings verifiziert habe, 
weil die fehlende Anpassung der Multiplexers an den gewünschten Kanal 
für mich Grund genug war für das Fehlverhalten.

[Stefan F. (Gast)]

>> Ich bekomme im H-term nur einen wert angezeit der von dem
> anderen etwas beeinflusst wird

> Du hast noch immer vergessen, am Anfang der while-Schleife
> für Kanal 5 den Mux wieder auf 5 zu stellen.

Falls dein problem nach der Korrektur immer noch besteht, kann es daran 
liegen, dass deine Signalquelle zu hochohmig ist (>10kΩ). Durch einen 
zusätzlichen Dummy Read kann man das häufig umgehen - falls du die Zeit 
dazu übrig hast.

int8_t read_adc(uint8_t channel)
{
    ADMUX = (ADMUX & 0xF0)+channel;   // Kanal wählen
    ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
    ADCSRA |= (1<<ADSC);              // Start nochmal ADC-Wandlung
    while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
    return ADCH;                      // Inhalt von ADCH lesen
}

while(1)
{
    USART_Transmit(read_adc(5));
    _delay_ms(1000);

    USART_Transmit(read_adc(4));
    _delay_ms(1000);
  }

[Michael H. (h_m)]

@Hildek und Stefan US schon einmal herzlichen Dank


Jetzt kann ich es mir zumindest vorstellen wie es geht. Ich habe jetzt 
zwei Potis mit jeweil 10K dran.


Es scheint zu funtionieren :-)

das heisst ich müsste Beim initialisieren des ADC"s vor der 
While-schleife
die Registerbits für die Kanalwahl gar nicht setzen?

und jetzt genau so Habe ich ihn auf den Controller.:

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

#define FOSC 16000000                // Set clock Speed in Hz
#define BAUD 9600                   // Set baud rate
#define UBRR_Value FOSC/16/BAUD-1   // Set baud rate value in baud rate register

void USART_Init( uint16_t ubrr)
{
  UBRR0H = (uint8_t)(ubrr >> 8);        // Set baud rate in high- and low-register
  UBRR0L = (uint8_t)ubrr;             // Set low-register always after high-register
  UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);   // Set frame format: 8data, 1stop bit
  UCSR0B = (1<<RXEN0)|(1<<TXEN0);     // Enable receiver and transmitter
}

void USART_Transmit(uint8_t data)
{
  while ( !( UCSR0A & (1<<UDRE0)) );    // Wait for empty transmit buffer
  UDR0 = data;                        // Put data into buffer, sends the data
}

uint8_t USART_Receive(void)
{
  while ( !(UCSR0A & (1<<RXC0)) );  // Wait for data to be received
  return UDR0;                        // Get and return received data from buffer
}

/**** Flush Receive-Buffer (entfernen evtl. vorhandener ungültiger Werte) ****/
void USART_Flush(void)
{
  uint8_t dummy;
  while (UCSR0A & (1<<RXC0))
  dummy = UDR0;
}

int8_t read_adc(uint8_t channel)
{
  ADMUX = (ADMUX & 0xF0)+channel;   // Kanal wählen
  ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
  while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
  ADCSRA |= (1<<ADSC);              // Start nochmal ADC-Wandlung
  while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
  return ADCH;                      // Inhalt von ADCH lesen
}


int main( void )
{
  uint16_t x, ergebnis,ergebnis1;
  uint8_t data;
  USART_Init(UBRR_Value);     // Init UART
  USART_Flush();              // Flush Receive-Buffer
  DDRB = 0xFF;                // alle PINs an PortB als Ausgänge
  
      //*** Init ADC ***
    ADCSRA |= (1<<ADEN);              // ADC aktivieren
    ADCSRA |= (1<<ADPS0)|(1<<ADPS1);    // Vorteiler auf 8
    ADMUX |= (1<<REFS0);              // Uref = 5V
    //ADMUX |= (1<<MUX2);                // ADC-Kanal 4 einstellen
    //ADMUX |= (1<<MUX2)|(1<<MUX0);       // ADC-Kanal 5 einstellen
    ADMUX |= (1<<ADLAR);              // Ausgabe linksbündig
    DIDR0 |= (1<<ADC5D);              // Dig. Input Kanal ADC5 deaktivieren (spart Strom)
     
    //*** Dummy Readout ***
    ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));            // Auf Abschluss der Konvertierung warten
    x = ADC;                            // Das Ergebnis der 1.Wandlung in x speichern
     

  while(1)
  {          
   
   USART_Transmit(read_adc(5));
   _delay_ms(1000);

   USART_Transmit(read_adc(4));
   _delay_ms(1000);

  }
}

[Stefan F. (Gast)]

> das heisst ich müsste Beim initialisieren des ADC"s vor der
> While-schleife
> die Registerbits für die Kanalwahl gar nicht setzen?

Richtig, doppelt gemoppelt ist nicht besser als einfach.

[HildeK (Gast)]

>> das heisst ich müsste Beim initialisieren des ADC"s vor der
>> While-schleife
>> die Registerbits für die Kanalwahl gar nicht setzen?

Häufig hat so ein μC n Eingänge für Analogsignale, einen 
Kanalwahlschalter n:1 (den MUX) aber nur einen ADC.
Nutzt man nur einen Kanal, reicht die Initialisierung wie deinem ersten 
Beispiel, also einmal den Kanal anwählen und dann immer wieder die 
Wandlung anstoßen.
Willst du aber mehrere Kanäle abfragen, dann musst du zuerst auf den 
gewünschten Kanal umschalten und dann wandeln.

[Stefan F. (Gast)]

Eine Korrektur:
> int8_t read_adc(uint8_t channel)

Ich glaube, der Rückgabewert sollte uint8_t sein, auch wenn man den 
Unterschied auf der seriellen Schnittstelle nicht bemerkt.

[Michael H. (h_m)]

Guten Morgen,

jetzt möchte ich bei einem Attiny85 den Analogwert von ADC1-Kanal1 in 
eine Variable übergeben. Jetzt kann ich mir das aber nicht auf dem 
Terminal seriell anzeigen lassen, weil der ja keine Usart Schnittstelle 
hat.Jetzt bekomme ich das einfach nicht hin.

könnte mir hier Bitte noch einmal jemand sagen was ich hier falsch 
mache. Oder wie ich mir den Variablen Inhalt ansehen kann.

/*
 * ATTINY_85.c
 *
 * Created: 03.03.2018 15:59:47
 * Author : USER
 */ 
#define F_CPU 1000000UL
#include <avr/io.h>
#include <util/delay.h>


uint16_t t = 0; // Variable für Delay ()


void MyDelay(uint16_t t)
 {
  while(t > 0) 
  {
    _delay_ms(1);
    t--;
  }
  return;
}

int8_t read_adc(uint8_t channel)
{
  ADMUX = (ADMUX & 0xF0)+channel;   // Kanal wählen
  ADCSRA |= (1<<ADSC);              // Start ADC-Wandlung
  while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
  ADCSRA |= (1<<ADSC);              // Start nochmal ADC-Wandlung
  while (ADCSRA &(1<<ADSC));        // Auf Abschluss der Konvertierung warten
  return ADCH;                      // Inhalt von ADCH lesen
}

int main(void)
{
    DDRB &= ~ (1<<PB2); // auf Eingang Bewegungsmelder
    DDRB =    (1<<PB3); // auf Ausgang Magnetventil
  
    uint16_t x;
  
   //*** Init ADC ***
    ADCSRA |= (1<<ADEN);                 // ADC aktivieren
    ADCSRA |= (1<<ADPS0)|(1<<ADPS1);     // Vorteiler auf 8
    ADMUX |= (1<<REFS0);                 // Uref = 5V
    ADMUX |= (1<<ADLAR);                 // Ausgabe linksbündig
   
     
    //*** Dummy Readout ***
    ADCSRA |= (1<<ADSC);                  // Start ADC-Wandlung
    while (ADCSRA &(1<<ADSC));            // Auf Abschluss der Konvertierung warten
    x = ADC;                              // Das Ergebnis der 1.Wandlung in x speichern
     

  
    while (1) 
    {
                  
     t = read_adc(1);
    
    
    if (PINB & (1<<PB2))
    {
      PORTB |= (1<<PB3);
      MyDelay(t);
    } 
    else
    {
      PORTB &= ~(1<<PB3);
    }
    }
}

[Stefan F. (Gast)]

Schau Dir meine HelloTiny Vorlage an, da wird serielle Ausgabe selbst 
auf den Kleinsten Tinies gemacht (durch Bit-Banging). Ist ganz einfach.
http://stefanfrings.de/avr_hello_world/index.html

[Michael H. (h_m)]

Danke, das ist sehr interessant, da muss ich mich mal in Ruhe umsehen.

und noch einmal zu obigen Code,da müsste doch jetzt in t 255 oder 1023 
drin stehen oder ? wenn nicht wie kann ich das ändern ?