MQTT on Arduino

Now the task is to get the Arduino talking to the MQTT broker on the Pi. There are two stages to this - the first is to instruct the ESP8266 to connect to the Pi's WiFi network, and the second is to exchange MQTT messages.

Connecting to the Pi

For this part we just need to use the ESP's built-in AT commands. Later, we will embed the commands in a sketch, but as a first test we can just use the serial monitor. Figure 4 illustrates the use of the commands to list WiFi access points, and to connect to the one with the SSID RPi1. For more information, please refer to the ESP8266 AT instruction set guide which was linked on the ESP setup page.

ESP8266 WiFi connection

Talking MQTT

We will be making use of two different libraries to help simplify the job of exchanging MQTT messages with the broker. Both of them can be installed using the Include Library → Manage Libraries from the menu.

The first one is WiFiEsp by bportaluri, and the second is PubSubClient by Nick O'Leary:

WiFiESP

PubSubCient

Start a new sketch, install the libraries, and then load the example code provided below. You can alter the variable values at the beginning of the sketch to match the details of your Pi.

The code is quite long compared to other examples we have seen. This is mainly to accommodate some of the uncertainty around network connections - for example, there are several sections concerned with retrying and reconnecting. The comments in the code and the notes below the listing provide some further information.

* Adapted from the following examples:
* WiFiEsp: https://github.com/bportaluri/WiFiEsp/tree/master/examples/WebClient
* PubSubClient: https://github.com/knolleary/pubsubclient/tree/master/examples/mqtt_basic
*/

#include &lt;PubSubClient.h&gt;
#include "WiFiEsp.h"
#include &lt;SoftwareSerial.h&gt;

SoftwareSerial espSerial(10, 11); // RX, TX
long int baudRate = 9600;

char ssid[] = "RPi1";             // your network SSID (name)
char pass[] = "Raspberry";        // your network password
int status = WL_IDLE_STATUS;      // the Wifi radio's status
char server[] = "192.168.1.1";    // IP address of the MQTT server
char topic[] = "Test";            // Default topic string
char clientId[] = "client1";      // Cliwent id: Must be unique on the broker

WiFiEspClient wifi;               // Initialize the Ethernet client object
PubSubClient mqttClient(wifi);    // Initialize the MQTT client

void setup() {
  Serial.begin(9600);

  // Set baud rate of ESP8266 to 9600 regardless of original setting
  set_esp8266_baud_rate(baudRate);
  espSerial.begin(baudRate);
  espSerial.print("AT+UART_CUR=");
  espSerial.print(baudRate);
  espSerial.print(",8,1,0,0\r\n");
  WiFi.init(&amp;espSerial);


  // check for the presence of the shield
  if (WiFi.status() == WL_NO_SHIELD) {
    Serial.println("WiFi shield not present");
    // don't continue
    while (true);
  }

  // attempt to connect to WiFi network
  while ( status != WL_CONNECTED) {
    Serial.print("Attempting to connect to WPA SSID: ");
    Serial.println(ssid);
    // Connect to WPA/WPA2 network
    status = WiFi.begin(ssid, pass);
  }

  // you're connected now, so print out the data
  Serial.println("You're connected to the network");

  printWifiStatus();

  mqttClient.setServer(server, 1883);
  mqttClient.setCallback(onReceive);
}

void loop() {
  char message[256];
  int i;

  for (i=0; i&lt;256; i++) {
    message[i] = 0;
  }

  if (Serial.available()) {
    Serial.readBytesUntil("\r",message, 255);
    mqttClient.publish(topic,message);
  }

  if (!mqttClient.connected()) {
    reconnect();
  }

  mqttClient.loop();

}

void printWifiStatus()
{
  // print the SSID of the network you're attached to
  Serial.print("SSID: ");
  Serial.println(WiFi.SSID());

  // print your WiFi shield's IP address
  IPAddress ip = WiFi.localIP();
  Serial.print("IP Address: ");
  Serial.println(ip);

  // print the received signal strength
  long rssi = WiFi.RSSI();
  Serial.print("Signal strength (RSSI):");
  Serial.print(rssi);
  Serial.println(" dBm");
}

void onReceive(char* topic, byte* payload, unsigned int length) {
  Serial.print("Message arrived [");
  Serial.print(topic);
  Serial.print("] ");
  for (int i=0;i&lt;length;i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void reconnect() {
  // Loop until we're reconnected
  while (!mqttClient.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (mqttClient.connect(clientId)) {
      Serial.println("connected");
      // Once connected, publish an announcement...
      mqttClient.publish(topic,"hello world");
      // ... and resubscribe
      mqttClient.subscribe(topic);
    } else {
      Serial.print("failed, rc=");
      Serial.print(mqttClient.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

void set_esp8266_baud_rate(long int baud_rate){
  long int baud_rate_array[] = {1200,2400,4800,9600,19200,38400,57600,74880,115200,230400};
  int i, j, pause=10;
  String response;

  Serial.println("Setting ESP8266 baud rate...");
  for (j=0; j&lt;5; j++){
    for (int i=0; i&lt;10; i++){
      espSerial.begin(baud_rate_array[i]);
      espSerial.print("AT\r\n");
      delay(pause);
      if (espSerial.available()) {
        response=espSerial.readString();
        response.trim();
        if (response.endsWith("OK")) {
          espSerial.print("AT+UART_CUR=");
          espSerial.print(baud_rate);
          espSerial.println(",8,1,0,0");
          delay(pause);
          if (espSerial.available()) {
            response=espSerial.readString();
          }
          espSerial.begin(baudRate);
          delay(pause);
          espSerial.println("AT");
          delay(pause);
          if (espSerial.available()) {
            response=espSerial.readString();
            response.trim();
            if (response.endsWith("OK"))
              break;
            else {
              Serial.println("Trying again...");
            }
          }
          else {
            Serial.println("Trying again...");
          }
        }
      }
    }
    if (response.endsWith("OK"))
      break;
  }
  espSerial.begin(baudRate);
  delay(pause);
  espSerial.println("AT");
  delay(pause);
  if (espSerial.available()) {
    response=espSerial.readString();
    response.trim();
    if (response.endsWith("OK")) {
      Serial.print("\r\nBaud rate is now ");
      Serial.println(baudRate);
    }
    else {
      Serial.println("Sorry - could not set baud rate");
      Serial.println("Try powering off and on again");
      Serial.println("Don't try to use 115200");
    }
  }
}

Line	Comment
26-32	One of the difficulties with the ESP8266 is knowing what speed to use before a connection has been made. The function`set_esp8266_baud_rate(baudRate)` tries all the common speeds until it finds the one that works.
35-53	These are inherited directly from the `WiFiEsp` example
55-56	These configure the MQTT client with the values set at the top of the sketch. `onReceive` is a callback function which is invoked when a message arrives.
59-78	In the main loop, any text entered into the serial monitor is read and published as an MQTT message. The default topic is defined at line 18.
80-96	Inherited from the `WiFiEsp` example
98-106	Adapted from the `PubSubClient` example. The function echoes any received messages to the serial monitor
108-127	Inherited from the `PubSubClient` example
134-190	Function to set the serial communications with the ESP8266 to a known value (9600 baud) as seen on the previous page (see below).

The central loop which starts at line 136 tries each of the speeds in the list. When a response of OK is received, we have identified the current baud rate. The outer loop which starts at line 135 tries up to five times before giving up.

The communications rate of the ESP defaults to 115200 baud on power-up. This speed tends to be unreliable and needs to be reduced. Another interesting thing to note about the sketch is that there are several calls to delay(pause) where the value of pause is 50ms. This is to allow the ESP hardware to react to the command it has just been given. Without the delay, the next operation could start before the first completes leading to unpredictable results.

Links

WiFiEsp reference

PubSubClient reference