Atmega128 Differenzspannung wird falsch berechnet.

[Jan S. (simpson1991)]

Hallo, ich habe folgendes Problem:
Ich möchte mir über den ADC die Differenzspannung zwischen F0 und F1 an 
einem Display ausgeben lassen.
Das Datenblatt des Atmega gibt dafür den MUX 10000 an.
Das Problem ist, dass beide Spannungen 5v und (0v-5v) addiert statt 
subtrahiert werden.
Weiß jemand wieso?

Edit: Sehe grad die Kommentare sind etwas durcheinander, hoffe dass 
stört nicht. :)

/*
 * AD-Wandler.c
 *
 * Created: 18.12.2017 11:27:10
 * Author : Sch
 */ 

#include <avr/io.h>
#include "lcd.h"
#define F_CPU 16000000UL
#include <util/delay.h>


int main(void)
{
  DDRB |= 0x00;//Eingang
  DDRC |= 0xFF;//Ausgang
  DDRF |= 0x00;//Eingang
  DDRG |= 0xFF;//Ausgang
  PORTC = 0;//PORTC ausschalten
  PORTF = 0;//PORTF ausschalten
  PORTG = 0;//PORTG ausschalten
  
  uint16_t wert1; // Deklarierung der Variable “wert1”
  uint16_t wert2; // Deklarierung der Variable “wert2”
  uint16_t wert3;
  
  char oupt1[20];
  char oupt2[20];
  
  lcd_init();
  
  ADMUX |= (0<<REFS1)|(1<<REFS0);//interne Referenzspannung an, AVCC als
            //Referenzspannungsquelle gewählt
  ADMUX |= (0<<MUX0) | (0<<MUX1) | (0<<MUX2) | (0<<MUX3) | (1<<MUX4);//PORTF0-PORTF1 mit Gain x1 
  ADMUX &= ~(1<<ADLAR);//ADC Right adjustment ist aktiviert
            //niederwertiges Byte im ADCL Register
            //des AD-Wandlers
            
  ADCSRA |= (1<<ADPS1)|(1<<ADPS0);//AD-Wandler-Rate auf 1/8 der Quarzfrequenz
                  //(hier = 16/8 MHz = 2 MHz)
  ADCSRA |= (1<<ADEN);//AD-Konverter "enablen" (=einschalten)
  ADCSRA &= ~(1<<ADIE);//Interrupt Modus ausschalten
  ADCSRA &= ~(1<<ADFR);//AD-Konverter läuft nicht im free running
            //mode (Es wird nur ein Einzelevent gewandelt)
            
  ADCSRA |= (1<<ADSC);//AD-Konverter einschalten Start Einzel-
            //Konversion
  
  while(ADCSRA & (1<<ADSC) ) {} //warten bis ADSC Bit gelöscht wird und ADC
                //fertig ist
  
    while(1)
    {
    
    ADCSRA |= (1<<ADSC); //“AD Start conversion” startet Konvertierung
    
    while(ADCSRA & (1<<ADSC)){} //warten bis ADSC Bit wieder von selbst gelöscht wird
    
    wert1 = ADCL;
        wert1 |= (ADCH << 8);              //(AD Konverter ist dann fertig)
    //wert1=ADCL+(256*ADCH);//Wert des AD-Konverters (10 bits als 2 x 8 Bit-Wert
              //aus 256 * Hi-Byte und Lo-Byte
    
    
    wert3=((REFS0*(ADCL+256*ADCH))/(1*512));//Dezimalwert in Volt
    
    
    itoa(wert1,oupt1,10);
    itoa(wert3,oupt2,10);
    
    lcd_clear();
    lcd_setcursor(0,1);
    lcd_string(oupt1);
    lcd_setcursor(0,2);
    lcd_string(oupt2);
    lcd_data('V');
    _delay_ms(50);
  }
  
  
}

[Johann L. (gjlayde)]

Ach wenn's nix mit deinem Problem zu tun hat...

Jan S. schrieb:
>   ADCSRA |= (1<<ADPS1)|(1<<ADPS0);//AD-Wandler-Rate auf 1/8 der
> Quarzfrequenz
>                   //(hier = 16/8 MHz = 2 MHz)

Der ADC schafft 2MHz ?

>     wert1 = ADCL;
>         wert1 |= (ADCH << 8);              //(AD Konverter ist dann
> fertig)

Besser: "wert1 = ADC;"

>     wert3=((REFS0*(ADCL+256*ADCH))/(1*512));//Dezimalwert in Volt

Nochmals Lesen und Byte-Frickel?

Besser: "wert3 = (REFS0 * wert1) / (1 * 512);"

Checken, ob die möglichen Werte von REFS0 nicht zu einem Überlauf des 
Zählers führen.  Falls dem so ist, mit 32 Bits rechnen lassen:

wert3 = (REFS0 * (uint32_t) wert1) / (1 * 512);

[Jan S. (simpson1991)]

Danke, aber er addiert immer noch,.

[S. Landolt (Gast)]

> wert3=((REFS0*(ADCL+256*ADCH))/(1*512));//Dezimalwert in Volt
?
REFS0 ist 6, was wird hier berechnet?