ADC funktioniert nicht

[Ja (Gast)]

Guten Tag,
Ich habe einen Code geschaffen, der bei Sekundenänderung das Ergebnis 
des ADC mit einem vorherigen ADC (Referenz) vergleicht und bei gleichem 
Ergebnis einen Zähler hochzählen soll, der dann bei erreichtem Wert 
einen Ausgang schalten soll.

Der Code an sich funktioniert, wenn es um den Zähler geht: nach 59 
Zählungen schlatet nämlich der Ausgang. Wenn ich aber die Spannung am 
ADC verändere, so passiert nichts, der Ausgang bleibt geschaltet, obwohl 
der Wert nicht mehr im Rahmen liegt.
Ja, ich habe alles mögliche am Code probiert, allerdings scheint es 
nicht zu funktionieren, deshalb frage ich nun hier:

#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHZ
#include <util/delay.h>
#include <avr/interrupt.h>

volatile unsigned int millisekunden;
volatile unsigned int sekunde;
volatile unsigned int minute;
volatile unsigned int stunde;
volatile int analogResult = 0; 
volatile int analogReferenz = 512;
volatile int Zaehler = 0;
volatile int sekundeCOM = 0;
volatile int sekundeCOM2 = 0;

ISR(ADC_vect)
{
  analogResult = (ADCH<<8)|ADCL;
}


int main(void)
{
  DDRB &= ~(1<<DDB4);
  // Timer 0 konfigurieren
  TCCR0A = (1<<WGM01); // CTC Modus
  TCCR0B |= (1<<CS01); // Prescaler 8
  // ((1000000/8)/1000) = 125
  OCR0A = 125-1;
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  
  // Global Interrupts aktivieren
  sei();
  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  ADMUX &= ~( (1<<REFS1)|(1<<REFS0)|(1<<ADLAR) );
  ADMUX |= (1<<MUX1);
  ADCSRB &=~( (1<<ADTS2)|(1<<ADTS1)|(1<<ADTS0) );
  DIDR0 |= (1<<ADC2D);
  ADCSRA |= (1<<ADEN)|(1<<ADIE);
  ADCSRA |= (1<<ADSC);
    while(1)
    {  
    
    
    PINB |= (1<<PINB3);
    sekundeCOM2 = sekunde;
    
      
    if ((sekundeCOM2 != sekundeCOM) & (analogResult < (analogReferenz +10)) & (analogResult > (analogReferenz -10)) )// & (analogResult > analogReferenz - 100) & (analogResult < analogReferenz + 100))
      { Zaehler++;
        sekundeCOM = sekundeCOM2;
      } 
      
      
      if ((analogResult > (analogReferenz + 10)) | (analogResult < (analogReferenz - 10)) ) //| (analogResult > (analogReferenz - 100)))
    { 
        Zaehler = 0;
        analogReferenz = analogResult;
        sekundeCOM = sekundeCOM2;
      }
      
        
          
          
    if ( Zaehler > 59)
    { PINB |= (1<<PINB0)|(1<<PINB1)|(1<<PINB2);
    } 
    
        
    
    
    }
}

ISR (TIMER0_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

Habt ihr Lösungsvorschläge?

[adenin (Gast)]

Ja schrieb:
> Habt ihr Lösungsvorschläge?

C-Grundlagen büffeln, speziell Unterschied zwischen & und &&

[Karl H. (kbuchegg)]

Ja schrieb:

Das hier
>     if ( Zaehler > 59)
>     { PINB |= (1<<PINB0)|(1<<PINB1)|(1<<PINB2);
>     }
ist wohl das einschalten.

Aber wo ist das Ausschalten?

So ein Ausgang schaltet sich ja nicht von selbst aus. Er behält immer 
den letzten Zustand bei. Wenn du ihn also abgeschaltet haben willst, 
dann musst du das auch programmieren.

Ganz angesehen davon, denke ich nicht, dass du hier das PIN Register 
benutzen willst. Je nach verwendetem Prozessor ist das maximal ein 
Toggeln des Ausgangs.

[Karl H. (kbuchegg)]

Ganz abgesehen davon.
Wo innerhalb der Schleife liest du den den ADC erneut aus?

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
> Ganz abgesehen davon.
> Wo innerhalb der Schleife liest du den den ADC erneut aus?

Habs gerade gesehen. Der ADC ist auf Interrupt geschaltet.

Noch was komplizierteres ist dir nicht eingefallen?
Oh Mann. Du hast schon eine gewisse Tendenz, dir selbst mit möglichst 
komplizierten Programmstrukturen selbst ein Bein zu stellen anstatt dir 
erst mal mit einem ganz simplen Programm eine funktionierende Basis zu 
schaffen.

[Bernhard S. (b_spitzer)]

Wieso die unnötige Flankenerkennung und das Rumgeschubse mit der 
Sekunde??

  if(millisekunden == 1000)
  {
    sekunde++;
    millisekunden = 0;
    FLAG = 1;            // Signal an Hauptprogramm
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }

und im Hauptprogramm

if (FLAG)
{
   FLAG = 0;        // Signal löschen
   TuWasBeiJederSekunde( );
}

Davon Abgesehen, die gegebenen Hinweise zu && und || beachten.

[Ralph S. (jjflash)]

Bernhard Spitzer schrieb:
> Davon Abgesehen, die gegebenen Hinweise zu && und || beachten.

besonders hier:

Ja schrieb:
> if ((sekundeCOM2 != sekundeCOM) & (analogResult < (analogReferenz +10))
> & (analogResult > (analogReferenz -10)) )

[Michael R. (Firma: Brainit GmbH) (fisa)]

Ralph S. schrieb:
> Bernhard Spitzer schrieb:
>> Davon Abgesehen, die gegebenen Hinweise zu && und || beachten.
>
> besonders hier:
>
> Ja schrieb:
>> if ((sekundeCOM2 != sekundeCOM) & (analogResult < (analogReferenz +10))
>> & (analogResult > (analogReferenz -10)) )

Wobei das an der Stelle vermutlich gar keinen Unterschied macht 
(korrigiert gehört es natürlich trotzdem)

[Ja (Gast)]

Sieht das in euren geübten Augen besser aus?
MfG

#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHZ
#include <util/delay.h>
#include <avr/interrupt.h>

volatile unsigned int millisekunden;
volatile unsigned int sekunde;
volatile unsigned int minute;
volatile unsigned int stunde;
volatile unsigned int FLAG;
volatile unsigned int analogresult;
volatile unsigned int analogreferenz = 128;
volatile unsigned int Zaehler = 0;




int main(void)
{
  DDRB &= ~(1<<DDB4);
  // Timer 0 konfigurieren
  TCCR0A = (1<<WGM01); // CTC Modus
  TCCR0B |= (1<<CS01); // Prescaler 8
  // ((1000000/8)/1000) = 125
  OCR0A = 125-1;
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  
  // Global Interrupts aktivieren
  sei();
  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  DDRB &= ~(1<<DDB4);
   ADMUX =
   (1 << ADLAR) |     // left shift result
   (0 << REFS1) |     // Sets ref. voltage to VCC, bit 1
    (0 << REFS0) |     // Sets ref. voltage to VCC, bit 0
   (0 << MUX3)  |     // use ADC2 for input (PB4), MUX bit 3
    (0 << MUX2)  |     // use ADC2 for input (PB4), MUX bit 2
    (1 << MUX1)  |     // use ADC2 for input (PB4), MUX bit 1
    (0 << MUX0);       // use ADC2 for input (PB4), MUX bit 0
     ADCSRA =
     (1 << ADEN)  |     // Enable ADC
     (0 << ADPS2) |     // set prescaler to 8, bit 2
    (1 << ADPS1) |     // set prescaler to 8, bit 1
    (1 << ADPS0);      // set prescaler to 8, bit 0

  
  
    while(1)
  
    {
    
    if (FLAG == 1)
  {    ADCSRA |= (1 << ADSC);         // start ADC measurement
      while (ADCSRA & (1 << ADSC) ); // wait till conversion complete
      ADCH = analogresult;
      FLAG = 0;
    }
    
    if ( (analogresult < (analogreferenz + 20)) && (analogresult > (analogreferenz - 20)))
    {
      Zaehler++;
    }
    
    else {
      Zaehler = 0;
      analogreferenz = analogresult;
    }
      
      if ( Zaehler > 59 )
      {
        PORTB |= (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3);
      }
      
    if ( Zaehler < 60 && (PORTB |= ((1<<PB0)|(1<<PB1)|(1<<PB2)|(PB3))))
    {
      PORTB &= ~((1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3));
    }
    
    
    
    
    
    }
}

ISR (TIMER0_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    FLAG = 1
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

[Hubert G. (hubertg)]

Ja schrieb:
> ADCH = analogresult;

Hm, ich schreib das immer andersrum.

[Ja (Gast)]

Hubert G. schrieb:
> Hm, ich schreib das immer andersrum.

Hättest du für mich (den Dummen) eine Begründung dafür?

[Hubert G. (hubertg)]

Weil Zuweisungen immer von rechts nach links gehen.
Du schreibst ja auch OCR0A = 125-1; weil du die Zahl ins Register 
schreiben willst und nicht umgekehrt.

[Ja (Gast)]

Dankeschön!

[M. K. (sylaina)]

Und warum eigentlich

analogResult = (ADCH<<8)|ADCL;

und nicht gleich

analogResult = ADC;

?

Und warum soll hier

Ja schrieb:
> ADCH = analogresult;

nur das HI-Byte ausgelesen werden, nicht aber nicht das LOW-Byte? 
(Abgesehen davon, dass es eigentlich anders herum stehen müsste)

[spess53 (Gast)]

Hi

>Und warum eigentlich

>analogResult = (ADCH<<8)|ADCL;


>und nicht gleich

>analogResult = ADC;

Weil ADLAR gesetzt ist und damit das Ergebnis 8-Bittig in ADCH steht.

MfG Spess

[Ja (Gast)]

spess53 schrieb:


> Weil ADLAR gesetzt ist und damit das Ergebnis 8-Bittig in ADCH steht.
 ich dachte schon, ich blicke nichts..

[Ja (Gast)]

Bin ich ein dummer Mensch, oder warum funktioniert das nicht?

/*
 * Bewegungssensor.c
 *
 * Created: 04.03.2015 10:21:49
 *  Author: Daniel
 */ 

/*
 * LEDblink_attiny85.c
 *
 * Created: 28.02.2015 12:40:40
 *  Author: Daniel
 */ 


#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHZ
#include <util/delay.h>
#include <avr/interrupt.h>

volatile unsigned int millisekunden;
volatile unsigned int sekunde;
volatile unsigned int minute;
volatile unsigned int stunde;
volatile unsigned int FLAG;
volatile unsigned int analogresult;
volatile unsigned int analogreferenz = 128;
volatile unsigned int Zaehler = 0;




int main(void)
{
  DDRB &= ~(1<<DDB4);
  // Timer 0 konfigurieren
  TCCR0A = (1<<WGM01); // CTC Modus
  TCCR0B |= (1<<CS01); // Prescaler 8
  // ((1000000/8)/1000) = 125
  OCR0A = 125-1;
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  
  // Global Interrupts aktivieren
  sei();
  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  DDRB &= ~(1<<DDB4);
   ADMUX =
   (1 << ADLAR) |     // left shift result
   (1 << REFS1) |     // Sets ref. voltage to VCC, bit 1
   (1 << REFS0) |     // Sets ref. voltage to VCC, bit 0
   (0 << MUX3)  |     // use ADC2 for input (PB4), MUX bit 3
   (0 << MUX2)  |     // use ADC2 for input (PB4), MUX bit 2
   (1 << MUX1)  |     // use ADC2 for input (PB4), MUX bit 1
   (0 << MUX0);       // use ADC2 for input (PB4), MUX bit 0
    ADCSRA =
    (1 << ADEN)  |     // Enable ADC
    (0 << ADPS2) |     // set prescaler to 8, bit 2
    (1 << ADPS1) |     // set prescaler to 8, bit 1
    (1 << ADPS0);      // set prescaler to 8, bit 0

  
  
 while(1)
  
    {
    
    if (FLAG == 1)
        {    ADCSRA |= (1 << ADSC);         // start ADC measurement
          while (ADCSRA & (1 << ADSC) ); // wait till conversion complete
          analogresult = ADCH;
          
        }
        
        if ( (FLAG == 1) && (analogresult < (analogreferenz + 20)) && (analogresult > (analogreferenz - 20)))
        {
          Zaehler++;
          FLAG = 0;
        }
        
        else {
          Zaehler = 0;
          analogreferenz = analogresult;
          FLAG = 0;
        }
          
          if ( Zaehler > 9 )
          {
            PORTB |= (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3);
          }
          
        else //if ( Zaehler < 10 && (PORTB |= ((1<<PB0)|(1<<PB1)|(1<<PB2)|(PB3))))
        {
          PORTB &= ~((1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3));
        }

ISR (TIMER0_COMPA_vect)
{
  millisekunden++;
  if(millisekunden == 1000)
  {
    sekunde++;
    FLAG = 1;
    millisekunden = 0;
    if(sekunde == 60)
    {
      minute++;
      sekunde = 0;
    }
    if(minute == 60)
    {
      stunde++;
      minute = 0;
    }
    if(stunde == 24)
    {
      stunde = 0;
    }
  }
}

[Karl H. (kbuchegg)]

        if ( (FLAG == 1) && (analogresult < (analogreferenz + 20)) && (analogresult > (analogreferenz - 20)))
        {
          Zaehler++;
          FLAG = 0;
        }
        
        else {
          Zaehler = 0;

ich glaube kaum, dass du den Zähler auch dann immer wieder zurück setzen 
willst, wenn die 1 Sekunde noch nicht um ist.

Tip: Trenn doch erst mal die Dinge.
Das eine ist, dass du jede 1 Sekunde eine Messung machen und auswerten 
willst.
Und das andere ist die Auswertung der Messung. Gerade am Anfang ist es 
des öfteren keine so gute Idee, wenn man das alles in ein einziges if 
quetschen will. Man verheddert sich dann leicht in den Bedingungen.

(Und es ist auch eine gute Idee, sich für Variablen einen vernünftigen 
Namen einfallen zu lassen, der ihrer Funktion entspricht. FLAG ist ein 
recht nichtssagender Name. 'MessungMachen' oder 'SekundeVorbei' wären 
jetzt mal angesehen vom Läge der Namen, wesentlich besser. Denn genau 
das wird damit angezeigt: 1 Sekunde ist vorbei. Es soll eine neue 
Messung gemacht werden.

....

  while( 1 ) {

    if( FLAG == 1 ) {      // 1 Sekunde ist vorbei. Messung machen und auswerten

       FLAG = 0;

       ADC abfragen

       if( abs( analogresult - analogreferenz ) < 20 ) {
         if( zaehler < 250 )   // Überlauf verhindern!
           zaehler++;
       }
       else {
         zaehler = 0;
         analogreferenz = analogresult;
       }

       if( zaehler > 59 )
         PORTB |= (1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3);
       else
         PORTB &= ~((1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3));
    }
  }
}

...

[Eric B. (beric)]

Ungetestet! Aber such schon mal die Unterschiede ;-)

#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHZ
#include <util/delay.h>
#include <avr/interrupt.h>

volatile unsigned int miliSeconds;
const    unsigned int adcReference      = 128u;
const    unsigned int adcRefMargin      =  20u;
const    unsigned int inRangeCountLimit =   9u;

#define PB0_TO_3 ((1<<PB0)|(1<<PB1)|(1<<PB2)|(1<<PB3)) 
      
static void initialize(void)
{
   DDRB &= ~(1<<DDB4);
   
   //Configure Timer 0
   TCCR0A = (1<<WGM01); // CTC Mode
   TCCR0B |= (1<<CS01); // Prescaler 8
   OCR0A = 125-1;       // ((F_CPU/8)/1000) = 125

   // Enable Compare Interrupt
   TIMSK |= (1<<OCIE0A);
  
   DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
   DDRB &= ~(1<<DDB4);
   ADMUX =
      (1 << ADLAR) |     // left shift result
      (1 << REFS1) |     // Sets ref. voltage to VCC, bit 1
      (1 << REFS0) |     // Sets ref. voltage to VCC, bit 0
      (0 << MUX3)  |     // use ADC2 for input (PB4), MUX bit 3
      (0 << MUX2)  |     // use ADC2 for input (PB4), MUX bit 2
      (1 << MUX1)  |     // use ADC2 for input (PB4), MUX bit 1
      (0 << MUX0);       // use ADC2 for input (PB4), MUX bit 0
   ADCSRA =
      (1 << ADEN)  |     // Enable ADC
      (0 << ADPS2) |     // set prescaler to 8, bit 2
      (1 << ADPS1) |     // set prescaler to 8, bit 1
      (1 << ADPS0);      // set prescaler to 8, bit 0
    
   sei();
}

int main(void)
{
   unsigned int adcResult;
   unsigned int inRangeCounter;
   
   initialize();
   for(;;)
   {
      if (doMeasurement)
      {
         // One second has passed - do the next AD conversion
         
         ADCSRA |= (1 << ADSC);
         while (ADCSRA & (1 << ADSC))
         {
            //do nothing - just wait till conversion complete
         }
         adcResult = ADCH;
         
         // Check result range
         if (((adcRefererence - adcRefMargin) <= adcResult)
            && (adcResult < (adcRefererence + adcRefMargin)))
         {
            // Show that count limit is reached
            if(inRangeCounter > inRangeCountLimit)
            {
               PORTB |= PB0_TO_3;
            }
            else
            {
               inRangeCounter ++;
            }
         }
         else
         {
            // Reset everything
            inRangeCounter = 0;
            analogreferenz = adcResult;
            PORTB &= ~PB0_TO_3
         }
         
         // Ready for next measurement
         doMeasurement = 0;
      }
   }
   return 0;
}

ISR(TIMER0_COMPA_vect)
{
   milliSecs ++;
   if(milliSecs >= 1000)
   {
      milliSecs = 0;
      doMeasurement = 1;
   }
}

[Bernhard S. (b_spitzer)]

[Erbsenzähler]
> Ungetestet!
Stimmt, doMeasurement  ist nicht deklariert :-)
Außerdem: gibt es auf dem AVR wirklich keine Möglichkeit, einzelne Bits 
als Flags zu nutzen?
Und ich finde

for(;;)

irgendwie verwirrender als

while(1)

auch wenn das 1 Tastendruck mehr ist. Dafür sind

return 0;

nach einer ENDLOSSCHLEIFE 9 unnötige Tastendrücke.
[/Erbsenzähler]

;-)

[Ja (Gast)]

Ich würde mal schätzen, das bei jedem doMeasurement == 1 (entspricht 
Sekundenzyklus, die if-Zeile ausgeführt wird (in ihr steckt das Messen)

[M. K. (sylaina)]

spess53 schrieb:
> Hi
>
>>Und warum eigentlich
>
>>analogResult = (ADCH<<8)|ADCL;
>
>
>>und nicht gleich
>
>>analogResult = ADC;
>
> Weil ADLAR gesetzt ist und damit das Ergebnis 8-Bittig in ADCH steht.
>
> MfG Spess

Ja und? ADC ist (ADCH << 8) | ADCL, dabei ist es völlig egal ob ADLAR 
gesetzt ist oder nicht. Hätte da jetzt nur analogResult = ADCH gestanden 
wäre es noch logisch gewesen aber so? Das macht hier keinen Sinn ADC 
nicht zu benutzen.

[Eric B. (beric)]

Bernhard Spitzer schrieb:

>> Ungetestet!
> Stimmt, doMeasurement  ist nicht deklariert :-)

Mea culpa, mea maxima culpa!

unsigned int doMeasurement;

Bitte schön!

> Außerdem: gibt es auf dem AVR wirklich keine Möglichkeit, einzelne Bits
> als Flags zu nutzen?

Ich glaub nicht. Wenigstens nicht in dem Sinne wie bei den ARM Cortex 
Bitfields...

> Und ich finde
>

for(;;)

> irgendwie verwirrender als
>

while(1)

> auch wenn das 1 Tastendruck mehr ist.

Geschmackssache.

> Dafür sind
>

return 0;

> nach einer ENDLOSSCHLEIFE 9 unnötige Tastendrücke.

Nicht für den OT. Der muss das ganze nur Copy/Pasten auf gut Neu-deutsch 
;-)

Und ich mag den Sonderfall für main() nicht. main() ist als int 
definiert und soll deswegen irgendeine integer zurückliefern, auch wenn 
er davor ein endlos schleift.

Edit: mich würde aber interessieren ob meine Version für den OT 
funktioniert. ich habe kein AVR hier zum ausprobieren.

[Karl H. (kbuchegg)]

Eric B. schrieb:

>

> unsigned int doMeasurement;
>

> Bitte schön!
>

Du bist auf ARM zu Hause?
Dann sei dir verziehen.

Auf einem AVR nimmst du nicht ungestraft und gedankenlos einfach einen 
int her. Ein int ist 16 Bit gross! Damit halst du dem armen 8-Bitter 
unnötige Mehrarbeit auf.

ein

uint8_t doMeasurement;

tuts völlig.

>> Außerdem: gibt es auf dem AVR wirklich keine Möglichkeit, einzelne Bits
>> als Flags zu nutzen?
>
> Ich glaub nicht. Wenigstens nicht in dem Sinne wie bei den ARM Cortex
> Bitfields...

Bitfields gibt es als C Ding selbstverständlich.

[Ja (Gast)]

Eric B. schrieb:
> mich würde aber interessieren ob meine Version für den OT
> funktioniert. ich habe kein AVR hier zum ausprobieren.

Hallo, vielen Dank für deine Mühe. Leider funktioniert dein Code nicht.
Ich habe den ADC sogar an Masse gelegt, um Fehlerquellen auszuschließen, 
leider wird PB0_TO_3 anscheinend nie aktiviert...

[Karl H. (kbuchegg)]

volatile uint8_t doMeasurement;
//******

[Ja (Gast)]

Ich habe kleinere Fehler im Code ausgemerzt (millisecs und miliseconds), 
habe aber keine Ahnung, warum das so nicht funktioniert..

[Ja (Gast)]

Karl Heinz schrieb:
> volatile uint8_t doMeasurement;

Ja und ADCReference darf auch keine constante sein oder?

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> volatile uint8_t doMeasurement;
>
> Ja und ADCReference darf auch keine constante sein oder?

Moment. Muss den Code noch genauer studieren.

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> volatile uint8_t doMeasurement;
>
> Ja und ADCReference darf auch keine constante sein oder?

So wie das vom TO angedacht war. Korrekt: darf keine Konstante sein.

Da ist auch noch ein Mischmasch

         if (((adcRefererence - adcRefMargin) <= adcResult)
//             **************
            && (adcResult < (adcRefererence + adcRefMargin)))
//                           **************
         {
....
         }
         else
         {
....
            analogreferenz = adcResult;
//          **************
...

die Idee ist es ja, dass sich die Referenz dauernd ständig anpasst. Das 
muss also dieselbe Variable sein.

Das bringt uns zur Frage:
> Leider funktioniert dein Code nicht.
was hast du noch verändert? So wie gepostet compiliert der Code ganz 
sicher nicht. Du musst ihn also verändert haben.

[Ja (Gast)]

#include <avr/io.h>
#define F_CPU 1000000UL // 1 MHZ
#include <util/delay.h>
#include <avr/interrupt.h>

volatile unsigned int milliSeconds;
volatile unsigned int adcReference      = 128u;
const    unsigned int adcRefMargin      =  20u;
const    unsigned int inRangeCountLimit =   9u;
volatile uint8_t doMeasurement;

//#define PB0_TO_3 ((1<<PB0)|(1<<PB1)|(1<<PB2));//|(1<<PB3))

static void initialize(void)
{
  DDRB &= ~(1<<DDB4);
  
  //Configure Timer 0
  TCCR0A = (1<<WGM01); // CTC Mode
  TCCR0B |= (1<<CS01); // Prescaler 8
  OCR0A = 125-1;       // ((F_CPU/8)/1000) = 125

  // Enable Compare Interrupt
  TIMSK |= (1<<OCIE0A);
  
  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  DDRB &= ~(1<<DDB4);
  ADMUX =
  (1 << ADLAR) |     // left shift result
  (1 << REFS1) |     // Sets ref. voltage to VCC, bit 1
  (1 << REFS0) |     // Sets ref. voltage to VCC, bit 0
  (0 << MUX3)  |     // use ADC2 for input (PB4), MUX bit 3
  (0 << MUX2)  |     // use ADC2 for input (PB4), MUX bit 2
  (1 << MUX1)  |     // use ADC2 for input (PB4), MUX bit 1
  (0 << MUX0);       // use ADC2 for input (PB4), MUX bit 0
  ADCSRA =
  (1 << ADEN)  |     // Enable ADC
  (0 << ADPS2) |     // set prescaler to 8, bit 2
  (1 << ADPS1) |     // set prescaler to 8, bit 1
  (1 << ADPS0);      // set prescaler to 8, bit 0
  
  sei();
}

int main(void)
{
  
  unsigned int adcResult;
  unsigned int inRangeCounter;
  
  initialize();
  for(;;)
  {
    //if (milliSeconds > 100)
    //{
    //  PORTB |= (1<<PB3);
    //}
    //else {
    //  PORTB &= ~(1<<PB3);
    //}
    if (doMeasurement == 1)
    {
      // One second has passed - do the next AD conversion
      
      ADCSRA |= (1 << ADSC);
      while (ADCSRA & (1 << ADSC))
      {
        //do nothing - just wait till conversion complete
      }
      adcResult = ADCH;
      
      // Check result range
      if (((adcReference - adcRefMargin) <= adcResult)
      && (adcResult < (adcReference + adcRefMargin)))
      {
        // Show that count limit is reached
        if(inRangeCounter > inRangeCountLimit)
        {
          PORTB |= (1<<PB3);
        }
        else
        {
          inRangeCounter ++;
        }
      }
      else
      {
        // Reset everything
        inRangeCounter = 0;
        adcReference = adcResult;
        PORTB &= ~(1<<PB3);
      }
      
      // Ready for next measurement
      doMeasurement = 0;
    }
  }
  return 0;
}

ISR(TIMER0_COMPA_vect)
{
  milliSeconds ++;
  if(milliSeconds >= 1000)
  {
    milliSeconds = 0;
    doMeasurement = 1;
  }
}

einige Variablen waren Quark, so compililiert er mir das. Allerdings 
schaltet der Ausgang niemals. Selbst dann nicht, wenn ADC an Masse liegt 
(Veränderung = 0).

[Ja (Gast)]

Ich habe so das Gefühl, dass das an der definierten ADCReference = 128u; 
liegt, vielleicht ändert der die mir dann nicht mehr.

[Ja (Gast)]

initialize();
for(;;) und return 0; können doch auch einfach mit while (1) dargestellt 
werden oder?

[Karl H. (kbuchegg)]

Nur zur Sicherheit:
Deine Eingangsspannung liegt aber schon am ADC2 Pin an?


(Persönlich hasse ich den Sch..., die ADC Routinen jedesmal neu zu 
schreiben. Im Tut gibt es so schöne Routinen dafür)

[Karl H. (kbuchegg)]

Ja schrieb:
> initialize();
> for(;;) und return 0; können doch auch einfach mit while (1) dargestellt
> werden oder?


Ja, aber das ist alles nicht das Problem.

[Ja (Gast)]

Karl Heinz schrieb:
> Eingangsspannung

Die auszuwertende, analoge Spannung liegt an ADC2 an, ja.
Ist ein Attiny85...

Karl Heinz schrieb:
> Ja, aber das ist alles nicht das Problem.

okay...

[Karl H. (kbuchegg)]

Da sich das jetzt schon in den 5. Tag reinzieht:
Können wir das ganze systematisch von mehr oder weniger bei 0 beginnend, 
in Schritten noch mal neu aufsetzen?

(Problem bei mir ist nämlich, dass ich auch zur Zeit auf keinen AVR 
zugreifen kann.)

[Karl H. (kbuchegg)]

Ja schrieb:

> Die auszuwertende, analoge Spannung liegt an ADC2 an, ja.
> Ist ein Attiny85...

Das ist schon mal gut zu wissen.

Denn der hat 3 Bits für die Referenzspannung.

Und die Kombination

  REFS2   REFS1   REFS0
    0       1       1

ist ungültig.

Womit hier

  ADMUX =
  (1 << ADLAR) |     // left shift result
  (1 << REFS1) |     // Sets ref. voltage to VCC, bit 1
  (1 << REFS0) |     // Sets ref. voltage to VCC, bit 0
  (0 << MUX3)  |     // use ADC2 for input (PB4), MUX bit 3
  (0 << MUX2)  |     // use ADC2 for input (PB4), MUX bit 2
  (1 << MUX1)  |     // use ADC2 for input (PB4), MUX bit 1
  (0 << MUX0);       // use ADC2 for input (PB4), MUX bit 0

schon mal der erste Fehler wäre.

[Ja (Gast)]

Karl Heinz schrieb:
> Da sich das jetzt schon in den 5. Tag reinzieht:
> Können wir das ganze systematisch von mehr oder weniger bei 0 beginnend,
> in Schritten noch mal neu aufsetzen

Klar, also:
Meine Intention:
Ich habe einen Attiny85 und eine analoge Spannung, die ausgewertet 
werden soll.
Auswertung: es soll ausgewertet werden, ob sich die Spannung verändert 
(in Betrachtung der Toleranz). Am besten soll dieser Check sekündlich 
stattfinden.
Wenn sich die Spannung nämlich nicht sonderlich verändert hat über eine 
Minute (nicht sonderlich = incl. Toleranz), dann soll/en Port/s als 
Ausgang geschaltet werden.
Das ist so die prinzipielle Idee.

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> Da sich das jetzt schon in den 5. Tag reinzieht:
>> Können wir das ganze systematisch von mehr oder weniger bei 0 beginnend,
>> in Schritten noch mal neu aufsetzen
>
> Klar, also:
> Meine Intention:
> Ich habe einen Attiny85 und eine analoge Spannung, die ausgewertet
> werden soll.
> Auswertung: es soll ausgewertet werden, ob sich die Spannung verändert
> (in Betrachtung der Toleranz). Am besten soll dieser Check sekündlich
> stattfinden.
> Wenn sich die Spannung nämlich nicht sonderlich verändert hat über eine
> Minute (nicht sonderlich = incl. Toleranz), dann soll/en Port/s als
> Ausgang geschaltet werden.
> Das ist so die prinzipielle Idee.

Alles schön und gut.
Nur fangen wir viel simpler an.

Du hast 4 LED und an diese 4 LED wird der Messwert ausgegeben (geeignet 
runtergeteilt). Ein Poti hast du am ADC EIngang oder sonst irgendeine 
Möglichkeit, dort eine veränderbare Spannung anzulegen?
Wie gross ist die zu messende Spannung maximal und was wollen wir als 
Referenzspannung nehmen.

Ehe das nicht klappt, dass du beim Drehen am Poti die LED sich nicht 
verändern siehst, brauchen wir mit komplexeren Dingen gar nicht erst 
anfangen. erst mal muss das einfache funktionieren.

[Ja (Gast)]

Ergibt durchaus Sinn; ja, Potis hab ich hier ein paar liegen.
Ich leg Vcc einfach an ADC an mit zwischengeschaltetem Poti, oder?

Zum Bild: was bedeutet das "X"?

[Karl H. (kbuchegg)]

Ja schrieb:
> Ergibt durchaus Sinn; ja, Potis hab ich hier ein paar liegen.
> Ich leg Vcc einfach an ADC an mit zwischengeschaltetem Poti, oder?

Jep.

        + Vcc
        |
       +-+
       | |
     <--------------- ADC2
       | |
       +-+
        |
     ---+--------- GND

Potiwert: 10k wären super.

Dann nehmen wir Vcc als Referenzspannung.


> Zum Bild: was bedeutet das "X"?

X ... don't care (also: spielt keine Rolle)

[Karl H. (kbuchegg)]

Dann ist das hier

#define F_CPU 1000000UL // 1 MHZ

#include <avr/io.h>
#include <util/delay.h>

/* ADC initialisieren */
void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = 0;

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  (void) ADCW;
}

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

int main(void)
{
  uint16_t adcValue;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  ADC_Init();

  while(1)
  {
    adcValue = ADC_Read( 2  );
    PORTB = adcValue / 64;
  }
}

das erste Testprogramm.

Bei Drehen am Poti müss sich an den LED was tun.

by the Way: wie rum sind deine LED angeschlossen? Leuchten die bei einer 
0 am Portpin oder bei einer 1?

Wenn: bei einer 0, dann eben

    PORTB = ~( adcValue / 64 );

[Karl H. (kbuchegg)]

Gibts ein Problem?

[Karl H. (kbuchegg)]

Klappts nicht?

[Ja (Gast)]

Karl Heinz schrieb:
> Klappts nicht?

Vielen vielen Dank erstmal: also, da scheint sich nichts zu tun...
Ich habe es mit Masse, Widerstand und VCC probiert, da leuchtet nichts. 
Kathode der LED liegt an Masse an, also passt das theoretisch. Ich weiß 
echt nicht, woran das liegen könnte...

[Ja (Gast)]

Okay sorry, ich scheine gerade einen heftigen geistigen Aussetzer gehabt 
zu haben: ES FUNKTIONIERT.

[Karl H. (kbuchegg)]

Hmmmmm.
Sollte aber eigentlich. Ausser der Einstellung für die Referenzspannung 
mit allen MUX Bits auf 0, ist mir nichts grossartiges mehr im Datenblatt 
aufgefallen.

OK, den Digitalportpin sollte man noch abschalten und da bin ich 
überfragt, ob das für den ADC ein Problem darstellt, wenn man es nicht 
macht. Sicherheitshalber

int main(void)
{
  uint16_t adcValue;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  DIDR0 |= (1<<ADC2D);

  ADC_Init();

  while .....
....

Deine LED funktionieren aber schon?
Wieder: sicherheitshalber

int main(void)
{
  uint16_t adcValue;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);
  DIDR0 |= (1<<ADC2D);

  ADC_Init();

  PORTB = 0x0F;
  _delay_ms( 200 );
  PORTB = 0x00;
  _delay_ms( 200 );
  PORTB = 0x0F;
  _delay_ms( 200 );

  while .....
....

Das gibt mal Lichtspiele, wenn das Programm startet. Kann nie schaden, 
wenn man da eine Bestätigung hat.

[Ja (Gast)]

Karl Heinz schrieb:
> Das gibt mal Lichtspiele, wenn das Programm startet. Kann nie schaden,
> wenn man da eine Bestätigung hat.

Der erste Code funktionert, also der mit dem ADC-Code. Also der ADC 
funktioniert!

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> Das gibt mal Lichtspiele, wenn das Programm startet. Kann nie schaden,
>> wenn man da eine Bestätigung hat.
>
> Der erste Code funktionert, also der mit dem ADC-Code. Also der ADC
> funktioniert!

Sag das doch gleich.

Gut. Dann gehts weiter.

[Karl H. (kbuchegg)]

Wir bringen jetzt mal die 1 Sekunde ins Spiel.
Das mach ich erst mal pragmatisch, indem ich mit einem _delay_ms() die 
Durchlaufzeit durch die Schleife auf ca 1 Sekunde anhebe. Um den delay 
kümmern wir uns später und ersetzen den durch einen Timer. Das ist im 
Moment nicht so wichtig.

Weiters bauen wir den Referenzwert ein, wobei uns diese zeitliche 
Mehfachreferenz noch wurscht ist. Wir gewinnen einfach jede 1 Sekunde 
einen neuen Wert und vergleichen ihn mit dem 'Referenzwert' aus der 
vorhergehenden Runde. Sind die beide (mit einer erlaubten Abweichung) 
gleich, dann: LED an (oder aus), wenn nicht dann eben LED aus (oder an).

Da die Differenz der beiden Werte negativ sein kann, hab ich den 
Datentyp für die Werte von einem uint16_t auf einen int16_t verändert. 
Dann gibt es bei der Subtraktion kein Problem mit negativen Werten.

int main(void)
{
  int16_t adcReference;
  int16_t adcValue;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  ADC_Init();

  adcReference = ADC_Read( 2  );

  while(1)
  {
    adcValue = ADC_Read( 2  );

    if( abs( adcReference - adcValue ) < 20 )
      PORTB |= 0xF0;
    else
      PORTB &= ~0xF0;

    adcReference = adcValue;
    _delay_ms( 1000 );
  }
}

Erwartetes Verhalten:
nach einer Änderung an der Eingangsspannung (am Poti drehen), sollten 
die LED erst mal abschalten um dann nach einer Zeit nicht länger als 1 
Sekunde wieder den ursprünglichen Zustand einzunehmen.

(Ich weiss nicht, ob Pin auf 1 bei dir LED leuchtet bedeutet oder nicht. 
Deine Aussage diesbezüglich war für mich nicht klar)

[Karl H. (kbuchegg)]

Karl Heinz schrieb:

> die LED erst mal abschalten um dann nach einer Zeit nicht länger als 1
> Sekunde wieder den ursprünglichen Zustand einzunehmen.

die Zeit kann ich leider nicht genauer festmachen, weil wir ja nicht 
wissen, wann genau du am Poti drehst, während der µC im delay hängt. Das 
kann sein, dass der gerade erst seine 1 Sekunde Wartezeit begonnen hat, 
es kann aber auch sein, dass sich die Wartezeit schon dem Ende zuneigt. 
Sehen sollte man allerdings was.

[Karl H. (kbuchegg)]

Autsch.,

Wie ist das denn passiert?
Tippfehler

    if( abs( adcReference - adcValue ) < 20 )
      PORTB |= 0xF0;

das muss natürlich

      PORTB |= 0x0F;

lauten!

(Was lernen wir daraus: wenn ich nicht zu faul gewesen wäre und mir 
statt dessen Makros für die LED definiert hätte, dann wäre der Fehler 
nicht passiert)

[Ja (Gast)]

Karl Heinz schrieb:
> das muss natürlich      PORTB |= 0x0F;

Nachdem ich das geändert habe, funktioniert es jetzt!

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> das muss natürlich      PORTB |= 0x0F;
>
> Nachdem ich das geändert habe, funktioniert es jetzt!


Gut.

Dann kommt als nächstes ein Zähler dazu, der mitzählt, wie oft auf 
'gleich' detektiert wurde.

Meld mich gleich wieder.

[Ja (Gast)]

int main(void)
{
  int16_t adcReference;
  int16_t adcValue;
  uint16_t Zaehler;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  ADC_Init();

  adcReference = ADC_Read( 2  );

  while(1)
  {
    adcValue = ADC_Read( 2  );

    if( abs( adcReference - adcValue ) < 20 )
    Zaehler++;
    //PORTB |= 0x0F;
    else
    //PORTB &= ~0x0F;
    Zaehler = 0;

    adcReference = adcValue;
    _delay_ms( 1000 );
    if (Zaehler > 9)
    {
      PORTB |= 0x0F;
    }
    
    else {
      PORTB &= ~0x0F;
    }
  }
}

Funktioniert ;)

[Karl H. (kbuchegg)]

OK. Nächste Version

Dazugekommen ist ein Zähler, der bei Übereinstimmung um 1 hochgezählt 
wird. Sind die Werte zu verschieden, dann wird der Zähler auf 0 gesetzt 
und die dann anliegende SPannung als neue Referenz genommen.

Ich hab die Anzahl erforderlicher Übereinstimmungen mal auf 5 gesetzt.

Auch hab ich eine kleine Modifikation gemacht. Solange die erforderliche 
Anzahl nicht beisammen ist, schalte ich die LED nicht einfach ab, 
sondern lass mir dort diesen Zähler ausgeben. D.h. an den LED müsste man 
sehen können, dass der Zähler sukzessive hochzählt.
Erst wenn die erforderliche Anzahl beisammen ist, dann gibt es an den 4 
LED 'die volle Dröhnung'
(OK, ich geb zu, dass ist auch eine kleine Spielerei. Aber ich seh sonst 
keine Möglichkeit festzustellen, ob der Zähler tatsächlich hochgezählt 
wird, oder ob es da noch einen nicht bedachten Effekt gibt)

#define F_CPU 1000000UL // 1 MHZ

#include <avr/io.h>
#include <util/delay.h>

/* ADC initialisieren */
void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = 0;

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  (void) ADCW;
}

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

#define REQUIRED  5

int main(void)
{
  int16_t adcReference;
  int16_t adcValue;
  uint8_t countEqual;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  ADC_Init();

  adcReference = ADC_Read( 2  );
  countEqual = 0;

  while(1)
  {
    adcValue = ADC_Read( 2  );

    if( abs( adcReference - adcValue ) < 20 )
    {
      if( count < REQUIRED )
        countEqual++;
    }
    else {
      countEqual = 0;
      adcReference = adcValue;
    }

    if( count == REQUIRED )
      PORTB |= 0x0F;
    else
    {
//      PORTB &= ~0xF0;               // so wirds dann im Endeffekt werden, ....
      PORTB = ( count & 0x0F );     // aber z uDebugzwecken lassen wir uns den count ausgeben.
    }

    _delay_ms( 1000 );
  }
}

[Ja (Gast)]

Karl Heinz schrieb:
> count

ist nicht definiert oder?

[Karl H. (kbuchegg)]

Karl Heinz schrieb:
> OK. Nächste Version

Ach ja.
Was ist das erwartete Verhalten?

Wird am Poti gedreht, dann sollten alle LED erst mal ausgehen Nach 
Beendigung des Drehens sollten die LED sukzessive binär von 0 bis 4 
hochzählen

        .     .     .     .
        .     .     .     X
        .     .     X     .
        .     .     X     X
        .     X     .     .

und beim 5.ten 'Takt', dann das Feuerwerk einschalten

        X     X     X     X

Soweit zur Erwartungshaltung, was passieren sollte :-)
Mal sehen, was wirklich passiert.

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> count
>
> ist nicht definiert oder?

Danke. Muss natürlich countEqual heissen.

Ich hätte noch mal drüber compilieren sollen. Ich änder das in meinem 
Studio gleich

[Ja (Gast)]

Super, funktioniert!
Der nächste Schritt wäre vermutlich der Timer oder?

[Karl H. (kbuchegg)]

Ja schrieb:

> Funktioniert ;)

zu spät gesehen.
Gratulation.

Aber noch nicht ganz.
WEnn die Schaltung etwas über 18 Stunden steht, ohne dass sich die 
Spannung am Eingang ändert, dann läuft dir dein Zaehler über. Aus 65535 
wird 0 und dann ... meldet deine Auswertung das falsche. D.h du musst 
diesen Überlauf verhindern.

Du kannst also hier

    if( abs( adcReference - adcValue ) < 20 )
    Zaehler++;

nicht einfach nur den Zaehler in jedem Fall erhöhen.

Auf der sicheren Seite bist du, wenn du den Zaehler nur dann erhöhst, 
wenn er kleiner als die von dir geforderte Anzahl bist. Da kann nichts 
passieren. Sieh dir an, wie ich das gemacht habe. Und sieh dir auch an, 
wie ich es gemacht habe, dass die beiden Zahlenwerte bei dieser 
Sicherung und bei der Auswertung auch definitiv immer übereinstimmen.

[Karl H. (kbuchegg)]

Ja schrieb:
> Super, funktioniert!
> Der nächste Schritt wäre vermutlich der Timer oder?

Jep.
D.h. falls du den überhaupt noch brauchst.

Wie wichtig ist die genaue Zeit? Gibt es noch etwas, was der µC tun 
müsste?

Wenn du sagst "Soooo wichtig ist die Zeit nicht, denn ich hab ja sowieso 
eine Granulierung in der ersten Sekunde nachdem sich die Spannung 
stabilisiert hat, also kommt es auf ein paar Zehntelmillisekunden pro 
Schleifendurchlauf auch nicht an"

bzw. wenn du sagst "Nö, das ist die einzige Aufgabe, die der µC hat"

dann brauchen wir nicht päpstlicher als der Papst sein und können das so 
lassen.

Wenn du aber sagst, nope geht so nicht, dann bauen wir den Timer rein.

[Ja (Gast)]

Karl Heinz schrieb:
> Auf der sicheren Seite bist du, wenn du den Zaehler nur dann erhöhst,
> wenn er kleiner als die von dir geforderte Anzahl bist. Da kann nichts
> passieren. Sieh dir an, wie ich das gemacht habe. Und sieh dir auch an,
> wie ich es gemacht habe, dass die beiden Zahlenwerte bei dieser
> Sicherung und bei der Auswertung auch definitiv immer übereinstimmen

Danke für den Tipp!
Ergibt durchaus Sinn.

[Karl H. (kbuchegg)]

Das hier

  while(1)
  {
    adcValue = ADC_Read( 2  );

    if( abs( adcReference - adcValue ) < 20 )
    Zaehler++;
    //PORTB |= 0x0F;
    else
    //PORTB &= ~0x0F;
    Zaehler = 0;

    adcReference = adcValue;
    _delay_ms( 1000 );

stimmt in deinem Programm auch noch nicht. Du willst nicht auf jeden 
Fall immer den aktuellen Spannungswert als neue Referenz nehmen. Denn 
wenn du nur langsam genug am Poti drehst, dann ändert sich der auch pro 
Durchlauf nur wenig. D.h. Obwohl sich deine Spannung laufend verändert, 
ist von einem Durchgang zum nächsten die Differenz immer kleiner als die 
vorgegebenen 20 und du zählst munter den Zaehler hoch, obwohl du bei 
entsprechend langsamen Drehen das Poti von einem Ende zum anderen 
durchdrehen kannst!


Und rück deinen Code ein!

[Ja (Gast)]

Karl Heinz schrieb:
> Wenn du aber sagst, nope geht so nicht, dann bauen wir den Timer rein

Timer wäre schon nötig, da das ganze auch erst nach einer bestimmten 
Zeit losgehen soll..

OK.

Das ist jetzt leicht, denn der Timer hat ja (denk ich) von Anfang an 
funktioniert.
Den Teil übernehmen wir einfach mal im wesentlichen.

[Karl H. (kbuchegg)]

OK. Hier mein Vorschlag.

Die Sache mit den Millisekunden ist gleich geblieben.
Die Auswertung (Messung plus vergleich) findet als EInheit nur dann 
statt,
wenn der Timer sein 'GO' gegeben hat.
Die Technik, wie man sowas macht, kennst du ja schon: eine (volatile) 
uint8_t Variable, die von der Timer-ISR auf 1 gesetzt wird und in der 
Hauptschleife wird geprüft, ob sie 1 ist und wenn ja, wird der 
Mechanismus angeworfen.

#define F_CPU 1000000UL // 1 MHZ

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define REQUIRED  9                     // wieviele 'gleiche' Messwerte sind erforderlich?
#define EPSILON   20                    // in welchem +-Bereich sind die Messwerte noch als gleich anzusehen (ADC-EInheiten) 

volatile uint16_t milliSekunden;
volatile uint8_t  doMeasure;

/* ADC initialisieren */
void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = 0;

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  (void) ADCW;
}

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

int main(void)
{
  int16_t adcReference;
  int16_t adcValue;
  uint8_t countEqual;

  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  TCCR0A = (1<<WGM01);  // CTC Modus
  TCCR0B |= (1<<CS01);  // Prescaler 8
  OCR0A = ( (F_CPU / 8 ) / 1000 ) - 1;    // auf 1 Millisekunde einstellen
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  ADC_Init();

  adcReference = ADC_Read( 2  );
  countEqual = 0;

  sei();      // alles fertig eingestellt: und los gehts!

  while(1)
  {
    if( doMeasure )
    {
      doMeasure = 0;

      adcValue = ADC_Read( 2  );

      if( abs( adcReference - adcValue ) < EPSILON )
      {
        if( countEqual < REQUIRED )
          countEqual++;
      }
      else {
        countEqual = 0;
        adcReference = adcValue;
      }

      if( countEqual == REQUIRED )
        PORTB |= 0x0F;
      else
        PORTB &= ~0xF0;
    }
  }
}

ISR (TIMER0_COMPA_vect)   // wird im Millisekundentakt aufgerufen
{
  milliSekunden++;
  if( milliSekunden == 1000 )
  {
    milliSekunden = 0;

    doMeasure = 1;
  }
}

[Karl H. (kbuchegg)]

Ein bischen übersichtlicher wird das Ganze, wenn wir den ganzen Teil mit 
der Messung und Auswertung aus main() rausnehmen und in eine eigene 
Funktion stecken.

#define F_CPU 1000000UL // 1 MHZ

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

#define REQUIRED  9                     // wieviele 'gleiche' Messwerte sind erforderlich?
#define EPSILON   20                    // in welchem +-Bereich sind die Messwerte noch als gleich anzusehen (ADC-EInheiten) 

volatile uint16_t milliSekunden;
volatile uint8_t  doMeasure;

/* ADC initialisieren */
void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = 0;

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
  }
  (void) ADCW;
}

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

int16_t adcReference;
int16_t adcValue;
uint8_t countEqual;

void performCheck()
{
   adcValue = ADC_Read( 2  );

  if( abs( adcReference - adcValue ) < EPSILON )
  {
    if( countEqual < REQUIRED )
      countEqual++;
  }
  else {
    countEqual = 0;
    adcReference = adcValue;
  }

  if( countEqual == REQUIRED )
    PORTB |= 0x0F;
  else
    PORTB &= ~0xF0;
}

int main(void)
{
  DDRB |= (1<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);

  TCCR0A = (1<<WGM01);  // CTC Modus
  TCCR0B |= (1<<CS01);  // Prescaler 8
  OCR0A = ( (F_CPU / 8 ) / 1000 ) - 1;    // auf 1 Millisekunde einstellen
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  ADC_Init();

  adcReference = ADC_Read( 2  );
  countEqual = 0;

  sei();      // alles fertig eingestellt: und los gehts!

  while(1)
  {
    if( doMeasure )
    {
      doMeasure = 0;
      performCheck();
    }
  }
}

ISR (TIMER0_COMPA_vect)   // wird im Millisekundentakt aufgerufen
{
  milliSekunden++;
  if( milliSekunden == 1000 )
  {
    milliSekunden = 0;

    doMeasure = 1;
  }
}

Dann ist der ganze Mess-Auswertevorgang eine abgeschlossene Einheit und 
hier in der Hauptschleife

...
  while(1)
  {
    if( doMeasure )
    {
      doMeasure = 0;
      performCheck();
    }
  }

ist es auch sehr leicht zu verstehen, wie die Logik läuft. Wenn der 
Timer sagt, dass der ADC zu überprüfen ist, dann macht das Programm 
genau das: den ADC überprüfen.

[Ja (Gast)]

Okay, es funktioniert perfekt, viel viel viel Dank, echt, ich habe durch 
diesen Prozess hier gerade sehr viel gelernt, und vermutlich auch viele 
andere, die das hier noch lesen werden!
Eine Frage hätte ich noch:
Ich habe stunden, minuten, sekunden auch noch in den ISR 
(TIMER0_COMPA_vect) hinzugefügt nach bekanntem Muster und auch als 
variable deklariert, meine Frage:
wie ist es zu lösen, dass die ganze Abfragerei erst nach minute > 0 
beginnt?

while (minute > 0 )

 funktioniert nicht [es passiert nichts], ebenso wie

 if( countEqual == REQUIRED && (minute > 0 )
    PORTB |= 0x0F;

 [hier leuchten von Anfang an 2 LEDS, nach 1 minute leuchten dann die 
anderen]?

[Karl H. (kbuchegg)]

Ja schrieb:
> Okay, es funktioniert perfekt, viel viel viel Dank, echt, ich habe durch
> diesen Prozess hier gerade sehr viel gelernt,


genau das war der Sinn der ganzen Sache.

> Eine Frage hätte ich noch:
> Ich habe stunden, minuten, sekunden auch noch in den ISR
> (TIMER0_COMPA_vect) hinzugefügt nach bekanntem Muster und auch als
> variable deklariert, meine Frage:
> wie ist es zu lösen, dass die ganze Abfragerei erst nach minute > 0
> beginnt?

Da gibts mehere möglichkeiten.
Eine wäre zb, dass in der ISR die Variable doMeasure erst dann auf 1 
gesetzt wird, wenn die Stunden bzw. Minuten richtig stehen :-)

>
>

> while (minute > 0 )
>

> funktioniert nicht [es passiert nichts],

Du musst weg von deinem Schleifendenken!

Du musst hin zu einem denken von:

Ich wach jetzt gerade auf. Ich seh mich um, wie ist meine Situation, was 
spielt sich in meiner Umgebung ab? Muss ich auf ein Ereignis reagieren? 
WEnn ja, dann mach ich das und dann leg ich mich wieder schlafen.

Auf etwas warten bedeutet nicht notwendigerweise, dass man aktiv daneben 
stehen bleibt und zusieht. Auf etwas warten kann auch bedeuten, dass man 
sich sozusagen 'den Weckere stellt' und wenn der klingelt man sich 
umsieht, ob es schon etwas zu tun gibt. Wenn ja, dann macht man das. 
Wenn nein, dann stellt man sich den Wecker für die nächste Periode und 
macht was anderes oder schläft.

Genau das ist die Art und Weise, wie man µC sinnvoll programmiert. Nicht 
in Warteschleifen denken, sondern in FOrm von Ereignissen die eintreten.
Bei dir ist das leicht, denn das einzige Ereignis, das 'eintritt', das 
ist, dass wieder eine Millisekunde um ist.

[Karl H. (kbuchegg)]

Ja schrieb:


> ebenso wie

 if( countEqual == REQUIRED && (minute > 0 )
>     PORTB |= 0x0F;

 [hier leuchten von Anfang an 2 LEDS, nach 1
> minute leuchten dann die anderen]?

Du musst hier ein bisschen vorsichtig sein!
Denn dieses if hat ein else, das immer dann zum Zug kommt, wenn die 
Bedingung IN IHRERE GESAMTHEIT nicht zutrifft. IN diesem else passieren 
aber Dinge. Und die passieren dann auch dann, wenn die minute eben noch 
nicht größer als 0 ist.

Wenn du also zu einer Bedingung weitere Ausdrücke hinzufügst (die in 
deinem Beispiel mit einem && verknüpft werden), dann musst du dich auch 
immer fragen: was bedeutet das jetzt wenn genau dieser Teil der Bedingun 
eben NICHT zutrifft. Was geht dann in meinem else ab?

   if( minuten > 0 )
   {
     if( countEqual == REQUIRED )
       ....  A
     else
       ....  B
   }

ist eben nicht dasselbe wie

   if( countEqual == REQUIRED && minuten > 0 )
     .... A
   else
     .... B

Für den Codeteil A ändert sich nichts. Der wird auch dann unter den 
gleichen Bedingungen ausgeführt. Aber für den Codeteil B ist alles ganz 
anders!

[Ja (Gast)]

Karl Heinz schrieb:
> ine wäre zb, dass in der ISR die Variable doMeasure erst dann auf 1
> gesetzt wird, wenn die Stunden bzw. Minuten richtig stehen

Aber damit würde die Messung ja nur noch minütlich stattfinden, oder 
nicht?

[Themaverwirrter (Gast)]

>> ADC funktioniert nicht

So wie es der Thread-Titel ausdrückt wäre der ausgerufene Sachverhalt
ja gleichzusetzen einem Defekt im/am ADC oder ein grösserer Defekt des
gesamten Prozessors.

.... also ein bischen voreilig ..... bzw Themaverfehlung ....

Oder frage ich mal in die Runde:

Ist es einfach "wurscht" was man im Titel schreibt?

[Karl H. (kbuchegg)]

Ja schrieb:
> Karl Heinz schrieb:
>> ine wäre zb, dass in der ISR die Variable doMeasure erst dann auf 1
>> gesetzt wird, wenn die Stunden bzw. Minuten richtig stehen
>
> Aber damit würde die Messung ja nur noch minütlich stattfinden, oder
> nicht?


Wieso?

ISR (TIMER0_COMPA_vect)   // wird im Millisekundentakt aufgerufen
{
  milliSekunden++;
  if( milliSekunden == 1000 )
  {
    milliSekunden = 0;
    Sekunden++;

    if( Sekunden == 60 )
    {
      Sekunden = 0;
      Minuten++;
    }

    // wir sind auf jeden Fall schon mal auf einer ganzen Sekunde
    // sind seit dem Start mehr als 5 Minuten vergangen, dann darf
    // daher auch der Auftrag zum Messen rausgegeben werden
    if( Minuten > 5 )
      doMeasure = 1;
  }
}

[Karl H. (kbuchegg)]

Und wegen der Stunden.

Es ist einfacher, wenn du die Zeit komplett in Form von Minuten 
ausdrückst. 2 Stunden und 23 Minuten sind 143 Minuten.

Wenn du da jetzt auch noch Stunden als eigene EInheit mit ins Boot 
holst, dann kann man das natürlich machen. Aber der Aufwand!

ISR (TIMER0_COMPA_vect)   // wird im Millisekundentakt aufgerufen
{
  milliSekunden++;
  if( milliSekunden == 1000 )
  {
    milliSekunden = 0;
    Sekunden++;

    if( Sekunden == 60 )
    {
      Sekunden = 0;
      Minuten++;

      if( Minuten == 60 )
      {
        Minuten = 0;
        Stunden++;
      }
    }

    // wir sind auf jeden Fall schon mal auf einer ganzen Sekunde
    // sind seit dem Start mehr als 2 Stunden und 23 Minuten vergangen,
    // dann darf
    // daher auch der Auftrag zum Messen rausgegeben werden
    if( ( Stunden > 2 ) ||
        ( Stunden == 2 && Minuten > 5 ) )
      doMeasure = 1;
  }
}

und seien wir uns mal ehrlich. Mit einem uint16_t für die Minuten kann 
man bis zu 65535 abzählen. Das sind 1092 Stunden. Oder 45.5 Tage.
Das sollte wohl reichen. :-)

[Ja (Gast)]

Alles klar, ich bedanke mich noch mal recht herzlich, du könntest dich 
auf jedem Fall dem Lehren widmen, so gut wie du das machst!
Dankeschön.

[Ja (Gast)]

Es tut mir fast ein wenig Leid, euch noch einmal belästigen zu müssen 
aber:
ich habe versucht, 2 Modi einzufügen.
Der erste soll aktiviert werden, wenn ein Schalter auf Ground geht.
Der zweite, wenn der Schalter gegen nichts geht und der interne Pull-up 
resistor greift und so an VCC geht.
der erste Modus: ganz normale Funktion, wie oben auch beschrieben
der zweite Modus: nach Wiederholungen des Watchdogs soll der gleiche 
Code wie bei 1 ausgeführt werden; Watchdog wegen des Stromsparens.
Problem:
Bei dem ersten Modus schalten sich die Pins 10 Sekunden nach Aktivierung 
wieder ab.
Der zweite scheint gar nicht erst zu funktionieren.
Könnte einer mal den Code überfliegen und Tipps geben?
Danke.

#define F_CPU 1000000UL // 1 MHZ

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>        // Supplied Watch Dog Timer Macros
#include <avr/sleep.h>      // Supplied AVR Sleep Macros

#define REQUIRED  5                     // wieviele 'gleiche' Messwerte sind erforderlich?
#define EPSILON   20                    // in welchem +-Bereich sind die Messwerte noch als gleich anzusehen (ADC-EInheiten)

volatile uint16_t milliSekunden;
volatile uint16_t watchdogcounter;
volatile uint8_t  doMeasure;
volatile unsigned int sekunde;
volatile unsigned int minute;
volatile unsigned int stunde;

/* ADC initialisieren */
void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Refernz wählen:
  ADMUX = 0;

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC) ) {         // auf Abschluss der Konvertierung warten
}
(void) ADCW;
}

uint16_t ADC_Read( uint8_t channel )
{
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x0F)) | (channel & 0x0F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {   // auf Abschluss der Konvertierung warten
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

int16_t adcReference;
int16_t adcValue;
uint8_t countEqual;

void performCheck()// modus: 1
{
  //PORTB |= (1<<PB3);// sensor: an
  //ADCSRA |= (1<<ADEN);                  // ADC aktivieren
  if (doMeasure == 1)
  { doMeasure = 0;
  
   adcValue = ADC_Read( 2  );

  if( abs( adcReference - adcValue ) < EPSILON )
  {
    if( countEqual < REQUIRED )
      countEqual++;
  }
  else {
    countEqual = 0;
    adcReference = adcValue;
  }
if (minute >= 0)
{

  if( countEqual == REQUIRED )
    PORTB |= (1<<PB1) | (1<<PB2);//0x0F;
  else
    PORTB &= ~((1<<PB1) | (1<<PB2));//( countEqual & 0x0F );//&= ~0x0F; //( countEqual & 0x0F )=binäre anzeige des zählers;
}  
}
}
ISR(WDT_vect) {
  watchdogcounter++;
}

void performCheck2()
{
  if (watchdogcounter < 2) //2250 = 24*60*60/8 (5h)
  {
    //sleep_enable();//8 sec schlaf
    sleep_mode();
  }
  else{
    //PORTB |= (1<<PB3);
    if (doMeasure == 1)
    {
    doMeasure = 0;
  adcValue = ADC_Read( 2  );

  if( abs( adcReference - adcValue ) < EPSILON )
  {
    if( countEqual < REQUIRED )
    countEqual++;
  }
  else {
    countEqual = 0;
    adcReference = adcValue;
  }
  if (minute >= 0)
  {

    if( countEqual == REQUIRED )
    PORTB |= (1<<PB1) | (1<<PB2); //0x0F;
    else
    PORTB &= ~((1<<PB1) | (1<<PB2));//( countEqual & 0x0F );//&= ~0x0F; //( countEqual & 0x0F )=binäre anzeige des zählers;
  }
  }  
    }  
}

int main(void)
{
  DDRB |= (0<<DDB0) | (1<<DDB1) | (1<<DDB2) | (1<<DDB3);// | (0<<DDB4); //DDB0 = input
  PORTB |= (1<<PB0); // pull up resistor
  PORTB |= (1<<PB3); // sensor: vcc=1

  TCCR0A = (1<<WGM01);  // CTC Modus
  TCCR0B |= (1<<CS01);  // Prescaler 8
  OCR0A = ( (F_CPU / 8 ) / 1000 ) - 1;    // auf 1 Millisekunde einstellen
  
  // Compare Interrupt erlauben
  TIMSK |= (1<<OCIE0A);
  ADC_Init();

  adcReference = ADC_Read( 2  );
  countEqual = 0;

  sei();      // alles fertig eingestellt: und los gehts!
  WDTCR |= (1<<WDP3) | (1<<WDP0) | (1<<WDE) | (1<<WDIE); //watchdog interrupt + 8sec

  while(1)
  {
    if(  (PINB & (1<<PINB0)) == 0 )//pressed (connection to ground)//doMeasure )
    {
      //doMeasure = 0;
      performCheck();//1
    }
   if(  (PINB & (1<<PINB0)) == 1 )//not pressed (connection to vcc) //doMeasure )
   {
     //doMeasure = 0;
     performCheck2();
   }
  
  }
}

ISR (TIMER0_COMPA_vect)   // wird im Millisekundentakt aufgerufen
{
  milliSekunden++;
  if( milliSekunden == 1000 )
  {  sekunde++;
    milliSekunden = 0;

    doMeasure = 1;
  }
   if(sekunde == 60)
   {
     minute++;
     sekunde = 0;
   }
   if(minute == 60)
   {
     stunde++;
     minute = 0;
   }
   if(stunde == 24)
   {
     stunde = 0;
   }
}

[Ja (Gast)]

Ich habe die while-Schleife grundlegend verändert, den Watchdog und 
seinen Interrupt definiert und einen neuen Modus hinzugefügt. In meinen 
Augen ist da alles korrekt. Compilen geht auch. Leider will der 
übermenschliche Code-Gott nicht so, wie ich das will.

[Ja (Gast)]

okay habs geschafft.

[Paul B. (paul_baumann)]

Ja schrieb:
> okay habs geschafft.

Glückwunsch dazu.

Schick doch den nun funktionierenden Quelltext hinterher, damit der 
Nächste, dem das Gleiche passiert, nicht in der Sackgasse endet.

MfG Paul