DEV Community: Oliver Thamm

How to build an office alarm system with Home IoT devices

Oliver Thamm — Wed, 14 Oct 2020 15:11:17 +0000

Building a security system with alarm and notifications using Home IoT hardware

Office security is a 100 billion dollar business. Trustworthy products and service providers come with a steep price tag. Specialised cloud-based solution providers come with the potential threat of misusing or selling your office’s IoT sensor data. Data privacy raises major concerns, since every supplier with access to data gets a full view of an office schedule—how employees behave and when the office is empty.

Hiring a security service company offers a good alternative to this. The security company could install a closed IIoT system within your company WiFi. But such services are very expensive.

A less pricey option is to use consumer market Home IoT devices and install it yourself. In this blog post, we show you how to make your own security system with just a bit of time and hacker spirit. Save a lot of money and no trust into an external security service company is required. We will show how to set up a text notification, play an alarm sound and change the color of a light to red when a motion sensor detects movement after 8pm.

Setting up the Home IoT motion sensor with lights

In Home IoT applications, motions sensors are often used to switch lights on only when they register movement within their range. In the right room this saves energy and money. The motion sensors keep associated lights switched off and switch them on only for a configurable timespan when they detect movement. If there is further movement around the sensor, the devices will remain switched on.

Home applications for this type of setup are often found in garages or driveways. Rooms in which people sit and stay usually don’t benefit. Also, pets can create unwanted side effects when they trigger motion sensors. In a small office, usage patterns are different to a private home. In an office before and after a workday, movement should trigger an alarm. Plus, it’s the kind of thing an office manager would like to know about.

For this post, we use the motion sensors of a global swedish furniture chain. Follow the basic setup as described by the vendor and our initial post. Screw open the back of the motion sensor device so you can see three buttons and put in batteries. Pair the motion sensor first with your hub device and then with the lights.

Go into the manufacturer's mobile app and test your setup. Use the app to name your light, e.g “room-a”.

Creating a service to report events and trigger an alarm

To access and react to events sent by the motion sensor, find out the device’s communication protocol. If the device communicates using keep-alive connections, e.g. CoaP or MQTT, then observe it’s messages. Otherwise frequently request, or poll, the device’s state.

The hardware we use works best when it does not directly observe the motion sensor but observes the associated light instead. That too is handled by drivers in IIoT Server. In Xapix IIoT Server drivers for this are included and you only need to configure the devices in the file ./config/devices.yml. Additionally configure your speaker and put your desired alarm audio file, e.g. “alarm.wav”, into a new folder ./tmp/iiot_office/media/.

devices:
  home_office:
    main_tradfri_hub:
      model_class: TradfriHub
      mac: XX:XX:XX:XX:XX:XX
      devices:
        room_a_bulb:
          model_class: TradfriLedColorBulb
          name: room-a
    speaker:
      model_class: Audio
      installation_name: iiot_office

One option to trigger alarms and send text notifications is to create your own local web server application. The web application needs to have an HTTP POST endpoint accepting JSON formatted data. In the code for the endpoint,put the decision logic for the alarm and notifications. Enter the endpoint’s URL as an environment variable named EVENT_WEBHOOK_URL for IIoT server.

A second option is to use our free Xapix Community Edition and it’s web UI to trigger data pipelines which change the light color, play an alarm sound and send text notifications.

If interested, then > CONTINUE READING < the full version of this article on our Xapix blog.

Join our Home IoT community

We are working on follow-ups to this blog series to inspire you with new ideas about how to use the Xapix IIoT Server once you have set it up. We would love to hear your ideas and collaborate!

Contact me on Twitter if you would like to discuss this tutorial or if you have questions or feedback about the Xapix Community Edition. We look forward to hearing from you!

How to detect data anomalies using a simulator and an IIoT factory model

Oliver Thamm — Wed, 07 Oct 2020 09:56:55 +0000

Detecting data anomalies in a constant event stream of IIoT sensor data

Manufacturing companies look for ways to automatically analyze recorded sensor data, detect errors and improve production processes. Anomaly detection in industrial sensor data is a challenge to many manufacturing companies, because there exists a large variety of sensor types and manufacturers on the IIoT market.

Popular IIoT applications often require anomaly detection, such as asset monitoring and alerting, predictive maintenance for machines and safety and security on the factory floor.

In this post, we show how to create a constant event stream of sensor data using our IIoT factory model, and how to manually add data anomalies. Record the event stream data and add the recordings to our simulator to replay them at will. Set up data pipelines to detect those data anomalies and respond to them by sending text notifications.

Producing a continuous stream of valid data with the camera-based product reader

In a previous blog post, we explained how to build an IIoT conveyor belt model. We made a camera-based product-reader model that reads product data from QR code strips. We also showed how to flexibly create such QR codes from a JSON file with product data.

In this post, we use the same method and add dimension measures as attributes “x_mm” and “y_mm” and values around 800.0 to the input data file. Vary each dimension measure by less than plus or minus 0.5 mm of tolerance and generate the QR codes. This is a sample of our product data:

[                            
  [ {"name":"product_id","value":"123456","data":{"variant":"2b","color":"green","x_mm":"800.21","y_mm":"799.85"}},    {"name":"product_id","value":"123451","data":{"variant":"2b","color":"green","x_mm":"800.49","y_mm":"799.96"}}
  ] //,...
]

Print the QR codes and glue them together to a strip long enough to wrap around the conveyor belt. Start the IIoT factory model and it produces a constant stream of product data including the dimension measures.

Manually adding data anomalies to the product data stream

Again, use the QR code maker script to create and print product data encoded in QR codes. This time they shall contain data anomalies. Create a new JSON file and vary at least one dimension value per record by more than plus or minus 0.5 mm of tolerance.

[
  [
{"name":"product_id","value":"123456","data":{"variant":"2b","color":"green","x_mm":"800.21","y_mm":"799.45"}},
{"name":"product_id","value":"123451","data":{"variant":"2b","color":"green","x_mm":"800.51","y_mm":"799.96"}}
  ],
  [
{"name":"product_id","value":"123452","data":{"variant":"2b","color":"green","x_mm":"799.81","y_mm":"798.85"}},    {"name":"product_id","value":"123457","data":{"variant":"2d","color":"red","x_mm":"801.22","y_mm":"800.35"}}
  ]
]

Generate the QR codes, print them and cut them out with scissors. Glue the QR codes to the back of coasters so we can throw them onto the conveyor belt of our IIoT factory model at will.

Recording the event stream of IIoT sensor data for a simulator

With the QR code strip and coasters with encoded product data in place, start the factory model and watch the event stream get printed to the monitor of your Raspberry Pi. Per default, the model will only produce valid product data as encoded on the QR code strip in an endless loop. Throw a coaster onto the conveyor belt and the model will add the respective data anomaly to the event stream. The factory model does not know what constitutes a data anomaly and will only report sensor data as measured.

Run the IIoT factory model two times for five minutes each and record the data. The first time do nothing with the coasters and therefore record a flawless stream of valid product data. The second time, use the coasters to add a few data anomalies to the recorded event stream. The HTTP API of our Raspberry Pi provides POST endpoints to start and stop the recording. The response body of the stop endpoint contains the recorded data.

The Ruby Sinatra code for recording the event streams we added to the open source Xapix IIoT Server looks like this:

$rec = nil

def recording?
  !$rec.nil?
end

def record_event!(event)
  event = event.slice('name', 'value', 'data').merge('timestamp' => Time.now.to_f)
  $rec << event if recording?
  event
end

post '/start_rec' do
  raise('already recording') if recording?
  $rec = []
  status 201
rescue StandardError => error
  status 400
  { error: error.message }.to_json
end

post '/stop_rec' do
  raise('not recording') unless recording?
  res_payload = $rec.to_json
  $rec = nil
  res_payload
rescue StandardError => error
  status 400
  { error: error.message }.to_json
end

# Make sure to call record_event! in your event endpoint
post '/event' do
  payload = parse_body(request)
  record_event!(payload)
  #...
end

The recorded data returned by the HTTP API has lots of doubles. This is because the limited number of product data QR codes on the conveyor belt repeat in a loop. To get unique product IDs and to save the recorded data to a trace file in which each line holds the data record of a single event in JSON format, run a script on the data that looks like this:

require 'json'                 

res_body = '[{ YOUR JSON RESPONSE }, ...]' 
File.open("./iiot_factory_product_dimensions_regular.json", 'w') do |f| 
  JSON.parse(res_body).each.with_index do |row, i|
    row['value'] = (100000 + i).to_s; 
    f.puts(row.to_json)
  end
end

Run the factory model twice to get two trace files, one with anomalies and one without any. The trace files can have hundreds of records and look like this:

{"name":"product_id","value":"100001","data":{"variant":"2b","color":"green","x_mm":"800.21","y_mm":"799.85"},"timestamp":1601371059.556218}
{"name":"product_id","value":"100002","data":{"variant":"2b","color":"green","x_mm":"799.81","y_mm":"799.85"},"timestamp":1601371062.339446}
{"name":"product_id","value":"100003","data":{"variant":"2c","color":"gray","x_mm":"800.11","y_mm":"800.05"},"timestamp":1601371065.3834803}
{"name":"product_id","value":"100004","data":{"variant":"2c","color":"gray","x_mm":"800.33","y_mm":"799.65"},"timestamp":1601371067.9262557}
{"name":"product_id","value":"100005","data":{"variant":"2b","color":"green","x_mm":"800.33","y_mm":"799.77"},"timestamp":1601371070.470316}

Replaying multiple event streams of IIoT sensor data with a simulator

We at Xapix added our two trace files to our simulator to replay the trace files on the simulator at will. In a previous blog post, we briefly explained how to build such a simulator yourself, in case you do not want to use ours.

Replay the trace file without anomalies multiple times simultaneously to simulate a lot of regular data volume. Next, replay a single trace file containing an anomaly in the simulator. The anomaly is hard to detect in the regular data traffic and therefore a good test for anomaly detection software.

Anomaly detection data pipelines

You could either build by hand a software script with decision logic reporting the data anomalies if an incident is recorded on your own Kafka server. It would need to work well with your simulator.

Or > CONTINUE READING < the full version of the article on our Xapix blog and create a free Xapix Community Edition account.

Join our Home IoT community

We are working on follow-ups to this blog series to inspire you with new ideas about how to use the Xapix IIoT Server once you have set it up. We would love to hear your ideas and collaborate!

Contact me on Twitter if you would like to discuss this tutorial or if you have questions or feedback about the Xapix Community Edition. Or really anything else as well. We look forward to hearing from you!

Building an IIoT conveyor-belt model and incident simulation

Oliver Thamm — Thu, 10 Sep 2020 18:24:43 +0000

Staging a critical machine incident that causes an emergency shutdown of the model

To detect and immediately react to incidents is a classic use case for Industrial Internet of Things (IIoT) applications. Of course, you don’t want to mess with production machinery in a factory to develop your software application. Using a model and simulator to stage, record, and replay incidents provides flexibility to prototype, iterate, and test your software without touching actual factory machines.

Simulating incidents requires a baseline data stream that represents normal operations of a machine. For example, a constant flow of product data. A singular event then interrupts such a constant stream. This might be something like sensor data of an incident.

For the abstract IIoT factory model, we want to stage several scenarios with various product data and incident data. We want to flexibly develop software or data pipelines that react to sensor data that indicates incidents. And we want to see the results of such reactions to sensor data in the real world equipment of our model.

In our previous blog post, we explained how to create a camera-based product-reader model reading QR code strips. We also showed how to flexibly create such QR codes from a JSON file with product data.

In this blog post, we share how to create a physical conveyor-belt model and stage an incident that causes an emergency shutdown of the model.

Staging an incident with the product reader

To prepare incident data, use the same method as for producing the QR code based product data stream you find in our previous post. Instead of strips with multiple product variants, we produce a strip with incident data compatible with our open source IIoT Server. Our file in ./qr_data/ is called “incidents.json” and looks like this:

[
  [
    {"name":"incident","value":"FOREIGN_OBJECT"}
  ],
  [
    {"name":"incident","value":"PERSON_TOO_CLOSE"}
  ],
  [
    {"name":"incident","value":"FIRE_ON_BELT"}
  ]
]

Next, run the script ruby ./make_qr_strip.rb incidents, open the generated HTML page “./qr_strips/incidents.html” in a web browser, and print it. Cut out the QR codes and glue them to the back of a coaster. We recommend writing the type of incident on each coaster to recognize them later.

Put the incident-data coasters on your product data strip and watch the product-reader model read the incident data and print it to your screen.

How to 3D-print the IIoT factory model’s conveyor belt rollers

We want to send the warmest thank you to the etventure tech guild team for their great support on building the model’s hardware and sensors! This wouldn’t be possible without your help.

Our factory model has a total of four 3D-printed rollers, each of which consists of two halves that screw together. One of these rollers propels the conveyor belt and has a special design. Instead of an even surface, this roller has a lot of grip and a gear attached, so the motor can propel it.

Building the IIoT factory model is a work in progress, and we welcome you ideas for optimizations on our Discord channel. Find the current versions of our 3D models for download here.

How to laser cut the IIoT factory model frame

Thanks to our friends at the etventure tech guild team, we are using a wooden laser cut frame for the model. If you have carpentry skills, you could build a similar frame, of course.

Our IIoT-factory model frame has two side panels with a couple of notches for the 3D printed rollers, the stabilizing bridges and the motor. The stabilizing bridges between the side panels are in a separate model file. Their current versions are all available for download here.

How to attach a stepper motor to the IIoT factory model frame

Select a corner of your frame to place your stepper motor and mount it. Do not tighten the screws too much, since adjustments may be necessary after mounting the rollers. On the inner side of the panel, attach the small 3D printed cogwheel to the stepper motor.

Pick the 3D printed roller with the attached gear, turn it so that the gear is in the corner of the motor and put it in the notch. Adjust the position of the motor so that the roller rests easy, but the motor’s small cogwheel still tightly fits into the roller’s gear.

The stepper motor we use on our IIoT factory model is set up with the x-axis slot of an Arduino motor controller. The motor can only be started by supplying power via USB and stopped by pulling the USB plug. We added a startup sequence that slowly accelerates the motor up to a certain speed to optimize grip on the conveyor belt.

Cutting the conveyor belt of the IIoT factory model

The ideal material for your conveyor belt is thin, light, flexible, and durable. Depending on the total size of your model, the length of your raw material could be important, too.

For our IIoT factory, we used a 2m-long travel yoga mat. They are made of rubber—an ideal material— and are much thinner and lighter than regular yoga mats. We just cut it to the right length and glued the ends together to form a belt.

Assembling the IIoT factory model prototype

Let’s put together the components. Put up the wooden side panels stabilized with bridges. Put the conveyor belt correctly around the rollers and fit them into the notches. Make sure the one gear attached to a roller is in the corner where the motor is. Adjust the motor’s position so it’s cogwheel fits with the roller gear. Wire up the Arduino motor controller with the motor plug the motor’s USB power supply into a smart plug configured to work with IIoT Server. Make sure initially your smart plug is switched off.

Put your product-reader model on top of your IIoT-factory model and make sure the distance and angle of its camera enable it to read the QR code product data strips on the conveyor belt.

Running the IIoT factory model and recording the sensor events for the simulator

Once everything is assembled, put your product-data strip on the conveyor belt and keep an incident coaster in your hand to throw in at will. Start the conveyor belt by switching on the smart plug by sending an HTTP request to your local IIoT Server API.

curl --location --request POST <YOUR_RASPBERRY_LOCAL_IP>:4567/device_cmd' \
--header 'Content-Type: application/json' \
--data-raw '{
    "device": "conveyor_belt_plug",
    "action": {
        "cmd": "plug_on"
    }
}'

Throw in your incident coaster and the event data should be printed to screen. As we do this we record a trace file that we can replay in the simulator later. It looks like this:

{"name":"product_id","value":"123456","data":{"variant":"2b","color":"green"},"timestamp":1598365799.4526498}
{"name":"product_id","value":"123452","data":{"variant":"2b","color":"green"},"timestamp":1598365804.0941744}
{"name":"product_id","value":"123458","data":{"variant":"2c","color":"gray"},"timestamp":1598365809.2619932}
{"name":"product_id","value":"123451","data":{"variant":"2b","color":"green"},"timestamp":1598365816.2038214}
{"name":"product_id","value":"123457","data":{"variant":"2d","color":"red"},"timestamp":1598365820.4342263}
{"name":"product_id","value":"123453","data":{"variant":"2b","color":"green"},"timestamp":1598365824.5778954}
{"name":"incident","value":"FIRE_ON_BELT", "timestamp":1598365826.5328884}

You could either build by hand a software script with decision logic sending the HTTP request to switch off your smart plug if an incident is recorded on your own Kafka server. It would need to work well with the simulator we suggested building in our initial post.

Or > CONTINUE READING < the full version of the article on our Xapix blog and create a free Xapix Community Edition account.

Join our Home IoT community

We are working on follow-ups to this blog series and will post updates in our Discord community to inspire you with new ideas about how to use the Xapix IIoT Server once you have set it up. We would love to hear your ideas and collaborate!

Contact us on our Discord community channel if you would like to discuss this tutorial or if you have questions or feedback about the Xapix Community Edition. Or really anything else as well. We look forward to hearing from you!

Automating office lights and plugs to save energy with Home IoT devices

Oliver Thamm — Fri, 04 Sep 2020 09:02:38 +0000

Small offices can save 20% of electricity and help save the environment

Automating light management using industrial internet of things (IIoT) devices in offices promises 20% energy savings and 100% environmental karma points. Large offices spend substantial amounts of money on service companies installing hardware and administration software. For small and medium sized offices, such investments will never pay off.

Here is an example calculation for a typical small company in a western country. If your office is consuming 10,000 kWh per year at an electric power price of $0.25 per kWh, the energy bill is $2.500 per year. Results vary, but most IIoT providers promise a 20% electricity saving using effective light management. That’s $500 per year saved in this example.

In this post we suggest DIY approaches to achieving the same results in small offices. All you need are some common Home IoT devices sold in consumer markets, the IIoT Server Open Source Software, and a little bit of hacker spirit. Invest half a day of work, have fun, save some money, and do something good for our planet.

Ensure Home IoT lights and plugs are switched off at night

Ensuring lights and other devices are switched off — not just in standby mode — at night is a simple way to save electricity and money. Offices are often empty over the weekend and for 12 to 14 hours per work day, for example between 7:00 p.m. and 9:00 a.m..

By running a scheduled task each evening, it becomes easy to prevent lights, monitors and power chargers from running when no one is around. By running an additional scheduled task in the morning you can make sure the smart plugs are switched on for employee’s convenience.

To run such scheduled tasks you need Home IoT devices that are connected and programmable via your local office WiFi. We suggest running our open source IIoT Server software on a Raspberry Pi, as described in our introduction blog post to this series. The IIoT Server supports a growing number of Home IoT devices. In our setup, we use lights from a global Swedish furniture chain and the Tp Link HS100 power plugs. Whatever hardware you use, set it up as described by their vendors. Then install IIoT Server as an additional way to send commands.

Setting up Home IoT devices to receive commands from IIoT Server

Set up your lights as described in our introduction blog post. We added a second light from the same manufacturer as a reading lamp. Connect the monitors and chargers on your desk with a multiplug socket and use a TP-Link HS100 smart plug as a gatekeeper to power supply.

Configure your devices in IIoT Server in the ./config/devices.yml file. Ours looks like this:

devices:
  office:                      
    room_a_bulb:               
      model_class: TradfriLedColorBulb
      hub_id: 65537            
    room_a_lamp:
      model_class: TradfriLedColorBulb
      hub_id: 65540
    room_a_plug:
      model_class: Hs100       
      ip: 192.168.10.77

Start the IIoT Server by following the manual. Test your setup and switch on all your lights and plugs, for example by using cURL:

curl --location --request POST 'localhost:4567/device_cmd' \
--header 'Content-Type: application/json' \
--data-raw '{
    "device": "room_a_lamp",
    "action": {
        "cmd": "bulb_on"
    }
}'

One option to schedule the execution of your commands at a specific time is to use the crontab program on your Raspberry Pi. Create two software scripts making HTTP calls to your IIot Server, one to switch all lights and plugs off and another to switch on all plugs. Finally, set up your desired schedule for running these scripts in crontab.

A second option is to use our free Xapix Community Edition and it’s web UI to set up a scheduler and trigger pipelines that switch on and off your lights and plugs.

If interested, then > CONTINUE READING < the full version of this article on our Xapix blog.

Join our Home IoT community

How to setup a local API for Home IoT Devices in your office using WiFi

Oliver Thamm — Thu, 03 Sep 2020 11:02:27 +0000

Small offices can profit from Home IoT devices made programmable with OSS

If you are working in an office with up to eight rooms, you may find yourself overlooked by commercial IoT solutions promising the typical benefits, e.g. energy savings, security improvements, disaster detection and other facility management improvements.

Luckily there are plenty of Home IoT product series on the market that you can use. Unfortunately, they are usually closed proprietary systems and don’t target specific office needs. At Xapix, we decided to open source our Industrial Internet of Things (IIoT) Server software that enables you to access common consumer-market Home IoT devices and develop custom office automation software against an HTTP API in your local office WiFi.

If you’d like an even simpler solution, you can enable the IIoT Server’s bridge to the free Xapix Community Edition and use the ready-made Xapix data pipelines.

This blog series explains how to save money, and improve security and convenience in small offices using consumer-market Home IoT devices.

Get started with a Home IoT test environment

This post sets up the technical work for the rest of the series with just a little bit of hacker spirit.

Most Home IoT device series are closed proprietary systems that often involve a gateway hub device and a vendor mobile app. We need a way to programmatically access the Home IoT devices, e.g. via an HTTP API, from within the local office WiFi as you do not want to expose it to the internet for security reasons.

Within this post, we explain how to set up a local API to a Home IoT light bulb on your development computer using our freshly released Open Source project IIoT Server and test your setup with a sample HTTP request via cURL or Postman.

If you have a free Xapix Community Edition account, we can even take the test setup one step further and create a Xapix pipeline. You’ll be able to turn your light bulb on and off with your web browser or cURL.

We will describe the setup process for a Mac computer and a light bulb, hub device, and dimmer of a globally operating swedish furniture chain. Feel free to use other hardware - the setup process is likely to be similar and we’d be happy to help if you want to reach out to us directly, e.g on our Discord community channel.

Send HTTP API requests to your Home IoT devices within your local WiFi

Setting up the Home IoT devices as documented by the vendor is the first step. You can follow the instructions that the maker includes in the product. For our devices, we connect the hub device to the office router and power plug and then use the vendor mobile app to register the hub device with the app.

Put batteries into the dimmer and register it with the vendor mobile app by putting the dimmer close to the hub and pressing the hub’s link button. Your hub device now manages your dimmer.

To register your light bulb with the app, plug in your light bulb, hold the dimmer close to the bulb and press the dimmer’s link button. Your hub now manages the dimmer, the dimmer manages your light bulb and the vendor mobile app controls everything. With the app or dimmer you should be able to dim, turn on and turn off the light bulb. The app additionally will allow you to change light color.

To do the same with cURL, Postman or your favourite programming language’s HTTP library, go ahead and download and install the Xapix IIoT Server and it’s dependency software libraries. Follow the setup instructions and install the necessary libraries.

One of the trickier steps is finding the IP address of your hub device within your local WiFi. You can best find it in your router’s administration UI. On a Mac you can also run arp -a in a terminal window and look for the IP address associated with your hub device’s MAC address to be found on the back of the device.

Once everything is configured, run the IIoT Server in a terminal window and next, to programmatically turn on your light bulb for the first time, run the cURL command:

curl --location --request POST 'localhost:4567/device_cmd' \
--header 'Content-Type: application/json' \
--data-raw '{
    "device": "test_bulb",
    "action": {
        "cmd": "bulb_on"
    }
}’

Congratulations! You are now good to go ahead and develop your own custom applications for your local office’s IoT setup.

Getting ready to integrate cloud APIs and services with your Home IoT setup

If you are interested in some easy paths to advanced tasks, especially when using web APIs and services, then we recommend trying our free Xapix Community Edition that seamlessly integrates with the IIoT Server when enabled. With Xapix, you can start by creating a basic data pipeline to test your setup and from that point onward, integrations with different APIs for solving your use-cases, e.g. weather forecast APIs or text notification APIs, will only be a few clicks away.

If interested, then > CONTINUE READING < the full version of this article on our Xapix blog.

Join our Home IoT community

We are working on numerous follow-ups to this blog-series and will be posting updates regularly within our Discord community to help inspire you on how best to make use of the Xapix IIoT Server once you have set it up. We would love to hear your ideas too and collaborate on this fun project.

Please contact us on our Discord community channel if you would like to discuss this tutorial or if you have questions or feedback about the Xapix Community Edition. Or really anything else as well. We look forward to hearing from you!

Explaining IIoT and event streaming projects with models

Oliver Thamm — Thu, 27 Aug 2020 15:01:31 +0000

How to build a hardware IIoT factory product reader and replay data using the simulator

If you work in IT or on a developer team, you may find it hard to explain the benefits of data-heavy event streaming or industrial internet of things (IIoT) projects to external stakeholders. This is when a model or simulator comes in handy.

Creating a model of the IIoT solution you're proposing can help you demonstrate how it works and why it's valuable. Enabling stakeholders to see your solution in action helps everyone better understand the technical solution — this is key to getting their support. The model needs to be functional at a moment’s notice — you never know when people will stop by! It also needs to be easily adjusted and look professional.

In this post, we will start building such a factory IIoT model by building a product-reader sensor, which records data from various scenarios — such as a normal constant product flow, start-and-stop modes and different types of incidents.

We want to send the warmest thank you to the etventure tech guild team for their great support on building the model’s hardware and sensors! This wouldn’t be possible without your help.

We also share concepts and tips for developing a simulator software that replays the data streams at any point in time so programmers can use it for building their own prototypes. We already operate such a simulator software for vehicles – you can learn more in our ride hail blog post.

Concept for a product reader sensor in the IIoT factory model

Factories have different types of product flows going in or out of their machines. To keep the factory model abstract and flexible enough to cover as many use cases as possible we use a paper strip with QR codes. Each QR code has JSON data with a specified format encoded but the product data content is fully flexible. This way when reading the QR codes we can simulate different types of products and incidents by just directly encoding them into QR.

For the product data sensor we use a Raspberry Pi 4 with a camera module and a Python script scanning the QR codes. Additionally, the Raspberry Pi runs a software very similar to our open source IIoT Server. The changes we made allow it to record locally and also stream all sensor events and API command logs via VPN to a Kafka cluster we operate.

We arrange our camera and Raspberry Pi so we can drag along the paperstrip with QR codes underneath the setup. The factory software records the events and at the same time streams them to our Kafka cluster in the cloud. The recorded events we store in a “trace file” to be replayed later by our factory simulator software.

Make paper strips with QR codes from JSON data

We are using the following Ruby script to make HTML pages with SVG QR codes. Store the file locally on your computer as “./make_qr_strip.rb”.

require 'json'
require 'rqrcode'              

data_file = ARGV[0]
data = JSON.parse(File.open("./qr_data/#{data_file}.json").read)

qr_strip_html =
  '<div>' + data.map do |row|  
    row.map do |record|
      qrcode = RQRCode::QRCode.new(record.to_json)
      '<svg>' +  qrcode.as_svg(
        offset: 0,             
        color: '000',
        shape_rendering: 'crispEdges',  
        module_size: 6,
        standalone: false      
      ) + '</svg>'
    end.join
  end.join('</div><div>') + '</div>'

html_page = '<html><head><style type="text/css">svg { margin: 20px; width: 300px; height: 300px; }</style></head><body>' + qr_strip_html + '</body><html>' 
File.open("./qr_strips/#{data_file}.html", 'w') { |f| f.puts html_page }

Create a directory “./qr_data/” to store your different JSON files containing product data for your various scenarios. In our case it is named “factory_intro_1.json”. Add columns and rows as desired. The format for each file is as follows:

[
  [                            
    {"name":"product_id","value":"123456","data":{"variant":"2b","color":"green"}},
    {"name":"product_id","value":"123451","data":{"variant":"2b","color":"green"}}
  ],
  [
    {"name":"product_id","value":"123452","data":{"variant":"2b","color":"green"}},
    {"name":"product_id","value":"123457","data":{"variant":"2d","color":"red"}}
  ]
]

Create a directory “./qr_strips/” the script stores your strips in. Finally, run ruby ./make_qr_strip.rb <YOUR QR_DATA_FILENAME> (e.g. ruby ./make_qr_strip.rb factory_intro_1) and find your strip as an HTML file in folder “./qr_strips/”. Open the strip file in a browser and print it out.

H2: Install your Raspberry Pi camera module and use it as a product reader sensor

Turn off your Raspberry Pi 4 and plug your camera module into it’s camera slot. Start the Raspberry Pi and in your “Raspberry Pi Configuration” menu in tab “Interfaces” to enable the camera.

To install our QR code reader script you need Python3 and pip3 installed. Next, install the following software libraries for video stream and image processing and QR code reading via pip3 install opencv-python imutils pyzbar.

Store the following script locally, e.g. in a file “./product_reader.py” and start the QR code scanning product reader in a terminal with command python3 ./product_reader.py.

from __future__ import print_function
import pyzbar.pyzbar as pyzbar 
import numpy as np
import cv2
from picamera import PiCamera
from imutils.video import VideoStream
import argparse
import datetime
import imutils
import time
import requests
from time import sleep

print("Start Video Stream")
vs = VideoStream(usePiCamera=True).start()
time.sleep(2.0)

last_3 = [None, None, None]
json_type_header = {'Content-Type': 'application/json'}

while True:
    frame = vs.read()
    frame = imutils.resize(frame, width=400)
    qr_codes = pyzbar.decode(frame) 
    for qr_code in qr_codes:
        qr_data = qr_code.data.decode('utf-8')
        if last_3.count(qr_data) == 0:
            print(qr_data)
            # DO SOMETHING USEFUL
            # In our case a local HTTP request
            # print(resp.status_code)         
            # if resp.status_code == 400:     
                # print(resp.json())              
            last_3.pop(0)
            last_3.append(qr_data)
    time.sleep(0.5)

Put the QR code in front of your camera and your running script should output the data encoded in your QR code. On our model we use this script to send the scanned product data to our IIoT factory server software which then will record the event and send the data to our Kafka cluster.

As we do this we record a trace file that we can replay in the simulator later. It looks like this:

{"name":"product_id","value":"123456","data":{"variant":"2b","color":"green"},"timestamp":1598365799.4526498}
{"name":"product_id","value":"123452","data":{"variant":"2b","color":"green"},"timestamp":1598365804.0941744}
{"name":"product_id","value":"123458","data":{"variant":"2c","color":"gray"},"timestamp":1598365809.2619932}
{"name":"product_id","value":"123451","data":{"variant":"2b","color":"green"},"timestamp":1598365816.2038214}
{"name":"product_id","value":"123457","data":{"variant":"2d","color":"red"},"timestamp":1598365820.4342263}
{"name":"product_id","value":"123453","data":{"variant":"2b","color":"green"},"timestamp":1598365824.5778954}

Next, you have 2 options. Either you could build a simulator script yourself reading the trace file and all it’s events. For example, you could group all events of a certain time interval and then iterate over these event groups, stream them to your own Kafka cluster and pause for the time interval length in between.

Or create a free Xapix Community Edition account and > CONTINUE READING < the full version of the article on our Xapix blog.

Join our IIoT community

We are working on numerous follow-ups to this blog-series and will be posting updates regularly within our Discord community to help inspire you on building IIoT models and simulators. We would love to hear your ideas too and collaborate on this fun project.