Hoe timer in C gebruiken?

Wat is de methode om een ​​timer in c te gebruiken? Ik moet wachten tot 500 ms voor een baan. Vermeld alstublieft een goede manier om deze baan te doen. Ik gebruikte sleep(3);Maar deze methode heeft geen werk in die tijdsduur te doen. Ik heb iets dat tot die tijd zal proberen om invoer te krijgen.


Antwoord 1, Autoriteit 100%

U kunt een time_tstructuren gebruiken en clock()functie van time.h .

Bewaar de starttijd in een time_tstruct door het gebruik van clock()en controleer de verstreken tijd door het verschil tussen opgeslagen tijd en de huidige tijd te vergelijken.


Antwoord 2, Autoriteit 217%

Hier is een oplossing die ik gebruikte (het heeft #include <time.h>):

int msec = 0, trigger = 10; /* 10ms */
clock_t before = clock();
do {
  /*
   * Do something to busy the CPU just here while you drink a coffee
   * Be sure this code will not take more than `trigger` ms
   */
  clock_t difference = clock() - before;
  msec = difference * 1000 / CLOCKS_PER_SEC;
  iterations++;
} while ( msec < trigger );
printf("Time taken %d seconds %d milliseconds (%d iterations)\n",
  msec/1000, msec%1000, iterations);

Antwoord 3, Autoriteit 67%

Ja, je hebt een lus nodig. Als u al een hoofdlus (de meeste GUI-event-driven dingen doet) kunt u waarschijnlijk uw timer steken in die. Gebruik:

#include <time.h> 
time_t my_t, fire_t;

Dan (voor tijden gedurende 1 seconde), initialiseer uw timer door de huidige tijd te lezen:

my_t = time(NULL);

Voeg het aantal seconden toe dat uw timer moet wachten en opslaan in Fire_t. Een time_t is in wezen een Uint32_t, misschien moet je het casten.

Binnen in je loop doe een andere

my_t = time(NULL);

Als (my_t & gt; fire_t), overweeg dan de timer ontslagen en doe de dingen die je daar wilt. Dat zal het waarschijnlijk opnemen het opnieuw instellen door een ander vuur te doen = tijd (null) + seconden_to_wait voor de volgende keer.

Een TIMET_T is een enigszins geëntische Unix-methode voor het opslaan van tijd als het aantal seconden sinds middernacht 1/1/1970, maar het heeft veel voordelen. Gedurende tijden van minder dan 1 seconde moet je GetTimeofday () (Microseconden (Microseconden) of Clock_GetTime () (Nanoseconden) gebruiken en omgaan met een struct-timeval of struct-tijdrespec, die een time_t en de microseconden of nanoseconden is, sinds die 1 seconde. Het maken van een timer werkt op dezelfde manier behalve wanneer u uw tijd toevoegt om te wachten, moet u onthouden om handmatig de draagkracht (in de time_t) te doen als de resulterende microseconden of nanoseconds-waarde langer dan 1 seconde gaat. Ja, het is rommelig. Zie man 2 keer, man gettimeofday, man Clock_getime.

Slaap (), USLEEP (), Nanosleep () heeft een verborgen voordeel. Je ziet het als het pauzeren van je programma, maar wat ze echt doen, is de CPU voor die hoeveelheid tijd vrijgeven. Herhaaldelijk pollen door de tijd te lezen en te vergelijken met de voltooide tijd (zijn we er al?) Zullen veel CPU-cycli verbranden die andere programma’s op dezelfde machine (en meer elektriciteit / batterij kunnen vertragen. Het is beter om () meestal te slapen, dan begint met het controleren van de tijd.

Als u probeert te slapen en tegelijkertijd te werken, hebt u discussies nodig.


Antwoord 4, Autoriteit 17%

Mogen deze voorbeelden helpen bij u

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
/*
    Implementation simple timeout
    Input: count milliseconds as number
    Usage:
        setTimeout(1000) - timeout on 1 second
        setTimeout(10100) - timeout on 10 seconds and 100 milliseconds
 */
void setTimeout(int milliseconds)
{
    // If milliseconds is less or equal to 0
    // will be simple return from function without throw error
    if (milliseconds <= 0) {
        fprintf(stderr, "Count milliseconds for timeout is less or equal to 0\n");
        return;
    }
    // a current time of milliseconds
    int milliseconds_since = clock() * 1000 / CLOCKS_PER_SEC;
    // needed count milliseconds of return from this timeout
    int end = milliseconds_since + milliseconds;
    // wait while until needed time comes
    do {
        milliseconds_since = clock() * 1000 / CLOCKS_PER_SEC;
    } while (milliseconds_since <= end);
}
int main()
{
    // input from user for time of delay in seconds
    int delay;
    printf("Enter delay: ");
    scanf("%d", &delay);
    // counter downtime for run a rocket while the delay with more 0
    do {
        // erase the previous line and display remain of the delay
        printf("\033[ATime left for run rocket: %d\n", delay);
        // a timeout for display
        setTimeout(1000);
        // decrease the delay to 1
        delay--;
    } while (delay >= 0);
    // a string for display rocket
    char rocket[3] = "-->";
    // a string for display all trace of the rocket and the rocket itself
    char *rocket_trace = (char *) malloc(100 * sizeof(char));
    // display trace of the rocket from a start to the end
    int i;
    char passed_way[100] = "";
    for (i = 0; i <= 50; i++) {
        setTimeout(25);
        sprintf(rocket_trace, "%s%s", passed_way, rocket);
        passed_way[i] = ' ';
        printf("\033[A");
        printf("| %s\n", rocket_trace);
    }
    // erase a line and write a new line
    printf("\033[A");
    printf("\033[2K");
    puts("Good luck!");
    return 0;
}

Bestand compileren, uitvoeren en verwijderen na (mijn voorkeur)

$ gcc timeout.c -o timeout && ./timeout && rm timeout

Probeer het zelf uit om het resultaat te zien.

Opmerkingen:

Testomgeving

$ uname -a
Linux wlysenko-Aspire 3.13.0-37-generic #64-Ubuntu SMP Mon Sep 22 21:28:38 UTC 2014 x86_64 x86_64 x86_64 GNU/Linux
$ gcc --version
gcc (Ubuntu 4.8.5-2ubuntu1~14.04.1) 4.8.5
Copyright (C) 2015 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Other episodes