A C++ template library for embedded applications
Designed and maintained by
Aster Consulting Ltd

Messaging framework

Overview

The messaging framework is designed to allow a powerful, but easy to use, message routing and handling system to be
created. It comprises of a collection of messages, message routers, message buses and finite state machines.
Routers, buses and state machines share a unified API that allows different parts of the framework to be mixed and
matched.
For example, a message source may pass messages to a message bus. The message bus may then forward messages to
a number of other message recipients such as other buses, routers and FSMs. The sender of the message does not need
to know the exact type of the receiver, only that it can receive messages.

Messages

message

All messages are untimately derived from etl::imessage.
They are directly derived from the template  etl::message<const etl::message_id_t ID>.
Each message must have an id that is at least unique to the receiver, though normally ids would be unique across the
application.

struct Message1 : public etl::message<1>
{
};

struct Message2 : public etl::message<2>
{
};

Messages are normally passed around as const references to etl::imessage.

By default, messages are not virtual. This may be changed by defining ETL_MESSAGES_ARE_VIRTUAL either in the project
properties or in etl_profile.h.

By default the message id is a uint_least8_t. This may be changed by defining ETL_MESSAGE_ID_TYPE as the required
type.

Message Routers

etl::message_router

Messages routers are defined to handle a specified set of messages. Defining a message router will mandate that a
specific set of on_receive functions to handle each message type be defined, along with an 'unknown' handler.
Failure to define the full set of handler functions will result in a compile error.

Message routers may either handle the message directly or implement message queues to defer handling.
The message router defines a message packet class for implementing heterogeneous message queues.
See the QueuedMessageRouter project in the examples directory.

Message Buses

etl::message_bus

Message buses are a type of message router.

Message buses distribute messages to other message recipients. They do not process any messages.
Other message recipients (those classes derived from etl::imessage_router)  may subscribe to the bus.
Messages sent to the bus may either be broadcast or directed only to routers with a specified id.

Message Timer

etl::message_timer

The message timer is a generator of messages. Up to 254 timers may be defined that can be configured to send a
message to a router, bus or FSM at periodic intervals.


Finite State Machines (FSM)

etl::fsm

FSMs are also a type of message router.
Messages sent to FSMs are handled in on_event handlers in classes derived from etl::fsm_state.
The states are defined to handle a specified set of messages. Failure to define the full set of event functions will result in a
compile error. Messages sent to states that have not been define to handle them will call an 'Unknown' handler.
The FSM class uses, surprisingly enough, the state pattern to change message handlers on state changes.

By default the state id is a uint_least8_t. This may be changed by defining ETL_STATE_ID_TYPE as the required type.


Examples

Examples of all of these classes may be found on their respective web pages.