Spannung messen und LED dimmen

[A. B. (developer_x)]

Sehr geehrtes Forum,
ich habe folgendes Problem:
1. Ich möchte gerne bei meinem Atmega88PA bei Kanal ADC0 eine Spannung 
messen. Ich habe des Weiteren eine LED an Port D0.
2. Ich lasse eine LED an und ausschalten (so oft, dass man die LED damit 
dimmen kann). Die Zeit, in welcher die LED an ist, ist von der, in 
welcher die LED aus ist, verschieden. Eine Schaltperiode soll 20ms 
dauern, 1 bis 2 ms davon darf die LED an sein, im anderen Teil aus.
3. Die gemessene Spannung soll für eine Varianz zwischen 1 und 2 ms 
sorgen, das heißt z.B. dass bei einer gemessenen Spannung von 2,5 V mit 
Referenz Spannung von 5V 1,5ms, bei einer gemessenen Spannung von 0 V 
nur 1 ms, und bei einer gemessenen Spannung von 5V 2 ms gewartet wird.
4. Ich habe hier diesen Code in C (ich habe voher immer in Assembler 
programmiert) und weiß nicht, warum das ganze nicht funktioniert

#define F_CPU 1000000UL
 
#include <avr/io.h>
#include <util/delay.h>
 
int main (void)
{
  DDRD = (1<<0);
  PORTD |= (0<<0);

  ADCSRA |= (0<<0);  // Taktgeschwindigkeit
  ADCSRA |= (0<<1);
  ADCSRA |= (1<<2);
  ADCSRA |= (0<<3);  // Interrupt
  // ADCSRA |= (1<<4); Wenn Umwandlung erfolgt  
  ADCSRA |= (0<<6);  // Free Run AUS
  ADCSRA |= (1<<7);  // Einschalten

  ADMUX |= (1<<0); // Kanal einstellung
  ADMUX |= (0<<1);
  ADMUX |= (0<<2);
  ADMUX |= (0<<3);
  ADMUX |= (0<<4);

  ADMUX |= (0<<5); //  Egal

  ADMUX |= (1<<6); // Referenzspannungseinstellungen
  ADMUX |= (0<<7);

  ADCSRA |= (1<<5);  // Start Conversion
  
  while( 1 ) 
  {
    PORTD ^= (1<<0); // anschalten

//  Warten bis Messung abgeschlossen
    while((ADCSRA & 4)) 
      ;
  uint16_t t = ADCH;
  t *= 2;
  t *= 2;
  t *= 2;
  t *= 2;
  t *= 2;
  t *= 2;
  t *= 2;
  t *= 2;

    uint16_t y = 1000;
  y += t;
  y /= 2;
  uint16_t b = 0;
  while(b<y)
    b++;

    ADCSRA |= (1<<5);  // Start Conversion




  PORTD ^= (1<<0); // ausschalten
//  Rest Warten
    uint16_t z = 20000-y;
  z/=2;
  uint16_t a = 0;
  while(a<z)
    a++;

  }
 
  return 0;
}

5. Ich denke es liegt daran, dass ich den Kanal nicht richtig gewählt 
habe, aber es gibt nirgends, auch nicht im Datenblatt des Atmega eine 
wirkliche Tabelle, in der man sehen kann wie man die Bits 0 bis 4 von 
ADMUX einzustellen hat, um den ADC0 anzusteuern.
6. Ich habe den Mikrocontroller nicht getaktet oder einen Quarz 
drangeschlossen, dementsprechend müsste er also die Frequenz 1 MHz 
haben.
7. Bitte habt etwas Rücksicht, bin totaler Anfänger.

Danke für eure Antworten,
m.f.G. Developer_X

[Karl H. (kbuchegg)]

K. R. schrieb:
> Sehr geehrtes Forum,
> ich habe folgendes Problem:
> 1. Ich möchte gerne bei meinem Atmega88PA bei Kanal ADC0 eine Spannung
> messen. Ich habe des Weiteren eine LED an Port D0.
> 2. Ich lasse eine LED an und ausschalten (so oft, dass man die LED damit
> dimmen kann). Die Zeit, in welcher die LED an ist, ist von der, in
> welcher die LED aus ist, verschieden. Eine Schaltperiode soll 20ms
> dauern, 1 bis 2 ms davon darf die LED an sein, im anderen Teil aus.

Sag doch gleich, dass du einen Servotester baust.


>   ADCSRA |= (1<<5);  // Start Conversion

5?

Das ADSC Bit ist an Bitposition 6 und nicht an 5.

Genau deshalb schreibt man das auch so

   ADCSRA |= ( 1 << ADSC );

und nicht mit Zahlenwerten für die Bitposition. Denn dann kann man das 
alles erstens lesen und zweitens macht man zumindest nicht diese 
bescheuerten Fehler.


Den Rest hab ich nicht mehr durchgesehen. Ich bin doch nicht wahsnsinnig 
und vergleiche alle deine Zahlenwerte mit dem Datenblatt, ob und was du 
da eigentlich alles eingestellt hast.

Schau dir die ADC Routinen im AVR-GCC-Tutorial an. (Nach ADC suchen. 
Dort gibt es fertige Routinen(*). Die kannst du verwenden und die sind 
dann auch lesbar. Im Gegensatz zu deinem Machwerk)


> 5. Ich denke es liegt daran, dass ich den Kanal nicht richtig gewählt
> habe

Ich denke es liegt daran, dass du erst mal ein bisschen C lernen 
solltest. SO wie du das machst, so programmiert man einfach nicht. Da 
hättest du bei Assembler auch bleiben können.



(*) Hier
http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Analoge_Ein-_und_Ausgabe
ist der Link auf den ADC Artikel vom C-Tutorial.


> 7. Bitte habt etwas Rücksicht, bin totaler Anfänger.

Dann fang mit was einfacherem an.
Dort wo alle anfangen. LED einschalten, LED ausschalten, LED blinken 
lassen. Dieses Projekt ist 5 Schuhnummern zu groß für dich.

[A. B. (developer_x)]

Ok, sry.
Ich habe meinen Code ein bisschen verändert. Ich denke jetzt sollte er 
leserlich sein.

#define F_CPU 1000000UL
 
#include <avr/io.h>
#include <util/delay.h>
 
 void ADC_Init(void) 
 {
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);    
  // oder interne Referenzspannung als Referenz für den ADC wählen:
  // ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  (void) 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
  }

  uint16_t x = ADCL; // mit uint16_t x
  x += (ADCH<<8);    // in zwei Zeilen (LSB/MSB-Reihenfolge und
                   // C-Operatorpriorität sichergestellt)

  return x;          // ADC auslesen und zurückgeben
}
 
int main (void)
{
  uint16_t adcval;
  uint16_t to_wait;
  uint16_t wait_v;

//  ADC Initialisieren
  ADC_Init();
 
//  LED PortD0 initialisieren
  DDRD   = (1<<0);
  PORTD |= (0<<0);

  while( 1 ) 
  {
  
  // Lade ADC_Value
     adcval = ADC_Read(0);  // Kanal 0

  // LED Anschalten
     PORTD ^= (1<<0); 
  
  // Warten 
     wait_v = 0;
   to_wait = 1000+adcval;
   while(wait_v<to_wait)
     wait_v++;

  // LED Ausschalten
     PORTD ^= (1<<0);

  // Warten
     wait_v = 0;
   to_wait = 20000-adcval;
   while(wait_v<to_wait)
     wait_v++;
  }

  return 0;
}

Ich habe die Routinen ADC Init und ADC Read aus dem Tutorial übernommen 
und
ADC Read angepasst, da mein Atmega88PA kein ADCW, sondern nur ADCL und 
ADCH Register besitzt.

Allerdings reagiert der MC immer noch überhaupt kein bisschen wenn ich 
an meinem POTI drehe.
Habt ihr eine Idee woran es liegen könnte?

[A. B. (developer_x)]

mir fällt auf, dass die warteschleifen überhaupt nicht funktionieren
ganz unabhängig vom ADC Problem

int main (void)
{
  uint16_t to_wait;
  uint16_t wait_v;

//  LED PortD0 initialisieren
  DDRD   = (1<<0);
  PORTD |= (0<<0);

  while( 1 ) 
  {
  // LED Anschalten
     PORTD ^= (1<<0); 
  
  // Warten 
     wait_v = 0;
     to_wait = 10;
     while(wait_v<to_wait)
      wait_v++;

  // LED Ausschalten
     PORTD ^= (1<<0);

  // Warten
     wait_v = 0;
     to_wait = 1000;
     while(wait_v<to_wait)
      wait_v++;
  }

  return 0;
}

Die Zeit, in welcher die LED an ist, ist so klein, dass die LED nicht 
leuchten dürfte, oder ganz schwach, aber fakt ist, dass die LED 
angeschalten wird, und die schleife dann nicht verlassen wird.

Was ist denn an dieser einfachen Schleife falsch?

[A. B. (developer_x)]

Seltsamerweise klappt das so doch.

#define F_CPU 1000000UL
 
#include <avr/io.h>
#include <util/delay.h>
 
 void ADC_Init(void) 
 {
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = (1<<REFS0);    
  // oder interne Referenzspannung als Referenz für den ADC wählen:
  // ADMUX = (1<<REFS1) | (1<<REFS0);
 
  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten
  // schon auf 0, also single conversion
  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren
 
  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */
 
  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
     Wandlung nicht übernommen. */
  (void) 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
  }

  uint16_t x = ADCL; // mit uint16_t x
  x += (ADCH<<8);    // in zwei Zeilen (LSB/MSB-Reihenfolge und
                   // C-Operatorpriorität sichergestellt)

  return x;          // ADC auslesen und zurückgeben
}
 
int main (void)
{
  uint16_t adcval;
  uint16_t to_wait;
  uint16_t wait_v;

//  ADC Initialisieren
  ADC_Init();
 
//  LED PortD0 initialisieren
  DDRD   = (1<<PD0);
  PORTD |= (0<<PD0);

  while( 1 ) 
  {
  
  // Lade ADC_Value
     adcval = ADC_Read(1);  // Kanal 0

  // LED Anschalten
     PORTD ^= (1<<PD0); 
  
  // Warten 
  //   adcval = 10;
     wait_v = 0;
   to_wait = 500+adcval;
   to_wait /= 10;
   while(wait_v<to_wait)
   {
    wait_v++;
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
   }

  // LED Ausschalten
     PORTD ^= (1<<PD0);

  // Warten
     wait_v = 0;
   to_wait = 20000-adcval;
   to_wait /= 10;
   while(wait_v<to_wait)
   {
    wait_v++;
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
    asm volatile ("nop");
   }
  }

  return 0;
}

Liegt vielleicht daran dass in C schleifen die sinnlos sind vom Compiler 
optimiert werden wenn man nicht extra von Assembler ne NOP Operation 
aufruft.
Danke trotzdem euch allen.

Klappt jetzt wunderbar. :)