MIMIC MQTT Lab and IOTA MAM

IOTA is *the* DLT (distributed ledger technology) for the Internet of Things.
The facility for distributing telemetry from sensors is called MAM (Masked
Authentication Messaging), for details see their blog.

We were able to transfer dynamically changing MQTT telemetry generated
from our Bosch sensor simulation in our MIMIC MQTT Lab sent to the public
MQTT broker broker.hivemq.com, then through IOTA MAM to the IOTA
tangle in real-time.

You can check it yourself at this online IOTA MAM Explorer,   enter this
string

MGFJOZACIOWFEKGZARLWYPVUZGSDCAZPVPYACGCZJADGQWHFJLG9ZJGXNFIMVTCXMJUEEXUTEE9DDXHTC

where it says "enter root-address here...", optionally disable the "Pretty
print (JSON)" button, and press the search button.

This is a proof-of-concept meant to show that you can publish end-to-end
any telemetry from sensors to the IOTA tangle in real-time to be consumed
by your IoT application.

See this in action in this Youtube video.

You can also check the transactions on the ledger at https://thetangle.org/.

Free, online MIMIC MQTT Lab for Samsung Artik

We have recently released this free, online MIMIC MQTT Lab for the
Samsung Artik IoT platform and it is available on the Artik marketplace.

In under 3 minutes you get a virtual lab with a simulation of a IoT
control system based on the MQTT standard.

You can investigate:

• authentication and access of MQTT-based sensors to Artik in your own account
• telemetry flowing from sensors to defined device types in Artik
• charting of that telemetry based on device manifest
• control of actuators from defined rules in Artik
• pathological conditions that deviate from the normal steady-state

Check out this Youtube video for the entire process from an empty Artik
account.

MIMIC MQTT Simulator supports Sparkplug IoT standard

Cirrus Link has published an open-source IIoT (Industrial IoT) standard
called Sparkplug which specifies a framework for stateful data exchange
between things (sensors, actuators, gateways) and applications via the
MQTT protocol.

Inductive Automation's Ignition platform with their MQTT Edge module
implements this standard to supply an industrial-strength scalable
IoT application environment. The eco-system of devices that connects
to Ignition via MQTT must support the Sparkplug state machine.

MIMIC MQTT Simulator is designed to perform large-scale development /
testing / proof-of-concept / deployment or training on IoT platforms,
including Ignition. We have applied the open source Sparkplug library
to simulated sensors in MIMIC to integrate a large number of things
into Ignition.

This screenshot shows  10 simulated Bosch sensors publishing unique
temperature values to Ignition.

(we have posted a follow-up article.)

Gartner Report: A Guidance Framework for Testing IoT Solutions

Take a look at this report  by Gartner's Research VP Sean Kenefick
about  testing IoT solutions. It mentions MIMIC Simulator as a test tool.

"... An IoT solution may be made up of hundreds or thousands of devices. To
test all of the devices in their real environments may be prohibitively
expensive or dangerous. However, you also need to ensure that your IoT
platform and back-end systems can handle the load of all of those devices
and correctly send and receive data as necessary."

MIMIC IoT Simulator enables rapid development, testing, tuning,
deployment and training of large-scale, heterogeneous IoT environments.

Train on Dell OpenManage Network Manager with MIMIC Simulator

The task to set up a lab for training your staff on Dell OpenManage
Network Manager is expensive and time-consuming. You have to
acquire the equipment, set it up, maintain it and customize it to
reproduce scenarios that you want to practice on. This has been
covered in a previous post.

This is where a network simulator like MIMIC Simulator can help.
Rather than setting up a physical lab that reproduces your production
environment, and scheduling time on this limited resource, you can
import it into MIMIC and multiply it many-fold so that each
of your operators can train on exactly the scenarios you need.

For example, these were scenarios we setup quickly with the simplest
out-of-the-box network that ships with MIMIC: it discovered the
topology shown

Since MIMIC simulates dynamic values at runtime, the performance
monitoring shows realistic values for instrumented resources:

and

We then setup some alarms and they show

To investigate who is generating the top traffic, we could pinpoint
the source of the problems.

Ask yourself how much effort this simple exercise is in your network.
Prepare your staff for contingencies before it costs you much more
in network downtime.

Integrating Samsung Artik and MIMIC MQTT Simulator via NODE-RED

The Samsung Artik IoT platform exports an API that you can use
to programmatically retrieve and change your device information.

This REST API can then be used in a variety of ways to control your
IoT implementation. In our case, we used it to define the devices that
interact with Artik, eg. for this Youtube video .

One of the ways is through the Node-RED graphical programming
environment. This small setup

allows us to retrieve the device information for our purposes with a
couple of clicks. From an initial state as shown in the Node-RED dashboard

by entering the single Bearer Token of the Artik API, it retrieves the
UserID, registered Device Types and Devices with a couple of clicks on
the trigger nodes.

By saving this information into a file, we can define those devices
as simulated sensors in MIMIC MQTT Simulator

Scaling your Node-RED dashboard with MIMIC MQTT Simulator

 

 

Overview

This article shows how you can scale your Node-red visualization to a
large number of sensors. We'll go beyond the tutorials that are readily
available to apply Node-RED to a common Internet of Things (IoT)
scenario. You'll see that what works for one sensor will not work for
many, and a strategy for improving it.

We start by visualizing telemetry for one sensor. It readily shows in
the textual, gauge and chart widgets of the Node-RED dashboard. But,
when we extend it to multiple sensors, the widgets are overrun with
values. We offer one possible solution by changing the problem statement.

The accompanying Youtube video shows this in real-time.

MQTT Lab

We'll be using the MIMIC MQTT Lab accessible on the Internet for free.
20 simulated sensors are publishing MQTT telemetry to the public
iot.eclipse.org broker.  We have seen this lab in previous articles and
videos.

 

 

Single sensor telemetry

We are using Node-RED to visualize our sensor telemetry with the
dashboard plug-in, and I'll go through it in detail.

First, on the left we see a MQTT input node labelled Single sensor
subscribed to a single topic from the public iot.eclipse.org broker.

It feeds to a debug node labelled msg.payload that lets us see what is being received.

In the debug tab we see the JSON payload of our standard simulated Bosch
sensor with telemetry containing acceleration, humidity, pressure and
temperature. Let's focus on temperature.

We can change the temperature at any point in time through the Agent 
Variable Store dialog in MIMIC. Let's do this now. Later we'll visualize the
changes.

We can link the debug node to different stages of our flow and see
what happens.

Next comes a json node, which converts the JSON in the payload to a
Javascript object. Let's link the debug node and see what is in the
object. You can see that the temperature value is accessible at
msg.payload.data.temp.value .

The JSON node then feeds into the Messages node, which is a
counter which counts the messages flowing through it. It feeds into
our dashboard to display the number of messages received. We see it
slowly incrementing.

Let's now link the json node to the rest of the flows to visualize
more of the telemetry.

I'll start by linking the json node to the NOOP node. This is just
a convenience node that will later let me do some easy re-linking.
It just passes the message straight through to some other nodes.

First is the Samples counter node, it counts the number of samples
arriving. For now, this is exactly the same as the number of MQTT
messages received.

We can see it in the Samples dashboard widget that is placed in the
Telemetry group in the Home dashboard.

This is what the dashboard looks like.

The SN number text widget underneath the samples widget extracts
the serial number that was received.

The temperature text widget shows the numeric value of the temperature
received.

The gauge and chart widgets need a single value extracted out of the
payload, which is what the Extract temp node does.

Let's change the temperature again in the MIMIC lab and see the
visualization.

As soon as we click Ok in the MIMIC Agent Variable Store dialog, the
value changes from 20000 mCelsius to 10000.

Many sensors

So far so good for one sensor. But, if you want to use this for many,
it will not work. Let's try by switching from the single sensor input
node to the many sensor input node labelled Bosch sensors.

First, we see many more messages received as shown in the debug
tab. The simulated sensors in our MQTT lab are only generating 1
message every 10 seconds on average, so you can see how easy it is
to overwhelm the collector with messages.

Second, the gauge only shows the value for the last received telemetry,
and the chart now becomes a jumble of lines for the different sensors.
It's hard to discern anything.

Let's now modify this setup to make this scenario a little more useful.
Let's say all the sensors below 80 degree celsius are normal, and
we only want to visualize the sensors that are running too hot.


We can do this with the switch node. It only sends along messages
that have a temperature value higher than 80 degrees.

Let's link it in, and see what happens.

I use an Inject node named clear stats to inject an empty message to
clear the stats.

Even though further messages are being received. No samples are reported.

Let's now change one of the sensors to an abnormally high temperature.

As soon as it reports, it is visualized.

We saw how MIMIC MQTT Simulator helps in scaling your NODE-RED
visualization.