unter C die Funktion Sleep() nutzen

[Kücken (Gast)]

Hi Leute,
was für Header muss ich denn includen, damit ich die Funktion Sleep 
aufrufen kann.
Danke schön

[Gast (Gast)]

unter Unix:
#include <unistd.h>

unter Windows:
#include <sleep.h>

[Johannes M. (johnny-m)]

Wenn Du nicht verrätst, welche Plattform und welchen Compiler Du 
verwendest, musst Du wohl selber in der Dokumentation des Compilers 
nachsehen...

[Kücken (Gast)]

<
Wenn Du nicht verrätst, welche Plattform und welchen Compiler Du
verwendest, musst Du wohl selber in der Dokumentation des Compilers
nachsehen...
>
Also: bei windows mit µVision programmiere ich einen XC167
Eigenltich möchte ich einfach eine LED ein und aus machen und damit man 
sie blinken sieht, brauch ich eine Pause dazwischen. Also habe ich mich 
an die gute alte Sleep erinnert, allerdings klappt das mit includen 
nicht, auch nicht #include <sleep.h>

[Chris (Gast)]

Sleep.h ist auch für Win32 anwendungen..
Schonmal an timer und interrupts gedacht?

[Kücken (Gast)]

<Sleep.h ist auch für Win32 anwendungen..
Schonmal an timer und interrupts gedacht?>

wollte es eigentlich vermeiden, da das Blinken nur zum Test ist

[Johannes M. (johnny-m)]

Ich erinnere mich nicht mehr wirklich an Keil µVision für C167, aber es 
ist sehr wahrscheinlich, dass auch der Keil-Compiler eine Bibliothek 
besitzt, die delay.h oder so ähnlich heißt. Das steht aber sicher alles 
in der Dokumentation von µVision bzw. in der Hilfe.

[Snt O. (snt-opfer)]

Wenn nicht, kann man 'Quick & Dirty' mit for super Warteschleifen bauen, 
für einen Test sollte das reichen und es versteht jeder Compiler, auf 
jeder Plattform.

 for (i=0; i<=10000; i++);

Je nach Geschwindigkeit braucht man int oder long int, wie weit man halt 
zählen will (= warten will). Zur Not innerhalb der Schleife noch was 
"sinnloses" tun oder zwei for - Schleifen kaskadieren.

Aber nur für solche Tests, der Controller macht innerhalb der Wartezeit 
rein gar nix ausser zählen, in "echten" Programmen sieht das etwas 
unprofessionell aus ;)

[Johannes M. (johnny-m)]

Snt Opfer wrote:
> Wenn nicht, kann man 'Quick & Dirty' mit for super Warteschleifen bauen,
> für einen Test sollte das reichen und es versteht jeder Compiler, auf
> jeder Plattform.
>
>  for (i=0; i<=10000; i++);
...Und der Optimizer versteht meist auch, dass die Schleife leer ist und 
optimiert sie weg...

[Snt O. (snt-opfer)]

Ja, aber wer hat dem beim Port togglen an ?
Er will doch nur testen...

[I_ H. (i_h)]

Deklarier i als volatile, dann darf der compiler nix wegoptimieren. Der 
GCC lässt leere Schleifen stehen, der icc macht sie öfters mal weg. 
Compiler speziell für uC dürften bei weitem nicht so gut optimieren.

[Snt O. (snt-opfer)]

Oder so.
Alternativ kann man ja in der Schleife irgendwas machen, anderes 
Portregister setzen zum Beispiel oder "sinnlos" den Inhalt einer 
Variable auf eine andere zuweisen, das dürfte dann stehen bleiben.

[I_ H. (i_h)]

Der icc macht es weg ;)

[Peter D. (peda)]

Kücken wrote:
> <Sleep.h ist auch für Win32 anwendungen..
> Schonmal an timer und interrupts gedacht?>
>
> wollte es eigentlich vermeiden, da das Blinken nur zum Test ist

Willst Du nur Testen oder auch Programmieren?

Kein vernünftiges Programm kommt ohne Timer aus, also ist es keine 
Vergeudung, sich mit dem Timer zu beschäftigen.
Man muß dazu nichtmal einen Interrupt aufsetzen, man kann ja das 
Überlaufbit auch pollen.

Und das schönste ist, man muß nicht rumprobieren, der Timer zählt exakt.
Man kann also ein Programm schreiben mit berechneten 1s Timerintervall 
und dann sinds auch wirklich 1s.

Zählschleifen muß man dagen erst ausprobieren.


Peter

[Gast (Gast)]

hi,

mach ein _nop_(); in die Schleife und include die intrins.h (KEIL)

Dann optimiert der Compiler die Schleife net raus.

Du kanst nat. auch optimierung im Projekt Eigenschaft ausschalten. Aber 
über kurz oder lang MUSST du verstehen was ein Timer macht und wie er 
funktionert ...

Also fang gar net erst das Schludern an ..

cu

[Jörg W. (dl8dtl) (Moderator)]

I_ H. wrote:
> Der
> GCC lässt leere Schleifen stehen, ...

Schon ein ganzes Weilchen nicht mehr.  Die sind schneller weg, als
man gucken kann.

[I_ H. (i_h)]

Stimmt, also der 4er macht's weg, der 3er lässt es stehen.

Aber wie gesagt, mit volatile muss es der compiler sowieso stehen 
lassen.

[EK (Gast)]

// AVR-GCC C#

#include <inttypes.h> //
#include <avr/io.h> //
#include <avr/interrupt.h>// #warning "This header file is obsolete.
//#include <avr/signal.h> //
//#include <avr/intrins.h>

//#include <mscorlib.dll>
//#include <unistd.h>

void delay_ms(unsigned short ms){
unsigned short outer1, outer2;//Init
outer1 = 1000; //Init
    while (outer1--) { //Cicle N1
        outer2 = 100; //init
        while (outer2--) { //Cicle N2
            while ( ms ) ms--; //Cicle N1+N2
        }
        outer2--; //-1
        outer1--; //-1
    }
}
//Hauptteil ===================================
int main(void){
    DDRC |= _BV(PC0); //Line1 PortC=1 "out"
    while(1) { // ewig
        PORTC &= ~_BV(PC0); //Bit PC0=0 (0V)---an
     //delay_ms(500); //Wartezeit 0.5 sek.
        PORTC |= _BV(PC0); //Bit PC0=1 (5V)---aus
     // delay_ms(500); //Wartezeit 0.5 sek.
    }
}
//=======================================================

[unbekannt (Gast)]

Mircrostft vc++ 2008:

//--------------------Countdown 3-1 unendlich 
oft----------------------------
#include <iostream>
#include <windows.h> //wegen Sleep
using namespace std; //wegeb cout
void main()
{
cout<< "Start\n";
anfang:;
cout<< "3\n";
Sleep(1000);
cout<< "2\n";
Sleep(1000);
cout<< "1\n\n\n";
Sleep(1000);
goto anfang;
}
//---------------------------ENDE--------------------------------------- 
-
Das Prog zählt immer von 3 bis 1 toll oder. So geht die sleep function 
unter vc++
Fals ich fehler gemacht hab sorry bin neu in c/c++.

[Sven P. (Gast)]

unbekannt wrote:
> Fals ich fehler gemacht hab sorry bin neu in c/c++.
Ja, hast du... :-)

Erster Fehler:
> Mircrostft vc++ 2008:

Zweiter Fehler: Dieses tolle Forum besitzt eine Funktion, um 
C-Quelltexte farblich hervorzuheben:

[c]C-Quelltext[/c]

.

Dritter Fehler:
goto ist fast immer die schlechteste Alternative. Besser und eindeutig 
übersichtlicher wäre hier eine Schleife.

 //--------------------Countdown 3-1 unendlich
 oft----------------------------
 #include <iostream>
 #include <windows.h> //wegen Sleep
 using namespace std; //wegeb cout
 void main()
 {
 cout<< "Start\n";
 for (;;) {
   cout<< "3\n";
   Sleep(1000);
   cout<< "2\n";
   Sleep(1000);
   cout<< "1\n\n\n";
   Sleep(1000);
 }
 }
 //---------------------------ENDE----------------------------------------

[chorus (Gast)]

Eigentlich sollte man allen C-Compiler Entwicklern für Mikrocontroller 
vorschreiben, dass sie eine "Sleep()" Funktion anbieten.

Allein die Diskussionlänge dieses Threads zeigt, dass so eine Funktion 
notwendig ist.

Ich sage nur: warum einfach, wenn man es sehr umständlich machen kann?

[unbekannt (Gast)]

Haku zu deinem Quelltext:

1.
error C2143: Syntaxfehler: Es fehlt ';' vor '--'
error C4430: Fehlender Typspezifizierer - int wird angenommen. Hinweis: 
"default-int" wird von C++ nicht unterstützt.
zu deinen Kommentar:
1. Der Tippfehler ist doch nicht so schlimm oder?
2.Die Quelltext Function hab ich nicht gemacht weils die Anderen auch 
nicht geamcht haben
3.Das mit Schleifen kann ich noch nicht. Ich befasse mich mit c++ seit 2 
Wochen Anhand des Buches: C++ Das Grundlagenbuch von Gerhard Willms und 
und goto hab ich halt in nem anderem Forum gelesen.

[Rufus Τ. F. (rufus)]

> Mircrostft vc++ 2008:

Hier wird die Win32-API-Funktion Sleep() verwendet. Die wird nicht vom 
Compiler zur Verfügung gestellt, sondern vom Betriebssystem. Und im 
Gegensatz zu ähnlich benannten Varianten auf irgendwelchen µCs 
"verballert" die Funktion auch nicht Rechenzeit in Zählschleifen, 
sondern nutzt den Scheduler des Betriebssystemes ...
Und daher ist Sleep auf einem Win32-System überhaupt nicht mit einem 
Sleep auf einem µC zu vergleichen.

[Martin (Gast)]

Es geht recht einfach.

Allerdings heißt die Funktion in C, welche in windows.h deklariert ist.
"_sleep();"

#include <stdio.h>
#include <windows.h>

int main(void)
{
    while(42)
    {
        _sleep(1000); //millisekunden
    }
    return 0;
}

Getestet mit DevC++, Code::Blocks auf WinXP

[Jörg W. (dl8dtl) (Moderator)]

Rufus t. Firefly wrote:

>> Mircrostft vc++ 2008:

> Hier wird die Win32-API-Funktion Sleep() verwendet.

...die natürlich prima inkompatibel mit der Posix-Funktion sleep()
ist, die ihr Argument in Sekunden nimmt. :-)

[Jean P. (fubu1000)]

Super dann installiert mal Windows XP auf eurem µC^^
Gruß.

[anonymouse (Gast)]

Jörg Wunsch schrieb:
>> Hier wird die Win32-API-Funktion Sleep() verwendet.
>
> ...die natürlich prima inkompatibel mit der Posix-Funktion sleep()
> ist, die ihr Argument in Sekunden nimmt. :-)
>
>
>
>

Danke, Danke, Danke, jetzt verstehe ich, warum die 5000ms so quälend 
langsam vergehen, seit ich auf Linux gewechselt bin...

Das sollte ganz oben stehen (vor Gastbeitrag), da dieser Thread nun 
Referenz Nr. 1 in der google suche nach sleep in c ist

[Abdul K. (ehydra)]

sleep() ist eine Funktion eines (Echtzeit)-BS und hat erstmal nix mit 
einem C-Compiler zu tun.
Sobald man sleep implementiert, hat man eine Abhängigkeit von Timern und 
CPU-Clock. Da aber der typische µC-Programmierer die Gewalt über alle 
Timer haben will, ist da ein Konflikt!
Keil hat dies so gelöst, das sie ein extra Mini-BS passend für ihre 
Umgebung anbieten.