Probleme mit _delay_us() bei #define Wert und int_8t Wert

[Ben S. (patersigmund)]

Hallo allerseits!

Ich hab ein Problem, und zwar bin ich dran eine PWM per Software zu 
lösen. Es funktioniert soweit auch ganz gut. Nur sobald ich versuche die 
Zeiten per Taster zu regeln streikt er.
Achso hier die Fehlerbeschreibung:
Wenn ich die Argumente der delays per Hand setze ist die LED wirklich 
auf einer sehr niedrigen Leuchtstufe. Wenn ich aber dann das Argument 
durch eine Funktion in i ausdrücke, leuchtet die LED bei weitem heller.

Wobei sich mir dann die Frage stellt obs einen Unterschied zwischen 
einem

#define WERT

und einem

uint16_t WERT

gibt

Vielleicht erkennt ja jemand meinen Fehler.

Gruß,
  me


Hier dann der C-Code.
Kurze Einleitung:
Das debounce hab ich mir aus dem Forum kopiert. Da ich mich darum erst 
später kümmern wollt.
Am Anfang die viele defines sind nur dafür da, damit ich das Programm 
nachher einfach auf die andere Hardware portieren kann.
Der Hauptteol befindet sich eigentlich ganz zu Schluss im else Teil.

#include <avr/io.h>
#include <stdint.h>

#ifndef F_CPU
#define F_CPU 800000UL
#endif
#include <util/delay.h>

#define DDR     DDRD
#define PORT     PORTD
#define PIN     PIND
#define TASTER1   PD2
#define TASTER2   PD3
#define LED1     PD5
#define LED2     PD6
#define TRIGGER    100
#define TIME    2500
#define STEP    1
#define MAX    (TIME/STEP)

#define debounce(port, pin)          \
({                \
  static uint8_t flag = 0;        \
  uint8_t i = 0;                  \
                              \
    if(flag){            \
     for(;;){          \
       if(!(port & 1<<pin)){      \
          i = 0;        \
          break;        \
            }               \
            _delay_us(TRIGGER);       \
         if(--i == 0){        \
          flag = 0;      \
          i = 0;        \
          break;        \
          }          \
        }                  \
    }              \
  else{              \
        for(;;){          \
            if((port & 1<<pin)){      \
        i = 0;        \
          break;        \
            }          \
            _delay_us(TRIGGER);      \
            if(--i == 0){        \
          flag = 1;      \
          i = 1;        \
          break;        \
            }          \
        }            \
    }              \
    i;              \
})

int main(){
  
  DDR |= (1<<LED1) | (1<<LED2);
  DDRA |= 0xff;
  PORTA &= 0x00;
  uint16_t i = 1;
  
  for(;;){
    
    if(debounce(PIN, TASTER1)){
      if(i < MAX){
        i++;
      }
      else{
        i = MAX;
      }
    }

    if(debounce(PIN, TASTER2)){
      if(i > 0){
        i--;
      }
      else{
        i = 0;
      }
    }  

    PORTA = i;  

    if(i == MAX){
      PORT |= (1<<LED1);
    }
    else if(i == 0){
      PORT &= ~(1<<LED1);
    }
    else{
      PORT |= (1<<LED1);
      _delay_us(1); // Arg. sollte sein: i
      PORT &= ~(1<<LED1);
      _delay_us(2500); // Arg. sollte sein: 2500-i
    }
  }

  return 0;
}

[Rolf Magnus (Gast)]

Benjamin Schwilling schrieb:
> Wobei sich mir dann die Frage stellt obs einen Unterschied zwischen
> einem#define WERT
> und einemuint16_t WERT
> gibt
>
> Vielleicht erkennt ja jemand meinen Fehler.

Doku nicht gelesen:

"Note:
In order for these functions to work as intended, compiler optimizations 
must be enabled, and the delay time must be an expression that is a 
known constant at compile-time. If these requirements are not met, the 
resulting delay will be much longer (and basically unpredictable), and 
applications that otherwise do not use floating-point calculations will 
experience severe code bloat by the floating-point library routines 
linked into the application."
( http://www.nongnu.org/avr-libc/user-manual/group__util__delay.html )

[Jannis C. (kabelwurm)]

Hallo,
versuch mal einem Zustand einen Wert zuzuweisen. Hoppla geht nicht.
->mit define kann man einen Zustand definieren und diesen logisch 
verwenden
->mit uint definiert man einen Vorzeichenlosen Integer.
Es ist sinvoll die bein Typen unterschiedlich zu Schreiben, da es sonst 
Probleme geben wird.
Bsp Integer klein, Zustände groß.
Gruß Jannis

[Ben S. (patersigmund)]

Ok ich seh schon, da muss ich mir dann doch was anderes einfallen 
lassen. Und einm Internet mich ein wenig über Timer schlau machen.

Danke für die Antworten!

[Uwe (de0508)]

Hallo,

habe gerade noch diese Frage entdeckt :

 F_CPU 800000UL

 == 800khz ?

ist das Absicht ?

[Ben S. (patersigmund)]

Ganz im Ernst. Ich hab keine Ahnung. Ich weiss zwar, dass die util/delay 
den F_CPU Wert brauch, aber in wie weit sich eine Veränderung dabei 
auswirkt weiss ich noch nicht so wirklich. ABER hab ja erst mit der µC 
Programmierung angefangen, von daher kommt das Wissen mit der Zeit.... 
hoffentlich ^^

BTW: Mir ist gestern noch ein Lösungsweg eingefallen. Ich hab einfach 
das Argument des _delay_us() auf 1 gesetzt und dieses dann in eine for() 
Schleife versteckt. Geht soweit eigentlich ganz schön.

[Rolf Magnus (Gast)]

Benjamin Schwilling schrieb:
> Ganz im Ernst. Ich hab keine Ahnung. Ich weiss zwar, dass die util/delay
> den F_CPU Wert brauch, aber in wie weit sich eine Veränderung dabei
> auswirkt weiss ich noch nicht so wirklich.

delay_us macht ja an sich nichts weiter als eine Warteschleife, die n 
mal wartet. Daraus ergibt sich eine Wartezeit von n * x Taktzyklen, 
wobei x die Anzahl an Zyklen pro Schleifendurchlauf ist. Wenn du aber 
eine Zeit in Mikro- oder  Millisekunden warten willst, mußt du daraus 
erstmal die Anzahl an nötigen Schleifendurchläufen berechnen, und dazu 
wird natürlich die Taktfrequenz des Prozessors benötigt.
Wenn du da nun einen um Faktor 10 zu niedrigen Wert angibst, wird die 
Wartezeit auch nur ein Zehntel der angegebenen Dauer sein.

> BTW: Mir ist gestern noch ein Lösungsweg eingefallen. Ich hab einfach
> das Argument des _delay_us() auf 1 gesetzt und dieses dann in eine for()
> Schleife versteckt. Geht soweit eigentlich ganz schön.

Das ist auch das übliche Vorgehen, wenn man eine variable Anzahl von 
Mikro- oder Millisekunden warten will. So wie ich es verstehe, brauchst 
du aber nur zwei Wartezeiten, deren Verhältnis du angeben kannst, und 
die Dauer in Mikrosekunden ist eigentlich nicht so wichtig. Dann kannst 
du auch die Basis-Funktionen verwenden (Siehe avr-libc-Doku 
"util/delay_base.h"). Denen kannst du auch Variablen übergeben, dafür 
gibst du die Wartezeit eben nicht in Mikrosekunden, sondern je nach 
Funktion in Vielfachen von 3 oder 4 Taktzyklen an.

[Ben S. (patersigmund)]

Danke für den Hinweis mit der delay_basic.h. Denn das _delay_loop 
arbeitet definitiv schöner. Vorallem kommt es ganz ohne Restflackern 
aus.