Third phase: Preparing your Arduino IDE

ESP8266 works in my context as a platform for transferring temperature and humidity measurements to Raspberry Pi. It also turns on/off LED, which is an example of lights. So in practise, one can follow temperature/humidity from distance AND control lights by using www-browser or mobile phone

In this phase you will see how to program the ESP8266 by using the Arduino IDE. In order to upload code to your ESP8266 using the Arduino IDE, you need to install the ESP8266 add-on (This will be explained in the section: embedded programming). You’ll also need to install some additional libraries to have everything ready for your ESP8266.

Libraries needed in my case

PubSubClient Library

The PubSubClient library provides a client for doing simple publish/subscribe messaging with a server that supports MQTT (basically allows your ESP8266 to talk with Node-RED).

• https://github.com/knolleary/pubsubclient/archive/master.zipClick here to download the PubSubClient library. You should have a .zip folder in your Downloads folder
• Unzip the .zip folder and you should get pubsubclient-master folder
• Rename your folder from pubsubclient-master to pubsubclient
• Move the pubsubclient folder to your Arduino IDE installation libraries folder
• Then, re-open your Arduino IDE

The library comes with a number of example sketches. See File >Examples > PubSubClient within the Arduino IDE software.

Library for BME280 sensor

To install the library navigate to the Arduino IDE > Sketch > Include Library > Manage Libraries… Wait for Library Manager to download libraries index and update list of installed libraries.

Filter your search by typing ‘bme280’. There should be a couple entries. Look for Adafruit BME280 Library by Adafruit. Click on that entry, and then select Install.

The BME280 sensor library uses the Adafruit Sensor support backend. So, search the library manager for Adafruit Unified Sensor and install that too (you may have to scroll a bit)

Selecting the right board on Arduino IDE

To see more about these settings, please navigate to embedded programming section, where I do describe these basics

Upload the code to ESP8266 via Arduino IDE

Now, you can upload the following code to your ESP8266. This code publishes messages of the temperature and humidity from the BME sensor on the room/temperature and room/humidity topics trough MQTT protocol.

The ESP is subscribed to the room/lamp topic to receive the messages published on that topic by the Node-RED application, to turn the lamp on or off.

You need to edit the code with your own SSID, password and RPi IP address.

				  
				
				//// IMPORTANT NOTICE (Fab Academy 2020 / Laru
//// This code is a remix of following projects done by others:
///  1. https://randomnerdtutorials.com/esp8266-and-node-red-with-mqtt/ (how to use MQTT and Nodered, but NOT how to use DIT sensor, because i didn't have that component)
///  2. https://lastminuteengineers.com/bme280-esp8266-weather-station/ (to learn how to use BME sensor, because I didn't have DIT sensor)
///  Libraries that I used to use BME sensor didn't have function to compute heatindex, so I have disabled it from this code below.

#include 
#include 
#include 
#include 
#include 

//define adafruit bme820 sensor
Adafruit_BME280 bme;

//

// Change the credentials below, so your ESP8266 connects to your router
const char* ssid = "ubinotko1";
const char* password = "";

// Change the variable to your Raspberry Pi IP address, so it connects to your MQTT broker
const char* mqtt_server = "192.168.100.47";

// Initializes the espClient. You should change the espClient name if you have multiple ESPs running in your home automation system
WiFiClient espClient;
PubSubClient client(espClient);


// Lamp - define port to be used
const int lamp = 2;



// Timers auxiliar variables
long now = millis();
long lastMeasure = 0;

// Don't change the function below. This functions connects your ESP8266 to your router
void setup_wifi() {
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("WiFi connected - ESP IP address: ");
  Serial.println(WiFi.localIP());
}

// This functions is executed when some device publishes a message to a topic that your ESP8266 is subscribed to
// Change the function below to add logic to your program, so when a device publishes a message to a topic that 
// your ESP8266 is subscribed you can actually do something
void callback(String topic, byte* message, unsigned int length) {
  Serial.print("Message arrived on topic: ");
  Serial.print(topic);
  Serial.print(". Message: ");
  String messageTemp;
  
  for (int i = 0; i < length; i++) {
    Serial.print((char)message[i]);
    messageTemp += (char)message[i];
  }
  Serial.println();

  // Feel free to add more if statements to control more GPIOs with MQTT

  // If a message is received on the topic room/lamp, you check if the message is either on or off. Turns the lamp GPIO according to the message
  if(topic=="room/lamp"){
      Serial.print("Changing Room lamp to ");
      if(messageTemp == "on"){
        digitalWrite(lamp, HIGH);
        Serial.print("On");
      }
      else if(messageTemp == "off"){
        digitalWrite(lamp, LOW);
        Serial.print("Off");
      }
  }
  Serial.println();
}

// This functions reconnects your ESP8266 to your MQTT broker
// Change the function below if you want to subscribe to more topics with your ESP8266 
void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    /*
     YOU MIGHT NEED TO CHANGE THIS LINE, IF YOU'RE HAVING PROBLEMS WITH MQTT MULTIPLE CONNECTIONS
     To change the ESP device ID, you will have to give a new name to the ESP8266.
     Here's how it looks:
       if (client.connect("ESP8266Client")) {
     You can do it like this:
       if (client.connect("ESP1_Office")) {
     Then, for the other ESP:
       if (client.connect("ESP2_Garage")) {
      That should solve your MQTT multiple connections problem
    */
    if (client.connect("ESP8266Client")) {
      Serial.println("connected");  
      // Subscribe or resubscribe to a topic
      // You can subscribe to more topics (to control more LEDs in this example)
      client.subscribe("room/lamp");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 5 seconds before retrying
      delay(5000);
    }
  }
}

// The setup function sets your ESP GPIOs to Outputs, starts the serial communication at a baud rate of 115200
// Sets your mqtt broker and sets the callback function
// The callback function is what receives messages and actually controls the LEDs
void setup() {
  pinMode(lamp, OUTPUT);

  //let's tell BME's I2C adress
  bme.begin(0x76);
  
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

}

// For this project, you don't need to change anything in the loop function. Basically it ensures that you ESP is connected to your broker
void loop() {

  if (!client.connected()) {
    reconnect();
  }
  if(!client.loop())
    client.connect("ESP8266Client");

  now = millis();
  // Publishes new temperature and humidity every 30 seconds
  if (now - lastMeasure > 30000) {
    lastMeasure = now;
    // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
    float h = bme.readHumidity();
    // Read temperature as Celsius (the default)
    float t = bme.readTemperature();
    // Read temperature as Fahrenheit (isFahrenheit = true)
  //  float f = bme.readTemperature(true);

    // Check if any reads failed and exit early (to try again).
    if (isnan(h) || isnan(t) ) {
      Serial.println("Failed to read from DHT sensor!");
      return;
    }

    // Computes temperature values in Celsius
 //   float hic = bme.computeHeatIndex(t, h, false);
    static char temperatureTemp[7];
  dtostrf(t, 6, 2, temperatureTemp);
    
    // Uncomment to compute temperature values in Fahrenheit 
    // float hif = dht.computeHeatIndex(f, h);
    // static char temperatureTemp[7];
    // dtostrf(hic, 6, 2, temperatureTemp);
    
    static char humidityTemp[7];
    dtostrf(h, 6, 2, humidityTemp);

    // Publishes Temperature and Humidity values
    client.publish("room/temperature", temperatureTemp);
    client.publish("room/humidity", humidityTemp);
    
    Serial.print("Humidity: ");
    Serial.print(h);
    Serial.print(" %\t Temperature: ");
    Serial.print(t);
    Serial.print(" *C ");
   // Serial.print(f);
    Serial.print(" *F\t Heat index: ");
   // Serial.print(hic);
    Serial.println(" *C ");
    // Serial.print(hif);
    // Serial.println(" *F");
  }
} 
				
					

Monitoring the execution of the code by using Serial monitor

After uploading the code, and with the Raspberry Pi running your Node-RED application and the Mosquitto broker, you can open the Arduino IDE serial monitor at a baud rate of 115200 and see what’s happening in real time.

This is helpful to check if the ESP has established a successful connection to your router and to the Mosquitto broker. You can also see the messages the ESP is receiving and publishing.

From the console window below, it's easy to recognize that ESP8266 and Raspberry Pi are communicating well, but temperature measures are not working as those should. In the next phase circuitry of the project is presented and tested

Fifth phase: Finalizing the UI and functionalities, but also Debugging non-functional features

Debugging, debugging, debugging and debugging

I got my first impression about Node-Red and MQTT from my cousin who works in the field of software engineering and IoT. So I had "some ideas before this assignment". Also our local instructor, Antti Mäntyniemi gave hints about using Node-Red and MQTT. I had also personal interest to learn how to integrate ESP platform via wifi to other tools and technologies, because in my final project I will rely on integration between ESP32 and smartphone.

Although combination of simple eletronics and MQTT-Node-red traffic seems to be pretty simple to build and operate, there are a lot of caveats that I did encounter during tinkering with the software and hardware components. Biggest obstacle for "smooth" end result was the fact, that I did compensate my limited programming experience on C-language with remixing existing projets together

So, being beginner, I had to follow existing tutorials and documentations to learn how to integrate these different technological parts together

• First project was complete tutorial of using Node-Red, MQTT and ESP8266 together to measure temp and control LED: https://randomnerdtutorials.com/esp8266-and-node-red-with-mqtt/
• Second project was about to build stand-alone weather station by using ESP8266: https://lastminuteengineers.com/bme280-esp8266-weather-station/

First tutorial was perfect fit for my purposes, except sensor used in this tutorial was different (DIT) than I had in my inventory (BME). So in order to get my BME sensor to integrated my project, I had use that second tutorial also to get ideas and examples.

Remixing of those two tutorials and limited timeframe led me to numerous of debugging events. Above I will highlight some of those.

Temperature measurements doesn't work, but LED light works

One of the issues that I had to debug was the fact that MQTT message exchange works perfectly, but ESP8266 doesn't measure temp and that's why MQTT messages are empty and Node-RED dashboard doesn't show any temperature and humidity related values

This was easy to see just by following acvities from serial monitor -window (picture below)

Because I had to adjust codebase by remixing two tutorials together and main code base was written by following tutorial where sensor was DIT-based, I got first series of error messages from Arduino IDE. Of course I knew this already, but because sensors were different, also needed code was different

I sorted those messages out, for example by definining Adafruit_BME280 bme; sensor, and starting the sensor bme.begin(0x76);

However, before I understood that I have to define BME sensor and start it by using hex code (adress of sensor in I2C bus) I had a lot of wrong ideas how to fix the issue. For example, I checked cables and pins of the ESP8266 multiple times. Most difficult thing was the fact, that I got code working well even without defining and starting BME. Somehow I managed to run code without starting BME at al all.

Anyway, eventually I got knowledge from different tutorials and found how to configure BME sensor

When LED is turned on, measurements will get very wrong values

Second debugging was done in the context where BEM sensor goes wild, when LED is activated. This was pretty "funny" because of temp decreased to -142 degrees and humidity was 100% until I did turn off lED

I almost understood that this is now issue which can be tracked to circuitry of BEM sensor and LED lamp. When I took I2C bus into use by adding it into C-code issue started. Somehow LED GPIO will mess I2C bus when LED is high.

Well, final solution was found from C code and it was pretty simple. I had tried different values to take GPIO for LED into use, while I was learning how to lit LED. When I took I2C bus into use I accidentally had value for LED GPIO Out in C-code which was in the conflict with I2C bus (D2 in ESP8266)

Figure: What did happen when I did turn LED on for temperature and humidity

Very very very embarrassing issue to be debugged: two parallel sketches compiled randomly

This was pretty weird issue, because code in Arduino IDE did change: sometimes I found that I have to write again changes, that I already had done.

Of course I thought that somehow I haven't saved my code and I have just lost my edits. But pretty soon I understood that I had earlier and current version of sketches available in separate windows. And Because I am who I am, I just randomly edited and compiled one of the parallel sketches

This is pretty typical "human error" in coding and was easily debugged when I understoond that I have to little bit elaborate my practises. This was solved by closing parallel sketch.

Figure: In this you can see how I had two "identical" sketches running on.

Finalizing the UI and Layout on Node-Red server

In order to increase at least little bit "professionalism" in this assignment I did small changes in my Node-Red configuration (new version of UI is also presented above in the second debugging example):

• I added realtime view to temperature
• I added trend data to humidity
• I regrouped both measurements into own groups
• In order to get those views working, I also needed to re-route data from MQTT intake(s) to respective Node-RED components by changing the flow (see picture below)

In addition to that, I also finetuned settings for y-axis in both charts. Y-axis of temperature chart got 18 celcius as minimum value and 34 as maxium temperature, while humidity chart got 25% as minimum value and 40% as maximum humidity. With such settings both graphs are more readable because of the more meaningful scale of the axis.

Figure: I added two new nodes: 24h humidity and current temperature, which are repsented in this diagram

Figure: In this dashboard you can see changed Y-axes and new realtime temp and humidity trend graph

Video demonstrator of working project where erros and issues were ironed out

In the gif animation below you can see my project in the action. When I switch lamp on, LED turns on and Arduino IDE console shows how temperature measurements are collected and communicated a via MQTT