Programm Problem mit ADC ergebniss Attiny13

[Fritz B. (kleinfritzchen)]

Hallo, ich möchte mir nach und nach ein Programm stricken mit dem ich 
einen Laminator auf ca. 200 Grad einregeln kann.
Ich bin grad am versuchen ein Poti auszulesen und über den ermittelten 
Wert eine Diode in der Blink-geschwindigkeit zu regeln.
Das Problem ist hier das ich als Rückgabewert des ADC kein Zahlenformat 
finde das ich in _delay_ms(xxx) eintragen kann ohne eine Fehlermeldung 
zu kriegen.
kann mir da vielleicht mal jemand einen Tip geben?

hier mal der Code:

#include <avr/io.h>
#include <util/delay.h>
//#define F_CPU = 1200000UL
uint16_t leseKanal(uint8_t mux);
uint16_t verz=0;
int main (void){
  DDRB=0x01;
  
  
  while (1){
    PORTB ^= 0x01;
    verz =  leseKanal(0x21);
    verz =verz*3;
    _delay_ms(verz);
  } return 0;
  
}

//Routine zum einlesen eines Kanales
uint16_t leseKanal(uint8_t mux)
{
  uint8_t i;
  uint8_t ergebniss;
  uint16_t foo;
  ADCSRA |= (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1);
    //ADC einschalten, Teiler auf 8
  ADMUX =mux;
  //lerlauf zum syncronisoeren
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){
    ;
  }
  foo = ADCW;
    
  foo = 0;
  //eigentlicher Abfragezyklus
  for(i=0;i<4;i++){
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC)){
      ;
    }
    foo +=ADCW;
  }
  foo = foo/4;
  foo += (foo>>2);
  ergebniss = (uint8_t)foo;
  return ergebniss;
  
}

[Karl H. (kbuchegg)]

Fritz Bie schrieb:
> Hallo, ich möchte mir nach und nach ein Programm stricken mit dem ich
> einen Laminator auf ca. 200 Grad einregeln kann.
> Ich bin grad am versuchen ein Poti auszulesen und über den ermittelten
> Wert eine Diode in der Blink-geschwindigkeit zu regeln.
> Das Problem ist hier das ich als Rückgabewert des ADC kein Zahlenformat
> finde das ich in _delay_ms(xxx) eintragen kann ohne eine Fehlermeldung
> zu kriegen.

das Problem ist nicht das Zahlenformat. Das Problem ist, dass du bei 
_delay_ms einen konstanten Wert angeben musst.
Du kannst also schreiben

  _delay_ms( 50 );

oder auch

  _delay_ms( 200 );

da sowohl 50 als auch 200 konstante Werte seind.
Du kannst aber nicht schreiben

  int zeit;

  ...
  _delay_ms( zeit );

weil zeit eine Variable ist und keine Konstante.
Hintergrund: _delay_ms erfordert vom Compiler einiges an Aufwand. Er 
ermittelt aus der Zahl ein Schleifenkonstrukt, dass so oft durchlaufen 
wird, dass die angegebene Zeit ziemlich genau erreicht wird.
Das geht aber nur dann gut, wenn der Compiler die angestrebte Zeit als 
Zahlenwert auch tatsächlich kennt! Denn nur dann kann der Compiler all 
die Zwischenberechnungen rausoptimieren, so dass im Endeffekt nur das 
Schleifenkonstrukt mit genau diesem Zeitverhalten entsteht.

Daher die Einschränkung.

Aber:
Wenn man 50 Zeiteinheiten warten will, dann kann man auch 50 mal 1 
Zeiteinheit warten. Das ist im Endergebnis fast das selbe. Will man x 
Zeiteinheiten warten, dann kann man auch x mal 1 Zeiteinheit warten.

Anstatt einem nicht korrekten

  _delay_ms( zeit );

kann man zb ein

   for( i = 0; i < zeit; i++ )
     _delay_ms( 1 );

machen und ist damit auch (fast) dort, dass man eine vorher nicht näher 
bestimmte Zeit abwarten kann. Die Zeiten werden nicht ganz genau 
stimmen, weil ja das for-Konstrukt auch seine Zeit braucht, aber 
meistens ist das nicht so schlimm. Wir reden da über ein paar 
Zehntel-Prozent, die die Zeit deswegen abweichen wird.

[Fritz B. (kleinfritzchen)]

Hallo,
ja hast recht,
als ich im mBett lag ist mir  diese Möglichkeit auch eingefallen.
danke erst mal so funktioniert es.

[Fritz B. (kleinfritzchen)]

Das Blinken funktioniert jetz! Aber ich kann den Blinkrütmus im Bereich 
von 0V bis Vcc 4 mal über den Bereich verändern. das heist das der 
Zyklus bei Vcc langsam ist und er sich bis zu einem Spannungsabfall von 
ca 1.2V immer Scneller wird um danach beim weiteren drehen am Poti 
wieder schlagartig langsam und dann beim weiterdrehen wieder schneller 
zu werden. Dieser  Zyklus Wiedrholt sich 4 mal bis ich bei Null V bin.
kann mir mal jemand erklären woran das liegt? hab ich was falsch 
programmiert?
Code:

#include <avr/io.h>
#include <util/delay.h>
//#define F_CPU = 1200000UL
uint16_t leseKanal(uint8_t mux);
uint16_t verz=0, i;
int main (void){
  DDRB=0x01;
  
  
  while (1){
    PORTB ^= 0x01;
    verz =  leseKanal(0x03);
    for ( i=0;i<=verz;i++){
      _delay_ms(2);
    }
  } return 0;
  
}

//Routine zum einlesen eines Kanales
uint16_t leseKanal(uint8_t mux)
{
  uint8_t i;
  uint8_t ergebniss;
  uint16_t foo;
  ADCSRA |= (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1);
    //ADC einschalten, Teiler auf 8
  ADMUX =mux;
  //lerlauf zum syncronisoeren
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){
    ;
  }
  foo = ADCW;
    
  foo = 0;
  //eigentlicher Abfragezyklus
  for(i=0;i<4;i++){
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC)){
      ;
    }
    foo +=ADCW;
  }
  ergebniss = foo/4;
  ergebniss = (ergebniss>>2);
  return ergebniss;
  
}

[Karl H. (kbuchegg)]

Fritz Bie schrieb:

> uint16_t leseKanal(uint8_t mux)
> {
>   uint8_t i;
>   uint8_t ergebniss;
    *******

>   ergebniss = foo/4;

foo/4 kann Werte zwischen 0 und 1023 ergeben.
ergebniss kann als uint8_t aber nur Werte zwischen 0 und 255 speichern.

[Fritz B. (kleinfritzchen)]

Besten dank!
hab ich glatt übersehen!
MfG Fritz