event.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2017 Inria
 * SPDX-FileCopyrightText: 2017 Kaspar Schleiser <kaspar@schleiser.de>
 * SPDX-FileCopyrightText: 2018-2019 Freie Universität Berlin
 * SPDX-License-Identifier: LGPL-2.1-only
 */
 
#pragma once
 
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
 
#include "assert.h"
#include "clist.h"
#include "irq.h"
#include "thread.h"
#include "thread_flags.h"
#include "ptrtag.h"
#include "ztimer.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef THREAD_FLAG_EVENT
#define THREAD_FLAG_EVENT   (0x1)
#endif
 
#define EVENT_QUEUE_INIT    { .waiter = thread_get_active() }
 
#define EVENT_QUEUE_INIT_DETACHED   { .waiter = NULL }
 
typedef struct event event_t;
 
typedef void (*event_handler_t)(event_t *);
 
struct event {
    clist_node_t list_node;     
    event_handler_t handler;    
};
 
typedef struct PTRTAG {
    clist_node_t event_list;    
    thread_t *waiter;           
} event_queue_t;
 
static inline void event_queues_init(event_queue_t *queues,
                                          size_t n_queues)
{
    assert(queues && n_queues);
    thread_t *me = thread_get_active();
    for (size_t i = 0; i < n_queues; i++) {
        memset(&queues[i], '\0', sizeof(queues[0]));
        queues[i].waiter = me;
    }
}
 
static inline void event_queue_init(event_queue_t *queue)
{
    event_queues_init(queue, 1);
}
 
static inline void event_queues_init_detached(event_queue_t *queues,
                                             size_t n_queues)
{
    assert(queues);
    for (size_t i = 0; i < n_queues; i++) {
        memset(&queues[i], '\0', sizeof(queues[0]));
    }
}
 
static inline void event_queue_init_detached(event_queue_t *queue)
{
    event_queues_init_detached(queue, 1);
}
 
static inline void event_queues_claim(event_queue_t *queues, size_t n_queues)
{
    assert(queues);
    thread_t *me = thread_get_active();
    for (size_t i = 0; i < n_queues; i++) {
        assert(queues[i].waiter == NULL);
        queues[i].waiter = me;
    }
}
 
static inline void event_queue_claim(event_queue_t *queue)
{
    event_queues_claim(queue, 1);
}
 
void event_post(event_queue_t *queue, event_t *event);
 
void event_cancel(event_queue_t *queue, event_t *event);
 
bool event_is_queued(const event_queue_t *queue, const event_t *event);
 
event_t *event_get(event_queue_t *queue);
 
event_t *event_wait_multi(event_queue_t *queues, size_t n_queues);
 
static inline event_t *event_wait(event_queue_t *queue)
{
    return event_wait_multi(queue, 1);
}
 
#if IS_USED(MODULE_XTIMER) || defined(DOXYGEN)
event_t *event_wait_timeout(event_queue_t *queue, uint32_t timeout);
 
event_t *event_wait_timeout64(event_queue_t *queue, uint64_t timeout);
#endif
 
#if IS_USED(MODULE_ZTIMER) || defined(DOXYGEN)
event_t *event_wait_timeout_ztimer(event_queue_t *queue,
                                   ztimer_clock_t *clock, uint32_t timeout);
#endif
 
static inline void event_loop_multi(event_queue_t *queues, size_t n_queues)
{
    while (1) {
        event_t *event = event_wait_multi(queues, n_queues);
        if (IS_USED(MODULE_EVENT_LOOP_DEBUG)) {
            uint32_t now;
            ztimer_acquire(ZTIMER_USEC);
 
            void _event_callback_handler(event_t *event);
            if (!IS_USED(MODULE_EVENT_CALLBACK) ||
                event->handler != _event_callback_handler) {
                printf("event: executing %p->%p\n",
                       (void *)event, (void *)(uintptr_t)event->handler);
            }
            now = ztimer_now(ZTIMER_USEC);
 
            event->handler(event);
 
            printf("event: %p took %" PRIu32 " µs\n",
                   (void *)event, ztimer_now(ZTIMER_USEC) - now);
            ztimer_release(ZTIMER_USEC);
        }
        else {
            event->handler(event);
        }
    }
}
 
static inline void event_loop(event_queue_t *queue)
{
    event_loop_multi(queue, 1);
}
 
void event_sync(event_queue_t *queue);
 
#ifdef __cplusplus
}
#endif