Thingsboard is an open source IoT Platform.

Pilot Things aims to integrate ThingsBoard into the App Server product while maintaining the existing graphical user interface (GUI). This integration will enable real-time IoT data visualization using Device Explorer as the primary backend data source.

To achieve this, a new Java module called ThingsBoardIntegration will be developed. This module will replace ThingsBoard’s default device connectivity, fetching real-time telemetry and metadata directly from Device Explorer. The integration will ensure seamless communication between IoT devices, the App Server, and ThingsBoard’s dashboard system.

Device data will be streamed in real-time using WebSocket, MQTT, or REST APIs to update dashboards and widgets without modifying the UI. The system will support historical data retrieval and live telemetry updates to maintain a smooth user experience.

Scalability and performance will be key priorities, optimizing data ingestion and processing for large-scale IoT deployments. The solution will maintain compatibility with ThingsBoard’s rule chains, alarms, and analytics features.

The project will be implemented in four phases: feasibility analysis, prototype development, full integration, and deployment. The ThingsBoardIntegration module will provide a robust and modular architecture, allowing future enhancements.

This integration will enhance IoT data management, ensure real-time insights, and offer a seamless user experience for App Server users.

The project consists of two major components to ensure full integration of ThingsBoard into the App Server while leveraging real-time telemetry from Device Explorer:

1. ThingsBoard Java Backend Integration – Handles the real-time data ingestion, API integration, and device management between Device Explorer and ThingsBoard.

2. ThingsBoard Rule Engine Integration – Ensures event processing, automation, and real-time actions using ThingsBoard’s built-in Rule Chain Engine.

Both components will work together to provide a complete ThingsBoard experience within the App Server ecosystem.

Part 1: ThingsBoard Java Backend Integration

The ThingsBoardIntegration module will act as a middleware service that connects Device Explorer to ThingsBoard dashboards. This module will replace ThingsBoard’s default device connectivity while ensuring real-time telemetry updates and device synchronization.

📌 Features of the ThingsBoard Backend Integration

1. Data Ingestion and Transformation

• Fetches real-time telemetry from Device Explorer via WebSocket, MQTT, or REST API.

• Transforms incoming sensor data into ThingsBoard-compatible telemetry JSON format.

2. Device and Asset Management

• Maps telemetry streams to ThingsBoard entity aliases.

3. Real-Time Data Flow

• Implements WebSocket-based telemetry updates for low-latency dashboard rendering.

• Pushes real-time events directly into the ThingsBoard Rule Engine.

4. API Services

• Provides REST APIs for:

• Fetching historical and live telemetry.

• Querying device metadata.

• Managing device connectivity.

• Acts as a data adapter between Device Explorer and ThingsBoard dashboards.

5. Security and Performance

• Ensures secure API communication with JWT-based authentication.

• Implements caching mechanisms to optimize real-time data retrieval.

• Supports scalable data ingestion with asynchronous processing.

Part 2: ThingsBoard Rule Engine Integration

Existing ThingsBoard Rule Engine must be fully integrated into the App Server to process IoT events, trigger automation, and execute business logic. The rule engine provides event-driven workflows for real-time alerts, notifications, and data transformations.

📌 Features of the Rule Engine Integration

1. Custom Rule Chains for Event Processing

• Ingests data from Device Explorer and applies rule-based processing.

• Supports event filtering, transformations, and threshold-based alerts.

• Automatically triggers actions like email notifications, API calls, or device commands.

5. Dashboard Interactivity and Automation

• Enables interactive dashboards that react to real-time device events.

• Supports dynamic UI updates when telemetry triggers a rule chain.

• Ensures that user-configurable business rules can be applied without modifying the backend code.