Sentinel: Industry 4.0 Smart Monitoring Node

by Ameya Angadi in Circuits > Microcontrollers

1393 Views, 18 Favorites, 0 Comments

Sentinel: Industry 4.0 Smart Monitoring Node

Problem Statement Analysis

In modern industrial environments, the "health" of a machine is often invisible until a catastrophic failure occurs. While many IoT solutions attempt to provide predictive maintenance, they frequently suffer from two critical flaws: Hardware Overload and Data Noise. Standard single-chip monitoring systems often crash or experience significant latency when trying to manage high-resolution displays, WiFi stacks, and precise sensor acquisition simultaneously. This leads to "blind spots" where transient mechanical faults are missed. Furthermore, raw accelerometer data is inherently biased by Earth's gravity, making it difficult to isolate true mechanical vibration from the static orientation of the sensor without complex, manual calibration. Finally, many low-cost monitors lack data persistence, meaning service records and next-maintenance schedules are lost every time the power is cycled.

Project Description: The Sentinel Hub

The Sentinel Predictive Maintenance Hub is a monitoring ecosystem designed to bridge the gap between raw mechanical data and actionable industrial intelligence. Unlike traditional single-processor monitors, Sentinel utilizes a dual-node architecture: a Raspberry Pi Pico serves as a dedicated Data Acquisition node, while an ESP32-S3-BOX-3 acts as the intelligent HMI (Human-Machine Interface) and Network Gateway.

The system performs sampling of tri-axis vibration, temperature, humidity, and atmospheric pressure. At its core, the project employs a Dynamic High-Pass Alpha Filter to digitally cancel out the effects of gravity, providing a pure "Linear G-Force" reading that reflects actual mechanical stress. Beyond local monitoring, the Sentinel Hub serves as a WiFi Gateway, hosting a responsive web dashboard that provides remote operators with real-time, color-coded status alerts. With integrated Non-Volatile Storage (NVS), it also functions as a persistent digital logbook, tracking maintenance cycles and service history even through power outages.

Supplies

ESP32-S3-BOX-3
Raspberry Pi Pico
MPU6050
BMP280
DHT11
Jumper Wires
USB-C Cable
Micro USB Cable
2x Breadboard

Hardware Setup

This project utilizes a Distributed Computing Architecture, requiring the assembly of two distinct nodes: the Intelligent HMI (ESP32-S3) and the Sensor DAQ Node (Pi Pico W).

Use the above Circuit Diagram to assemble the circuit.

Assembly of the ESP32-S3-BOX-3 Part

The ESP32-S3-BOX-3 serves as the central hub. It handles the high-resolution display, WiFi stack, and the HTTP Web Server.

Connect the ESP32-S3-BOX-3's display module to the ESP32-S3-BOX-3's BREAD module.

Assembly of the Pi Pico Part

The Raspberry Pi Pico W acts as the high-speed Data Acquisition (DAQ) node. It is responsible for sampling the sensor array and performing required functions to collect and process the data.

Vibration Sensor (MPU6050): Use the dedicated I2C Bus 1 (GPIO 2 - SDA, GPIO 3 - SCL) for maximum isolation.

Connect SDA to GPIO 2 and SCL to GPIO 3.

Environment Sensors (BMP280 & DHT11): Use the I2C Bus 0 (GPIO 4 - SDA, GPIO 5 - SCL)

for the BMP280: SDA to GPIO 4 and SCL to GPIO 5.

Connect the DHT11 Data Pin to GPIO 15.

Connect the power of each sensor pin to the 3V3 Out and GND pins of the pico.

Mechanical Mounting: The MPU6050 must be securely mounted to the machinery being monitored. The High-Pass Alpha Filter logic assumes the sensor is rigidly attached to the vibration source to ensure Signal Integrity.

Connecting the Two Parts (ESP32 - Pico)

UART Connectivity: Connect the communication lines.

RXD1 (GPIO 40): Connect to the Pi Pico TX (GP0).

TXD1 (GPIO 41): Connect to the Pi Pico RX (GP1).

Power Distribution: To ensure WiFi stability and prevent brownouts: Connect the 3V3 Out pin of the ESP32 to the VBUS pin of the Pi Pico, that is the pico will be powered by the ESP32. Ensure a Common Ground (GND) is established between both boards.

HMI Mounting: Ensure the BOX-3 is oriented for easy viewing, as it will provide the primary Real-Time Health Status and NTP-synced clock display.

UI/UX Design & Visual Assets

The visual identity and user interface of the Sentinel Hub were engineered to prioritize readability and operator speed. In an industrial setting, every second counts, so the design focuses on delivering high-contrast, "at-a-glance" information.

Pixel Art Asset Creation in GIMP

To maintain a clean, technical aesthetic that consumes minimal memory on the ESP32, all logos and branding elements were custom-designed as Pixel Art.

Using GIMP (GNU Image Manipulation Program), icons were created at specific resolutions (e.g., 50x50) to ensure they remained sharp on the BOX-3’s display without anti-aliasing blur. By working at the pixel level, we ensured that the Sentinel branding and status indicators were visually distinct even when viewed from a distance or in low-light factory conditions. These assets were exported as regular .png images to optimize the UI.

UI Development With SquareLine Studio

The core interface was architected using SquareLine Studio, a powerful visual tool for the LVGL (Light and Versatile Graphics Library).

The design utilizes a User-Centric (UX) approach, featuring:

Intuitive Layouts: A variety of interactive buttons and sliders (such as the real-time brightness control) that is easy to use.
Descriptive Labels: Every data point is accompanied by well-defined labels and units (e.g. "hPa", "°C") to eliminate ambiguity during high-stress monitoring.
Universal Iconography: By using standardized industrial icons, the UI transcends language barriers, allowing any worker to immediately recognize temperature, vibration, or humidity levels.

Rapid Fault Detection: The UI logic is tied directly to the sensor stream. If the machine deviates from its baseline, the status labels and web server background change color instantly. This allows workers to understand within a fraction of a second if the machine is functioning abnormally, facilitating an immediate safety response.

Critical Setup Note

To match the UI design, you must delete the default lvgl, ui folders, and lv_conf.h from your Documents\Arduino\libraries\ directory. Extract all the files and folders provided in this Zip file Files_To_Copy.zip. Copy all the lvgl, ui folders, and lv_conf.h from this zip file at Documents\Arduino\libraries\ directory.

All these files are available in this Github Repository.

If you wish to modify the UI, extract all files in Sentinel_Design_Files.zip, and then import the project (.spj) file located in the extracted folder using SquareLine Studio. Make the desired changes, followed by using Create template button in Squareline Studio and save this template at the desired location. Further the orignal lvgl, ui folders, and lv_conf.h from your Documents\Arduino\libraries\ directory should be replaced by the new lvgl, ui folders, and lv_conf.h from the library folder of your saved location.

Software Development & Programming

The software for both nodes in the Sentinel Hub was developed using the Arduino IDE, leveraging its vast ecosystem of libraries to manage high-speed data streams and complex graphical rendering.

Part 1: Coding the ESP32-S3-BOX-3 (Sentinel_ESP32.ino)

The central HMI node is programmed via the Sentinel_ESP32.ino sketch. This part of the system manages the LVGL graphics engine, handles WiFi connectivity, and serves the HTTP Web Dashboard.

Required Manual Libraries: To compile this code, the following libraries must be installed manually via the Arduino Library Manager:

LVGL (v8.3.11): Authored by kisvegabor. This is the core graphics library.
ESP_Display_Panel: Authored by Espressif Systems. This provides the hardware-specific drivers for the BOX-3 integrated display. Installation

Configuration

Update your WiFi credentials in the main firmware:

const char* ssid = "";

const char* password = "";

configTime(19800, 0, "pool.ntp.org");

Folder Structure: You must copy the entire folder named Sentinel_ESP to your local directory. This folder contains the main .ino file along with the ui.h, lvgl_v8_port.h and other important files. Board Support: Ensure you have the latest ESP32 Board Library installed in your IDE. IDE Settings: In the Arduino IDE, select the board as ESP32S3 Box. While the "Box 3" specific definition might not be visible in all versions, selecting the standard ESP32S3 Box works perfectly for this hardware without any compatibility issues.

Part 2: Coding the Pico DAQ Node (Sentinel_Pico.ino)

The high-speed sensor acquisition is handled by the Sentinel_Pico.ino sketch. This code is optimized for Digital Signal Processing (DSP) and Serial Data Streaming.

Core & Environment: This node requires the Earle Philhower Pico Core for RP2040 support.

You can follow my detailed tutorial on setting up this core here: Getting Started with Raspberry Pi Pico in Arduino IDE.

Required Manual Libraries: The following libraries by Adafruit Industries must be installed manually. Please ensure you select "Install All Dependencies" when prompted:

DHT Sensor Library: Used for the DHT11 temperature and humidity data.

Adafruit BMP280 Library: Used for high-precision atmospheric pressure readings.

Adafruit MPU6050: Used for the tri-axis accelerometer and vibration monitoring.

Adafruit Unified Sensor: A required base dependency for the sensors above.

By offloading these sensor tasks to the Pi Pico, we ensure that the ESP32-S3 remains completely responsive for user interaction and network requests, preventing the system "hangs" common in single-processor designs.

Remote Monitoring & Web Integration

The Sentinel Hub extends its functionality beyond the physical device by acting as a WiFi Gateway. This allows for remote, real-time monitoring of industrial assets from any workstation on the same network.

Web Server Implementation

The ESP32-S3-BOX-3 hosts a built-in HTTP Web Server. While the internal display updates at a lightning-fast rate, the web server is optimized to serve a Minimalist Dashboard designed for remote oversight.

High-Frequency Data Refresh: The internal web state is updated every 50ms to match the Pico’s vibration stream, ensuring that the data served is always current.

Context-Aware Visual Alerts: The web server utilizes Dynamic CSS. Depending on the health status, the background color of the dashboard automatically transitions between Industrial Gray (Healthy), Safety Orange (Caution), and Vibrant Red (Danger). This creates a highly visible remote alarm system.

Low-Latency Communication: By utilizing a lightweight HTML structure, the server minimizes the processing load on the ESP32, ensuring that serving web requests never interferes with the critical LVGL UI rendering or UART data parsing.

Local HTML Dashboard

To facilitate a professional monitoring station, a Local HTML File was developed to act as the primary interface for PC-based operators.

Iframe Integration: The local file uses an HTML Iframe to pull the live sensor data directly from the ESP32’s IP address. If needed open this file to edit the local IP of the ESP32 here. This method allows us to add multiple Sentinel nodes on a single screen thsu making monitoring very easy.

Auto-Sync Logic: A custom JavaScript loop was implemented to refresh the data every 500 milliseconds. This allows for a steady, reliable stream of telemetry on the computer screen without overwhelming the network bandwidth.

UX Continuity: The remote dashboard mirrors the essential data from the physical BOX-3 screen, including Vibration Magnitude, Temperature, Atmospheric Pressure, and Maintenance Schedules, providing a unified experience for the worker.

The html code file is available with the name "Sentinel Dashboard.html".

Future Improvements

Looking ahead, the Sentinel Hub is designed to be an expandable platform for Industrial IoT (IIoT). A primary next step is the integration of an SD Card Module to enable Local Data Logging, allowing for years of historical telemetry to be archived for audit and trend analysis. This massive dataset of vibration, temperature, and atmospheric pressure will serve as the foundation for training Advanced AI Models.

By utilizing Machine Learning frameworks like TensorFlow Lite, these models could run directly on the ESP32-S3 at the edge or on a centralized Monitoring Laptop to detect subtle patterns in mechanical wear that are invisible to static thresholds.

Conclusion

The Sentinel Predictive Maintenance Hub represents a significant step forward in low-cost, high-reliability industrial monitoring. By moving away from traditional monolithic software designs and embracing a Distributed Computing Architecture, the project successfully solves the common issues of system latency and unexpected machine down-time.

Through the combination of High-Pass Alpha Filtering for gravity-free vibration sensing, Non-Volatile Storage for persistent service logging, and a Dual-Node WiFi Gateway, the Sentinel Hub provides a comprehensive solution for factories. It is more than just a sensor; it is an Intuitive HMI that empowers workers with the data they need to prevent failure before it happens. Whether viewed on the ESP32-S3-BOX-3 display or a remote web dashboard, Sentinel ensures that machine health is always visible, documented, and actionable.

Code

Code for the Pico DAQ Node (Check GitHub Repo):

* Project Name: Sentinel

* Designed For: Raspberry Pi Pico/Pico W

* License: GPL3+

* This project is licensed under the GNU General Public License v3.0 or later.

* You are free to use, modify, and distribute this software under the terms

* of the GPL, as long as you preserve the original license and credit the original

* author. For more details, see <https://www.gnu.org/licenses/gpl-3.0.en.html>.

* Code Created And Maintained By: Ameya Angadi

* Last Modified On: March 30, 2026

* Version: 1.0.0

#include <Wire.h>

#include <DHT.h>

#include <Adafruit_BMP280.h>

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#define DHTPIN 15

DHT dht(DHTPIN, DHT11);

Adafruit_BMP280 bmp(&Wire);

Adafruit_MPU6050 mpu;

// Calibration Globals

float baseMag = 0;

float offX = 0, offY = 0, offZ = 0;

float filtX = 0, filtY = 0, filtZ = 0;

const float alpha = 0.8; // Filter strength (0.8 to 0.9 is best)

void initSensors() {

Wire.end(); Wire1.end();

Wire.setSDA(4); Wire.setSCL(5); Wire.begin();

bmp.begin(0x76);

Wire1.setSDA(2); Wire1.setSCL(3); Wire1.begin();

mpu.begin(0x68, &Wire1);

dht.begin();

}

void calibrateMPU() {

Serial.println("Calibrating... Keep Still!");

float sumX = 0, sumY = 0, sumZ = 0, sumMag = 0;

int samples = 100;

for(int i = 0; i < samples; i++) {

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

sumX += a.acceleration.x;

sumY += a.acceleration.y;

sumZ += a.acceleration.z;

sumMag += sqrt(pow(a.acceleration.x, 2) + pow(a.acceleration.y, 2) + pow(a.acceleration.z, 2));

delay(10);

}

offX = sumX / samples;

offY = sumY / samples;

offZ = sumZ / samples;

baseMag = sumMag / samples;

Serial.printf("Baseline Set: %.2f m/s^2\n", baseMag);

}

void setup() {

Serial.begin(115200);

Serial1.begin(115200); // TX: GP0

initSensors();

calibrateMPU(); // Run Tare Calibration

}

void loop() {

sensors_event_t a, g, temp_mpu;

if (!mpu.getEvent(&a, &g, &temp_mpu)) { initSensors(); return; }

// 1. DYNAMIC HIGH-PASS FILTER (The "Gravity Canceller")

// We estimate gravity (Low Pass)

filtX = (alpha * filtX) + ((1.0 - alpha) * a.acceleration.x);

filtY = (alpha * filtY) + ((1.0 - alpha) * a.acceleration.y);

filtZ = (alpha * filtZ) + ((1.0 - alpha) * a.acceleration.z);

// We subtract gravity to get only Linear Acceleration (High Pass)

float linX = a.acceleration.x - filtX;

float linY = a.acceleration.y - filtY;

float linZ = a.acceleration.z - filtZ;

// 2. CALCULATE VIBRATION INTENSITY (G-Force)

// This is the "Magnitude" of just the vibration components

float vibeMag = sqrt(pow(linX, 2) + pow(linY, 2) + pow(linZ, 2)) / 9.81;

// 3. GET ENVIRONMENTAL DATA

float t = dht.readTemperature();

float h = dht.readHumidity();

float p = bmp.readPressure() / 100.0F;

// --- PACKET SENDING ---

// $[T, H, P, RelX, RelY, RelZ, RelVibe]*

Serial1.print("$[");

Serial1.print(t, 1); Serial1.print(",");

Serial1.print(h, 0); Serial1.print(",");

Serial1.print(p, 1); Serial1.print(",");

Serial1.print(linX, 2); Serial1.print(","); // Cleaned X

Serial1.print(linY, 2); Serial1.print(","); // Cleaned Y

Serial1.print(linZ, 2); Serial1.print(","); // Cleaned Z

Serial1.print(vibeMag, 2); // Cleaned Combined G

Serial1.println("]*");

delay(100);

}

Code for the ESP32-S3-BOX3 Node (Check GitHub Repo):

* Project Name: Sentinel

* Designed For: ESP32 S3 BOX 3

* License: GPL3+

* This project is licensed under the GNU General Public License v3.0 or later.

* You are free to use, modify, and distribute this software under the terms

* of the GPL, as long as you preserve the original license and credit the original

* author. For more details, see <https://www.gnu.org/licenses/gpl-3.0.en.html>.

* Code Created And Maintained By: Ameya Angadi

* Last Modified On: March 30, 2026

* Version: 1.0.0

#include <Arduino.h>

#include <WiFi.h>

#include <WebServer.h>

#include <time.h>

#include <Preferences.h>

#include <esp_display_panel.hpp>

#include <lvgl.h>

#include <ui.h>

#include "lvgl_v8_port.h"

using namespace esp_panel::drivers;

using namespace esp_panel::board;

// --- CONFIGURATION ---

const char* ssid = "";

const char* password = "";

#define RXD1 40

#define TXD1 41

WebServer server(80);

Preferences prefs;

Board *board = nullptr;

// Global Data

float g_temp = 0, g_hum = 0, g_pres = 0;

float g_x = 0, g_y = 0, g_z = 0, g_vibe = 0;

String g_status = "WAITING";

String g_last_maint = "01/01/2026";

String g_next_maint = "01/07/2026";

int currentBrightness = 100;

unsigned long lastWifiCheck = 0;

// Web Server Background Color Logic (Vibrant Shades)

void handleRoot() {

String bg = "#1a1a1a"; // Dark Gray (default)

if (g_status == "DANGER") bg = "#ff4b2b"; // Vibrant Safety Red

else if (g_status == "CAUTION") bg = "#ff9800"; // Vibrant Safety Orange

String html = "<html><head><style>";

html += "body { font-family: 'Segoe UI', sans-serif; background: " + bg + "; color: white; padding: 25px; margin: 0; transition: background 0.4s; }";

html += ".card { background: rgba(0,0,0,0.75); padding: 30px; border-radius: 20px; border: 1px solid rgba(255,255,255,0.2); max-width: 450px; margin: auto; box-shadow: 0 10px 30px rgba(0,0,0,0.5); }";

html += "h2 { margin: 0; text-transform: uppercase; letter-spacing: 2px; text-shadow: 2px 2px 4px rgba(0,0,0,0.5); }";

html += ".metric { margin: 18px 0; border-bottom: 1px solid rgba(255,255,255,0.1); padding-bottom: 10px; }";

html += ".val { font-weight: bold; font-size: 1.6em; color: white; }";

html += ".label { color: #bbb; display: block; font-size: 0.85em; text-transform: uppercase; margin-bottom: 5px; }";

html += "</style></head><body><div class='card'>";

html += "<h2>SYSTEM " + g_status + "</h2><br>";

html += "<div class='metric'><span class='label'>Vibration Intensity</span><span class='val'>" + String(g_vibe) + " G</span></div>";

html += "<div class='metric'><span class='label'>Temperature</span><span class='val'>" + String(g_temp) + " C</span></div>";

html += "<div>" + String(g_hum) + "% Humidity | " + String(g_pres) + " hPa</div><br>";

html += "<div style='font-size: 0.8em; color: #aaa;'>Service: " + g_last_maint + " | Due: " + g_next_maint + "</div>";

html += "</div></body></html>";

server.send(200, "text/html", html);

}

// --- EVENT HANDLERS ---

void onBrightnessChange(lv_event_t * e) {

lv_obj_t * slider = lv_event_get_target(e);

int val = lv_slider_get_value(slider);

if (val < 10) val = 10;

currentBrightness = val;

board->getBacklight()->setBrightness(currentBrightness);

}

void updateSettingsScreenUI() {

if (millis() - lastWifiCheck > 2000) {

lastWifiCheck = millis();

String ssidStr = WiFi.SSID();

if(ssidStr.isEmpty()) ssidStr = "Searching...";

lv_label_set_text(ui_LabelWifiSSID, ("SSID: " + ssidStr).c_str());

if (WiFi.status() == WL_CONNECTED) {

lv_label_set_text(ui_LabelWifiStatus, "Status: Connected");

lv_obj_set_style_text_color(ui_LabelWifiStatus, lv_color_hex(0x00FF00), 0);

} else {

lv_label_set_text(ui_LabelWifiStatus, "Status: Disconnected");

lv_obj_set_style_text_color(ui_LabelWifiStatus, lv_color_hex(0xFF0000), 0);

}

void onMaintBtnClicked(lv_event_t * e) {

struct tm info;

if (getLocalTime(&info)) {

char buf[15];

strftime(buf, sizeof(buf), "%d/%m/%Y", &info);

g_last_maint = String(buf);

info.tm_mon += 6;

mktime(&info);

strftime(buf, sizeof(buf), "%d/%m/%Y", &info);

g_next_maint = String(buf);

prefs.begin("maint", false);

prefs.putString("last", g_last_maint);

prefs.putString("next", g_next_maint);

prefs.end();

lv_label_set_text(ui_LabelLastMaintainaceDate, g_last_maint.c_str());

lv_label_set_text(ui_LabelNextMaintDate, g_next_maint.c_str());

}

void setup() {

Serial.begin(115200);

Serial1.begin(115200, SERIAL_8N1, RXD1, TXD1);

Serial1.setTimeout(50);

board = new Board();

board->init();

assert(board->begin());

lvgl_port_init(board->getLCD(), board->getTouch());

lvgl_port_lock(-1);

ui_init();

if(ui_ButtonUpdateMaint) lv_obj_add_event_cb(ui_ButtonUpdateMaint, onMaintBtnClicked, LV_EVENT_CLICKED, NULL);

if (ui_SliderBrightness) {

lv_slider_set_range(ui_SliderBrightness, 10, 100);

lv_slider_set_value(ui_SliderBrightness, 100, LV_ANIM_OFF);

lv_obj_add_event_cb(ui_SliderBrightness, onBrightnessChange, LV_EVENT_VALUE_CHANGED, NULL);

}

prefs.begin("maint", true);

g_last_maint = prefs.getString("last", "01/01/2026");

g_next_maint = prefs.getString("next", "01/07/2026");

prefs.end();

lv_label_set_text(ui_LabelLastMaintainaceDate, g_last_maint.c_str());

lv_label_set_text(ui_LabelNextMaintDate, g_next_maint.c_str());

lvgl_port_unlock();

WiFi.begin(ssid, password);

server.on("/", handleRoot);

server.begin();

configTime(19800, 0, "pool.ntp.org");

}

void loop() {

server.handleClient();

static unsigned long lastClock = 0;

struct tm timeinfo;

if (lv_scr_act() == ui_SettingScreen) {

lvgl_port_lock(-1);

updateSettingsScreenUI();

lvgl_port_unlock();

}

if (Serial1.available() > 0) {

String raw = Serial1.readStringUntil('\n');

if (raw.startsWith("$[")) {

String data = raw.substring(raw.indexOf("$[") + 2, raw.indexOf("]"));

float v[7]; int count = 0;

char* ptr = strtok((char*)data.c_str(), ",");

while (ptr != NULL && count < 7) { v[count++] = atof(ptr); ptr = strtok(NULL, ","); }

if (count == 7) {

g_temp = v[0]; g_hum = v[1]; g_pres = v[2];

g_x = v[3]; g_y = v[4]; g_z = v[5]; g_vibe = v[6];

lvgl_port_lock(-1);

uint32_t s_color = 0x00FF00;

if (g_temp > 55.0 || g_vibe > 0.70) { g_status = "DANGER"; s_color = 0xFF0000; }

else if (g_temp > 42.0 || g_vibe > 0.15) { g_status = "CAUTION"; s_color = 0xFFA500; }

else { g_status = "HEALTHY"; s_color = 0x00FF00; }

lv_label_set_text(ui_LabelHealthStatus, g_status.c_str());

lv_obj_set_style_text_color(ui_LabelHealthStatus, lv_color_hex(s_color), 0);

char b[16];

snprintf(b, sizeof(b), "%.1f C", g_temp);

lv_label_set_text(ui_LabelTemp, b); lv_label_set_text(ui_LabelTempES, b);

snprintf(b, sizeof(b), "%.0f %%", g_hum);

lv_label_set_text(ui_LabelHum, b); lv_label_set_text(ui_LabelHumES, b);

snprintf(b, sizeof(b), "%.1f hPa", g_pres); lv_label_set_text(ui_LabelBMPressure, b);

snprintf(b, sizeof(b), "X: %.2f G", g_x); lv_label_set_text(ui_LabelXaxis, b);

snprintf(b, sizeof(b), "Y: %.2f G", g_y); lv_label_set_text(ui_LabelYaxis, b);

snprintf(b, sizeof(b), "Z: %.2f G", g_z); lv_label_set_text(ui_LabelZaxis, b);

snprintf(b, sizeof(b), "%.2f G", g_vibe); lv_label_set_text(ui_LabelCombinedMPU, b);

lvgl_port_unlock();

}

if (millis() - lastClock > 1000) {

lastClock = millis();

if (getLocalTime(&timeinfo)) {

char t_b[10], p_b[5], d_b[15];

strftime(t_b, sizeof(t_b), "%I:%M", &timeinfo);

strftime(p_b, sizeof(p_b), "%p", &timeinfo);

strftime(d_b, sizeof(d_b), "%d/%m/%Y", &timeinfo);

lvgl_port_lock(-1);

lv_label_set_text(ui_LabelTime12Hr, t_b);

lv_label_set_text(ui_LabelTimeAMPM, p_b);

lv_label_set_text(ui_LabelDate, d_b);

lvgl_port_unlock();

}

delay(2);

}

Code for the Local HTML File (Check GitHub Repo):

<!DOCTYPE html>

<html>

<head>

<title>Sentinel Remote Dashboard</title>

<style>

body { background: #000; color: white; text-align: center; font-family: sans-serif; }

iframe { width: 400px; height: 415px; border: 2px solid #333; border-radius: 10px; margin-top: 50px; }

.info { margin-top: 10px; color: #888; }

</style>

</head>

<body>

<h1>Predictive Maintenance Monitor</h1>

setInterval(function() {

document.getElementById('sentinelFrame').src = document.getElementById('sentinelFrame').src;

}, 500);

</script>

</body>

</html>

Github Repository

Check the Github Repo Link for all design files, code, images, and all other instructions.