Controlling an Arduino-based car with Solace PubSub+ Event Broker
Tags: fordevelopers, mqtt, eventbroker, solace
Published: 2020-03-09 18:21:17

![](https://solace.com/wp-content/uploads/2019/06/Icon-for-connected-vehicle-initiatives.png) 

Let me start with a disclaimer that I am very new to Arduino. Despite having an Electrical Engineering degree, I had never really played around Arduino until very recently. The code referenced in this post was handed down to me by my colleagues at Solace.

Recently, I presented for the first time at Solace’s meetup in New York. For this meetup, we decided to cover a specific feature of Solace PubSub+ which we thought our users and prospects would find interesting:  **Replay**. [PubSub+’s Replay](https://docs.solace.com/Overviews/Message-Replay-Overview.htm) feature is relatively new but extremely powerful and one that many users have welcomed.

![control Arduino car with pubsub+ event broker](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-1.png)

Every meetup’s success depends on two factors:

1. Food and drinks
2. Demo

Food and drinks were a no-brainer. We got a bunch of delicious pizza and lots of craft beer (lagers, pilsners, sours, and even _rosé_ cider!).

However, having a cool demo for your meetup requires a lot of planning. We could have easily demoed Replay via PubSub+ admin UI. While it would have gotten the point across, it wouldn’t have been visually appealing. After a lot of discussions, we decided to use a car powered by Arduino and controlled by PubSub+. The idea was simple and visually appealing. We would build an Arduino-powered car and control it by sending MQTT messages via PubSub+. Then, we will replay those messages and show the car repeating its earlier steps (this is when the crowd goes “_oooh aaaah”)._

In this post, I would like to show you how you can build your own Arduino-powered car and control it with [PubSub+ Event Broker](https://solace.com/products/event-broker/). Let’s get started.

Here are the steps to achieve our goal:

1. Assemble car from the car kit
2. Configure code and upload to Arduino chip
3. Send messages to control the car

## **Assemble Car from the Car Kit**

** ** I don’t want to document all the steps I followed to assemble the car because, to be honest, I was just following instructions from other blogs. The instructions that came with the kit were not very helpful and very difficult to understand.

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-2.png)

You can buy the kit from [Amazon](https://amzn.to/2ur9WMd). More details about the kit can be found on [this site](https://www.sinoning.com/collections/assembly-car-kit/products/2wd-l293d-wifi-rc-smart-car-with-nodemcu-shield-for-esp-12e-based-on-esp8266-mobile-control). This [YouTube video](https://www.youtube.com/watch?time_continue=4&v=sEjhM3cMlhc&feature=emb_logo) was very helpful and I highly recommend using it as a starting point.

The assembled car should look like this:

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-3.png)

## Configuring Code and Uploading to Arduino Chip

Once you have the car assembled, it is time to upload code to the Arduino chip. You can find the code on Solace’s [github](https://github.com/solacese/car-demo). In the repo, you will find `car_demo/arduino/src/car_kit.ino` which is the code that you will need to open using Arduino IDE and upload it to chip. Note that the following instructions are meant for the ESP8266 chip only.

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-4.png)

### **Downloading Arduino IDE**

To be able to upload code to the chip, you will need to [download](https://www.arduino.cc/en/main/software) and use the Arduino IDE. I recommend downloading the software instead of just using the browser version. Once installed, open `car_kit.ino` in the Arduino IDE.

### **Configuring code**

Before you can upload the code, you need to modify the code slightly to get it to work for you. You need to make a minimum of two changes:

1. Enter wifi details so the chip can connect to the Internet
2. Enter MQTT broker details

Modify the following lines by entering your Wifi details:

```
const char\* ssid = "<ssid>";const char\* password =  "<ssid\_pwd>";
```

Modify the following lines by entering your MQTT broker details:

```
const char\* mqttServer = "";const int mqttPort = ;const char\* mqttUser = "";const char\* mqttPassword = "";
```

You will need an MQTT broker running so you can enter the relevant connection settings. Of course, I would recommend using Solace’s PubSub+ Event Broker which supports MQTT. You can spin up an instance via [Solace Cloud](https://solace.com/products/event-broker/cloud/) for free.

### Configuring board

Before uploading this code to your Arduino chip, you will need to configure your IDE to work with the specific model of your chip as well as install `PubSubClient` and `ArduinoJson` libraries.

Arduino IDE supports a lot of ‘boards’/chips out-of-box but sadly, doesn’t support the ESP8266 chip. So, we need to add it manually to Arduino’s Board Manager. To do so, go to  **Arduino**  >  **Preferences** and enter the URL: http://arduino.esp8266.com/stable/package\_esp8266com\_index.json

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-4.5.png)

Click **OK**.

Now, go to **Tools > Boards > Boards Manager** , and search for ESP8266. You will now see ESP8266 board by ESP8266 Community. Click on Install to install it. You can also choose to install a specific version if needed. We are using 2.6.3 currently.

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-4.6.png)

### **Installing necessary libraries**

Now, you are ready to install `PubSubClient` and `ArduinoJson` libraries. You can easily do that by going to  **Tools**  >  **Manage Libraries**  and simply searching for them and installing them.

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-5.png)

Once you have these libraries installed, you are ready to upload the code to the Arduino chip. Plug your chip into your computer via Micro USB cable. You will see a blue LED light as soon as you plug in the chip. If you don’t see the light, try toggling the white switch on the chip to turn it on.

Finally, go to  **Sketch**  >  **Upload**  to upload the code to your chip.

That’s it!

## Sending MQTT messages via PubSub+

You can now go to PubSub+ UI and send some sample messages to your chip to control the car.

### **Getting the Chip ID**

If you are using the exact code from `car_kit.ino`, you will need to publish messages to `car/drive/${chipID}` topic where `chipID` is your Chip’s ID. You can get the Chip ID by looking at the output of your code in the Serial Monitor. To be able to run the Serial Monitor from Arduino, you will need to make sure your chip is plugged in via USB to your laptop. When you upload the code, you can run the Serial Monitor to see the output.

Here is the output of my Serial Monitor:

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-6.png)

As shown in the screenshot above, my Chip ID is 6994174.

Here is some good [documentation](https://www.instructables.com/id/HOW-TO-use-the-ARDUINO-SERIAL-MONITOR/) on how to use Arduino’s Serial Monitor.

### **Sending MQTT Messages**

The payload of your message should be in JSON format and should include three values:

- l – power for the left motor with a range of -100 to 100
- r – power for the right motor with a range of -100 to 100
- d – duration in milliseconds

Negative power will make the motor turn in the opposite direction compared to positive power. For example, l:100, r:100 and d:500 will make the car move forward for 500 milliseconds. If you want to turn right, you can set l to 0 and if you want to turn left, you can set r to 0, respectively. You can control how far the car drives by adjusting the duration (d) parameter.

Here is a sample payload:

```
{"l": 100,"r": 100,"d": 700}
```

 ![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-7.png)

Solace PubSub+ Try Me! Publisher

It’s up to you how you would like to publish these JSON messages. For development, you can simply use Solace’s _Try Me!_ tab and use the Publisher app there to publish these messages.

Of course, you can build a nice shiny app or program a joystick to send such messages. It’s up to you how creative you want to get!

## Architecture

Now that we have our car running, let’s take a step back and look at the architecture of our setup:

![](https://solace.com/wp-content/uploads/2020/03/arduino-car-post_pic-8.png)

On the left side, we have our assembled car powered by an Arduino chip and subscribing to an MQTT topic with QoS 1. You can see where we specify the subscription in the code:

```
// Subscribe to car specific drive commands char carDriveTopic[40]; sprintf(carDriveTopic, "car/drive/%lu", chipId); client.subscribe(carDriveTopic, 1);
```

As you can see, we are subscribing to `car/drive/${chipId}` with QoS of 1. Specifying QoS to be 1 causes PubSub+ to create an internal queue and map car/drive/${chipId} topic to the queue. When we publish JSON messages to the `car/drive/${chipId}` topic, our messages are sent to the queue and then to the Arduino chip.

On the right side, we have our Controller UI which is simply the javascript Publisher app on _Try Me!_ tab on Solace Cloud.

Needless to say, the MQTT broker being used here is Solace’s PubSub+ Event Broker running on AWS.

That’s pretty much it! I hope you found this post useful. For more information, visit [**PubSub+ for Developers**](https://www.solace.dev/). If you have any questions, post them to the [**Solace Developer Community**](https://solace.community/).

The post [Controlling an Arduino-based car with Solace PubSub+ Event Broker](https://solace.com/blog/arduino-car-solace-replay/) appeared first on [Solace](https://solace.com).