MQTT client for Arduino based PLC as a I/Os module.

In this chapter #1 it is explained how to configure your Industrial Arduino based PLC as a MQTT I/Os Module. 

Before starting this chapter, it would be interesting to take a look on how MQTT protocol works, what is a JSON and their applications. 

After that, take a fast look on the next libraries:

• MQTT: MQTT Post

• ArduinoJson: ArduinoJson library

           (The version of the Json library has to be the ArduinoJson-5.13.5.zip one).

The architecture of the code is written for a M-Duino21+, but is designed to be extended for the rest of the M-Duinos. There are four different arrays that include all the available I/Os in the M-Duino PLCs. 

These arrays are: digitalOutputs , analogOutputs, digitalInputs, analogInputs

So, every array will be structured as follows:

digitalOutputs[NUM_ZONES][NUM_DIGITAL_OUTPUTS_PER_ZONE] = {{Q0_0, Q0_1... }, {Q1_0, Q1_1...}, {Q2_0, Q2_1...} 

This last example would be for a M-Duino 58+. As you can see, every zone is subdivided with their related pins nomenclature.

After explaining how to access to the inputs mapping you are ready to learn the rest of the code. 

In the setup() we are just making the initialization of Ethernet and the MQTT client called mqtt, relating the callback function when we receive a message through MQTT and allthe actual input values. After this, we just have three main functions in the loop() function. The first one is the reconnect() function and we'll call it if there is no connection with the server. If there is connection we are going to use the mqtt.loop() function that will maintain the connectivity with our server. Apart of this two functions we also have the updateInputs() funcion that will update the real value of the inputs at every loop.

Let's go deeper in the functions to have a better understating of what they do:

• OUTPUTS MANAGEMENT:

Firs of all, we have the reconnect() function that will subscribe to the "Q" and "A" topics. One topic is dedicated to analog outputs ("A") and the other one ("Q") is dedicated to the digital outputs. If the M-Duino PLC is not connected to the server, then they will stop the client connection in order not to cause any issues with the server ports. 

The second step is to understand how the outputs' control works. In order to know this, you'll need to look into the callback function. In this program the callback function is receiveMqttMessage(). This function will run every time that we receive a message and it decides if the topic is for the analog or the digital pins. After that, the right function for it is called; setDigitalOutput() function or setAnalgoOutput() function.

The setDigitalOutput() function extracts and analyzes the JSON file, confirms that the zone and the pin exists and then executes the digitalWrite() function to update the desired output. 

The setAnalogOutput() function works exactly the same way.

The ANALOG_OUTPUTS_OFFSET constant is used to offset the value of the analog pins. Analog pins are placed in the positions  5, 6 ,7. This is why the ANALOG_OUTPUTS_OFFSET is 5.

• INPUT MANAGEMENT:

In the main loop we have the function updateInputs()  that will update all the values of the inputs. This function will be comparing all the previous values to the current ones  and if the new values have changed, then the program will publish the new values though MQTT. The digital values will be comparing if there is a 0 or a 1, the function that make this work is updateDigitalInput().

In the analog site the program will compare if the analog value has changed to a number higher than 5. If the current value is higher or lower than the previous one, then the  new value will be published. The function that makes this work is updateAnalogInput().

/*
   Copyright (c) 2019 Boot&Work Corp., S.L. All rights reserved
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Lesser General Public License for more details.
   You should have received a copy of the GNU Lesser General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

// included library depending of M-Duino version 
#ifdef MDUINO_PLUS
#include <Ethernet2.h>
#else
#include <Ethernet.h>
#endif

// libraries needed for MQTT communication
#include <ArduinoJson.h>
#include <PubSubClient.h>
#define MQTT_ID "demo"
#define NUM_ZONES 1
#define NUM_DIGITAL_OUTPUTS_PER_ZONE 5
#define DIGITAL_OUTPUTS_OFFSET 0

const int digitalOutputs[NUM_ZONES][NUM_DIGITAL_OUTPUTS_PER_ZONE] = {
  {Q0_0, Q0_1, Q0_2, Q0_3, Q0_4},    //adapt it to the M-Duino model that you are using
};
#define NUM_ANALOG_OUTPUTS_PER_ZONE 3
#define ANALOG_OUTPUTS_OFFSET 5

const int analogOutputs[NUM_ZONES][NUM_DIGITAL_OUTPUTS_PER_ZONE] = {
  {A0_5, A0_6, A0_7},    //adapt it to the M-Duino model that you are using
};
#define NUM_DIGITAL_INPUTS_PER_ZONE 7
#define DIGITAL_INPUTS_OFFSET 0

const int digitalInputs[NUM_ZONES][NUM_DIGITAL_INPUTS_PER_ZONE] = {
  {I0_0, I0_1, I0_2, I0_3, I0_4, I0_5, I0_6},    //adapt it to the M-Duino model that you are using
};
#define NUM_ANALOG_INPUTS_PER_ZONE 6
#define ANALOG_INPUTS_OFFSET 7
#define ANALOG_INPUTS_THRESHOLD 5 // Filtering threshold

const int analogInputs[NUM_ZONES][NUM_ANALOG_INPUTS_PER_ZONE] = {
  {I0_7, I0_8, I0_9, I0_10, I0_11, I0_12},    //adapt it to the M-Duino model that you are using
};
byte mac[] = { 0xDE, 0xED, 0xBA, 0xFE, 0xFE, 0xAE };
IPAddress broker(10, 0, 3, 21);
unsigned port = 1883;
// Initialize client
EthernetClient client;
PubSubClient mqtt(client);
int digitalInputsValues[NUM_ZONES][NUM_DIGITAL_INPUTS_PER_ZONE];
int analogInputsValues[NUM_ZONES][NUM_ANALOG_INPUTS_PER_ZONE];

////////////////////////////////////////////////////////////////////////////////////////////////////
void setup(){ 
  Ethernet.begin(mac);
  mqtt.setServer(broker, port);
  mqtt.setCallback(receiveMqttMessage);
  // Init variables
  for (int i = 0; i < NUM_ZONES; ++i) {
    for (int j = 0; j < NUM_DIGITAL_INPUTS_PER_ZONE; ++j) {
      digitalInputsValues[i][j] = digitalRead(digitalInputs[i][j]);
    }
    for (int j = 0; j < NUM_ANALOG_INPUTS_PER_ZONE; ++j) {
      analogInputsValues[i][j] = analogRead(analogInputs[i][j]);
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void loop() {
  if (!mqtt.connected()) {
    reconnect();
  } else {
    mqtt.loop();
  }
  updateInputs();
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void updateInputs() {
  for (int i = 0; i < NUM_ZONES; ++i) {
    for (int j = 0; j < NUM_DIGITAL_INPUTS_PER_ZONE; ++j) {
      updateDigitalInput(i, j);
    }
    for (int j = 0; j < NUM_ANALOG_INPUTS_PER_ZONE; ++j) {
      updateAnalogInput(i, j);
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void updateDigitalInput(int zone, int index) {
  int value = digitalRead(digitalInputs[zone][index]);
  if (value != digitalInputsValues[zone][index]) {
    digitalInputsValues[zone][index] = value;
    publishInput(zone, index + DIGITAL_INPUTS_OFFSET, value);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void updateAnalogInput(int zone, int index) {
  int value = analogRead(analogInputs[zone][index]);
  int minValue = value > ANALOG_INPUTS_THRESHOLD ? value - ANALOG_INPUTS_THRESHOLD : 0;
  int maxValue = value < 1023 - ANALOG_INPUTS_THRESHOLD ? value + ANALOG_INPUTS_THRESHOLD : 1023;
  if ((analogInputsValues[zone][index] < minValue) || (analogInputsValues[zone][index] > maxValue)) {
    analogInputsValues[zone][index] = value;
    publishInput(zone, index + ANALOG_INPUTS_OFFSET, value);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void setDigitalOutput(char *payload, unsigned int len) {
  DynamicJsonBuffer json(JSON_OBJECT_SIZE(3));
  JsonObject &root = json.parseObject(payload, len);
  if (root.success()) {
    int zone = root["zone"];
    if (zone >= NUM_ZONES) {
      // Invalid zone
      return;
    }
    int index = root["index"];
    index -= DIGITAL_OUTPUTS_OFFSET;
    if (index >= NUM_DIGITAL_OUTPUTS_PER_ZONE) {
      // Invalid digital output
      return;
    }
    int value = root["value"];
    digitalWrite(digitalOutputs[zone][index], value);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void setAnalogOutput(char *payload, unsigned int len) {
  DynamicJsonBuffer json(JSON_OBJECT_SIZE(3));
  JsonObject &root = json.parseObject(payload, len);
  if (root.success()) {
    int zone = root["zone"];
    if (zone >= NUM_ZONES) {
      // Invalid zone
      return;
    }
    int index = root["index"];
    index -= ANALOG_OUTPUTS_OFFSET; 
    if (index >= NUM_ANALOG_OUTPUTS_PER_ZONE) {
      // Invalid analog output
      return;
    }
    int value = root["value"];
    analogWrite(analogOutputs[zone][index], value);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void reconnect() {
  if (mqtt.connect(MQTT_ID)) {
    mqtt.subscribe("Q");
    mqtt.subscribe("A");
  } else {
    // MQTT connect fail
    client.stop();
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void receiveMqttMessage(char* topic, byte* payload, unsigned int len) {
  if (strcmp(topic, "Q") == 0) {
    // Set digital output
    setDigitalOutput((char*) payload, len);
  } else if (strcmp(topic, "A") == 0) {
    // Set analog output
    setAnalogOutput((char*) payload, len);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void publishInput(int zone, int index, int value) {
  DynamicJsonBuffer json(JSON_OBJECT_SIZE(3));
  JsonObject &root = json.createObject();
  if (root.success()) {
    root["zone"] = zone;
    root["index"] = index;
    root["value"] = value;
    publish("I", root);
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void publish(const char *topic, JsonObject &root) {
  unsigned len = root.measureLength();
  if (len > 0) {
    char *payload = new char[len + 1];
    if (payload) {
      root.printTo(payload, len + 1);
      publish(topic, payload);
      delete[] payload;
    }
  }
}

////////////////////////////////////////////////////////////////////////////////////////////////////
void publish(const char *topic, const char *payload) {
  if (mqtt.connected()) {
    mqtt.publish(topic, payload);
  }
}

In the previous chapters we have seen how to install Node-RED in our computer and a useful Arduino code for Industrial Shields PLCs .  This code w ill be referred to during the entire course and we will be interacting with it to debug our own programs. 

In this chapter  #2, we are going to step forward and we are going to see how to visualize the input values of our M-Duino in a Dashboard. 

The first step is to install the stable version of Node-RED-Dashboards API. Remember that Node-RED-Dashboard requires Node-RED to be installed.

Go to the terminal and go to the directory where Node-RED was installed in:

 cd .node-red

The next step is typing the command to install the Node-RED-Dashboard:

  npm node-red-dashboard

If you want more information about the Node-RED-Dashboard take a look in the following link:      Node-RED-Dashboard

RUNNING NODE-RED 

Once Node-RED-Dashboard is installed we can proceed to start out firs program. 

First of all, we will learn how to execute and work with Node-RED. If you have installed Node-RED you can use the following command: 

node-red