zwei werte in if-abfrage vergleichen, trotz unterschiedlichen werten wird if-abfrage nicht ausgelöst

[Johannes (Gast)]

Hallo,
ich habe an adc0 (atmega328p) einen Poti und möchte mir gerne den adc 
über uart ausgeben lassen. Aber nur, wenn sich dieser ändert. Dazu lese 
ich diesen im Timerinterrupt (jede 1ms) ein und speichere den Wert in 
adcval. In meiner While-schlife vergleiche ich den eingelesenen Wert mit 
den vorigen wert, welcher in adcvalOld steht. Wenn diese unterschiedlich 
sind, soll mir der wert über uart gesendet werden und der aktuelle wert 
wird in adcvalOld gespeichert, damit beim nächsten aufruf der wert nicht 
erneut gesendet wird. Allerdings wird mir der Wert nie gesendet. Nehme 
ich die Abfrage raus, bekomme ich den wert dauernd gesendet. Dieser 
ändert sich auch, wenn ich am poti drehe. Ich habe aber keine erklärung, 
warum das so ist. Der wert muss ja unterschiedlich sein. Daher weiß ich 
nicht, warum nichts gesendet wird. Habt ihr einen rat und könnt was 
sehen, woran es hapern könnte?

static char sendString[4];
static uint16_t adcval = 0; // adc
static uint16_t adcvalOld = 0; // adc

int main(void)
{
  timer0_init(&TCCR0A,  ~(1 << WGM00) | (1 << WGM01),
          &TCCR0B,  ((1 << CS00) | (1 << CS01)) & ~(1 << CS02),
          &OCR0A,   (250 - 1),
          &TIMSK0,  (1 << OCIE0A),
          &TCNT0, 0);


  uart_init(&UBRR0H, &UBRR0L, MYUBRR,/* Set baud rate */
      &UCSR0B, ((1<<RXCIE0)|(1<<RXEN0)|(1<<TXEN0)), /* Enable receiver and transmitter */
      &UCSR0C, ((1<<UCSZ00)|(1<<UCSZ01)));  /* Set frame format: 8data, 1stop bit */

  ADC_Init();

  sei();
  while(1)
  {
    if(adcval != adcvalOld)
    {
      itoa(adcval, sendString, 10);
      uart_sendString(sendString);
      uart_transmit('\n');
      adcvalOld = adcval;
    }

  }
}

ISR (TIMER0_COMPA_vect)
{
  static uint16_t timerInterruptTicks = 0;  // Anzahl der Aufrufe der ISR

  timerInterruptTicks++;
  adcval = ADC_Read(0);

  // Eine Sekune vorbei
  if(timerInterruptTicks>=1000)
  {
    timerInterruptTicks = 0;
  }
}

void ADC_Init(void)
{
  // die Versorgungsspannung AVcc als Referenz 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
  }
  return ADCW;                    // ADC auslesen und zurückgeben
}

[Müchi (Gast)]

Die beiden Variablen musst Du "volatile" deklarieren, weil sie in der 
ISR verändert werden.
sonst optimiert Dein Compiler die weg und ersetzt sie einfach mit einer 
statischen 0.

[Müchi (Gast)]

bzw...

zumindest die adcval muss volatile sein.

[Martin B. (ratazong)]

Das einzige, was mir auffällt, ist dass adcval nicht als volatile 
deklariert ist. Das sollte er aber sicherheitshalber, damit der 
Optimierer nichts wegoptimiert.

Hast Du Dir mal den Assembleroutput angeguckt?

[Johannes (Gast)]

Das mit dem Volatile hat gestimmt. Das hat das Problem behoben.
aber mit statisch ist die variable doch auch global und in allen 
funktionen bekannt oder nicht?

[MaWin (Gast)]

Martin B. schrieb:
> Das einzige, was mir auffällt, ist dass adcval nicht als volatile
> deklariert ist.

Es könnte auch auffallen, sass sich ADC Werte eigentlich immer bei jeder 
Abfrage um +/-1 ändern, und daher der ganze Ansatz, nur Dinge tun zu 
wollen wenn man am Poti dreht, Schwachsinn ist. Man müsste wenigstens 
spezifizieren wie weit man innerhalb welcher Zeit dreht.

[Martin B. (ratazong)]

Johannes schrieb:
> Das mit dem Volatile hat gestimmt. Das hat das Problem behoben.
> aber mit statisch ist die variable doch auch global und in allen
> funktionen bekannt oder nicht?

Ja, bekannt ist es, aber das reicht nicht. Der Optimierer könnte auf die 
Idee kommen adcval vor der while(1) Schleife in ein Register zu laden, 
um die Schleife zu beschleunigen. Die if Abfage in der Schleife bekommt 
dann nicht mit, dass sich adcval geändert hat. Das siehst Du im 
Assembleroutput.

[Manfred (Gast)]

> Es könnte auch auffallen, sass sich ADC Werte eigentlich immer bei jeder
> Abfrage um +/-1 ändern, und daher der ganze Ansatz, nur Dinge tun zu
> wollen wenn man am Poti dreht, Schwachsinn ist.

Das sind die Grundlagen, die man sich als Anfänger erarbeiten muß *). 
Auf das Wackeln des ADC-Wertes ist wohl am Anfang jeder hereingefallen.

VoltageRead1 = analogRead (1);
if ((VoltageRead1 - lastVoltage1) > 1 || (lastVoltage1 - VoltageRead1) > 1) {
  // pruefen auf <> 1 weil ungleich nicht klappt, vermutlich Rauschen.
  Serial.print("Port A1 = ");
  Serial.println(VoltageRead1);
  lastVoltage1 = VoltageRead1;
  }

In der Hauptschleife steuere ich noch eine LED an, ob das Poti rechts 
oder links der Mitte steht, nicht ohne Grund mit zwei unterschiedlichen 
Abfragewerten:

if (analogRead (1) > 520) {
  digitalWrite(9, HIGH);
  }
if (analogRead (1) < 500) {
  digitalWrite(9, LOW);
  }

@Johannes: Das ist keine Kritik, eher im Gegenteil - erstmal einfache 
Funktionen durchspielen, bevor Dich ein reales Projet zur Verzweifelung 
treibt.

Johannes schrieb:
> einen Poti
Das Poti, also unbestimmt ein Poti.

[Heiko L. (zer0)]

Was auch noch zu beachten wäre, ist, dass dort 16-bit Werte verglichen 
werden, und dieser Vergleich auf 8-bit Micros nicht atomar ist. Kann 
also auch zu falschen Ergebnissen führen.