I had this neat idea to control a mobile robot using Node-RED. Before creating the Node-RED dashboard for a robot, I wanted to create something simple as a proof of concept. And, in this article, I’m going to share with you how to configure Node-RED with the Wemos D1 Mini using MQTT.
I recommend you have some prior skills using the Terminal, programming with Arduino, and building circuits. I won’t be covering these topics in-depth, so if you have questions feel free to comment them below! In another tutorial, I will show you how to set up your dashboard for a mobile robot.
Don’t forget to subscribe to receive updates when that tutorial launches.
How to configure Node-RED and Wemos D1 Mini using MQTT
There are a lot of moving pieces to get everything to communicate properly. Essentially, we’re going to wire up a circuit to the Wemos D1 Mini. Then, we will connect the Wemos to our router and send information to our computer using MQTT. The computer will also be connected to the same router and have both MQTT and Node-RED installed. Finally, we can create a Node-RED flow to capture and display sensor data in a dashboard. When we visit the dashboard in our browser, we’ll be able to see values from the Potentiometer (in real-time) and control all of our LED’s.
A picture is worth a thousand words, so here’s a quick overview of what we’re going to build.
When we’re done, we should have a prototype that looks something like this.
Technical Definitions before we start
I also want to define a couple of terms before we begin.
MQTT (Message Queuing Telemetry Transport) is a messaging protocol that simplifies the way we communicate (publish and subscribe) to messages between machines.
In this project, we will use an open-sourced MQTT broker, called Mosquitto. I will use MQTT and Mosquitto interchangeably throughout this tutorial.
Node-RED is a flow-based development tool commonly used for Internet of Things (IoT).
We’re also going to be subscribing and publishing to topics. You can think of a topic as a message. Topics contain information that we want to send or receive. Subscribing to a topic means we’ll receive the information in. Publishing to a topic means we’re sending data out. This is always in reference to the device that’s communicating. The topic name is pretty important because it contains the data from our device. Therefore, I will be italicizing all topic names to make them easier to find.
Controller and Circuit Components
This tutorial is pretty simple, so you won’t need many components to get started. Here’s the list of materials in case you don’t have them already.
- 4X LED’s (I’m using Red, Yellow, Green, and White colors)
- 4X 220 Ohm resistors
- Wemos D1 Mini (or NodeMCU)
- Jumper Wires
- 5K Potentiometer
One of the biggest things I can share with you, is that you don’t need a Raspberry Pi to complete this project. I’m using my computer to run MQTT and Node-RED. If you want to use the Raspberry Pi to host your communications, that’s fine as well, but it’s not necessary.
Now that we have a general understanding of the system, I’m going to split the tutorial into three parts.
Part 1: Setup your computer with Node-RED and MQTT
I’m going to use my MacBook Pro for this, but you could also get setup running a Raspberry Pi. I haven’t tested this on Windows, but I imagine the process is similar once you have Node-RED and Mosquitto installed.
First, install Node-RED for your operating system.
Then install Mosquitto (MQTT broker)
Here’s a link to the Mosquitto download page. Once you have mosquitto, you can launch and interact with MQTT using these terminal commands. Write them down or copy/paste them somewhere, because they’re really helpful!
Start Mosquitto from Terminal
> brew services start mosquitto
Stop Mosquitto from Terminal
> brew services stop mosquitto
Subscribe to topic/hello
> mosquitto_sub -t topic/hello
Publish “your message” to topic/hello
> mosquito_pub -t topic/hello -m “your message”
You can test to see if mosquitto is working properly by opening up two different terminal windows and subscribing to a topic in one and publishing to the same topic in another. You should have 3 separate terminal windows open.
This is what it should look like:
Launch Node-RED & Create a Flow
Now, let’s open up Node-RED. Open up a terminal and type
Node-RED will launch typically on
https://127.0.0.1:1880 Open up this address in your browser. I recommend using Chrome. If you’ve never used Node-RED before, welcome! Watch this quick little getting started video before continuing.
While this is a video using an industrial controller that has Node-RED, it does provide a good overview of how to create a flow and get started within the software.
You can also read the Getting Started guide to create your first flow. While this may seem foreign at first, once you create a few flows, it’ll start to make sense.
Verify Node-RED can Receive and Send MQTT messages
Subscribe to a Message using Mosquitto
Now that we have Node-RED running, we’re going to subscribe to a message.This is eventually how we’ll receive messages from the Wemos D1 Mini.
First select the MQTT and a debug node from the menu on the left. Connect them together with a wire. Then, open up the MQTT block and type “localhost” as the hostname. Next, Enter topic/hello as the topic name. This is what your node should look like.
You’ll need to add a Server. Click on the pencil icon and use the screenshot below to fill out the settings.
Connect the right side of the MQTT block to the left side of the debug block.
Finally, deploy the flow by clicking the Deploy button in the top right.
Now open up the debug window. Also, open up a terminal window and publish a message to the same we defined above (topic/hello).
> mosquitto_pub -t topic/hello -m "hello world"
When you press enter, you should see this message transfer over to your debug window.
Publish a Message using Mosquitto
Let’s publish a message to ensure we have bidirectional communication.
Bring an Inject Node and an MQTT output node into your flow. Connect them together using a wire. Then open up the Inject node and change the payload to String. I’m going to send over the String, “hello world (node-red)” to show you that we’re sending data from Node-RED on the topic, topic/hello.
Next, open up the MQTT output node and make sure your server is set to localhost:1883 and the topic name is topic/hello.
Finally, click the deploy button in the top right corner. Inject the input node, and you should see “hello world (node-red)” in your debug tab.
If this happens, you’re ready to move to the next step! We have successfully connected mosquitto to Node-RED!
If not, go ahead and try the steps above again until it works!
Part 2: Wire & Program your Controller
Here’s the circuit diagram.
We’re keeping it really simple with 4 LEDs and a Potentiometer.
Once your circuit is wired up, you’ll need to write some code to Subscribe and Publish sensor data to Mosquitto. We’ll use the PubSubClient Library for this.
PubSubClient Library using Arduino IDE
If you’re using the Arduino IDE, you can install this library by going to Sketch > Include Library > Manage Libraries. Type in “PubSubClient” in the search menu. Choose the library by Nick O’Leary. Click Install. You may have to restart Arduino if prompted.
PubSubClient Library using Platformio
On Atom.io/Platformio, go to the Platformio Home. Then click Libraries on the left. Search for PubSubClient. Click the Install button and restart Atom.
Program the Wemos D1 Mini
Set up your program like you typically would control the LED’s and potentiometer. Define variables for your pins, configure the
loop() methods. Verify that your LED’s and potentiometer are working before continuing.
Now, let’s write a quick sketch to turn on the red LED when a ‘1’ is received and off when a ‘0’ is received.
We’ll use this modified template originally created by the Bald Engineer as a starting point.
Then, we’ll add additional functionally to control all 4 of our LED’s. You can test this out by opening up a Terminal window and sending a publishing command.
For example, to turn the red LED on, use this command:
> mosquitto_pub -t ledStatus/red -m "1"
To turn off the red LED, use this command:
> mosquitto_pub -t ledStatus/red -m "0"
If everything is configured properly, you should see the red LED turn on and off, respectively. Repeat this process for the remaining 3 LED’s. The code template should provide enough of a start to get all of your LED’s working. But if you need some inspiration, click here for a hint.
Publish Potentiometer Data to an MQTT Topic
Lastly, we’ll need to publish data from the potentiometer to another topic. I’m going to call this topic sensor/potentiometer.
To do this, we’ll modify our loop method. I’m going to send a new reading every 20 seconds.
Refer to the following code:
Part 3: Create a Dashboard in Node-RED
You’ll need to install the Dashboard library using NPM. Use the README page on the GitHub repository to get this configured.
Once installed, you’ll have access to all of the nodes used to make dashboard widgets.
For this project, we’ll use 4 switches to publish messages to each LED topic. This will allow us to click the button on the dashboard and turn the LED on and off. We’ll also periodically send data from the potentiometer to the dashboard to display on a gauge.
Configure a Switch Node to Control an LED
Drag a switch node and an MQTT node into the flow. Connect them together with a wire.
Next, open up the switch node (double click on it). Fill out the properties similar to the following screenshot. Make sure your “On Payload” is 1 and your “Off Payload” is 0. The topic name should match the name of the topic your LED is subscribed to. For the red LED, I used the topic name ledStatus/red.
Click Done. Then deploy this flow. Open up the Dashboard by clicking the box with the arrow in the dashboard tab.
Click the LED switch on your dashboard. You should see the LED turn on and off if it’s configured properly!
Add a Gauge to show Potentiometer Readings
We will show the potentiometer readings in our dashboard using a gauge widget.
Drag over an MQTT node and a gauge node. Connect them together with a wire. Next, open up the. MQTT node and verify that the server is localhost:1883 and the topic is sensor/potentiometer. Make sure you use the same name from the Wemos code.
Open up the gauge node and copy the settings shown below. This will change how the gauge appears on the dashboard. Feel free to use your own version of these settings to better match your data.
Once you’ve added in the gauge, deploy the flow and open up your dashboard. You should see something like this.
Interact with the switches and the potentiometer. Verify that you can turn the LED’s on and off. Make sure you’re getting readings from the potentiometer on your dashboard.
You can add additional widgets and functionality as you feel, but this will be a good starting point as we work towards controlling a mobile robot with Node-RED.
We covered a lot of topics in this tutorial. Everything from configuring an MQTT broker, to using Node-RED to create dashboards, to wiring up a circuit and writing code for our Wemos board.
I know this tutorial was rather lengthy, but I wanted to provide some fundamental information before moving on to more complicated applications. In the next tutorial, we’re going to wire up a DC motor and control it using Node-RED. This will get us one step closer to controlling our Mobile Robot!
If you have any questions, feel free to post them below! Node-RED has a lot of features, so it’d be good to explore different ways of collecting, publishing, and processing data.
Try this project?
Share your experience in the comments section below! If you have any questions, I’m here to help!