Delay_Wertübergabe

[Pierre G. (bqube)]

Guten narbend,

Versteh ich das richtig, wenn ich der Delay Funktion eine Variable 
übergeben möchte schreibe ich einfach selbst eine Funktion die den Wert 
so lange verringert bis ich meine Zeit gewartet hab ?

void sleep ( uint8_t ms )
{
    for(; ms > 0; ms--) _delay_ms(1);
}
 
int main( void )
{
    int x = 0;                  // Variable als Wartezeit erstellen
    DDRB = ( 1 << PB0 );        // PB0 an PORTB als Ausgang setzen
 
    while( 1 ) {                // Endlosschleife
        PORTB ^= ( 1 << PB0 );  // Toggle PB0 z.B. angeschlossene LED
        sleep(x); 
        x++;       
    }
    return 0;
}

Mfg Bqube

[Marcel P. (souko)]

Guten Abend,

genau, funktioniert !

[Justus S. (jussa)]

ist die Frage, wie genau du das delay brauchst...die For-Schleife gibt 
es ja nicht umsonst...

[Pierre G. (bqube)]

Meine Angst liegt bei der Genauigkeit der Zählung

Sagen wir mal ich habe 1000us die ich warten will und dazu verwende ich 
die oben genannte for schleife, weil der Wert in einer Variable steht. 
Dann warte ich am Ende ja bestimmt keine 1000us mehr sonder 1020 oder so 
in der Art.

Oder sehe ich das falsch


Mfg Bqube

[Marcel P. (souko)]

Nein, mit der oben genannten Schleife wartest du eher ms statt us ;-)

Ne, aber im Ernst. wenn es hier auf µs ankommt, dann denke ich, wird das 
Springen in die Schleife, das durchlaufen dieser und das zurück springen 
ja auch Zeit verbraten.

Bei 10-20 µs denke ich ist das nicht sehr viel, aber sobald es größer 
wird, kann es schon zu den von dir genannten Ausmaßen kommen.

Wobei es auch hier von der Geschwindigkeit deines Prozessors abhängt.

[Pierre G. (bqube)]

So hab ich mir das nun gedacht

Wert der Variable an die Funktion Übergeben

WARTEN(SUM);

Funktion ausführen // So lage warten bis us nicht mehr größer ist als 0

void WARTEN ( uint16_t us )
{
    for(; us > 0; us--) _delay_us(1);
}

Und dann würde es ganz normal weiterlaufen

Wenn ich euch und die Funktion richtig verstanden habe.

Mfg Bqube

[Marcel P. (souko)]

sollte so funktionieren.

Aber die Genauigkeit leidet hier, je größer deine Wartezeiten werden.
Nur ob man sich hier in nennenswerten Bereichen bewegt, dazu sollten mal 
die Leute mit richtig Erfahrung was sagen ;-)

[Pierre G. (bqube)]

Genau das würde mich mal Interessieren aber ich glaube nicht das es bei 
meinem Projekt so Tragisch sein wird denn ich erzeuge ein Summensignal 
mit 8 Kanälen wo jeder kanal eine Maximale länge von 2ms hat und darbei 
paar us dürften nicht schaden :)

Es ist ein Attiny26 der mit 8Mhz Betrieben wird

Mfg Bqube

[Marcel P. (souko)]

Naja, Prinzipiell kann man das ja sogar ausrechnen.

du kannst ja mal deinen compilierten Code Disassemblieren. Dann siehst 
du welche Assembler-Anweisungen für die schleife zuständig sind, und im 
Datenblatt steht, wie viele Takte der Proz braucht für jeden Befehl (die 
meisten brauchen einen einzigen Takt)

Dann kannst du mit deinem CPU-Frequenz und der Anzahl der Takte genau 
ausrechnen wie lange deine Schleife wirklich braucht.

Ich hab aber hier nochwas gefunden:

Beitrag "Delay: Exakt n Ticks erzeugen (avr-gcc)"

ich glaube sehr viel genauer gehts nicht mehr.

Und ich habe mir auch schon oft sagen lassen, das manche zeitkritische 
Dinge einfach nur in Assembler zu machen sind. (Ich selber kann kein 
Assembler - nur einen Befehl - NOP ;-)  )

[Peter D. (peda)]

Pierre Gnauck schrieb:
> ich erzeuge ein Summensignal
> mit 8 Kanälen wo jeder kanal eine Maximale länge von 2ms hat

Für Signalerzeugung ist der Timer mit Compare-Interrupt gedacht.
Delay hat da nichts verloren.

Wenn Du auf den ATtiny261 wechselst, hast Du auch 10- bzw. 16-Bit Timer.

[Karl H. (kbuchegg)]

Pierre Gnauck schrieb:

> meinem Projekt so Tragisch sein wird denn ich erzeuge ein Summensignal
> mit 8 Kanälen wo jeder kanal eine Maximale länge von 2ms hat und darbei
> paar us dürften nicht schaden :)

Das klingt nach einer Variante einer Servo-Ansteuerung.

Lies mal hier nach, wie man sowas richtig macht
Modellbauservo Ansteuerung

Völlig ohne Delay, der Timer macht die ganze Arbeit mit ein bischen 
Hilfe durch eine ISR.
Und das beste daran: der macht das völlig im Hintergrund, ohne dass dir 
der µC durch die dauernden Delay blockiert wird.
Allerdings: Peter hats schon gesagt - mit lediglich 8 Bit Timern wirst 
du da eher nicht glücklich werden. Schlechte µC Wahl.