ATxmega8E5 ADC_Problem

[DEU (Gast)]

Hallo,

ich versuche zwei ADC-Kanäle vom ATxmega8E5 Microcontroller von Atmel 
auszulesen. Leider scheint die Auswertung nicht zu klappen am ADC PIN.2 
liegen 1,07V an und bei der if-Abfrage müsste es die Variable 
s_GLO.ucHardwareVersion = STD setzen es springt aber immer in den else 
Zweig.

Hat jemand eine Idee was im Quellcode noch verkehrt ist bzw. wie ich es 
noch testen könnten?

 

if ( (s_GLO.ui16VoltageHwVer > MIN_VOLT_TH_STD) /*&& (s_GLO.ui16VoltageHwVer < MAX_VOLT_TH_STD)*/ )
              {
                if( ui16TimerADC == 0)
                {
                  s_GLO.ucHardwareVersion = STD;
                  
                }
              }
              else
              {
                s_GLO.ucHardwareVersion = WL;
              }


void ADC_init (void)
{
  ADCA.CTRLB = ADC_RESOLUTION1_bm;    // set ADC-Resolution to 8Bit
  ADCA.REFCTRL = ADC_REFSEL2_bm;      // select Referenz Vcc/2 @3,19V = 1,595V = 1,514V (Offset = 13 = 81mV) @3,55V = 1,775V = 1,685V   (Offset = 13 = 90mV)
  ADCA.PRESCALER = ADC_PRESCALER2_bm;   // select Prescaler 64 = 125kHz
  ADCA.CH0.CTRL = ADC_CH_INPUTMODE0_bm; // select Single-ended mode
  //ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS1_bm;//ADC_CH_MUXPOS0_bm; // select ADC-Pin1
  ADCA.CTRLA = ADC_ENABLE_bm | ADC_START_bm; //set ADC enable  and start ADC-conversion 
  
}




 uint8_t ADCA_Selection(ADC_CH_t *Channel, uint8_t Pin)
 { 
   (*Channel).MUXCTRL = (Pin << 3); //selection of ADC-Pin
   
   while( !(*Channel).INTFLAGS);   
   
   return (*Channel).RESL;
 }




void ADC_read (void)
{      
  static uint8_t ucADC_Buffer_HW_Ver[ADC_BUFFER_SIZE], ucADC_Buffer_Bat_Volt[ADC_BUFFER_SIZE];
  static uint8_t ucADC_Buffer_Pointer;
  uint8_t uci;  
  
  if( (e_Zustand != DC_LADEN) )
  {
    ADC_init();  
    
    ucADC_Buffer_Pointer++;
    
    if(ucADC_Buffer_Pointer >= ADC_BUFFER_SIZE)
    {
      ucADC_Buffer_Pointer = 0;
    }    
    
    ucADC_Buffer_HW_Ver[ucADC_Buffer_Pointer] = ADCA_Selection( &(ADCA.CH0), 2); 
    
    ucADC_Buffer_Bat_Volt[ucADC_Buffer_Pointer] = ADCA_Selection( &(ADCA.CH0), 1); 

    s_GLO.ui16Akkuspannung = 0;
    s_GLO.ui16VoltageHwVer = 0;
    
    for (uci = 0; uci < ADC_BUFFER_SIZE; uci++)
    {
      s_GLO.ui16VoltageHwVer += ucADC_Buffer_HW_Ver[uci];
      s_GLO.ui16Akkuspannung += ucADC_Buffer_Bat_Volt[uci]; 
    }
    
    s_GLO.ui16VoltageHwVer /= ADC_BUFFER_SIZE;
    s_GLO.ui16Akkuspannung /= ADC_BUFFER_SIZE;  
  } 
}

[DEU (Gast)]

Hat niemand einen Tipp? Ich habe mir schon gedacht das ich vllt das 
umschalten zwischen den beiden Kanälen verzögern muss oder so?

[Dennis K. (scarfaceno1)]

Ist das der ganze Code?
Was passiert vor der if Verzweigung?

Wird der ADC denn auch vorher mal ausgelesen?

[M. K. (sylaina)]

DEU schrieb:
> Hat niemand einen Tipp? Ich habe mir schon gedacht das ich vllt das
> umschalten zwischen den beiden Kanälen verzögern muss oder so?

Dein Quellcode ist nicht komplett. Es ist z.B. nirgends zu sehen wo 
ui16TimerADC definiert ist geschweige denn wo es beschrieben wird.

Tipp: Reduziere deinen Code auf ein Minimum und schaue ob das Problem 
dann immer noch besteht. Von da aus erweiterst du deinen Code immer 
Schritt für Schritt bis zu deinem jetzigen Code. Somit solltest du recht 
zügig die Stelle finden, an der es nicht mehr passt.

[DEU (Gast)]

Hallo,

ich habe den Quellcode jetzt möglichst reduziert habe aber nun das 
Problem wenn ich beide Pins vom ADC gleichzeitig auslese dann bekomme 
ich zufällige Werte eingelesen.
Wenn ich nur einen Pin auslese funktionert es.


Was könnte das Problem sein?

#define  F_CPU 8000000UL
#include <util/delay.h>
#include <avr/io.h>
#include <stdint.h>
#include "prototypen.h"
#include "defines.h"

/*######################## begin global variables ##########################*/

struct global
{  
  /*ADC-read*/
  uint16_t ui16VoltageHwVer;              // voltage for HW-Ver. detection
  uint16_t ui16Akkuspannung;              // Bat voltage
  
} s_GLO;


int main(void) 
{   
  /*initialization*/
     clock_init(); 
  port_init();  
  ADC_init();      
  
  /*main loop*/
    while (1)
    {  
    /*read ADC*/
    ADC_read();
    
    
    
    /*decision illumination HW-Rev.*/   
    if ( (s_GLO.ui16VoltageHwVer > 152) && (s_GLO.ui16VoltageHwVer < 195) ) //66
    {
        //LED grün Ver._STD
      PORTD.OUTCLR = PIN5_bm;      
    }
    
    else
    {
      PORTD.OUTSET = PIN5_bm;      
    }  
  
    if ( (s_GLO.ui16VoltageHwVer > 195) )
    {
        //LED magenta Ver._WL
      PORTD.OUTCLR = PIN7_bm;
      PORTD.OUTCLR = PIN6_bm;    
    }
    
    else
    {
      PORTD.OUTSET = PIN7_bm;
      PORTD.OUTSET = PIN6_bm;  
    }
  
    if ( (s_GLO.ui16VoltageHwVer < 152 ) )
    {
        //LED blau Ver_PDD    
      PORTD.OUTCLR = PIN7_bm;  
    }
    
    else
    {
      PORTD.OUTSET = PIN7_bm;
    }    
    
  }
 
    return 0;
}


void clock_init (void)
{
  OSC.CTRL |= OSC_RC8MEN_bm; //oscillator at 8 MHz 
  while(!(OSC.STATUS & OSC_RC8MRDY_bm)); //wait for oscillator ready
  CCP = CCP_IOREG_gc; //protect I/O register, interrupts are ignored
  CLK.CTRL = (CLK.CTRL &~ CLK_SCLKSEL_gm) | CLK_SCLKSEL_RC8M_gc; //activate internal oscillator
}


void port_init (void)
{  
  /*Pinout Port A*/
  // 1: Charge voltage (ADC 0,93V-1,4V)  -INPUT
  // 2: HW-Ver. detection (ADC)       -INPUT
  
  /*Charge voltage*/
  PORTA.DIRCLR = PIN1_bm;
  
  /*HW-Ver. detection*/
  PORTA.DIRCLR = PIN2_bm; 
  
  
  /*Pinout Port D*/  
  
  // 5: Status LED green -OUTPUT
  // 6: Status LED red   -OUTPUT
  // 7: Status LED blue  -OUTPUT  
  
  /*Status LED green*/
  PORTD.DIRSET = PIN5_bm; 
  PORTD.OUTSET = PIN5_bm; //Status LED green OFF
  
  /*Status LED red*/
  PORTD.DIRSET = PIN6_bm; 
  PORTD.OUTSET = PIN6_bm; //Status LED red OFF
  
  /*Status LED blue*/
  PORTD.DIRSET = PIN7_bm; 
  PORTD.OUTSET = PIN7_bm; //Status LED blue OFF  
      
}

void ADC_init (void)
{
  ADCA.CTRLB = ADC_RESOLUTION_8BIT_gc;            // set ADC-Resolution to 8 Bit
  ADCA.REFCTRL = ADC_REFSEL_INTVCC2_gc;           // select Reference Vcc/2 
  ADCA.PRESCALER = ADC_PRESCALER_DIV128_gc;       // select Prescaler 64 = 125kHz  
  ADCA.CTRLA = ADC_ENABLE_bm;            // set ADC enable    
}

 
 uint8_t ADCA_Conversion(ADC_CH_t *Channel, uint8_t Pin)
 { 
   Channel->CTRL = ADC_CH_INPUTMODE_SINGLEENDED_gc;
   Channel->MUXCTRL = (Pin << 3);
   Channel->CTRL |= ADC_CH_START_bm;
   
   while(!Channel->INTFLAGS);
   return Channel->RES;
 }


void ADC_read (void)
{  
    s_GLO.ui16VoltageHwVer = ADCA_Conversion( &(ADCA.CH0), 2);    
  
    s_GLO.ui16Akkuspannung = ADCA_Conversion( &(ADCA.CH0), 1);          
}

[DEU (Gast)]

Hat Jemand eine Idee?

Es muss doch möglich sein zwei ADC-Eingänge durch Umschalten zu messen, 
oder?

[Gerhard G. (xmega)]

Hallo,

DEU schrieb:
> Channel->MUXCTRL = (Pin << 3);

ist eine Schreibweise die ich nicht kenne.

Meine Zugriffe starte ich zum Beispiel mit:

ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN1_gc ;
ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS_PIN2_gc ;
usw.


Gruß G.G.

[Falk B. (falk)]

@ DEU (Gast)

>Hat jemand eine Idee was im Quellcode noch verkehrt ist bzw. wie ich es
>noch testen könnten?


>void ADC_init (void)
>{
>  ADCA.CTRLB = ADC_RESOLUTION1_bm;    // set ADC-Resolution to 8Bit
>  ADCA.REFCTRL = ADC_REFSEL2_bm;      // select Referenz Vcc/2 @3,19V = 1,595V = 
1,514V (Offset = 13 = 81mV) @3,55V = 1,775V = 1,685V   (Offset = 13 = 90mV)
>  ADCA.PRESCALER = ADC_PRESCALER2_bm;   // select Prescaler 64 = 125kHz
>  ADCA.CH0.CTRL = ADC_CH_INPUTMODE0_bm; // select Single-ended mode
>  //ADCA.CH0.MUXCTRL = ADC_CH_MUXPOS1_bm;//ADC_CH_MUXPOS0_bm; // select ADC-Pin1

Das sieh soweit OK aus.

>  ADCA.CTRLA = ADC_ENABLE_bm | ADC_START_bm; //set ADC enable  and start 
ADC-conversion

Warum startest du den ADC hier? Einschalten (enable) reich vollkommen.

> uint8_t ADCA_Selection(ADC_CH_t *Channel, uint8_t Pin)

Der Name dieser Funktion ist irreführend! Es wird nicht nur der 
ADC-Kanal ausgewählt, es wird auch gemessen! Also sollte diese Funktion 
irgendwie eas mit read heißen!

https://www.mikrocontroller.net/articles/Strukturierte_Programmierung_auf_Mikrocontrollern#Benennung_von_Variablen.2C_Makros.2C_Nutzung_von_Anweisungen

> {
>   (*Channel).MUXCTRL = (Pin << 3); //selection of ADC-Pin

Falscher Fehler. Beim ATXmega arbeitet man mit den vordefinerten 
Bitmasken, NICHT den Bitnummern!
Siehe Bitmanipulation. Hier muss du per switch() die Pinnummer in 
das passende Bitmuster umrechnen. Im einfachsten Fall geht es mit einem 
direkten Reinschreiben, das muss man aber prüfen, ob das so im 
Datenblatt steht (das hah ich nicht)

   (*Channel).MUXCTRL = Pin;

>void ADC_read (void)

Auch der Name ist falsch, denn sie macht deutlich mehr als den ADC 
auslesen.

>{
>  static uint8_t ucADC_Buffer_HW_Ver[ADC_BUFFER_SIZE], 
ucADC_Buffer_Bat_Volt[ADC_BUFFER_SIZE];
>  static uint8_t ucADC_Buffer_Pointer;
>  uint8_t uci;

>  if( (e_Zustand != DC_LADEN) )
>  {
>    ADC_init();

Das hier ist falsch! Du willst den ADC nicht bei jedem Auslesen 
initialisieren! Das macht man nur einmal beim Programmstart.

[Dominik B. (odysseus1710)]

DEU schrieb:
> Channel->MUXCTRL = (Pin << 3);

Damit setzt du für MUX beim ersten Aufruf '10000' und beim zweiten 
'1000'
Folgich wählst du als Eingänge ADC0 und ADC8, das sicher nicht die 
Kanäle sind, die an deinen Pins anliegen.

[DEU (Gast)]

Dominik B. schrieb:
> Damit setzt du für MUX beim ersten Aufruf '10000' und beim zweiten
> '1000'

das ist genau das was ich machen will denn laut Datenblatt ist Bitnummer 
4 Pin 1 und Bitnummer 3 Pin2.

An PortA Pin 1 und Pin 2 liegen genau meine Spannungen an die ich 
einlese.

Falk B. schrieb:
>>   (*Channel).MUXCTRL = (Pin << 3); //selection of ADC-Pin
>
> Falscher Fehler. Beim ATXmega arbeitet man mit den vordefinerten
> Bitmasken, NICHT den Bitnummern!
> Siehe Bitmanipulation. Hier muss du per switch() die Pinnummer in
> das passende Bitmuster umrechnen. Im einfachsten Fall geht es mit einem
> direkten Reinschreiben, das muss man aber prüfen, ob das so im
> Datenblatt steht (das hah ich nicht)
>
>    (*Channel).MUXCTRL = Pin;

ich habe es im Simulator durchgespielt und die Richtigen Bits werden im 
Register MUXCTRL gesetzt





ich habe auch schon versucht zwischen den Kanalwechsel zu warten, hat 
aber keinen Effekt. Das Problem ist das ein Channel für sich 
funktioniert nehme ich aber den zweiten dazu werden falsche werte 
eingelesen.


Was könnte noch das Problem im Quellcode sein?

[Dominik B. (odysseus1710)]

DEU schrieb:
> Dominik B. schrieb:
>> Damit setzt du für MUX beim ersten Aufruf '10000' und beim zweiten
>> '1000'
>
> das ist genau das was ich machen will denn laut Datenblatt ist Bitnummer
> 4 Pin 1 und Bitnummer 3 Pin2.

Mein Fehler. Habe mich auf ein falsches Datenblatt bezogen bei dem 
MUXPOS die Bits 0 bis 3 sind.


DEU schrieb:
> ich habe auch schon versucht zwischen den Kanalwechsel zu warten, hat
> aber keinen Effekt

Du wartest nach dem Start einer Wandlung auf das Interrupt-Flag
DEU schrieb:
> while(!Channel->INTFLAGS)

Laut Datenblatt wird dieses Flag entweder zurückgesetzt, wenn der 
Interrupt Vector aufgerufen wird oder das Bit manuell mit einer '1' 
beschrieben wird.
Vermutlich wird das Flag also nach der ersten Wandlung nie zurückgesetzt 
und beim Start der zweiten Wandlung nicht mehr gewartet bis diese fertig 
ist.