How do I create a transformer that can post back a transformed message back on the bus?

[rvt]

What I am looking for is a message bus with routers, properly like https://www.etlcpp.com/message_broker.html where I can add a transformer of a message from one type to a other type.

When using a message_broker I was only beable to post the message to the broker itself, but messages did not arrive at the routers.

I had something like this:

struct Bus : public etl::message_bus<10U>
{
};

Message1 message1; 
Message2 message2;
Message3 message3;

Bus bus;
Broker broker; // Code I used below

// Create routers
Router1 router1;  // public etl::message_router< Router1, Message2, Message1, Message3>
Router2 router2; // public etl::message_router< Router1, Message2, Message1, Message3>
Router3 router3; // public etl::message_router< Router1, Message2, Message1, Message3>

// Subscribe
bus.subscribe(broker);
bus.subscribe(router1);
bus.subscribe(router2);
bus.subscribe(router3);

// Send a message
bus.receive(Message1{});

// router1 message1 received
// router2 message1 received
// router3 message1 received
// broker message1 received

// Here I also expected that router1, router2 and router 2 would have received the transformed message3 but they do not receive the transformed message.

But perhaps I did mis-understand how the broker should work.

In general what I like to do is:

1. Receive different messages or message types (NMEA strings)
2. Transform them if needed, or create new messages based on a timer or other kind of status within the system
3. Output them to RS232, UDP, BlueTooth etc...

Question:

1. Would this be a good design to use one bus for the various different message types?
2. If the above idea of one bus is not the correct one, what would be a better way to handle this?

Two concepts I am not clear have, and what I might need is:

1. Successor, not sure what that is yet...
2. The Subscription as mentioned here https://www.etlcpp.com/message_broker.html

thanks!

  class Broker : public etl::message_broker
  {
  public:

    Broker()
      : message_broker()
    {
    }

    Broker(etl::message_router_id_t id)
      : message_broker(id)
    {
    }

    using etl::message_broker::receive;

    // Hook incoming messages and translate Message5 to Message4.
    void receive(const etl::imessage& msg) override
    {
      if (msg.get_message_id() == Message1::ID)
      {
        etl::message_broker::receive(Message3());
      }
      else
      {
        etl::message_broker::receive(msg);
      }
    }
  };

[jwellbelove]

I'll take a look at that

[rvt]

Hello,

thanks for responding.. I got it working with a subscription, so perhaps my expectancy was incorrect on how the bus would work, and if a Router can place something on the bus by just using the receive method available on the router..

[jwellbelove]

The ETL's message_bus and message_broker can roughly be equated with a network hub and switch respectively.

Any messages sent to a message_bus will be sent to all connected subscribers, like a network hub.
Messages sent to a message_broker will only send to routers that specifically request to be notified of certain messages.

The successor functionality is to allow routers to be chained together, so that if a message is not handled by the current router, then it will be passed on to the next.

I worked with NMEA comms when I was contracted to Raymarine (a subsidiary of FLIR) some years ago.
I borrowed the basics of the J1939 protocol on a completely different contract to assign CAN IDs to modules on gas & oil well monitoring equipment.

[rvt]

Thanks,

I will wrap my head around the concepts and play with it a bit more. Thanks for the quick reply, awesome lib!

[jwellbelove]

Thanks.

If you want to capture a Message1 and then post an additional Message3 to the bus then you may be able to do it by overriding the receive function for the bus, similar to what you did for the broker, but post both messages.

I'll see if I can put together a quick example.

[jwellbelove]

#include "etl/message_bus.h"
#include "etl/message_broker.h"

#include <iostream>

struct Message1 : etl::message<1> {};
struct Message2 : etl::message<2> {};
struct Message3 : etl::message<3> {};

struct Bus : public etl::message_bus<10U>
{
  using base = etl::message_bus<10U>;

  // Hook incoming messages and translate Message1 to Message3.
  void receive(const etl::imessage& msg) override
  {
    if (msg.get_message_id() == Message1::ID)
    {
      base::receive(msg);
      base::receive(Message3());
    }
    else
    {
      base::receive(msg);
    }
  }
};

class Router1 : public etl::message_router<Router1, Message2, Message1, Message3>
{
public:

  void on_receive(const Message1&)
  {
    std::cout << "Router1 received Message1\n";
  }

  void on_receive(const Message2&)
  {
    std::cout << "Router1 received Message2\n";
  }

  void on_receive(const Message3&)
  {
    std::cout << "Router1 received Message3\n";
  }

  void on_receive_unknown(const etl::imessage&)
  {
    std::cout << "Router1 received unknown message\n";
  }
};

class Router2 : public etl::message_router<Router2, Message2, Message1, Message3>
{
public:

  void on_receive(const Message1&)
  {
    std::cout << "Router2 received Message1\n";
  }

  void on_receive(const Message2&)
  {
    std::cout << "Router2 received Message2\n";
  }

  void on_receive(const Message3&)
  {
    std::cout << "Router2 received Message3\n";
  }

  void on_receive_unknown(const etl::imessage&)
  {
    std::cout << "Router2 received unknown message\n";
  }
};

class Router3 : public etl::message_router<Router3, Message2, Message1, Message3>
{
public:

  void on_receive(const Message1&)
  {
    std::cout << "Router3 received Message1\n";
  }

  void on_receive(const Message2&)
  {
    std::cout << "Router3 received Message2\n";
  }

  void on_receive(const Message3&)
  {
    std::cout << "Router3 received Message3\n";
  }

  void on_receive_unknown(const etl::imessage&)
  {
    std::cout << "Router3 received unknown message\n";
  }
};

int main()
{
  Message1 message1;
  Message2 message2;
  Message3 message3;

  Bus bus;

  // Create routers
  Router1 router1;
  Router2 router2;
  Router3 router3;

  // Subscribe
  bus.subscribe(router1);
  bus.subscribe(router2);
  bus.subscribe(router3);

  // Send a message
  bus.receive(Message1{});
}

Router1 received Message1
Router2 received Message1
Router3 received Message1
Router1 received Message3
Router2 received Message3
Router3 received Message3

[rvt]

That's a nice solution I will have to ponder on... It does nto allow me to make seperate 'worker' modules, since I only will have one bus, but I expect to have several way's of capturing and re-sending a 'translates' message.
For example if a GPS message comes in with a date/time stamp I might want to send a date/time message around... Just a though..

But I will have some flexibility now I can play with! Again thanks for helping with the idea's and letting me know..

[jwellbelove]

There is another feature in the message routers. If you post a message to a bus and specify particular router Id, then that message will only go to those routers that have that Id.