Atmega32, Poti, ADC, Poti-am LCD ausgeben

[Stefan S. (derprogrammierer2)]

Hallo an alle!
Mein zweiter Post!

Und zwar will ich diesmal 2 Potis auf meinem Atmega32 Bord bedienen und 
den Zahlenwert am LCD-Display ausgeben. Am Ausgeben scheitert es bei 
mir:

// system-includes
#include <avr/io.h>
// lokale includes
#include "..\LCD\lcd.h"
// Prototyps
void AD_Init();
unsigned char ucGetADValue_8Bit(char cAD_Channel);
char* Convert_ADU_to_Text(unsigned char ADC_Value);


int main(void)
{
  unsigned char ADC_Value_CH1,ADC_Value_CH2;    // unsigned nur im positiven bereich
  char Text[21];        // 21 Zeichen weil LCD hat 20 + ENTER
  
  lcd_init();
  lcd_blank();
  
    while(1)
    {
    // Beide Potis einlesen
        ADC_Value_CH1 = ucGetADValue_8Bit (1);
    ADC_Value_CH2 = ucGetADValue_8Bit (2);  // nicht sicher ob der 2er richtig ist
    
    // Anzeigen der ADU Werte
    lcd_print(1,0,Convert_ADU_to_Text(ADC_Value_CH1));
    lcd_print(2,0,Convert_ADU_to_Text(ADC_Value_CH2));
    
    }
}

char* Convert_ADU_to_Text(unsigned char ADC_Value)
{
  // Funktion 
}

// Initialisierung des ADU
void AD_Init()
{
  // interne Referenzspannung von 5V .. VCC
  //    REFS0 .. 1
  //    REFS1 .. 0
  // Ausrichtung des Ergebnisses im ADCL und ADCH -- Rechts
  //    ADLAR = 0
  // Auswahl des Kanals
  //    MUX0...MUX4 alle 0 --> ADC0 --> Kanal 0 ausgewählt
  
  // ADMUX = 0x40;
  // oder
  ADMUX = (1 << REFS0);
  
  // ADEN=1 ... Einschalten des ADC
  // Prescaler setzen ... auf 128 --> 125kHz automatik Umsetzung
  // ADPS0..2 alle auf 1
  // eine Möglichkeit:  ADCSRA = 0x87;    // 1000 0111
  // oder
  ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2);
}


// Unterste 8 Bit - ADCLOW nehmen wir
unsigned char ucGetADValue_8Bit(char cAD_Channel)
{
  AD_Init();  // Initialisierung
  // Kanal einstellen ... vorher alle Kanäle löschen - tut das ADInit schon
  ADMUX |= cAD_Channel;
  
  // Starten der Umsetzung
  ADCSRA |= (1<<ADSC);
  
  // warten bis die Umsetzung fertig ist
  while (ADCSRA & (1<<ADSC))
  {
    ;
  }
  
  // Ergebnis auslesen
  return(ADCL);  
  
}

So schaut mein Programm aus. Wie realisiere ich das jetzt mit sprintf, 
itoa usw?  Also im Unterprogramm wo // Funktion steht

p.s: Danke euch schon im Vorraus! Entschuldige mich für meine Kommentare 
im Programm falls etw falsch ist haha , sind nur meine Gedanken

[Stefan S. (derprogrammierer2)]

wäre echt super, wenn mir irgendwer helfen könnt :( verzweifle grad

[Ralph W. (ralph_w713)]

Stefan S. schrieb:
> #include "..\LCD\lcd.h"

mir kommt der include ein wenig falsch vor!

[Stefan S. (derprogrammierer2)]

Ralph W. schrieb:
> Stefan S. schrieb:
>> #include "..\LCD\lcd.h"
>
> mir kommt der include ein wenig falsch vor!

ich könnt auch nur lcd.h reinschreiben

[Wolfgang A. (Gast)]

Stefan S. schrieb:
> ich könnt auch nur lcd.h reinschreiben

Reinschreiben kannst du da vieles. Nützen tut es nur etwas, wenn die 
Datei dort auch liegt.

[Stefan S. (derprogrammierer2)]

Wolfgang A. schrieb:
> Stefan S. schrieb:
>> ich könnt auch nur lcd.h reinschreiben
>
> Reinschreiben kannst du da vieles. Nützen tut es nur etwas, wenn die
> Datei dort auch liegt.

es liegt nicht an den Includes, sondern am Programm. da bin ich mir 
sicher

[Rene H. (Gast)]

Was für ein Display? Wie angeschlossen etc. etc.

Im Zweifelsfall nimm die Fleury Lib.

Grüsse,
R.

[Stefan S. (derprogrammierer2)]

Rene H. schrieb:
> Was für ein Display? Wie angeschlossen etc. etc.
>
> Im Zweifelsfall nimm die Fleury Lib.
>
> Grüsse,
> R.

ich hab 0 ahnung... das lcd funktioniert .. jedoch kann ich nicht diese 
ADU Werte ausgeben... ich muss sie vorher hier:

char* Convert_ADU_to_Text(unsigned char ADC_Value)
{
}

umwandeln in character, und das schaffe ich nicht

oder vielleicht liege ich auch in dem punkt falsch,

Ich würde euch dann fragen, was muss ich eurer Meinung nach tun damit 
ich den Wert vom Poti ausgeben kann? (ADC_Value_CH1, ADC_Value_CH2)

[fb (Gast)]

http://www.mikrocontroller.net/articles/FAQ
Gleich das erste Kapitel!

[Stefan S. (derprogrammierer2)]

fb schrieb:
> http://www.mikrocontroller.net/articles/FAQ
> Gleich das erste Kapitel!

wie genau wende ich das an? itoa geht nicht, da ich keine integer zahl 
habe.

was ist utoa? ultoa?

[Dieter F. (Gast)]

Stefan S. schrieb:
> fb schrieb:
>> http://www.mikrocontroller.net/articles/FAQ
>> Gleich das erste Kapitel!
>
> wie genau wende ich das an? itoa geht nicht, da ich keine integer zahl
> habe.
>
> was ist utoa? ultoa?

Kennst Du google (und kannst ggf. auch Englisch)?

[fb (Gast)]

Stefan S. schrieb:
> itoa geht nicht, da ich keine integer zahl habe.
Dann mach halt eine draus. Oder besser überlaß das dem Compiler, der 
weis wie es geht.

char* Convert_ADU_to_Text( unsigned char ADC_Value, char* buffer )
{
  return itoa( ADC_Value, buffer, 10 );
}

> was ist utoa? ultoa?
utoa ist die Variante für 'unsigned', ultoa für 'unsigned long'. utoa 
kannst Du auch nehmen (ultoa ginge ebenfalls, wäre hier aber etwas 
zuviel des Guten).

char* Convert_ADU_to_Text( unsigned char ADC_Value, char* buffer )
{
  return utoa( ADC_Value, buffer, 10 );
}

[Stefan S. (derprogrammierer2)]

(Kann ich davon ausgehen das mir keiner mit dem Problem da oben (mein 
Programm) helfen kann? )Habe in ein paar Tagen einen Test und das wäre 
so ein Programm, bei dem ich mir gut vorstellen könnte,dass das zum Test 
kommt.
Ich bin echt nicht gut im Programmieren, ich kenne nur die 
Grundfunktionen. Wenn ich irgendwie euch auf die Nerven gehe, tut es mir 
Leid (:

ah, danke für den obigen Post.

[Rene H. (Gast)]

Nimm sprintf.

Grüsse,
R.

[Stefan S. (derprogrammierer2)]

so schauts jz bei mir aus:

// Prototyps
void AD_Init();
unsigned char ucGetADValue_8Bit(char cAD_Channel);
char* Convert_ADU_to_Text(unsigned char ADC_Value, char* Text);


int main(void)
{
  unsigned char ADC_Value_CH1,ADC_Value_CH2;    // unsigned nur im positiven bereich
  char Text[21];        // 21 Zeichen weil LCD hat 20 + ENTER
  
  lcd_init();
  lcd_blank();
  
    while(1)
    {
    // Beide Potis einlesen
        ADC_Value_CH1 = ucGetADValue_8Bit (1);
    ADC_Value_CH2 = ucGetADValue_8Bit (2);  // nicht sicher ob der 2er richtig ist
    
    // Anzeigen der ADU Werte
    lcd_print(1,0,Convert_ADU_to_Text(ADC_Value_CH1,Text));
    lcd_print(2,0,Convert_ADU_to_Text(ADC_Value_CH2,Text));
    
    }
}

char* Convert_ADU_to_Text(unsigned char ADC_Value, char* Text)        // char* kein direkter Speicher zugewiesen
{
  // Funktion
  return sprintf(Text,"%s",ADC_Value);
}

zeigt immernoch nichts an

[fb (Gast)]

Rene H. schrieb:
> Nimm sprintf.

Für das, was der TE haben wollte völliger overkill. Und da er schon mit 
einem simplen itoa/utoa Aufruf überfordert ist, ist er das mit dem 
Aufruf von 'variadic Functions' erst recht

[Stefan S. (derprogrammierer2)]

unsigned char ucGetADValue_8Bit(char cAD_Channel);
char* Convert_ADU_to_Text(unsigned char ADC_Value, char* buffer);


int main(void)
{
  unsigned char ADC_Value_CH1,ADC_Value_CH2,buffer;    // unsigned nur im positiven bereich
  char Text[21];        // 21 Zeichen weil LCD hat 20 + ENTER
  
  lcd_init();
  lcd_blank();
  
    while(1)
    {
    // Beide Potis einlesen
        ADC_Value_CH1 = ucGetADValue_8Bit (1);
    ADC_Value_CH2 = ucGetADValue_8Bit (2);  // nicht sicher ob der 2er richtig ist
    
    // Anzeigen der ADU Werte
    lcd_print(1,0,Convert_ADU_to_Text(ADC_Value_CH1,buffer));
    lcd_print(2,0,Convert_ADU_to_Text(ADC_Value_CH2,buffer));
    
    }
}

char* Convert_ADU_to_Text( unsigned char ADC_Value, char* buffer )
{
  return utoa( ADC_Value, buffer, 10 );
}

klappt auch nicht.

[fb (Gast)]

fb schrieb:
> ist er das mit dem
> Aufruf von 'variadic Functions' erst recht
Sag ich doch:

return sprintf(Text,"%s",ADC_Value);

das funktioniert nicht, lies dir die Doku zu sprintf durch! Insbesondere 
die zum Formatstring.

[Rene H. (Gast)]

Ich tippe auf dem Handy, deshalb halte ich mich knapp.

char* Convert_ADU_to_Text( unsigned char ADC_Value, char* val)
{
  sprintf(val, "%u", ADC_Value);
  
  return(val);
}

[fb (Gast)]

Stefan S. schrieb:
> klappt auch nicht.

Da sollte schon der Compiler rummeckern.
In der Version davor war der Aufruf von 'Convert_ADU_to_Text' noch 
richtig.

Kannst Du mit lcd_print überhaupt irgenwas auf dem Display ausgeben?

[Stefan S. (derprogrammierer2)]

fb schrieb:
> Stefan S. schrieb:
>> klappt auch nicht.
>
> Da sollte schon der Compiler rummeckern.
> In der Version davor war der Aufruf von 'Convert_ADU_to_Text' noch
> richtig.
>
> Kannst Du mit lcd_print überhaupt irgenwas auf dem Display ausgeben?

wenn ich sowas wie
lcd_print(0,1,"Hallo!"); eingebe , ja.
auch ein character (oder besser gesagt nur ein char.

char Text[20];
..
lcd_print(0,1,Text);

das geht alles.

[fb (Gast)]

Rene H. schrieb:
> Ich tippe auf dem Handy, ...
Wenn er die FAQ (http://www.mikrocontroller.net/articles/FAQ) ein paar 
Zeilen weiter gelesen hätte, wäre er vielleicht auch selbst drauf 
gekommen.

[fb (Gast)]

Was klappt denn dann nicht? Wird gar nichts ausgegeben? Was falsches?
Stimmen die ersten beiden Parameter von lcd_print? Also geht z.B.
lcd_print(1,0,"Hallo");
lcd_print(2,0,"Huhu");
?

Ansonsten, wie sieht denn Deine Beschaltung aus?
Was hängt bei Dir am AREF-Pin (ich hoffe nur ein Kondensator)?
An welchen Pins hängen Deine Potis? PA1 & PA2?

Mit welcher Frequenz läuft dein ATmega? Der ADC braucht min 50kHz und Du 
teilst durch 128.

Deine ucGetADValue_8Bit hat auch noch Probleme. Du liest z.B. nie ADCH

[Stefan S. (derprogrammierer2)]

fb schrieb:
> Was klappt denn dann nicht? Wird gar nichts ausgegeben? Was falsches?
> Stimmen die ersten beiden Parameter von lcd_print? Also geht z.B.
> lcd_print(1,0,"Hallo");
> lcd_print(2,0,"Huhu");
> ?
>
> Ansonsten, wie sieht denn Deine Beschaltung aus?
> Was hängt bei Dir am AREF-Pin (ich hoffe nur ein Kondensator)?
> An welchen Pins hängen Deine Potis? PA1 & PA2?
>
> Mit welcher Frequenz läuft dein ATmega? Der ADC braucht min 50kHz und Du
> teilst durch 128.
>
> Deine ucGetADValue_8Bit hat auch noch Probleme. Du liest z.B. nie ADCH


PA1 und PA0  - potis  (ADC1 und ADC0)

der quartz  hat 16 MHz

und wie lese ich ADCH mit? Man hat ja bei (wenn ADLAR = 0) ADCLOW, und 
da ist Bit: 0,1,2,3,4,5,6,7,8,9 ansprechbar, nur weis ich nicht wie 
genau ich Bit 8 und 9 anspreche. das wäre ja ADCL und ADCH zusammen??? 
Wie schreibe ich das in meine Funktion?

[fb (Gast)]

Stefan S. schrieb:
> PA1 und PA0  - potis  (ADC1 und ADC0)

Dann stimmt das hier nicht:

ADMUX |= cAD_Channel;

bzw. das:

ADC_Value_CH1 = ucGetADValue_8Bit (1);
ADC_Value_CH2 = ucGetADValue_8Bit (2);  // nicht sicher ob der 2er richtig ist

Du fragst ADC1 und ADC2 ab, Datenblatt lesen (z.B. Table 84)!

> der quartz  hat 16 MHz
Ok, das passt dann mit dem 128er Prescaler (vorausgesetzt die Fuses sind 
auch passend eingestellt).

> nur weis ich nicht wie
> genau ich Bit 8 und 9 anspreche.
Indem Du ADCH liest. Das mußt Du bei ADLAR = 0 sowieso tun, siehe 
Datenblatt S.203.
Oder Du überläßt das dem GCC, der weis wie es geht:
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#16-Bit_Register_.28ADC.2C_ICR1.2C_OCR1x.2C_TCNT1.2C_UBRR.29

uint16_t t = ADC;
return (unsigned char)(t >> 2);

Alternative: ADLAR = 1 setzen und dann stattdessen nur:

return(ADCH);

[fb (Gast)]

Achso, die wichtigsten Fragen sind immer noch offen:
Was klappt denn nicht? Wie sind Deine Erwartungen, was passiert 
stattdessen?
...

[Stefan S. (derprogrammierer2)]

fb schrieb:
> Achso, die wichtigsten Fragen sind immer noch offen:
> Was klappt denn nicht? Wie sind Deine Erwartungen, was passiert
> stattdessen?
> ...

Sorry.

Und zwar:

Ich will jetzt auf meinem AVR-Board, auf dem 2 Potentiometer drauf sind 
diese 2 Potis verstellen(also drehen) und zugleich das dieser Wert am 
LCDangezeigt wird. D.h. ich drehe mein Poti (nur im positiven Bereich 
0+) und der Wert bei dem ich gerade bin wird am LCD angezeigt.

Was nicht klappt: Da bin ich mir auch nicht sicher. Ich kriege halt 
keinen Wert auf meinem LCD wenn ich am Poti drehe, und ich weiss nicht 
ob das an meinem sprintf liegt oder an sonst was.

Was stattdessen passiert: Nichts. Das LCD ist an(geschlossen), getestet 
habe ich es mit anderen Programmen, es funktioniert. Ich bin relativ neu 
in diesem Mikrocontroller-Bereich und auch im Programmieren allgemein. 
:(

[Stefan S. (derprogrammierer2)]

Ich möchte den "Wert" eines Potis (den aktuellen)
mittels ADC einlesen und danach auf einem LCD ausgeben

[fb (Gast)]

Du hast geschrieben, das ein

lcd_print(0,1,"Hallo!");

 funktioniert. Was bedeuten denn die ersten beiden Parameter? Welche 
Werte sind möglich?
Wie groß ist Dein Display? Wo auf dem Display steht das "Hallo"?
Geht z.B.:

int main(void)
{
  lcd_init();
  lcd_blank();

  while(1)
  {
    lcd_print(1,0,"Hallo");
    lcd_print(2,0,"Huhu");
  }
}

Das Dein Program falsche Werte anzeigt ist klar. Aber irgendwas sollte 
schon angezeigt werden.

BTW. Welche LCD Lib verwendest Du? Link?

[Stefan S. (derprogrammierer2)]

fb schrieb:
> Du hast geschrieben, das einlcd_print(0,1,"Hallo!"); funktioniert. Was
> bedeuten denn die ersten beiden Parameter? Welche
> Werte sind möglich?
> Wie groß ist Dein Display? Wo auf dem Display steht das "Hallo"?

lcd_print(0,1,"Hallo!");

ist falsch. da habe ich etwas falsches hingeschrieben.

es müsste: lcd_print(1,0,"Hallo!"); -- x,y, ist halt meine position am 
lcd

stehen. das funktioniert, bzw mein Text fängt in der ersten Zeile links 
an.

ein ausschnitt aus dem handbuch:

"Zur Konfiguration des LCD gibt es im Controller-IC Control-Register. 
Die darzustellenden Zeichen werden
zunächst in die 80 Speicherzellen aufgenommen und danach am LCD 
angezeigt. Dabei sind die Speicherzellen
0 bis 15 der ersten Zeile am Display und die Speicherzellen 40 bis 55 
der 2. Zeile zugeordnet.
"

Noch ein Auszug:

"

void toggle_enable_pin(void);
  void lcd_send(unsigned char type, unsigned char c);
  void lcd_set_cursor(uint8_t x, uint8_t y);
  void lcd_write(char *t);
  void lcd_print(int x,int y,char *t);
  void lcd_init();
  void lcd_blank();

"

[fb (Gast)]

Ok x und y, dann müßte bei:

  while(1)
  {
    lcd_print(1,0,"Hallo");
    lcd_print(2,0,"Huhu");
  }

eigentlich sowas wie "HHuhu" links oben im Display stehen.
Bei

  while(1)
  {
    lcd_print(1,0,"Hallo");
    lcd_print(1,1,"Huhu");
  }

sollten dann zwei Zeilen zu sehen sein?

[Stefan S. (derprogrammierer2)]

fb schrieb:
> Ok x und y, dann müßte bei:
>

>   while(1)
>   {
>     lcd_print(1,0,"Hallo");
>     lcd_print(2,0,"Huhu");
>   }
>

> eigentlich sowas wie "HHuhu" links oben im Display stehen.
> Bei
>

>   while(1)
>   {
>     lcd_print(1,0,"Hallo");
>     lcd_print(1,1,"Huhu");
>   }
>

> sollten dann zwei Zeilen zu sehen sein?

jap, Hallo links oben in der ersten
und Huhu in der zweiten links

[fb (Gast)]

Dann so?

#include <avr/io.h>
#include "..\LCD\lcd.h"

void AD_Init();
unsigned char ucGetADValue_8Bit(unsigned char cAD_Channel);
char* Convert_ADU_to_Text(unsigned char ADC_Value, char* buffer);

int main(void)
{
  unsigned char ADC_Value_CH1,ADC_Value_CH2;    // unsigned nur im positiven bereich
  char Text[21];        // 21 Zeichen weil LCD hat 20 + ENTER
  
  lcd_init();
  lcd_blank();
  
  while(1)
  {
    // Beide Potis einlesen
    ADC_Value_CH1 = ucGetADValue_8Bit(0);
    ADC_Value_CH2 = ucGetADValue_8Bit(1);  // nicht sicher ob der 2er richtig ist
    
    // Anzeigen der ADU Werte
    lcd_print(1,0,Convert_ADU_to_Text(ADC_Value_CH1,Text));
    lcd_print(1,1,Convert_ADU_to_Text(ADC_Value_CH2,Text));
    
  }
}

char* Convert_ADU_to_Text( unsigned char ADC_Value, char* buffer )
{
  sprintf( buffer , "%u    ", ADC_Value );
  return buffer;
}

void AD_Init()
{
  ADMUX = (1<<REFS0) | (1<<ADLAR);
  ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2);
}

unsigned char ucGetADValue_8Bit(unsigned char cAD_Channel)
{
  AD_Init();  // Initialisierung
  ADMUX = (ADMUX & 0xe0) | ( cAD_Channel & 0x07 );
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));
  return(ADCH);  
}

Da die ADC-Werte durchaus von Messung zu Messung schwanken und sehr 
schnell aufs LCD geschrieben werden, könnte es allerdings schwer werden 
die dann auch zu lesen.

[Stefan S. (derprogrammierer2)]

fb schrieb:

> Da die ADC-Werte durchaus von Messung zu Messung schwanken und sehr
> schnell aufs LCD geschrieben werden, könnte es allerdings schwer werden
> die dann auch zu lesen.

würde dagegen helfen wenn man das ganze mit delay verlangsamt? oder mit 
einer if (PIND & (1<<TASTE) erst das lesen starte. ich probier mal rum. 
Danke !

[Stefan S. (derprogrammierer2)]

im lcd wird wieder nichts angezeigt.
ich bin offiziell jetzt verzweifelt. ich glaub ich gebs auf heute und 
versuchs in paar tagen wieder. ich weiss einfach nicht worans liegt

[Marco G. (grmg2010)]

Das klingt ein wenig so, als ob du keinen Wert vom ADC bekommst und der 
Buffer daher leer ist und somit nichts angezeigt wird.
Versuch doch mal der Funktion einen festen Wert zu geben/also dem 
ADC_VALUE_CH1 oder ADC_VALUE_CH2). Wenn dann kein Wert angezeigt wird, 
muss etwas an der Ausgaberoutine nicht ganz korrekt sein. Wenn mit einem 
festen Wert eine Anzeige bekommst gibt es Probleme mit dem ADC

[DH1AKF W. (wolfgang_kiefer)]

Schau mal hier, wie es geht:
Beitrag "80 MHz- Zähler mit Atmega32A"

[Dieter F. (Gast)]

fb schrieb:
> return(ADCH);

Warum liest Du kein Datenblatt und schaust auch nicht mal im WWW, wie 
andere es machen.

Aus der Messung resultiert ein 16-Bit-Wert im "Doppel-Register" ADC 
(ADCH und ADCL). Datenblatt S. 213:

After the conversion is complete (ADIF is high), the conversion result 
can be found in the ADC Result Registers (ADCL, ADCH).

In Assembler musst Du die in einer definierten Reihenfolge auslesen und 
verarbeiten. Der GCC-Compiler kennt die Reihenfolge und übernimmt das 
für Dich. Du kannst das Ergebnis (sofern Du keine linksbündige Ausgabe 
gewählt hast - was Du leider mit Setzen des ADLAR-Bits gemacht hast 
...!!) als "normale" 16-Bit-Zahl ohne Vorzeichen verwenden und mit 
SPRINTF für die Ausgabe umformen.

DH1AKF liest den jeweiligen ADC-Kanal so:

uint16_t ReadADC(uint8_t ADCport){
  
  ADMUX  |=(ADCport & 7);           // Kanal anwählen
  ADCSRA |= (1<<ADSC);              // Start A/D- Wandlung
  while(ADCSRA&(1<<ADSC));          // Warten auf Ende der Konversion

  return(ADC);
}

Das Ergebnis / den Aufruf könntest Du (z.B. für ADC-Kanal 1)so 
gestalten:

char outString[10];

...

sprintf(outString, "%u", ReadADC(1));
lcd_print(1,0,outString)

[DH1AKF W. (wolfgang_kiefer)]

Dieter F. schrieb:
> DH1AKF liest den jeweiligen ADC-Kanal so:


Das wurde korrigiert:

uint16_t ReadADC(uint8_t ADCport){
const uint8_t admux_mask = (1<<MUX4)|(1<<MUX3)|(1<<MUX2)|(1<<MUX1)|(1<<MUX0);

  ADMUX = (ADMUX & ~(admux_mask)) | (ADCport & 7);//    Kanal anwählen, vorher löschen  
  ADCSRA |= (1<<ADSC);//              Start A/D- Wandlung
  while(ADCSRA&(1<<ADSC));//            Warten auf Ende der Konversion
  return(ADC);
}

Warum? Weil bei Wechsel des Kanals erst einmal die alten Kanalbits 
gelöscht werden müssen.

Man könnte auch schreiben:

ADMUX = (ADMUX & 224) | (ADCport & 7);// Kanal löschen und neu setzen

[fb (Gast)]

Dieter F. schrieb:
> fb schrieb:
>> return(ADCH);
>
> Warum liest Du kein Datenblatt und schaust auch nicht mal im WWW, wie
> andere es machen.
>
> Aus der Messung resultiert ein 16-Bit-Wert im "Doppel-Register" ADC
> (ADCH und ADCL). Datenblatt S. 213:

Dann solltest Du das Datenblatt ebenfalls nochmal lesen!
Wenn ADLAR auf 1 gesetzt ist steht der Wert linksbündig in ADC. Wenn man 
nur 8 Bit (die obersten halt) haben will reicht es nur ADCH zu lesen. 
Datenblat S.217:
"Consequently, if the result is left adjusted and no more than 8-bit 
precision is required, it is sufficient to read ADCH."

[Dieter F. (Gast)]

fb schrieb:
> Dieter F. schrieb:
>> fb schrieb:
>>> return(ADCH);
>>
>> Warum liest Du kein Datenblatt und schaust auch nicht mal im WWW, wie
>> andere es machen.
>>
>> Aus der Messung resultiert ein 16-Bit-Wert im "Doppel-Register" ADC
>> (ADCH und ADCL). Datenblatt S. 213:
>
> Dann solltest Du das Datenblatt ebenfalls nochmal lesen!
> Wenn ADLAR auf 1 gesetzt ist steht der Wert linksbündig in ADC. Wenn man
> nur 8 Bit (die obersten halt) haben will reicht es nur ADCH zu lesen.
> Datenblat S.217:
> "Consequently, if the result is left adjusted and no more than 8-bit
> precision is required, it is sufficient to read ADCH."

Ja, wenn Du die volle Auflösung nicht brauchst und sowieso runden 
willst.
Der TO hat aber nichts davon geschrieben.

Sorry - ich meinte mit meiner Antwort den TO und habe Deinen Beitrag 
erwischt :-\

Dieter F. schrieb:
> Du kannst das Ergebnis (sofern Du keine linksbündige Ausgabe
> gewählt hast - was Du leider mit Setzen des ADLAR-Bits gemacht hast
> ...!!)

Und ADLAR kenne ich sehr wohl :-)

[fb (Gast)]

Dieter F. schrieb:
> Der TO hat aber nichts davon geschrieben.

Geht doch eindeutig aus dem Funktionsnamen und dem Returntyp hervor:
"unsigned char ucGetADValue_8Bit(char cAD_Channel)"

[Dieter F. (Gast)]

fb schrieb:
> Geht doch eindeutig aus dem Funktionsnamen und dem Returntyp hervor:
> "unsigned char ucGetADValue_8Bit(char cAD_Channel)"

Ja, deswegen liest er im Einstiegs-Post auch das low-Register aus. Er 
weiß/wusste es wahrscheinlich nicht besser ... .

[fb (Gast)]

Dieter F. schrieb:
> Ja, deswegen liest er im Einstiegs-Post auch das low-Register aus.
Aber nur das ADCL ohne ADCH, was auch verkehrt ist weil:
"When ADCL is read, the ADC Data Register is not updated until ADCH is 
read."
Daß der Wert ohne die 2 obersten Bit dann ziemlich

Hatte ich den TE aber auch schon alles geschrieben, einschließlich dem 
Hinweis auf die 16Bit Variante, siehe: 
Beitrag "Re: Atmega32, Poti, ADC, Poti-am LCD ausgeben" und die 
2 folgenden Posts.

> Er weiß/wusste es wahrscheinlich nicht besser ... .
Sicher.

[fb (Gast)]

fb schrieb:
> Daß der Wert ohne die 2 obersten Bit dann ziemlich
Ooops, da fehlt noch was:

Daß der Wert ohne die 2 obersten Bit dann ziemlich sinnlos ist, ist 
sowieso klar.

[Dieter F. (Gast)]

fb schrieb:
> Daß der Wert ohne die 2 obersten Bit dann ziemlich sinnlos ist, ist
> sowieso klar.

Schön, dass Du das auch merkst :-)

[Stefan S. (derprogrammierer2)]

jap, habe es jz geschafft. danke euch!!

[Dietrich L. (dietrichl)]

Stefan S. schrieb:
> jap, habe es jz geschafft. danke euch!!

Üblicherweise sagt man dann auch, was bei Dir das Problem war und wie 
Deine Lösung aussieht - als Hilfe für andere Leser!

Gruß Dietrich

[Stefan S. (derprogrammierer2)]

so schaut meine Lösung aus:

#include <avr/io.h>
#include "..\LCD\lcd.h"


void ADC_init(void);
uint16_t ADC_read(uint8_t kanal);
void lcd_wInt(int convNum);




int main(void)
{
  int ADC_Wert=0;
  ADC_init();
  lcd_init();
  DDRD = 0xF0;
  int buttonstate = 0;
  
  while(1)
  {
    
    if (!(PIND & (1<<PD3))&&(buttonstate == 0))
    {
      
      buttonstate = 1;
      
      ADC_Wert = ADC_read(1);
      lcd_wInt(ADC_Wert);  
      
      PORTD= 0xF0;
      
    }
    else if ((PIND & (1<<PD3))&&(buttonstate == 1))
    {
      
      buttonstate = 0;
      
      lcd_blank();
      
      PORTD= 0x00;
        
    }
  
  }
}
void ADC_init(void){
  //Diese Funktion aktiviert den ADC -- falsch muss 3 prescaler setzen
  ADCSRA |= (1<<ADEN);  //ADC aktivieren und
  ADCSRA |= (1<<ADPS2);  //Teilungsfaktor auf 64 stellen:
  ADCSRA |= (1<<ADPS1);  //siehe Datenblatt Maskierung
  
}
uint16_t ADC_read(uint8_t kanal){

  ADMUX=kanal; //Kanal des Multiplexers wählen:
  sbi(ADCSRA,ADSC);//Messung starten
  while(bit_is_set(ADCSRA,ADSC));// Auf Ergebnis warten:
  return ADCW;
}
/*
  Funktion:      LCD_wInt(write Integer)
  
  Eingabeparameter:  int convNum:
              Integerzahl die in einen String umgewandelt werden soll
              und übers LCD ausgegeben werden soll
  
  Augabeparameter:  keine
  
  Rückgabe      keine(Ich wollte dass die Funk. eine string Var. zurückgibt dass hat aber nicht funktioniert)
  
  Die Funktion ermittelt zuerst wieviele Stellen Die Integer Zahl hat. Als nächstes ermittelt sie die Ziffern der 
  einzelnen Stellen und schreibt diese schließlich als Character in den String. Zum Schluss wird der String am LCD
  ausgegeben.
*/
void lcd_wInt(int convNum)
{
  char stringNum[10], charNum[10]="0123456789";
  int runVar = 1,saveVar=0,numLen = 0;
  
  while((convNum%runVar)!=convNum)  //Ermittlung der Ziffernanzahl 
  {                  //Schleife wird durchlaufen solange Rest der Modfunk. Die Zahl selbst ist.
    numLen++;            //Erhöhung der Ziffernanzahl
    runVar=runVar*10;        //Anpassung der Laufvariable
  }
  
  stringNum[numLen]='\0';        //Ende des Strings festlegen
  runVar = 10;            //Anpassung der Laufvariable
  for(int i=numLen;i>0;i--)      //Schleife wird durchlaufen bis alle Stellen der Zahl abgearbeitet wurden
  {
    saveVar = convNum%runVar;    //Ziffernwert auf die Zwischenvariable speichern
    stringNum[i-1]=charNum[saveVar];//Ziffernwert auf den string speichern
    convNum = convNum-(saveVar);  //Anpassen der Int Zahl
    convNum = convNum/10;      //-"-
  }
  lcd_write(stringNum);        //String ausgeben
}

Ich weiss zwar nicht wieso, aber sprintf oder itoa funktionieren hier 
nicht. das mit uint (also der hinweis und die hilfe von euch hat echt 
geholfen. danke).

Wäre echt interessant zu wissen wieso sprintf oder itoa nicht klappen..

[Stefan S. (derprogrammierer2)]

geht doch mit itoa und sprintf, nur bissl pfuschen und tricksen.

#case closed

[Dieter F. (Gast)]

Stefan S. schrieb:
> nur bissl pfuschen und tricksen

K.A., was Du mit "pfuschen und tricksen" meinst - aber das geht ganz 
normal:

#include <stdlib.h>
#include <avr/io.h>
#include <string.h>
#include <stdio.h>
#include <util/delay.h>
#include "lcd.h"

char    outString[10];
uint8_t    printposy;
uint16_t    adc0_wert = 1024;
uint16_t    adc1_wert = 1024;
uint16_t    adc0_wert_old = 0;
uint16_t    adc1_wert_old = 0;

void    ADC_init(void);
uint16_t  ADC_read(uint8_t kanal);


int main(void)
{
  ADC_init();
  lcd_init(LCD_DISP_ON);
  lcd_clrscr();
  
  while(1)
  {
    adc0_wert = 0;
    for (uint8_t i=0;i<32;i++)
    {
      adc0_wert += ADC_read(0);
    }
    adc0_wert = adc0_wert>>5;
    if (adc0_wert != adc0_wert_old)
    {
      lcd_gotoxy(0,0);
      lcd_puts("ADC0:           ");
      sprintf(outString, "%u", adc0_wert);
      printposy = 16 - strlen( outString );
      lcd_gotoxy(printposy,0);
      lcd_puts(outString);
      adc0_wert_old = adc0_wert;
    }
    
    adc1_wert = 0;
    for (uint8_t i=0;i<32;i++)
    {
      adc1_wert += ADC_read(1);
    }
    adc1_wert = adc1_wert>>5;
    if (adc1_wert != adc1_wert_old)
    {
      lcd_gotoxy(0,1);
      lcd_puts("ADC1:           ");
      sprintf(outString, "%u", adc1_wert);
      printposy = 16 - strlen( outString );
      lcd_gotoxy(printposy,1);
      lcd_puts(outString);
      adc1_wert_old = adc1_wert;
    }
  }
}


void ADC_init(void)
{
  ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0);
  ADCSRA |= (1<<ADEN);
}

uint16_t ADC_read(uint8_t kanal)
{
  static uint8_t kanal_old = 0x08;
  
  const uint8_t admux_mask = (1<<MUX4)|(1<<MUX3)|(1<<MUX2)|(1<<MUX1)|(1<<MUX0);

  if (kanal_old != kanal)
  {
    ADMUX = (ADMUX & ~(admux_mask)) | (kanal & 0x07);
  }
  ADCSRA |= (1<<ADSC);
  while(ADCSRA&(1<<ADSC));
  return(ADC);
}

Ich hab die Display-Ausgabe noch etwas beruhigt (durch 
Mittelwert-Bildung aus 32 Lese-Zyklen und Abfrage auf Wert-Änderung). 
Ich nutze den ADC-Prescaler 128, da ich einen 16 MHz Quarz dran habe.
Basis ist die Fleury-Lib mit einen 4 * 16 Zeichen Display.

[Wolfgang (Gast)]

Dieter F. schrieb:
> Ich hab die Display-Ausgabe noch etwas beruhigt (durch
> Mittelwert-Bildung aus 32 Lese-Zyklen und Abfrage auf Wert-Änderung).

Richtig beruhigen würde man sie, indem man die Anzeige mit einer 
Hysterese versieht, die größer als das Rauschen der (ggf. vorher 
gemittelten) Daten ist. Sonst gibt es immer Werte, bei denen die Anzeige 
unruhig wird.