Think Different: How to start with real time data analysis

unplush

I can explain how to do real-time IoT sensor data analysis with Arduino Uno, MQTT, Node-RED, and ThingSpeak.

Some details about Arduino Uno, MQTT, and Node-RED:

Arduino Uno is an open-source microcontroller board based on the ATmega328P microcontroller. It is a popular choice for IoT projects because it is relatively inexpensive and easy to use.

MQTT is a lightweight messaging protocol that is often used for IoT applications. It is a publish/subscribe protocol, which means that clients can publish messages to topics and other clients can subscribe to topics to receive messages.

Node-RED is a visual programming tool that can be used to create flows to control IoT devices and visualize data. It is a popular choice for IoT projects because it is easy to learn and use.

Here are some links to learn more about these technologies:

Arduino Uno: https://www.arduino.cc/en/Main/ArduinoBoardUno
MQTT: https://mqtt.org/
Node-RED: https://nodered.org/

The following are the steps involved:

Connect the sensors to the Arduino Uno. The sensors will need to be connected to the Arduino Uno’s digital or analogue pins.
Write the Arduino code to read the sensor data and publish it to MQTT. The Arduino code will need to use the MQTT client library to publish the sensor data to an MQTT broker.
Configure the MQTT broker. The MQTT broker will need to be configured to accept messages from the Arduino.
Create a Node-RED flow to subscribe to the MQTT topic and visualize the data. Node-RED is a visual programming tool that can be used to create flows to subscribe to MQTT topics and visualize the data.
Create a ThingSpeak channel to store the data. ThingSpeak is a data analytics platform that can store and visualize data.

Switch configuration:

Here is an example of how to do this:

Connect a temperature sensor to the Arduino Uno’s analogue pin A0.
Write the Arduino code to read the temperature sensor data and publish it to MQTT. The code would look something like this:

#include <MQTTClient.h>

const char* ssid = "your_ssid";
const char* password = "your_password";
const char* mqtt_server = "your_mqtt_server";
const int mqtt_port = 1883;

MQTTClient client;

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

  client.begin(mqtt_server, mqtt_port, ssid, password);
  client.onMessageReceived(messageReceived);
}

void loop() {
  client.loop();
}

void messageReceived(MQTTClient* client, char* topic, byte* payload, unsigned int length) {
  Serial.print("Received message on topic: ");
  Serial.println(topic);
  Serial.print("Message: ");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }
  Serial.println();
}

void publishTemperature() {
  float temperature = analogRead(A0) / 1023.0 * 5.0;
  char temperature_str[10];
  dtostrf(temperature, 1, 2, temperature_str);
  client.publish("temperature", temperature_str);
}

void setup() {
  ...
}

void loop() {
  publishTemperature();
  delay(1000);
}

Configure the MQTT broker to accept messages from the Arduino. The MQTT broker configuration will depend on the specific broker that you are using.
Create a Node-RED flow to subscribe to the MQTT topic and visualize the data. The Node-RED flow would look something like this:

[mqtt in]
topic: temperature

[debug]
message: payload

Create a ThingSpeak channel to store the data. The ThingSpeak channel configuration will depend on the specific channel that you are creating.

Once you have completed these steps, you can see the sensor data in real time in Node-RED and ThingSpeak.

To send data from an Arduino Uno to a server using an ESP8266 module, you can follow these steps. In this example, we'll assume you're using the ESP8266 module as a Wi-Fi module and want to send data via HTTP.

1. Connect Arduino Uno and ESP8266:

- Connect the Arduino Uno to the ESP8266 using serial communication (UART). You will need to cross-connect the TX and RX pins. Ensure that both devices share a common ground.

2. Program the ESP8266:

- Use the Arduino IDE to program the ESP8266 module. You can use the ESP8266 AT firmware and send AT commands from the Arduino Uno to configure the ESP8266.

- Upload a basic script to the ESP8266 that sets it up as a Wi-Fi client and connects to your Wi-Fi network. You'll need to provide your network SSID and password.

- You can use the `SoftwareSerial` library on the Arduino Uno to communicate with the ESP8266 via AT commands.

3. Send Data from Arduino to ESP8266:

- In your Arduino code, you can read data from the DHT22 temperature sensor and the voltage sensor.

- Use the `Serial` library to send data to the ESP8266 via the serial connection. For example, you might send a string with the sensor values as a JSON payload.

<code>

```arduino

#include <DHT.h>

#define DHTPIN 2 // Digital pin connected to the DHT22 sensor

#define DHTTYPE DHT22

DHT dht(DHTPIN, DHTTYPE);

void setup() {

Serial.begin(9600);

dht.begin();

}

void loop() {

// Read temperature and humidity from DHT22

float temperature = dht.readTemperature();

float humidity = dht.readHumidity();

// Read voltage from your voltage sensor

float voltage = analogRead(A0) * 0.0048828125; // Adjust this value based on your sensor calibration

// Create a JSON string with the sensor values

String data = "{\"temperature\":" + String(temperature, 2) + ",\"humidity\":" + String(humidity, 2) + ",\"voltage\":" + String(voltage, 2) + "}";

// Send the data to the ESP8266

Serial.println(data);

delay(5000); // Delay for 5 seconds before the next reading

}

```

</code>

<code>

Another code example below.

#include <ESP8266WiFi.h>

#include <DHT.h>

#include <TimeLib.h>

#include <DS1307RTC.h>

#include <EmonLib.h>

EnergyMonitor emon1;

#define DHTPIN 4 // Define the DHT sensor pin

DHT dht(DHTPIN, DHT22);

const char* ssid = "Your_SSID";

const char* password = "Your_Password";

const char* host = "flask-bot-xabor.amvera.io";

const int port = 80;

const char* apiKey = "Your_API_Key";

void setup() {

Serial.begin(115200);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(1000);

Serial.println("Connecting to WiFi...");

}

dht.begin();

emon1.current(0, 60); // Setup emon library

emon1.voltage(AC_VOLTAGE, 235, 1.7);

setSyncProvider(RTC.get);

}

void loop() {

float supplyVoltage = emon1.Vrms;

float humidity = dht.readHumidity();

float temperature = dht.readTemperature();

int rssi = WiFi.RSSI();

if (isnan(humidity) || isnan(temperature)) {

Serial.println("DHT sensor reading error.");

delay(10000);

return;

}

Serial.print("Humidity: ");

Serial.println(humidity);

Serial.print("Temperature: ");

Serial.println(temperature);

Serial.print("Voltage: ");

Serial.println(supplyVoltage);

Serial.print("RSSI: ");

Serial.println(rssi);

if (timeStatus() == timeSet && now() % 30 == 0) {

sendData(humidity, temperature, supplyVoltage);

getRSSI();

}

void sendData(float humidity, float temperature, float supplyVoltage) {

String url = "/update?api_key=" + String(apiKey) + "&field1=" + String(humidity) + "&field2=" + String(temperature) + "&field3=" + String(supplyVoltage);

String request = "GET " + url + " HTTP/1.1\r\nHost: " + host + "\r\n\r\n";

Serial.println("Connecting to server...");

WiFiClient client;

if (client.connect(host, port)) {

Serial.println("Connected to server");

client.print(request);

while (client.connected()) {

if (client.available()) {

String line = client.readStringUntil('\r');

Serial.print(line);

}

client.stop();

Serial.println("Connection closed");

} else {

Serial.println("Connection to server failed.");

}

void getRSSI() {

int rssi = WiFi.RSSI();

Serial.println("RSSI: " + String(rssi));

delay(1000);

}

</code>

4. ESP8266 to Server Communication:

- On the ESP8266, you need to write code to receive data from the Arduino Uno and send it to your server via an HTTP POST request. You can use the ESP8266WiFi and ESP8266HTTPClient libraries to do this.

- The ESP8266 should parse the data from the Arduino, connect to your server's endpoint, and send the data in the format expected by your server.

Here's an example of how to send an HTTP POST request from the ESP8266:

```arduino

#include <ESP8266WiFi.h>

#include <ESP8266HTTPClient.h>

const char* ssid = "YourSSID";

const char* password = "YourPassword";

const char* serverURL = "https://yourserver.com/api/endpoint"; // Replace with your server's URL

void setup() {

Serial.begin(115200);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

delay(1000);

Serial.println("Connecting to WiFi...");

}

void loop() {

if (Serial.available()) {

String data = Serial.readStringUntil('\n');

HTTPClient http;

http.begin(serverURL);

http.addHeader("Content-Type", "application/json");

int httpResponseCode = http.POST(data);

if (httpResponseCode > 0) {

String response = http.getString();

Serial.println("HTTP Response Code: " + String(httpResponseCode));

Serial.println("Server response: " + response);

} else {

Serial.println("HTTP Error");

}

http.end();

}

```

5. Server-Side Handling:

- Ensure that your server is set up to receive and process the data sent by the ESP8266.

- The server should expect POST requests with JSON payloads, parse the data, and store it or perform any required actions.

6. Monitor Serial Output:

- Debug and monitor the serial output from both the Arduino Uno and ESP8266 to identify any issues.

Remember to adapt the code to your specific needs and hardware connections. Ensure that you have the necessary libraries installed in your Arduino IDE, including ESP8266 libraries and DHT sensor libraries if required. Additionally, replace placeholders like "YourSSID," "YourPassword," and "https://yourserver.com/api/endpoint" with your actual network credentials and server information.

I found this article very handy if you are a beginner for this board and ESP8266

I am a Software Architect | AI, Data Science, IoT, Cloud ⌨️ 👨🏽 💻

I love to learn and share the knowledge. Thank you.