POSIX interface

#include <pthread.h>
#include <time.h>

#define PERIOD_NS 250000L   /* 250 µs */

static void *sampling(void *arg)
{
    struct timespec next;

    clock_gettime(CLOCK_MONOTONIC, &next);
    for (;;)
    {
        next.tv_nsec += PERIOD_NS;
        if (next.tv_nsec >= 1000000000L)
        {
            next.tv_sec += 1;
            next.tv_nsec -= 1000000000L;
        }
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);
        read_sensor(arg);
    }
}

#include <pthread.h>
#include <semaphore.h>

static pthread_mutex_t lock;
static sem_t sample_ready;

static void *control(void *arg)
{
    for (;;)
    {
        sem_wait(&sample_ready);
        pthread_mutex_lock(&lock);
        update_output();
        pthread_mutex_unlock(&lock);
    }
}

void start_control(void)
{
    pthread_attr_t attr;
    pthread_t thread;
    struct sched_param param = { .sched_priority = 12 };

    sem_init(&sample_ready, 0, 0);
    pthread_mutex_init(&lock, NULL);
    pthread_attr_init(&attr);
    pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
    pthread_attr_setschedpolicy(&attr, SCHED_FIFO);
    pthread_attr_setschedparam(&attr, &param);
    pthread_create(&thread, &attr, control, NULL);
}

#include <mqueue.h>
#include <fcntl.h>

static mqd_t samples;

static void *telemetry(void *arg)
{
    struct sample s;

    for (;;)
    {
        mq_receive(samples, (char *)&s, sizeof s, NULL);
        transmit(&s);
    }
}

void open_samples(void)
{
    struct mq_attr attr = {
        .mq_maxmsg = 8,
        .mq_msgsize = sizeof(struct sample),
    };

    samples = mq_open("/samples", O_CREAT | O_RDWR, 0600, &attr);
}

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

static void on_timeout(union sigval arg)
{
    link_lost();
}

static void *receiver(void *arg)
{
    struct sigevent ev = {
        .sigev_notify = SIGEV_THREAD,
        .sigev_notify_function = on_timeout,
    };
    struct itimerspec one_shot = {
        .it_value = { .tv_nsec = 100000000L },   /* 100 ms */
    };
    timer_t timeout;

    timer_create(CLOCK_REALTIME, &ev, &timeout);
    for (;;)
    {
        timer_settime(timeout, 0, &one_shot, NULL);
        receive_frame();
    }
}