linux - 在linux C中的特定时间发送信号

Question

我正在为树莓派编写一个 C 程序，我需要在特定时间(在我的例子中是午夜)做一些事情。我不想每次都像“轮询”一样检查时间，但我想使用信号生成一个中断软件并让处理程序完成他的工作。在此示例中，我能够设置第一个中断，但在 TIMER_FREQUENCY 之后它不会发送下一个中断，因此我在处理程序中创建了一个新计时器，以连续拥有一个新计时器，该计时器将在 TIMER_FREQUENCY 秒后到期。

例子

#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <math.h>
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>
#include <sys/wait.h>

/* 3h = 3 * 60 * 60*/
#define TIMER_FREQUENCY 10800

static int count;

void timer_expired(int sig)
{
    /* Set new timer for next interrupt - 3 hours*/
    struct sigaction act;
    clockid_t clock_id;
    timer_t timer_id;
    struct sigevent clock_sig_event;
    struct itimerspec timer_value;
    int ret;

    /* timestamp */
    time_t now;
    struct tm* tm_info;

    char *temp=(char*)malloc(20*sizeof(char));

    /* Register new action for SIGUSR1 */
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_handler =  timer_expired;
    ret = sigaction(SIGUSR1, &act, NULL);
    assert(ret == 0);

    clock_id = CLOCK_MONOTONIC;
    memset(&clock_sig_event, 0, sizeof( struct sigevent));
    clock_sig_event.sigev_notify = SIGEV_SIGNAL;
    clock_sig_event.sigev_signo = SIGUSR1;
    clock_sig_event.sigev_notify_attributes = NULL;
    /* Creating process interval timer */
    ret = timer_create(clock_id, &clock_sig_event, &timer_id);
    assert(ret == 0);

    /* setitng timer interval values */
    timer_value.it_interval.tv_sec = TIMER_FREQUENCY;
    timer_value.it_interval.tv_nsec = 0;

    /* setting timer initial expiration values*/
    memset(&timer_value, 0, sizeof(struct itimerspec));
    timer_value.it_value.tv_sec = TIMER_FREQUENCY;
    timer_value.it_value.tv_nsec = 0;

    /* Prendo l'orario attuale */
    time(&now);
    tm_info=localtime(&now);
    strftime(temp,20,"%H:%M:%S",tm_info);

    count++;

    // use this handler
    printf("Ricevuto %d° segnale alle ore: %s \n",count,temp);

    printf("Attendo segnale fra 3 ore...\n");

    /* Create timer */
    ret = timer_settime(timer_id, 0, &timer_value, NULL);
    assert(ret == 0);

}

int main(void)
{
    struct sigaction act;
    clockid_t clock_id;
    timer_t timer_id;
    struct sigevent clock_sig_event;
    struct itimerspec timer_value;
    int ret;


    char *giorno=(char*)malloc(3*sizeof(char));
    char *ora=(char*)malloc(3*sizeof(char));
    char *minuti=(char*)malloc(3*sizeof(char));
    char *secondi=(char*)malloc(3*sizeof(char));

    time_t fine, now;
    struct tm* tm_info;

    char *temp=(char*)malloc(20*sizeof(char));

    double seconds=0.0;
    long int intervallo=0;
    float ore=0.0;

    count=0;

    /* Here i get seconds from now until 23:59:59 to set first timer */

    time(&now);
    time(&fine);
    tm_info=localtime(&now);

    strftime(giorno,3,"%d",tm_info);
    strftime(ora,3,"%H",tm_info);
    strftime(minuti,3,"%M",tm_info);
    strftime(secondi,3,"%S",tm_info);

    sprintf(temp,"%d:%d:%d",23,59,59);
    strptime(temp,"%H:%M:%S",tm_info);
    fine=mktime(tm_info);

    time(&now);

    // get seconds until fine
    seconds=difftime(fine,now);

    intervallo=(long int)seconds;
    ore=intervallo/3600;
    printf("Secondi restanti fino alle 23:59:59 : %lis = %f ore \n",intervallo, ore);

    count=0;
    /* Register new action for SIGUSR1 */
    memset(&act, 0, sizeof(struct sigaction));
    act.sa_handler =  timer_expired;
    ret = sigaction(SIGUSR1, &act, NULL);
    assert(ret == 0);

    clock_id = CLOCK_MONOTONIC;
    memset(&clock_sig_event, 0, sizeof( struct sigevent));
    clock_sig_event.sigev_notify = SIGEV_SIGNAL;
    clock_sig_event.sigev_signo = SIGUSR1;
    clock_sig_event.sigev_notify_attributes = NULL;

    /* Creating process interval timer */
    ret = timer_create(clock_id, &clock_sig_event, &timer_id);
    assert(ret == 0);

    /* setitng timer interval values */
    timer_value.it_interval.tv_sec = intervallo;
    timer_value.it_interval.tv_nsec = 0;

    /* setting timer initial expiration values*/
    memset(&timer_value, 0, sizeof(struct itimerspec));
    timer_value.it_value.tv_sec = intervallo;
    timer_value.it_value.tv_nsec = 0;

    /* Create timer */
    ret = timer_settime(timer_id, 0, &timer_value, NULL);
    assert(ret == 0);

    /* Now we have a timer with following features:
     * It will expire after 24 hours and excute fucntion timer_expired
     * upon expiration */

    /* I've used sleep into while because I just want to wait and handle the interrupt using less CPU as possible */
    while(1){
        sleep(500);  
    }

    /*
     * Do something here
     *
     * To test, sleep()  for 5 sec and set timer expiry as 1 sec i.e.
     * TIMER_FREQUENCY as 1.
     * In this case first timer will expire after 1 sec and sleep will
     * come out, also timer_expired() will be executed. Later time will expire after every 1 sec.
     *
     * We can also use SIGEV_THREAD instead of SIGEV_SIGNAL in clock_sig_event.sigev_notify
     * while creating timer_id using timer_create().In that case we need to check for other parameter
     * as well.
     */

    exit(EXIT_SUCCESS);
}

这是输出:

pi@raspberrypi:~/Desktop/TastoW/rtc $ ./rtc
Secondi restanti fino alle 23:59:59 : 22200s = 6.000000 ore 
Ricevuto 1° segnale alle ore: 23:59:59 
Attendo segnale fra 3 ore...
Ricevuto 2° segnale alle ore: 02:59:59 
Attendo segnale fra 3 ore...
Ricevuto 3° segnale alle ore: 05:59:59 
Attendo segnale fra 3 ore...
Ricevuto 4° segnale alle ore: 08:59:59 
Attendo segnale fra 3 ore...

Answer 1

使用 timer_create() 注册一个警报和 timer_settime() .

同时使用 sigaction() 注册 SIGALRM 处理程序这样当计时器到期时，信号处理程序将被执行。现在您可以使用处理程序来完成这些工作。

请注意始终使用async-signal-safe functions在信号处理程序中发挥作用。

示例

#include <stdio.h>
#include <signal.h>
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>
#include <sys/wait.h>

/* 24h = 24 * 60 * 60*/
#define TIMER_FREQUENCY 86400

void timer_expired(int sig)
{
        // use this handler
}

int main(void)
{
        struct sigaction act;
        clockid_t clock_id;
        timer_t timer_id;
        struct sigevent clock_sig_event;
        struct itimerspec timer_value;
        int ret;

        /* Register new action for SIGUSR1 */
        memset(&act, 0, sizeof(struct sigaction));
        act.sa_handler =  timer_expired;
        ret = sigaction(SIGUSR1, &act, NULL);
        assert(ret == 0);

        clock_id = CLOCK_MONOTONIC;
        memset(&clock_sig_event, 0, sizeof( struct sigevent));
        clock_sig_event.sigev_notify = SIGEV_SIGNAL;
        clock_sig_event.sigev_signo = SIGUSR1;
        clock_sig_event.sigev_notify_attributes = NULL;
        /* Creating process interval timer */
        ret = timer_create(clock_id, &clock_sig_event, &timer_id);
        assert(ret == 0);

        /* setitng timer interval values */
        memset(&timer_value, 0, sizeof(struct itimerspec));
        timer_value.it_interval.tv_sec = TIMER_FREQUENCY;
        timer_value.it_interval.tv_nsec = 0;

        /* setting timer initial expiration values*/
        timer_value.it_value.tv_sec = TIMER_FREQUENCY;
        timer_value.it_value.tv_nsec = 0;

        /* Create timer */
        ret = timer_settime(timer_id, 0, &timer_value, NULL);
        assert(ret == 0);

        /* Now we have a timer with following features:
         * It will expire after 24 hours and excute fucntion timer_expired
         * upon expiration */

        /*
         * Do something here
         *
         * To test, sleep()  for 5 sec and set timer expiry as 1 sec i.e.
         * TIMER_FREQUENCY as 1.
         * In this case first timer will expire after 1 sec and sleep will
         * come out, also timer_expired() will be executed. Later time will expire after every 1 sec.
         *
         * We can also use SIGEV_THREAD instead of SIGEV_SIGNAL in clock_sig_event.sigev_notify
         * while creating timer_id using timer_create().In that case we need to check for other parameter
         * as well.
         */

        exit(EXIT_SUCCESS);
}