Fehler beim ADC in meinem C-programm

[fragender (Gast)]

Hallo Leute,
Ich habe vor mir eine µC Steuerung für mein Netzteilprojekt zu bauen. 
Verwendet wird ein Atmega8 bei 8Mhz intern (ersmal). Da ich grad am üben 
mit C bin (etwas ehrfahrener Anfänger :D) hab ich mich mal an die ganze 
Sache mit ADC, PWM, und LCD gesetzt und versucht was zu erreichen. Ich 
hab mir zur Hilfe und zur Erklärung das AVRGCC tutorial von 
mikrocontroller.net zu rate gezogen wie man im Quelltext unschwer 
erkennen kann. Die Sachen zur ansteuerung von PWM und ADC des Atmega hab 
ich verstanden Dank dem Tutorial nur beim LCD hab ich noch nicht ganz 
alles verstanden (kommt mit der Zeit und Erfahrung :-) denk ich mal  ) 
deswegen hab ich das mal so übernommen nicht wundern das ist jetzt Ja 
auch nicht mein anliegen.

Nun ist es so das ich drei ADC kanäle (ADC0 ADC1 ADC2) nutzen möchte 
aber irgendwie trennt er die einzelnen adc ergebnisse nicht von den 
Aufgaben was damit geschehen soll (siehe unten bei Int main(void)) also 
muss ja meinerseits ein Fehler sein.Könnt ihr mir helfen/sagen wie man 
DIESEN Fehler behebt?

(Ja ich weiß der Code ist naja nicht der beste aber naja)

#define F_CPU 8000000            //interner 1MHz OSzillator
#include <avr/io.h>
#include <lcd_routines.h>
#include <util/delay.h>
#include <stdlib.h>
#include <stdio.h>

void ADC_Init(void){            //ADC initialisieren
  
  uint16_t result;            //Ergebnisvariable "result"
  
  ADMUX = (1<<REFS0);            //Referenzspannung von Avcc  
  
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);    //Vorteiler = 8
  ADCSRA = (1<<ADEN);            //ADC aktivieren
  
  result = ADCW;
    
}

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);          // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {      // auf Abschluss der Konvertierung warten
  }
  return (ADCW);              // ADC auslesen und zurückgeben
}

/* ADC Mehrfachmessung mit Mittelwertbbildung */
/* beachte: Wertebereich der Summenvariablen */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t nsamples )
{
  uint32_t sum = 0;
  
  for (uint8_t i = 0; i < nsamples; ++i ) {
    sum += ADC_Read( channel );
  }
  
  return (uint16_t)( sum / nsamples );
}

 ////////////////////////////////////////////////////////////////////////////////
 // Erzeugt einen Enable-Puls
 static void lcd_enable( void )
 {
   LCD_PORT |= (1<<LCD_EN);     // Enable auf 1 setzen
   _delay_us( LCD_ENABLE_US );  // kurze Pause
   LCD_PORT &= ~(1<<LCD_EN);    // Enable auf 0 setzen
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Sendet eine 4-bit Ausgabeoperation an das LCD
 static void lcd_out( uint8_t data )
 {
   data &= 0xF0;                       // obere 4 Bit maskieren
   
   LCD_PORT &= ~(0xF0>>(4-LCD_DB));    // Maske löschen
   LCD_PORT |= (data>>(4-LCD_DB));     // Bits setzen
   lcd_enable();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Initialisierung: muss ganz am Anfang des Programms aufgerufen werden.
 void lcd_init( void )
 {
   // verwendete Pins auf Ausgang schalten
   uint8_t pins = (0x0F << LCD_DB) |           // 4 Datenleitungen
   (1<<LCD_RS) |                // R/S Leitung
   (1<<LCD_EN);                 // Enable Leitung
   LCD_DDR |= pins;
   
   // initial alle Ausgänge auf Null
   LCD_PORT &= ~pins;
   
   // warten auf die Bereitschaft des LCD
   _delay_ms( LCD_BOOTUP_MS );
   
   // Soft-Reset muss 3mal hintereinander gesendet werden zur Initialisierung
   lcd_out( LCD_SOFT_RESET );
   _delay_ms( LCD_SOFT_RESET_MS1 );
   
   lcd_enable();
   _delay_ms( LCD_SOFT_RESET_MS2 );
   
   lcd_enable();
   _delay_ms( LCD_SOFT_RESET_MS3 );
   
   // 4-bit Modus aktivieren
   lcd_out( LCD_SET_FUNCTION |
   LCD_FUNCTION_4BIT );
   _delay_ms( LCD_SET_4BITMODE_MS );
   
   // 4-bit Modus / 2 Zeilen / 5x7
   lcd_command( LCD_SET_FUNCTION |
   LCD_FUNCTION_4BIT |
   LCD_FUNCTION_2LINE |
   LCD_FUNCTION_5X7 );
   
   // Display ein / Cursor aus / Blinken aus
   lcd_command( LCD_SET_DISPLAY |
   LCD_DISPLAY_ON |
   LCD_CURSOR_OFF |
   LCD_BLINKING_OFF);
   
   // Cursor inkrement / kein Scrollen
   lcd_command( LCD_SET_ENTRY |
   LCD_ENTRY_INCREASE |
   LCD_ENTRY_NOSHIFT );
   
   lcd_clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Sendet ein Datenbyte an das LCD
 void lcd_data( uint8_t data )
 {
   LCD_PORT |= (1<<LCD_RS);    // RS auf 1 setzen
   
   lcd_out( data );            // zuerst die oberen,
   lcd_out( data<<4 );         // dann die unteren 4 Bit senden
   
   _delay_us( LCD_WRITEDATA_US );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Sendet einen Befehl an das LCD
 void lcd_command( uint8_t data )
 {
   LCD_PORT &= ~(1<<LCD_RS);    // RS auf 0 setzen
   
   lcd_out( data );             // zuerst die oberen,
   lcd_out( data<<4 );           // dann die unteren 4 Bit senden
   
   _delay_us( LCD_COMMAND_US );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Sendet den Befehl zur Löschung des Displays
 void lcd_clear( void )
 {
   lcd_command( LCD_CLEAR_DISPLAY );
   _delay_ms( LCD_CLEAR_DISPLAY_MS );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Sendet den Befehl: Cursor Home
 void lcd_home( void )
 {
   lcd_command( LCD_CURSOR_HOME );
   _delay_ms( LCD_CURSOR_HOME_MS );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Setzt den Cursor in Spalte x (0..15) Zeile y (1..4)
 
 void lcd_setcursor( uint8_t x, uint8_t y )
 {
   uint8_t data;
   
   switch (y)
   {
     case 1:    // 1. Zeile
     data = LCD_SET_DDADR + LCD_DDADR_LINE1 + x;
     break;
     
     case 2:    // 2. Zeile
     data = LCD_SET_DDADR + LCD_DDADR_LINE2 + x;
     break;
     
     case 3:    // 3. Zeile
     data = LCD_SET_DDADR + LCD_DDADR_LINE3 + x;
     break;
     
     case 4:    // 4. Zeile
     data = LCD_SET_DDADR + LCD_DDADR_LINE4 + x;
     break;
     
     default:
     return;                                   // für den Fall einer falschen Zeile
   }
   
   lcd_command( data );
 }
 
 ///////
 /////////////////////////////////////////////////////////////////////////
 // Schreibt einen String auf das LCD
 
 void lcd_string( const char *data )
 {
   while( *data != '\0' )
   lcd_data( *data++ );
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Schreibt ein Zeichen in den Character Generator RAM
 
 void lcd_generatechar( uint8_t code, const uint8_t *data )
 {
   // Startposition des Zeichens einstellen
   lcd_command( LCD_SET_CGADR | (code<<3) );
   
   // Bitmuster übertragen
   for ( uint8_t i=0; i<8; i++ )
   {
     lcd_data( data[i] );
   }
}   


void st(void){
  while (bit_is_set(PINB,0)){}
  PORTB |= _BV(PB4);
  lcd_setcursor(0,1);
  lcd_string("  PSU 30/1500");
  lcd_setcursor(0,2);
  lcd_string("(Soft.-vers 1.1)");
  _delay_ms(2000);
  PORTB |= _BV(PB5);
  lcd_clear();
  lcd_setcursor(15,1);
  lcd_string("V");
  lcd_setcursor(6,1);
  lcd_string("A");
}


void standby(void){
  lcd_clear();
  lcd_setcursor(1,1);
  lcd_string("   Goodbye!");
  _delay_ms(2000);
  PORTB &= ~_BV(PB4);
  PORTB &= ~_BV(PB5);
  while (bit_is_set(PINB,0)){}
  st();
  
}

int main(void){
  
  DDRB = 0b11110010;
  PORTB = PORTB | _BV(PB0) | _BV(PB2) | _BV(PB3);
  TCCR1A = (1<<WGM11) | (1<<WGM10) | (1<<COM1A1); 
  TCCR1B = (1<<CS10); 
  
  ADC_Init();
  lcd_init();
  st();
    
  uint16_t delay = 0;
  uint16_t adcval;
  uint16_t volt;
  uint16_t amp;
  double resv;
  double resa;
  char strv[10];
  char stra[10];
  
  while(1){
    
  adcval = ADC_Read(0);
  volt = ADC_Read(1);
  amp = ADC_Read(2);
  OCR1A = adcval;
  
  if (bit_is_clear(PINB,2)){
    standby();  
  }  
  
  if (delay > 40000){
      resa = amp;
      resa /= 100 * 4.8876;
      dtostrf(resa, 5, 2, stra);
      lcd_setcursor(0,1);
      lcd_string(stra);
      
      resv = volt;
      resv /= 1000 * 4.8876;
      dtostrf(resv, 5, 2, strv);
      lcd_setcursor(9,1);
      lcd_string(strv);
      delay = 0;
  }
  delay ++;
  }
}

[holger (Gast)]

>aber irgendwie trennt er die einzelnen adc ergebnisse nicht von den
>Aufgaben was damit geschehen soll

Bahnhof?

[hawo1997 (Gast)]

Es geht mir halt darum das ich ich egal an welchen pin ich eine Spannung 
anschließe (von den adc pins) das die Ergebnisse in den variablen "volt" 
"amp" und "adcval" gleich sind obwohl sie ja mit

adcval = ADC_Read(0); volt = ADC_Read(1); amp = ADC_Read(2);

eigendlich jede von einem anderen adc pin (halt adc0 adc1 und 
adc2)festgestellt wurden
so denke ich das ich wahrscheinlich für jede variable den gleichen adc 
kanal festgelegt hab nur warum passiert das an jedem adc pin von adc0 - 
5?...

ich vermute das da der fehler liegt.

wenn ja wie behebt man ihn?

sorry für das missachten von groß und Kleinschreibung

Gruß hawo

[spess53 (Gast)]

Hi

#define F_CPU 8000000            //interner 1MHz OSzillator

Was nun, 8MHz oder 1MHz?

>  ADCSRA = (1<<ADPS1) | (1<<ADPS0);    //Vorteiler = 8

Passend für 1MHz. Für 8MHz zu wenig.

MfG Spess

[al_guesto (Gast)]

hawo1997 schrieb:
> Es geht mir halt darum das ich ich egal an welchen pin ich eine Spannung
> anschließe (von den adc pins) das die Ergebnisse in den variablen "volt"
> "amp" und "adcval" gleich sind obwohl sie ja mit

Was ist denn gleich? =0 oder =1023 oder passt das Ergebnis wenigstens 
zur angelegten Spannung, also wenn du an ADC0 die Spannung anlegst ist 
das Ergebnis für ADC0 korrekt und quasi "nur" an den anderen beiden 
Kanälen falsch?

[Uwe (de0508)]

Lege mal alle ADC Eingänge mit 10k Ohm auf Masse, dann wird auch der 
sample and hold Kondensator umgeladen. Bei offenen Eingängen geht das 
nicht!

[fragender (Gast)]

Es ist so das ich ja mit

  adcval = ADC_Read(0);
  volt = ADC_Read(1);
  amp = ADC_Read(2);

so dachte ich jede Variable auf einen eigenen ADC channel gepackt habe. 
(adcval an ADC0, volt an ADC1 und amp an ADC2) so dachte ich. Jetzt ist 
es so das adcval zum steuern der PWM an PB1 ist, volt und amp für 
Messung von Strom und Spannung Also müsste ja nach dem was ich grad 
sagte die PWM an ADC0 (=PC0), die zu messende Spannung (volt) an ADC1 
(=PC1) und der zu messende Strom (amp) an ADC2 (=PC2) anliegen. Nun ist 
es aber so das ich wenn ich mit einem Poti zwischen GND und +5V an EINEN 
der drei ADCs gehe werden immer alle drei Sachen (PWM, Spannungsanzeige 
und Stromanzeige) geändert egal ob an ADC0 ADC1 oder ADC2 und das ist 
das was nicht läuft.

Und mein anliegen ist es wie man das jetzt korrigiert.

MfG
hawo

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

fragender schrieb:
> Nun ist
> es aber so das ich wenn ich mit einem Poti zwischen GND und +5V an EINEN
> der drei ADCs gehe werden immer alle drei Sachen (PWM, Spannungsanzeige
> und Stromanzeige) geändert egal ob an ADC0 ADC1 oder ADC2 und das ist
> das was nicht läuft.

Das liegt daran, das unbeschaltete ADC Eingänge am S&H Kondensator 
'kleben'. Du musst alle Kanäle mit Potis oder anderen Spannungsquellen 
beschicken und dann mal messen.

[fragender (Gast)]

ok mach ich mal

[fragender (Gast)]

Achso ... ich probiers mal aus

MfG

[fragender (Gast)]

So mit den Widerständen von den ADCs zu Masse hat es mehr oder weniger 
geklappt naja ... die werte von den anderen ADCs verändern sich nicht 
mehr bis nur noch sehr wenig aber der ADCwert ist höchstens nur noch 560 
anstatt 1023 egal welchen wert das Poti oder die Widerstände haben.

[Karl H. (kbuchegg)]

fragender schrieb:
> So mit den Widerständen von den ADCs zu Masse hat es mehr oder weniger
> geklappt naja ... die werte von den anderen ADCs verändern sich nicht
> mehr bis nur noch sehr wenig aber der ADCwert ist höchstens nur noch 560
> anstatt 1023 egal welchen wert das Poti oder die Widerstände haben.

Nur zur Sicherheit:
Du hast aber nicht auch an dem Eingang, an dem das Poti hängt auch noch 
einen Widerstand zugeschaltet? Oder?

Du brauchst
* entweder Poti
* oder Widerstand

[fragender (Gast)]

Nein hab ich ich nicht.
An ADC0 hängt ein Poti
An ADC1 und 2 ein Widerstand gegen Masse.

[fragender (Gast)]

Also ich hab jetzt an ADC0 ein 200k Poti und an ADC1 und 2 jeweils einen 
7,5k Widerstand gegen Masse geschaltet. Das Poti steht auf Vollanschlag 
richtung Vcc (4,9V) dir gemessene Spannung An PortC.0 des Atmega beträgt 
4.85V. Im Bild sieh man die ADC Werte von ADC0 ADC1 und ADC2.

MfG

[fragender (Gast)]

Ich verstehe es nicht mit einem einzelnen ADC geht es ja.

[Reiner F. (reiner)]

Hallo,
ich habe den Beitrag interessiert mitgelesen und bin jetzt neugierig.
Ist das Problem gelöst? Woran lag's?

[Uwe (Gast)]

> Also ich hab jetzt an ADC0 ein 200k Poti
zu hochohmig

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

spess53 schrieb:
> Hi
>
> #define F_CPU 8000000            //interner 1MHz OSzillator
>
> Was nun, 8MHz oder 1MHz?
>
>>  ADCSRA = (1<<ADPS1) | (1<<ADPS0);    //Vorteiler = 8
>
> Passend für 1MHz. Für 8MHz zu wenig.
>
> MfG Spess

Hast du das korrigiert? Les dir nochmal die ADC Kapitel im Datenblatt 
durch und setzt den ADC auf eine Samplerate, die er auch verträgt:
"By default, the successive approximation circuitry requires an input 
clock frequency between 50kHz and 200 kHz to get maximum resolution. If 
a lower resolution than 10 bits is needed, the input clock frequency to 
the ADC can be higher than 200 kHz to get a higher sample rate."

Du musst also 8Mhz mindestens durch 32 teilen (= 250kHz, immer noch 
knapp zu viel), um die volle Auflösung zu bekommen, besser ist 64 als 
Teilerfaktor.