Create a timer


#include <signal.h>
#include <time.h>

int timer_create( clockid_t clock_id,
                  struct sigevent * evp,
                  timer_t * timerid );


The clock source that you want to use; one of:
NULL, or a pointer to a sigevent structure containing the event that you want to deliver when the timer fires.
A pointer to a timer_t object where the function stores the ID of the new timer.



Use the -l c option to qcc to link against this library. This library is usually included automatically.


The timer_create() function creates a per-process timer using the specified clock source, clock_id, as the timing base.

Note: This function fails if the clock ID corresponds to the CPU-time clock of a process or thread different from the process or thread invoking the function.

You can use the time ID that the function stores in timerid in subsequent calls to timer_gettime(), timer_settime(), and timer_delete().

The timer is created in the disabled state, and isn't enabled until you call timer_settime().

We recommend the following event types:

If the evp argument is NULL, a SIGALRM signal is sent to your process when the timer expires. To specify a handler for this signal, call sigaction().


Success. The timerid argument is set to the timer's ID.
An error occurred (errno is set).


All timers are in use. You'll have to wait for a process to release one.
The clock_id isn't one of the valid CLOCK_* constants.


 * Demonstrate how to set up a timer that, on expiry, 
 * sends us a pulse.  This example sets the first 
 * expiry to 1.5 seconds and the repetition interval 
 * to 1.5 seconds.

#include <stdio.h>
#include <time.h>
#include <sys/netmgr.h>
#include <sys/neutrino.h>


typedef union {
        struct _pulse   pulse;
        /* your other message structures would go 
           here too */
} my_message_t;

   struct sigevent         event;
   struct itimerspec       itime;
   timer_t                 timer_id;
   int                     chid;
   int                     rcvid;
   my_message_t            msg;

   chid = ChannelCreate(0);

   event.sigev_notify = SIGEV_PULSE;
   event.sigev_coid = ConnectAttach(ND_LOCAL_NODE, 0, 
                                    _NTO_SIDE_CHANNEL, 0);
   event.sigev_priority = getprio(0);
   event.sigev_code = MY_PULSE_CODE;
   timer_create(CLOCK_REALTIME, &event, &timer_id);

   itime.it_value.tv_sec = 1;
   /* 500 million nsecs = .5 secs */
   itime.it_value.tv_nsec = 500000000; 
   itime.it_interval.tv_sec = 1;
   /* 500 million nsecs = .5 secs */
   itime.it_interval.tv_nsec = 500000000; 
   timer_settime(timer_id, 0, &itime, NULL);

    * As of the timer_settime(), we will receive our pulse 
    * in 1.5 seconds (the itime.it_value) and every 1.5 
    * seconds thereafter (the itime.it_interval)

   for (;;) {
       rcvid = MsgReceive(chid, &msg, sizeof(msg), NULL);
       if (rcvid == 0) { /* we got a pulse */
            if (msg.pulse.code == MY_PULSE_CODE) {
                printf("we got a pulse from our timer\n");
            } /* else other pulses ... */
       } /* else other messages ... */


POSIX 1003.1 TMR

Cancellation point No
Interrupt handler No
Signal handler Yes
Thread Yes


The QNX Neutrino version of timer_create() is different from the QNX 4 version, which was based on a draft standard.

See also:

clock_getres(), clock_gettime(), clock_settime(), nanosleep(), _pulse, sigaction(), sigevent, sleep(), TimerCreate(), timer_delete(), timer_getexpstatus(), timer_getoverrun(), timer_gettime(), timer_settime()

Clocks, Timers, and Getting a Kick Every So Often chapter of Getting Started with QNX Neutrino

Tick, Tock: Understanding the Neutrino Microkernel's Concept of Time chapter of the QNX Neutrino Programmer's Guide