Through a series of posts, we are detailing how to make your NCD sensors AI-enabled with Elipsa.
In the last blog post, we walked through the steps of configuring the NCD IoT Predictive Maintenance Sensor V3 in Node-Red. In this post, we will continue with Node-Red to stream this sensor data to Elipsa to easily build predictive maintenance models for intelligent real-time monitoring.
To utilize Elipsa, you will first need an Elipsa Access Key which you can get for free here.
Step 1: Utilize Elipsa's NCD Predictive Maintenance Template
Elipsa’s Rapid Deployment Templates are the simplest and fastest approach to building and deploying AI-based predictive maintenance models at scale.
Elipsa's NCD AI Template, enables NCD customers to quickly add predictive insights to their NCD sensor data.
Elipsa's NCD Template
To use the NCD template for monitoring your equipment, it’s as simple as selecting the template and copying it to your Elipsa profile:
Find the template at https://www.elipsa.ai/templates
Click on the NCD template. This will bring you back up to the form at the top with the API Key of the public template pre-populated. Enter your username and access key
Click Copy Template. Once the template is copied to your account, a new API key will appear. Document this new key as this will be the API key that you utilize to build your predictive maintenance models.
By default, this template is configured to monitor data points named x, y, and z to match the vibration data from the NCD sensor. As described in our blog explaining our AI templates, Elipsa will collect and learn from your machine's streaming data until an initial model is built after 2,880 data points are received (~2 days). Elipsa will automatically retrain your machine's monitoring model after 43,200 data points are received (~1 month).
With the template saved to your account, you can now begin streaming live data from your sensor. In fact, you can now utilize this single API to automatically build machine learning based predictive maintenance models for any number of machines that utilize 3-axis vibration data.
Custom AI Templates
In addition to selecting a template from the library, you can create custom templates to match your specific data points being monitored or to adjust the training data requirements. For our testing, instead of using the default NCD template, we built custom template to see if we can build a successful AI monitoring model with only a few hours worth of training.
Step 2: Stream Data to Elipsa Using Node-Red
With your new template API key in hand, calling the Elipsa APIs in Node-Red is as simple as using an HTTP Request node. Prior to that, we need to re-format the msg.payload in Node-Red to match the expected JSON format that Elipsa will receive. Additionally, we must make sure that the NCD sensor is setup to report the processed data that we are expecting.
The NCD sensor, has the ability to collect raw X,Y, Z axis vibration readings every few seconds, or to aggregate them into a processed data stream showing a variety of statistical vibration readings such as max and RMS that are reported to Node-Red every minute.
For this test we are going to be using the maximum acceleration and thus we need to ensure that the sensor is in Processed mode. To do this, go back to the Step 1 post and in the sensor configuration, ensure that the Mode is set to Processed. If it is not, select Processed from the dropdown and follow the steps in the post to push the new config to the sensor.
The Elipsa API expects to receive four types of information in the JSON payload:
Your Elipsa access key used to authenticate your connection
The Unique name or ID of the machine being monitored. This piece of information is critical as it allows you to use the same API endpoint for multiple machines of the same type simply by changing the unique ID of the machine you are sending data for
Whether the data is sent in a batch or not. In most use cases, data is streamed as individual real-time points. However, in certain use cases, such as monitoring the raw vibration data of an NCD sensor, we are able to send batches of data in a single API call.
Finally, the streaming data itself
In our use case, we will be sending a single set of data points every one minute. As a result, the model will not be called in batch mode. Configuring the msg.payload for non-batch mode and sending it to Elipsa can be handled in Node-Red in two simple steps:
Add and Configure Function Node
Drag a ‘Function’ node into your wire sheet.
On the properties sheet, Enter the following code:
var data = msg.payload;
//CONSTRUCT OBJECT TO SEND TO ELIPSA
msg.payload = {
"access_key":"your-access-key",
"unique_id":"unique-id-of-machine",
"batch":"N",
"Data": {
"x": data.sensor_data.x_max_ACC_G,
"y": data.sensor_data.y_max_ACC_G,
"z": data.sensor_data.z_max_ACC_G
}
};
return msg; As you can see above, we are utilizing the processed max acceleration value over the one minute period for each axis and training an AI model on those values.
The code builds out the message payload that Elipsa is expecting. Simply copy this code into Node-Red and replace it with your access key and the unique ID you are assigning the machine being monitored by this sensor.
Add and Configure HTTP Request
With the msg.payload in the correct format, we now look to send the data to Elipsa via a REST API. This is done through an HTTP Request node.
Drag the HTTP Request node into your wire sheet
On the properties page, Select POST as the method
For the URL enter (replacing the string after the final / with the access key recorded when you created the template: https://api.elipsa.ai:9090/graphdb/api/v1.0/deployments/template/your-template-api-key
Next to Return select ‘a parsed JSON object’
Note: another option for streaming data to Elipsa is to utilize the custom Elipsa Predictive Maintenance node which you can install via Node-Red. The steps above are for utilizing native Node-Red nodes but you can utilize the video here to learn more about how to utilize the Elipsa node instead.
Finally, connect the output of your function node to the input of the HTTP Request node. We also suggest connecting the output of HTTP Request to a debug node to monitor the response from Elipsa. Click Deploy.
Once the Wireless Gateway is connected to the function node, Node-Red will be collecting vibration readings every minute from your sensor, formatting that data into the correct msg.payload and steaming it to Elipsa.
Note: your sensor should be on and connected to the machine before you connect the Wireless Gateway to the function node and start streaming live data to Elipsa.
AI Based Predictive Maintenance in Practice
Now that we have walked through how to configure your NCD Predictive Maintenance sensor and how to start intelligently monitoring it through Elipsa AI, let’s test it out to see it in practice.
Using our NCD Predictive Maintenance sensor, we connected the vibration probe to the enclosure of an industrial fan capable of running at 3 distinct speeds. Push and release the reset button on the sensor to recalibrate it and turned the fan on to the lowest speed.
Back in Node-Red, we connect the Wireless Gateway Node to the function node that we added to reformat our data. When the NCD sensor next transmits data to Node-Red, it is transformed, sent to Elipsa, and receives a response back in Node-Red with the initial message of “Model Created: Ready to Stream Data”.
Every minute, as the sensor transmits new data to Node-Red, it is reformatted, passed to Node-Red and then to Elipsa, returning the status of the learning process and how many additional data points are needed before the initial model is built. Note: during this time, the prediction and confidence of there being a problem is always returned as 0 since the model is still learning.
After only 100 minutes, Elipsa takes the collected data points and automatically builds the initial AI-based Predictive Maintenance model with no additional requirements from the user. At this point, the status message informs the user that we are now making predictions against the original model while waiting to collect enough data to retrain.
Results
With the initial model built, we simulated a problem by changing the speed of the fan between the second and third settings and eventually turning the machine off (similar behavior to a potential failure of the fan itself). The idea was to determine whether we could detect a change in the state of the machine or a behavioral change indicative of failure simply through vibration, and more importantly with only a limited size data set.
As you can see from the Elipsa Dashboard above, when the fan speed increased (indicated by the vertical dotted blue line), the vibration profile changes as well. Because the new profile was outside of what the AI learned as normal, a prediction of an anomaly was triggered.
Note: when a model is being trained Elipsa returns a prediction of -1 as you can see by the vertical dotted blue line in the chart above
In our test, predictions were fed back into Node-Red for the user while also available in the Elipsa Dashboard. Via Node-Red, or via our Decision Flow engine, the insights could be utilized for a variety of value added tasks from notifying a technician, to changing the setting on a given machine, and even to feeding another AI algorithms for further intelligent automation and monitoring.
Conclusion
The integration of Elipsa into NCD sensors is simple, fast, and flexible. It is the easiest way to take a vibration sensor and generate actionable AI insights.
The example we gave in this post demonstrated how to stream data to Elipsa using our simple REST APIs. We exhibited this in Node-Red but the same APIs can be used from any application capable of making an HTTP request. In a future post, we will detail how to also integrate with Elipsa using MQTT,
The data generated from the NCD sensors is extremely valuable, but combined with Elipsa’s automated machine learning engine, the joint solution creates even more value in the form of predictive insights designed to eliminate downtime, increase operating efficiency, and reduce the overall cost of quality.
Elipsa is a leader in delivering fully automated, scalable AI solutions for industrial IoT applications. Elipsa’s AI-based, Predictive Maintenance seamlessly deploys across any workflow on the edge or in the cloud, increasing the availability and output of critical equipment. Elipsa’s self-training AI models and bolt-on approach enable AI deployments that are simple, fast, and flexible. To learn more, please visit https://www.elipsa.ai