Mistake on this page?
Report an issue in GitHub or email us

Event

The Event class provides APIs to configure events delay and period timings. The timings use the std::chrono::duration class provided by the <utility> library. You can use post API to post an event to the underlying EventQueue, and you can use cancel to cancel the most recently posted event.

The Event class is thread safe. The post and cancel APIs are IRQ safe.

Event class reference

Public Member Functions
template<typename F >
 Event (EventQueue *q, F f)
 Create an event. More...
 Event (const Event &e)
 Copy constructor for events. More...
Eventoperator= (const Event &that)
 Assignment operator for events. More...
 ~Event ()
 Destructor for events. More...
void delay (duration d)
 Configure the delay of an event. More...
void delay (int d)
 Configure the delay of an event. More...
void period (duration p)
 Configure the period of an event. More...
void period (int p)
 Configure the period of an event. More...
int post (ArgTs...args) const
 Posts an event onto the underlying event queue. More...
void call (ArgTs...args) const
 Posts an event onto the underlying event queue, returning void. More...
void operator() (ArgTs...args) const
 Posts an event onto the underlying event queue, returning void. More...
void cancel () const
 Cancels the most recently posted event. More...
template<typename F , typename... ContextArgTs>
 Event (EventQueue *q, F f, ContextArgTs...context_args)
 Create an event. More...
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, ArgTs...), B0 b0)
 Create an event. More...
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, ArgTs...) const, B0 b0)
 Create an event. More...
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, ArgTs...) volatile, B0 b0)
 Create an event. More...
template<typename T , typename R , typename B0 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, ArgTs...) const volatile, B0 b0)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, ArgTs...), B0 b0, B1 b1)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, ArgTs...) const, B0 b0, B1 b1)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, ArgTs...) volatile, B0 b0, B1 b1)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, ArgTs...) const volatile, B0 b0, B1 b1)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, ArgTs...), B0 b0, B1 b1, B2 b2)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const, B0 b0, B1 b1, B2 b2)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) volatile, B0 b0, B1 b1, B2 b2)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...), B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event. More...
template<typename T , typename R , typename B0 , typename B1 , typename B2 , typename B3 , typename B4 >
 Event (EventQueue *q, const volatile T *obj, R(T::*method)(B0, B1, B2, B3, B4, ArgTs...) const volatile, B0 b0, B1 b1, B2 b2, B3 b3, B4 b4)
 Create an event. More...
Static Public Member Functions
static void thunk (void *func, ArgTs...args)
 Static thunk for passing as C-style function. More...

EventQueue example: posting events to the queue

The code below demonstrates how you can instantiate, configure and post events.

/*
 * Copyright (c) 2020 Arm Limited and affiliates.
 * SPDX-License-Identifier: Apache-2.0
 */
#include "mbed.h"

// Creates an event bound to the specified event queue
EventQueue queue;
void handler(int count);
Event<void(int)> event1(&queue, handler);
Event<void(int)> event2(&queue, handler);


void handler(int count)
{
    unsigned time_ms = equeue_tick();
    printf("Timestamp = %d Event = %d \n", time_ms, count);
    return;
}

void post_events(void)
{
    // Events can be posted multiple times and enqueue gracefully until
    // the dispatch function is called. Each event will be processed
    // subject to any delay and period specified. Each time an event has
    // been dispatched it will be re-queued ready for the next dispatch
    // period.
    event1.post(1);      // Event1 with a value of 1
    event1.post(2);      // Event1 with a value of 2
    event1.post(3);      // Event1 with a value of 3

    // Cancel the last event posted ie Event1 with a value of 3
    event1.cancel();

    event1.post(4);      // Event1 with a value of 4

    event2.post(5);      // Event2 with a value of 5

}


// Example  demonstrates the following:
// 1. Post 5 different events to a queue
// 2. Configure the event delay and period for each
// 3. Invoke the dispatcher to dispatch events for a specified period
//
//    | 100ms |    200ms    | 100ms | 100ms |    200ms     |
//            ^             ^       ^       ^              ^
//       Events 1,2,4       ^       ^       ^              ^
//        dispatched        ^       ^       ^              ^
//                          ^       ^       ^              ^
//                   Events 1,2,4   ^       ^              ^
//                    dispatched    ^       ^              ^
//                                  ^       ^              ^
//                               Event 5    ^              ^
//                                          ^              ^
//                                      Event 1,2,4        ^
//                                       dispatched        ^
//                                                         ^
//                                                       Events 1,2,4
//                                                        dispatched
//
// Expected Output
//
// Timestamp = 100 Event = 1
// Timestamp = 127 Event = 2
// Timestamp = 156 Event = 4
// Timestamp = 300 Event = 1
// Timestamp = 327 Event = 2
// Timestamp = 356 Event = 4
// Timestamp = 400 Event = 5
// Timestamp = 500 Event = 1
// Timestamp = 527 Event = 2
// Timestamp = 556 Event = 4
// Timestamp = 700 Event = 1
// Timestamp = 727 Event = 2
// Timestamp = 756 Event = 4

int main()
{
    // Example 1 Dispatch posted events for a specified period
    Thread event_thread;

    // The event can be manually configured for special timing requirements
    // specified in milliseconds (using Chrono durations)
    event1.delay(100ms);       // Starting delay - 100 msec
    event1.period(200ms);      // Delay between each event - 200msec

    event2.delay(400ms);           // Starting delay - 400 msec
    event2.period(non_periodic);   // Single non periodic event

    event_thread.start(callback(post_events));

    // Posted events are dispatched in the context of the queue's
    // dispatch function. Note that the EventQueue library has yet to be
    // converted to using Chrono times and thus times are still specified
    // in integer millisecond units.
    // 800 ms will allow the posted events to be dispatched multiple times
    queue.dispatch(800);

    event_thread.join();

}

Important Information for this Arm website

This site uses cookies to store information on your computer. By continuing to use our site, you consent to our cookies. If you are not happy with the use of these cookies, please review our Cookie Policy to learn how they can be disabled. By disabling cookies, some features of the site will not work.