rt 0.19.0

A real-time operating system capable of full preemption
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

#include <rt/notify.h>

#include <rt/trace.h>

void rt_notify_post(struct rt_notify *note)
{
    rt_sem_post(&note->sem);
}

void rt_notify_or(struct rt_notify *note, uint32_t value)
{
    const uint32_t old =
        rt_atomic_fetch_or(&note->value, value, RT_ATOMIC_RELAXED);
    rt_trace_notify_or(note, old, value, old | value);
    rt_notify_post(note);
}

void rt_notify_set(struct rt_notify *note, uint32_t value)
{
    const uint32_t old =
        rt_atomic_exchange(&note->value, value, RT_ATOMIC_RELAXED);
    rt_trace_notify_set(note, old, value);
    rt_notify_post(note);
}

uint32_t rt_notify_wait(struct rt_notify *note)
{
    rt_sem_wait(&note->sem);
    return rt_atomic_load(&note->value, RT_ATOMIC_RELAXED);
}

uint32_t rt_notify_wait_clear(struct rt_notify *note, uint32_t clear)
{
    rt_sem_wait(&note->sem);
    const uint32_t old =
        rt_atomic_fetch_and(&note->value, ~clear, RT_ATOMIC_RELAXED);
    rt_trace_notify_clear(note, old, clear, old & ~clear);
    return old;
}

bool rt_notify_trywait(struct rt_notify *note, uint32_t *value)
{
    if (!rt_sem_trywait(&note->sem))
    {
        return false;
    }
    *value = rt_atomic_load(&note->value, RT_ATOMIC_RELAXED);
    return true;
}

bool rt_notify_trywait_clear(struct rt_notify *note, uint32_t *value,
                             uint32_t clear)
{
    if (!rt_sem_trywait(&note->sem))
    {
        return false;
    }
    const uint32_t old =
        rt_atomic_fetch_and(&note->value, ~clear, RT_ATOMIC_RELAXED);
    *value = old;
    rt_trace_notify_clear(note, old, clear, old & ~clear);
    return true;
}

bool rt_notify_timedwait(struct rt_notify *note, uint32_t *value,
                         unsigned long ticks)
{
    if (!rt_sem_timedwait(&note->sem, ticks))
    {
        return false;
    }
    *value = rt_atomic_load(&note->value, RT_ATOMIC_RELAXED);
    return true;
}

bool rt_notify_timedwait_clear(struct rt_notify *note, uint32_t *value,
                               uint32_t clear, unsigned long ticks)
{
    if (!rt_sem_timedwait(&note->sem, ticks))
    {
        return false;
    }
    const uint32_t old =
        rt_atomic_fetch_and(&note->value, ~clear, RT_ATOMIC_RELAXED);
    *value = old;
    rt_trace_notify_clear(note, old, clear, old & ~clear);
    return true;
}