Skip to content

Desktop Robotti with RabbitMQ

Overview

This example demonstrates bidirectional communication between a mock physical twin and a digital twin of a mobile robot (Desktop Robotti). The communication is enabled by RabbitMQ Broker.

Desktop Robotti with RabbitMQ Broker and Digital Twin

Example Structure

The mock physical twin of mobile robot is created using two python scripts

  1. data/drobotti_rmqfmu/rmq-publisher.py
  2. data/drobotti_rmqfmu/consume.py

The mock physical twin sends its physical location in (x,y) coordinates and expects a cartesian distance calculated from digital twin.

Desktop Robotti DT structure

The rmq-publisher.py reads the recorded (x,y) physical coordinates of mobile robot. The recorded values are stored in a data file. These (x,y) values are published to RabbitMQ Broker. The published (x,y) values are consumed by the digital twin.

The consume.py subscribes to RabbitMQ Broker and waits for the calculated distance value from the digital twin.

The digital twin consists of a FMI-based co-simulation, where Maestro is used as co-orchestration engine. In this case, the co-simulation is created by using two FMUs - RMQ FMU (rabbitmq-vhost.fmu) and distance FMU (distance-from-zero.fmu). The RMQ FMU receives the (x,y) coordinates from rmq-publisher.py and sends calculated distance value to consume.py. The RMQ FMU uses RabbitMQ broker for communication with the mock mobile robot, i.e., rmq-publisher.py and consume.py. The distance FMU is responsible for calculating the distance between (0,0) and (x,y). The RMQ FMU and distance FMU exchange values during co-simulation.

Digital Twin Configuration

This example uses two models, one tool, one data, and two scripts to create mock physical twin. The specific assets used are:

Asset Type Names of Assets Visibility Reuse in Other Examples
Models distance-from-zero.fmu Private No
rmq-vhost.fmu Private Yes
Tool maestro-2.3.0-jar-with-dependencies.jar Common Yes
Data drobotti_playback_data.csv private No
Mock PT rmq-publisher.py Private No
consume.py Private No

This DT has many configuration files. The coe.json and multimodel.json are two DT configuration files used for executing the digital twin. You can change these two files to customize the DT to your needs.

The RabbitMQ access credentials need to be provided in multimodel.json. The rabbitMQ-credentials.json provides RabbitMQ access credentials for mock PT python scripts. Please add your credentials in both these files.

Lifecycle Phases

Lifecycle Phase Completed Tasks
Create Installs Java Development Kit for Maestro tool and pip packages for python scripts
Execute Runs both DT and mock PT
Clean Clears run logs and outputs

Run the example

To run the example, change your present directory.

cd /workspace/examples/digital_twins/drobotti_rmqfmu

If required, change the execute permission of lifecycle scripts you need to execute, for example:

chmod +x lifecycle/create

Now, run the following scripts:

Create

Installs Open Java Development Kit 17 in the workspace. Also install the required python pip packages for rmq-publisher.py and consume.py scripts.

lifecycle/create

Execute

Run the python scripts to start mock physical twin. Also run the the Digital Twin. Since this is a co-simulation based digital twin, the Maestro co-simulation tool executes co-simulation using the two FMU models.

lifecycle/execute

Examine the results

The results can be found in the /workspace/examples/digital_twins/drobotti_rmqfmu directory.

Terminate phase

Terminate to clean up the debug files and co-simulation output files.

lifecycle/terminate

References

The RabbitMQ FMU github repository contains complete documentation and source code of the rmq-vhost.fmu.

More information about the case study is available in:

Frasheri, Mirgita, et al. "Addressing time discrepancy between digital
and physical twins." Robotics and Autonomous Systems 161 (2023): 104347.