event.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017 Inria
 *               2017 Kaspar Schleiser <kaspar@schleiser.de>
 *               2018-2019 Freie Universität Berlin
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#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
 
#ifndef CONFIG_EVENT_LOOP_DEBUG_THRESHOLD_US
#  define CONFIG_EVENT_LOOP_DEBUG_THRESHOLD_US (0)
#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)) {
            ztimer_acquire(ZTIMER_USEC);
 
            void _event_callback_handler(event_t * event);
            if ((CONFIG_EVENT_LOOP_DEBUG_THRESHOLD_US == 0) &&
                (!IS_USED(MODULE_EVENT_CALLBACK) ||
                 event->handler != _event_callback_handler)) {
                printf("event: executing %p->%p\n",
                       (void *)event, (void *)(uintptr_t)event->handler);
            }
            uint32_t now = ztimer_now(ZTIMER_USEC);
            /* events might modify themself */
            void *handler_ptr = (void *)(uintptr_t)event->handler;
 
            event->handler(event);
 
            uint32_t dt = ztimer_now(ZTIMER_USEC) - now;
 
            if ((CONFIG_EVENT_LOOP_DEBUG_THRESHOLD_US == 0) ||
                dt > CONFIG_EVENT_LOOP_DEBUG_THRESHOLD_US) {
                printf("event: %p->%p ran: %" PRIu32 " usec\n",
                       (void *)event, handler_ptr, dt);
            }
            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