2 ADC Ports abfragen bei Bedarf Atmega32

[Gerhard H. (oderlachs)]

Hallo Freunde !

Ich habe einen Anwendung wo ich je nach Bedarf die ADC Ports 0,1,2 
PA0..2 abfragen möchte.
Nun habe ich das Problem was ich programmiertechnisch tun muss um zBps 
wenn ich ADC0 ausgelesen habe bei Bedarf auf ADC2 umschalte um dort den 
Wert auszulesen. Bis lang habe habe ich mit einem ADC Eingang gearbeitet 
und es klappt so für die geforderte Genauigkeit.
Da MUX0,MUX1 und MUX2 im ADMUX Register verschieden gesetzt werden, habe 
ich mich irgendwie verrannt wie das lösen kann...grrr
Vielleicht gehe ich auch verkehrt daran bei der Lösung. Hier mal mein 
Codeauszug für erst mal einen ADC , vieleicht sollte ich die Routinen 
ADC_Init() und ADC_Mess zusammenlegen für jeden Eingang extra..

/*====================================================================*/
/*                                                                    */
/*                   ADC Funktionen                                   */
/*                                                                    */
/*              ADC0 = PA0  ADC1 = PA1 usw...                         */
/*              Vorteiler auf 32 bei 3,6864Mc                         */
/*====================================================================*/

void ADC_Init_ADC0();
void ADC_Init_ADC1();
uint16_t ADC0_Mess();
/*====================================================================*/
/*                                                                    */
/*                                                                    */
/*         PA0  als ADC Eingang                                       */
/*                                                                    */
/*====================================================================*/

void ADC_Init_ADC0()
{
  ADCSRA |= (1 << ADEN);
  ADCSRA |= (1 << ADPS2)|(1 << ADPS0); // Teiler 32
  ADMUX  |= (1 << REFS0);              // Referenz 5V
        // MUX0...3 nicht gesetzt da ADC0 verwendet wird
  ADMUX  |= (1 << ADLAR);              // linksbuendig

}
/*====================================================================*/
/*                                                                    */
/*                                                                    */
/*         PA1  als ADC Eingang                                       */
/*                                                                    */
/*====================================================================*/

void ADC_Init_ADC1()
{
  ADCSRA |= (1 << ADEN);
  ADCSRA |= (1 << ADPS2)|(1 << ADPS0); // Teiler 32
  ADMUX  |= (1 << REFS0);              // Referenz 5V
  ADMUX  |= (1 << MUX0);               // ADC1 auswaehlen
  ADMUX  |= (1 << ADLAR);              // linksbuendig
  
}

/*====================================================================*/
/*                                                                    */
/*                                                                    */
/*        Messung                                                     */
/*                                                                    */
/*====================================================================*/

uint16_t ADC0_Mess()

{   uint16_t x;
  ADCSRA |= (1 << ADSC);
  while (ADCSRA &(1 << ADSC));
  x = ADC;
  ADCSRA |= (1 << ADSC);
  while (ADCSRA &(1 << ADSC));
  return ADC ;
}
  
/*====================================================================*/

Vielleicht kann mir ja BITTE  ein erfahrenderer User ein paar Tips 
geben???

Gruss und Dank

Gerhard

[Ralf G. (ralg)]

Man braucht nur eine Init-Funktion.
Beim Aufruf von 'ADCx_Mess()' wird nur noch der Eingang ausgewählt.
Siehe: https://www.mikrocontroller.net/articles/Bitmanipulation

[c-hater (Gast)]

Gerhard H. schrieb:

> Nun habe ich das Problem was ich programmiertechnisch tun muss um
> zBps wenn ich ADC0 ausgelesen habe bei Bedarf auf ADC2 umschalte um
> dort den Wert auszulesen.

Das ist (für jemanden wie dich) tatsächlich garnicht so einfach. Man 
muss nämlich drei Sachen zu (bis zu) drei verschiedenen Zeitpunkten tun:

1) Umschalten von ADMUX vom "Normalkanal" auf den ausnahmsweise 
gewünschten Kanal. Das ist trivial und kann (zumindest theoretisch) 
jederzeit problemlos erfolgen. Praktisch allerdings nicht, dazu später 
mehr.

2) Zurückschalten von ADMUX auf den "Normalkanal". Das ist ziemlich 
kitzlig, denn dass darf nicht zu früh erfolgen und nicht zu spät. Das 
Zeitfenster für die Umschaltung entspricht genau einem Zyklus des 
AD-Wandlers. Das Zeitfenster beginnt beim Eintreffen des ersten 
Wandlerergebnisses nach 1) und endet KURZ VOR dem Eintreffen des zweiten 
Wandlerergebnisses nach 1).

3) Abfischen des einen richtigen Samples für den ausnahmsweise 
gewünschten  Kanal aus dem Strom der Samples für den Normalkanal. Das 
eine richtige Sample ist genau das, was als ZWEITES nach 1) eintrifft.

Hört sich sehr kompliziert an? Ist es auch. Mit deinem Programmieransatz 
ist sowas nämlich praktisch kaum zuverlässig lösbar. Zuverlässig wird es 
erst, wenn man die gesamte AD-Wandlung auf einen interruptbasierten 
Ansatz hebt und die Wahl der Kanäle mit der Arbeit der Wandlerhardware 
über die ISR synchronisiert.

Dann gibt es nämlich nur noch einen Zeitpunkt im Wandlerzyklus, an dem 
irgendetwas passiert: der Zeitpunkt des ADC-Interrupts. Das vereinfacht 
alles extrem. Es bleibt aber leider immer noch ein wenig kompliziert, 
man muss in parallelen Vorgängen denken können, um das richtig zu 
handhaben.

Der Trick besteht aus zwei Teilen:

1) Einzig und allein die ISR wählt den Wandlerkanal der Hardware. Man 
muss die Kanalwahl also erstmal im RAM puffern, wenn man sie zu jeder 
beliebigen Zeit vornehmen will. Erst die ISR tut es (die Einstellung von 
ADMUX) dann im richtigen Moment tatsächlich.

2) Einzig und allein die ISR holt die Ergebnisse vom AD-Wandler und 
ordnet sie den Kanälen zu, denn nur sie kann wissen, zu welchem Kanal 
welches Ergebnis gehört. Es ist nämlich dann genau der Kanal, der exakt 
ZWEI Wandlerzyklen zuvor durch sie selber gewählt wurde.

Das ist nur das Grundkonzept. Das variiert man dann. Für das Szenario, 
dass es einen "Normalkanal" gibt und nur gelegentlich einzelne Samples 
eines anderen Kanals benötigt werden, würde die ISR z.B. ganz anders 
aussehen als in einem Szenario, in dem mehrere Kanäle mit konstanter 
Samplerate gewandelt werden sollen.

Alles in allem: das ist schon sowas wie tatsächlich programmieren. Im 
Gegensatz zu: Wichsvorlagen aus dem Netz zusammen zu kleben...

[Gerhard H. (oderlachs)]

Hallo !

Danke für die Hinweise !
Ralf , ich habe es mal nach Deinem Vorschlag gemacht, klappt wunderbar.

Mit ISR usw  wäre wohl, wie mit Kanonen auf Spatzen zu schiessen ;)

Wenn ich, mal einen anderen ADC Eingang irgendwann auswähle, brauch ich 
dazu keine ISR, sondern nur eine Buttonabfrage, auf dessen Resultat  die 
jeweilige ADC Routine aufgerufen  wird, danach ist es wurscht...bis mal 
wieder per Button ein anderer  ADC Eingang gewählt. Im einfachsten 
Falle, könnte ich den Messeingang bei Bedarf auch per Relais auf ein und 
den selben ADC Pin umschalten , selbst wenn da ein paar MilliVolt flöten 
gehen macht es nichts da  ich nur in 200...500mV Sprüngen 
rechnen/handeln muss, das heisst der µC bei der Auswertung.

Gruss und Dank

Gerhard