Culture

Off-The-Shelf Hacker: Run MQTT on a Wearable Device

24 Jan 2018 3:01am, by

Last week, we looked at reading an ultrasonic range finder and displaying the distance on a nice on-screen gauge. I demonstrated how you could use a gauge on a wearable device, such as for a steampunk conference badge.

Since the badge is “connected,” which is to say, hooked up to a local area network over WiFi, we could also use it as a data collection device. Practical? Maybe. The concept could be transferred over to a less dramatic gadget like a small box you’d clip to your belt, put on a table or integrate into a product.

Reliably transferring data from one device to another is a job for a sweet data transfer protocol called MQTT. It’s a subscription-publication server model and can run on the badge or any number of other machines, including notebooks and servers. In MQTT-speak a server is commonly known as a broker. There’s even a client that works on an ESP8266. The server itself is pretty light, so installing it on the conference badge isn’t a big burden, even when equipped with the Raspberry Pi model 2 board.

Today we’ll install MQTT, capture data from the range finder and then publish it to the server, right there on the badge. I used an external HDMI monitor and keyboard for testing, although they are certainly optional once everything is working properly. We’ll also see the data appear on a networked Linux notebook, using a readily available MQTT client. Data could just as easily be captured from buttons, a photocell, a temperature sensor or other sensing devices. You’ll need to install the python-rpi.gpio software to use those devices with the Pi.

In an upcoming story, we’ll look at mating the MQTT server-sensor concept on the badge, with the slick on-screen gauge that we built last week, running remotely on the notebook. MQTT works so much better than a home-grown protocol.

Install MQTT on the Badge

Install the MQTT server and client software either with apt-get or a package manager like synaptic. Here’s a quick rundown on Raspberry Pi MQTT installation.

Testing is pretty straightforward.

First, open a terminal (on the Pi) and execute the mosquitto subscription command. The terminal will then just sit there waiting for data to come into the “rangeval” topic.

mosquitto_sub -t rangeval

In another terminal, publish some “test” data to the rangeval topic.

mosquitto_pub -t rangeval -m "test"

You should see the word “test” show up in the subscription terminal window, each time you run the publish command.

Python usually is included in versions of Linux, running on the Raspberry Pi. If not, it’s easy to add.

sudo apt-get install python

You might also need to install pip, Python’s built-in application installation tool.

sudo apt-get install python-pip

Next, open the browser, go to GitHub and download the Paho Python-MQTT library zip file to the Raspberry Pi 2, on the badge. Unzip the file and cd into the resultant directory.

Look for the setup.py file and run it using Python

python setup.py install

With everything installed, it’s time to move on to publishing the rangefinder data, using a Python script and the MQTT libraries.

Send Real Data Through MQTT

Below is a simple Python script to read serial data and publish it to the badge’s MQTT server. Recall that there’s an Arduino on the badge that manages the rangefinder and sends the data to the Raspberry Pi over the serial port. Serial ports are sometimes flaky, so be sure to run the stty command first.

stty -raw -crnl -F /dev/ttyAMA0 115200

Copy the following code into a text file then execute it with Python.

import paho.mqtt.publish as publish
import serial

ser = serial.Serial('/dev/ttyAMA0', 115200) 
while True: 
  serial_line = ser.readline()
  print (serial_line)
  publish.single("rangeval", serial_line, hostname="localhost")

If the subscription terminal is still up, you should see rangefinder data immediately scrolling by in the window. Otherwise run the subscription command again.

mosquitto_sub -t rangeval

MQTT on the Linux Notebook

Installing MQTT on a Linux notebook is no big deal either. Use apt-get or your favorite package manager. Be sure to include the MQTT client applications.

Be sure the badge is properly connected to the local network and that the Python script is still streaming data to the server.

You’ll need to know the IP address of the MQTT server, on the badge, to use the MQTT client remotely on the notebook.

Execute the ifconfig command, in a terminal, on the Pi to get the IP address. Look for the “inet” line associated with your WiFi card, typically marked as wlan0.

Make sure the notebook is on the same network and execute the MQTT subscription command in a terminal window.

mosquitto_sub -h 192.168.1.120 -t rangeval

The -h option is simply the Pi’s IP address and the -t represents the MQTT topic of rangeval. You should see the rangefinder data streaming by in the terminal. Look back at the subscription window on the Pi and you’ll see the exact same data there, too.

That’s the beauty of the MQTT one-to-many and many-to-one publication-subscription model. You could have tens, hundreds or thousands of MQTT clients consuming this data if you wanted. Likewise, you could also publish vast amounts of data, going the other direction, just as easily.

What’s Next

As soon as I work out the bugs with adapting the Processing steampunk on-screen gauge program, using MQTT, on the notebook, I’ll write up a little story covering the topic. Keep in mind that we aren’t necessarily limited to displaying rangefinder data on a remote gauge. We could also use the Python-MQTT client scripts to feed graphs or do analysis or any number of other jobs.

My challenge for physical computing is to identify and hammer out practical uses for this awesome technology. The tools are there. Leveraging the capabilities in productive ways is what Off-The-Shelf Hackers do.

Feature image via Pixabay.


A digest of the week’s most important stories & analyses.

View / Add Comments

Please stay on topic and be respectful of others. Review our Terms of Use.