Hardware Required
Software Used
Library Used
Arduino Client for MQTT
Wire Library
Uploading the code to ESP32 using Arduino IDE
Serial Monitor Output
Making Ubidots Work
Output

Published June 26, 2019 © GPL3+

Ubidots, ESP32 and Long Range Wireless Vibration & Temp

In this project, we will measure vibration and temperature using NCD vibration and temperature sensor, ESP32, and Ubidots.

IntermediateProtip2 hours1,729

Ubidots, ESP32 and Long Range Wireless Vibration & Temp

Things used in this project

Hardware components

National Control Devices ESP32 IoT WiFi BLE Module with Integrated USB

National Control Devices IoT Long Range Wireless Vibration And Temperature Sensor

National Control Devices Long Range Wireless Mesh Modem with USB Interface

Software apps and online services

Arduino IDE

NI LabView Utility

Ubidots

Story

Vibration is truly a to and fro movement—or oscillation—of machines and components in motorized gadgets. Vibration in the industrial system may be a symptom, or motive, of a hassle, or it can be associated with everyday operation. For instance, oscillating sanders and vibratory tumblers depend upon vibration to feature. Internal combustion engines and tools drive, then again, revel in a sure amount of unavoidable vibration. Vibration can imply a hassle and if left unchecked can cause harm or expedited deterioration. Vibration can be resulting from one or extra factors at any given time, the maximum not unusual being an imbalance, misalignment, put on, and looseness.This damage can be minimize by analyzing Temperature and Vibration Data on Ubidots using esp32 and NCD wireless vibration and temperature sensor.

Hardware Required

ESP-32: The ESP32 makes it easy to use the Arduino IDE and the Arduino Wire Language for IoT applications. This ESp32 IoT Module combines Wi-Fi, Bluetooth, and Bluetooth BLE for a variety of diverse applications. This module comes fully-equipped with 2 CPU cores that can be controlled and powered individually, and with an adjustable clock frequency of 80 MHz to 240 MHz. This ESP32 IoT WiFi BLE Module with Integrated USB is designed to fit in all ncd.io IoT products.
IoT Long Range Wireless Vibration And Temperature Sensor: IoT Long Range Wireless Vibration And Temperature Sensor is battery operated and wireless, meaning that current or communication wires need not be pulled to get it up and operating. It tracks the vibration information of your machine constantly and captures and operate hours at full resolution together with other temperature parameters.In this we are using NCD’s Long Range IoT Industrial wireless vibration and temperature sensor, boasting up to a 2 Mile range using a wireless mesh networking architecture.
Long Range Wireless Mesh Modem with USB Interface

Software Used

Arduino IDE
Ubidot

Library Used

PubSubClient Library
Wire.h

Arduino Client for MQTT

This library provides a client for doing simple publish/subscribe messaging with a server that supports MQTT

For more information about MQTT, visit mqtt.org.

Download

The latest version of the library can be downloaded from GitHub

Documentation

The library comes with a number of example sketches. See File > Examples > PubSubClient within the Arduino application.Full API Documentation.

Compatible Hardware

The library uses the Arduino Ethernet Client api for interacting with the underlying network hardware. This means it Just Works with a growing number of boards and shields, including:

Arduino Ethernet
Arduino Ethernet Shield
Arduino YUN – use the included YunClient in place of EthernetClient, and be sure to do a Bridge.begin() first
Arduino WiFi Shield - if you want to send packets greater than 90 bytes with this shield, enable the MQTT_MAX_TRANSFER_SIZE option in PubSubClient.h.
Sparkfun WiFly Shield – when used with this library.
Intel Galileo/Edison
ESP8266
ESP32The library cannot currently be used with hardware based on the ENC28J60 chip – such as the Nanode or the Nuelectronics Ethernet Shield. For those, there is an alternative library available.

Wire Library

The Wire library allows you to communicate with I2C devices, often also called "2 wire" or "TWI" (Two Wire Interface), can download from Wire.h.

Basic Usage

Wire.begin()Begin using Wire in master mode, where you will initiate and control data transfers. This is the most common use when interfacing with most I2C peripheral chips.
Wire.begin(address)Begin using Wire in slave mode, where you will respond at "address" when other I2C masters chips initiate communication.

Transmitting

Wire.beginTransmission(address)Start a new transmission to a device at "address". Master mode is used.
Wire.write(data)Send data. In master mode, beginTransmission must be called first.
Wire.endTransmission()In master mode, this ends the transmission and causes all buffered data to be sent.

Receiving

Wire.requestFrom(address, count)Read "count" bytes from a device at "address". Master mode is used.
Wire.available()Retuns the number of bytes available by calling receive.
Wire.read()Receive 1 byte.

Steps to send data to labview vibration and temperature platform using IoT Long Range Wireless Vibration and Temperature Sensor and Long Range Wireless Mesh Modem with USB Interface:

First, we need a Labview utility application which is ncd.io Wireless Vibration and Temperature Sensor.exe file on which data can be viewed.
This Labview software will work with ncd.io wireless Vibration Temperature sesnor only
To use this UI, you will need to install following drivers Install run time engine from here 64bit
32 bit
Install NI Visa Driver
Install LabVIEW Run-Time Engine and NI-Serial Runtime.
Getting started guide for this product.

Uploading the code to ESP32 using Arduino IDE:

Download and include the PubSubClient Library and Wire.h Library.
You must assign your unique Ubidots TOKEN, MQTTCLIENTNAME, SSID (WiFi Name) and Password of the available network.
Compile and upload the Ncd__vibration_and_temperature.ino code.
To verify the connectivity of the device and the data sent, open the serial monitor.If no response is seen, try unplugging your ESP32 and then plugging it again. Make sure the baud rate of the Serial monitor is set to the same one specified in your code 115200.

Serial Monitor Output

Making Ubidots Work

Create the account on Ubidots.
Go to my profile and note down the token key which is a unique key for every account and paste it to your ESP32 code before uploading.
Add a new device to your ubidot dashboard name ESP32.

Click on devices and select devices in ubidot.

Now you should see the published data in your Ubidots account, inside the device called "ESP32".

Inside device create new variable name sensor in which your temperature reading will be shown.

Create New variable

Now you are able to view the Temperature and other sensors data which was previously viewed in serial monitor.This happened because the value of different sensor readings is passed as a string and store in variable and publish to variable inside device esp32 .

Create dashboard in ubidots.

Go to data select dashboard and inside dashboard create different widgets and add new widget to your dashboard screen.

Output

Ncd_vibration_and_temperature.ino

///this code is written and tested for ncd.io IoT Long Range Wireless Vibration Temperature with arduino due
///sensor data structure can be found here https://store.ncd.io/product/long-range-iot-wireless-vibration-temperature-sensor/
/// sensor can be found here https://ncd.io/long-range-iot-wireless-vibration-sensor-product-manual/

#include <HardwareSerial.h>
//HardwareSerial Serial1(1); // use uart2
#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#define WIFISSID "xyz" // Put your WifiSSID here
#define PASSWORD "xyz" // Put your wifi password here
#define TOKEN "xyz" // Put your Ubidots' TOKEN
#define MQTT_CLIENT_NAME "xyz" // MQTT client Name, please enter your own 8-12 alphanumeric character ASCII string; 
//it should be a random and unique ascii string and different from all other devices

/****************************************
   Define Constants
 ****************************************/
#define VARIABLE_LABEL "sensor"// Assing the variable label
#define VARIABLE_LABEL1 "AdcValue"
#define VARIABLE_LABEL2 "Battery"
#define VARIABLE_LABEL3 "RMS_X"
#define VARIABLE_LABEL4 "RMS_Y"
#define DEVICE_LABEL "esp32" // Assig the device label
uint8_t data[54];
int k = 10;
int i;
char mqttBroker[]  = "industrial.api.ubidots.com";
char payload[100];
char topic[150];
char topic2[150];
char topic3[150];
char topic4[150];
char topic5[150];
// Space to store values to send
char str_sensor[10];
char str_sensorbat[10];
char str_sensorAdc[10];
char  str_sensorRmsx[10];
char  str_sensorRmsy[10];
/****************************************
   Auxiliar Functions
 ****************************************/
WiFiClient ubidots;
PubSubClient client(ubidots);

void callback(char* topic, byte* payload, unsigned int length) {
  char p[length + 1];
  memcpy(p, payload, length);
  p[length] = NULL;
  String message(p);
  Serial.write(payload, length);
  Serial.println(topic);
}

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) {
    Serial.println("Attempting MQTT connection...");

    // Attemp to connect
    if (client.connect(MQTT_CLIENT_NAME, TOKEN, "")) {
      Serial.println("Connected");
    } else {
      Serial.print("Failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 2 seconds");
      // Wait 2 seconds before retrying
      delay(2000);
    }
  }
}
void setup()
{
  Serial.begin(115200);
  WiFi.begin(WIFISSID, PASSWORD);
  // Assign the pin as INPUT
  Serial1.begin(115200, SERIAL_8N1, 16, 17); // pins 16 rx2, 17 tx2, 19200 bps, 8 bits no parity 1 stop bit
  Serial.begin(9600);
  Serial.println("ncd.io IoT ESP32 Vibration Temperature sensor");

  Serial.println();
  Serial.print("Wait for WiFi...");

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }

  Serial.println("");
  Serial.println("WiFi Connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  client.setServer(mqttBroker, 1883);
  client.setCallback(callback);

}
void loop() {
  if (!client.connected()) {
    reconnect();
  }


  data[0] = Serial1.read();
  delay(k);
  if (data[0] == 0x7E)
  {
    while (!Serial1.available());
    for ( i = 1; i < 54; i++)
    {
      data[i] = Serial1.read();
      delay(1);
    }
    if (data[15] == 0x7F) /////// to check if the recive data is correct
    {
      if (data[22] == 0x08) //////// make sure the sensor type is correct
      {
        int16_t rms_x = ((uint16_t)(((data[24]) << 16) + ((data[25]) << 8) + (data[26])) / 100);
        int16_t rms_y = ((uint16_t)(((data[27]) << 16) + ((data[28]) << 8) + (data[29])) / 100);
        int16_t rms_z = ((uint16_t)(((data[30]) << 16) + ((data[31]) << 8) + (data[32])) / 100);

        int16_t max_x = ((uint16_t)(((data[33]) << 16) + ((data[34]) << 8) + (data[35])) / 100);
        int16_t max_y = ((uint16_t)(((data[36]) << 16) + ((data[37]) << 8) + (data[38])) / 100);
        int16_t max_z = ((uint16_t)(((data[39]) << 16) + ((data[40]) << 8) + (data[41])) / 100);

        int16_t min_x = ((uint16_t)(((data[42]) << 16) + ((data[43]) << 8) + (data[44])) / 100);
        int16_t min_y = ((uint16_t)(((data[45]) << 16) + ((data[46]) << 8) + (data[47])) / 100);
        int16_t min_z = ((uint16_t)(((data[48]) << 16) + ((data[49]) << 8) + (data[50])) / 100);


        int cTemp = ((((data[51]) * 256) + data[52]));
        float battery = ((data[18] * 256) + data[19]);
        float voltage = 0.00322 * battery;
        Serial.print("Sensor Number  ");
        Serial.println(data[16]);
        Serial.print("Sensor Type  ");
        Serial.println(data[22]);
        Serial.print("Firmware Version  ");
        Serial.println(data[17]);
        Serial.print("Temperature in Celsius :");
        Serial.print(cTemp);
        Serial.println(" C");

        Serial.print("RMS vibration in X-axis :");
        Serial.print(rms_x);
        Serial.println(" mg");
        Serial.print("RMS vibration in Y-axis :");
        Serial.print(rms_y);
        Serial.println(" mg");
        Serial.print("RMS vibration in Z-axis :");
        Serial.print(rms_z);
        Serial.println(" mg");

        Serial.print("Min vibration in X-axis :");
        Serial.print(min_x);
        Serial.println(" mg");
        Serial.print("Min vibration in Y-axis :");
        Serial.print(min_y);
        Serial.println(" mg");
        Serial.print("Min vibration in Z-axis :");
        Serial.print(min_z);
        Serial.println(" mg");

        Serial.print("ADC value:");
        Serial.println(battery);
        Serial.print("Battery Voltage:");
        Serial.print(voltage);
        Serial.println("\n");
        if (voltage < 1)
        {
          Serial.println("Time to Replace The Battery");
        }
        dtostrf(cTemp, 4, 2, str_sensor);
        dtostrf(battery, 4, 2, str_sensorAdc);
        dtostrf(voltage, 4, 2, str_sensorbat);
        dtostrf(rms_x, 4, 2, str_sensorRmsx);
        dtostrf(rms_y, 4, 2, str_sensorRmsy);
      }
    }
    else
    {
      for ( i = 0; i < 54; i++)
      {
        Serial.print(data[i]);
        Serial.print(" , ");
        delay(1);
      }
    }
  }
    sprintf(topic, "%s", ""); // Cleans the topic content
    sprintf(topic, "%s%s", "/v1.6/devices/", DEVICE_LABEL);

    sprintf(payload, "%s", ""); // Cleans the payload content
    sprintf(payload, "{\"%s\":", VARIABLE_LABEL); // Adds the variable label   
    sprintf(payload, "%s {\"value\": %s", payload, str_sensor); // Adds the value
    sprintf(payload, "%s } }", payload); // Closes the dictionary brackets
    client.publish(topic, payload);
    
    sprintf(topic2, "%s", ""); // Cleans the topic content
    sprintf(topic2, "%s%s", "/v1.6/devices/", DEVICE_LABEL);

    sprintf(payload, "%s", ""); // Cleans the payload content
    sprintf(payload, "{\"%s\":", VARIABLE_LABEL1); // Adds the variable label   
    sprintf(payload, "%s {\"value\": %s", payload, str_sensorAdc); // Adds the value
    sprintf(payload, "%s } }", payload); // Closes the dictionary brackets
    
    client.publish(topic2, payload);
    sprintf(topic3, "%s", ""); // Cleans the topic content
    sprintf(topic3, "%s%s", "/v1.6/devices/", DEVICE_LABEL);

    sprintf(payload, "%s", ""); // Cleans the payload content
    sprintf(payload, "{\"%s\":", VARIABLE_LABEL2); // Adds the variable label   
    sprintf(payload, "%s {\"value\": %s", payload,  str_sensorbat); // Adds the value
    sprintf(payload, "%s } }", payload); // Closes the dictionary brackets
    
    client.publish(topic3, payload);
    sprintf(topic4, "%s", ""); // Cleans the topic content
    sprintf(topic4, "%s%s", "/v1.6/devices/", DEVICE_LABEL);

    sprintf(payload, "%s", ""); // Cleans the payload content
    sprintf(payload, "{\"%s\":", VARIABLE_LABEL3); // Adds the variable label   
    sprintf(payload, "%s {\"value\": %s", payload,  str_sensorRmsx); // Adds the value
    sprintf(payload, "%s } }", payload); // Closes the dictionary brackets
    
    client.publish(topic4, payload);
     sprintf(topic5, "%s", ""); // Cleans the topic content
    sprintf(topic5, "%s%s", "/v1.6/devices/", DEVICE_LABEL);

    sprintf(payload, "%s", ""); // Cleans the payload content
    sprintf(payload, "{\"%s\":", VARIABLE_LABEL4); // Adds the variable label   
    sprintf(payload, "%s {\"value\": %s", payload,  str_sensorRmsy); // Adds the value
    sprintf(payload, "%s } }", payload); // Closes the dictionary brackets
    
    client.publish(topic5, payload);
    client.loop();
    delay(1000);
}

Credits

Manish Jugran

38 projects • 7 followers

An IoT developer, want to connect different sensors to the cloud, automate your business and company using the Internet of Things.

Contact

Comments

Please log in or sign up to comment.

Ubidots, ESP32 and Long Range Wireless Vibration & Temp