Overview
EVVR OS is a powerful system designed for energy management, industrial process monitoring, remote asset management, and commercial space management, based on an advanced technical architecture. Particularly suitable for small and medium-sized enterprises and organizations, EVVR OS offers robust device management, automation, data processing, and security features that allow businesses to efficiently manage and optimize their devices and workflows. With comprehensive protocol support, intuitive customization tools, flexible deployment options, and strong security, EVVR OS is an ideal platform for building intelligent and automated business environments.
Technical Architecture
The technical architecture of EVVR OS is designed around modularity, scalability, and high performance, built on a microservices architecture and containerization technologies to ensure flexibility, maintainability, and reliability across various deployment environments. Standardized interfaces and protocol adaptation technologies provide flexible, scalable, and efficient solutions. The system supports seamless integration of various devices and services through a unified data protocol and powerful service management capabilities, catering to diverse business needs. The core components of the system architecture include:
Message Center (MQTT)
In EVVR OS, the MQTT protocol (Message Queuing Telemetry Transport) serves as the core communication protocol, using an MQTT Broker to handle message transmission efficiently and with low latency. All devices, services, and external clients communicate with the Broker via MQTT clients.
- MQTT Clients: Every device or service connected to the system acts as an MQTT client, subscribing to or publishing messages to the Broker.
- Message Communication Mechanism: Based on a publish/subscribe model, the system uses MQTT topics to transmit information, reducing direct connections between devices and services, improving system decoupling.
- High Scalability: With MQTT, the system can support thousands of devices concurrently, ensuring high concurrency processing capacity.
Component Services
EVVR OS offers a variety of built-in component services that help users efficiently manage the functionalities and resources of the system. Each service module is a separate microservice that can be easily extended and customized to meet the specific needs of different business scenarios. Below are some of the key component services in EVVR OS:
Component services in EVVR OS:
1.User Service: The User Management module handles all functions related to user identity authentication and permission management. It supports creating users, user groups, and roles, allowing for hierarchical management and permission combinations.
2.Device Service: This module manages device integration, data retrieval, control, and deletion. Each Device Service instance is responsible for connecting a specific protocol, ensuring that devices can interact correctly with EVVR OS.
- Matter Device Service: Supports devices that use the Matter protocol, which is a widely adopted IoT standard that ensures high security and low-latency communication.
- MQTT Device Service: Supports devices that communicate using MQTT, suitable for real-time communication applications such as environment sensors or remote monitoring devices.
- HTTP Device Service: Connects devices that communicate over HTTP, supporting devices with RESTful APIs for scenarios like cloud platform data integration and device state retrieval.
- LoRa Device Service: Connects devices using LoRa, a long-range, low-power protocol suitable for devices like agricultural sensors or industrial equipment.
- Modbus Device Service: Provides integration with industrial automation equipment like PLCs and sensors using the Modbus protocol.
- Z-Wave Device Service: Integrates devices using the Z-Wave protocol, typically used for smart home automation devices such as sensors, locks, and lighting.
- Zigbee Device Service: Supports Zigbee-based devices commonly used in home automation, such as smart thermostats and lighting controllers.
- Security Camera Device Service: Integrates security cameras that support the ONVIF standard, offering video monitoring and real-time data stream management.
- Air Conditioner Device Service: Allows control over air conditioning devices, including adjustments to temperature, mode, and fan speed for enhanced comfort.
3.Voice Control Service: This service allows integration with smart voice assistants such as Amazon Alexa, enabling users to control devices in EVVR OS through voice commands.
4.Driver Service: This service provides a flexible tool for editing device driver files. Users can optimize or customize the display logic, control logic, and other interaction details for devices.
- UI Customization: Users can modify the display of device interfaces (e.g., icons, layouts) to meet specific needs.
- Driver Optimization: Users can modify the behavior and interaction logic of device drivers.
5.Automation Service: This service features a powerful automation engine, enabling users to create and manage automation rules via an intuitive, graphical interface.
- Visual Editor: A drag-and-drop interface on the web that simplifies the creation of complex automation rules.
- App Support: Allows users to modify automation rule parameters on mobile devices for quick adjustments and optimizations.
6. Zone Service: Enables the creation and management of virtual rooms, allowing users to map physical spaces with virtual representations and manage device groupings within those rooms.
7.Dashboard Service: Provides powerful data visualization tools that enable users to create real-time monitoring dashboards, displaying device statuses and system operation data.
8.Form Network Service: Helps users link multiple EVVR OS systems and devices together, enabling intelligent interactions between different components of the system.
9.OTA Service: Provides remote upgrade functionality for both the system and connected devices.
10.P2P Service: Enables remote connections from mobile apps to EVVR OS via secure, peer-to-peer (P2P) communication.
TLP-MP Protocol
EVVR OS utilizes its proprietary TLP-MP protocol to unify the management of multi-protocol device data and interactions, ensuring compatibility and seamless interoperability across diverse devices. The TLP-MP protocol comprises the following core elements:
1.Message Communication: Defines a communication protocol with two modes:
- Request/Response Mode: Services can actively request data from other services for point-to-point data exchange.
- Event Broadcasting Mode: Services can notify other services of updates via event broadcasts, suitable for multi-service collaboration scenarios.
2. Service Definition: Uses YAML files to standardize data structures and interfaces for services:
- Restful Style: Service interactions are clearly defined to support efficient development and maintenance.
- Cross-Language SDK Support: Service definition files automatically generate code templates for services in multiple languages (e.g., C++, Python, JavaScript), enhancing development efficiency.
Device Definition
Device data is abstracted into a Device-Channel-Attribute three-layer structure, which is detailed in a device model file. This abstraction allows the system to efficiently manage device data and ensure seamless interaction between various devices. The layers are defined as follows:
- Attribute: The smallest functional unit of a device, such as switch status, power level, or temperature.
- Channel: Represents a logical sub-device, for instance, each individual switch in a multi-way switch.
- Device: A physical IoT device.
Example:
{
"thingId": "zigbee:0x00158D00067EF607",
"modelId": "zigbee:EVVR.SRB01.tlp-mod",
"bridgeId": "zigbee:silabsZigbeeBridge",
"label": "Main Light",
"status": "ONLINE",
"attributeLabels": {
"tlp.a.switch.onoff": "On/Off"
},
"attributes": {
"tlp.a.switch.onoff": true
}
}
This model illustrates a Zigbee-based device with a specific thing ID and model ID. It shows the device’s current status, its attributes (e.g., on/off switch), and the related metadata.
Device Drivers
Device drivers serve as the core files that connect EVVR OS with specific protocol devices. These drivers include:
- Device Model Description: Defines the general features and structure of a device.
- TLP to Protocol Mapping Logic: Maps the TLP protocol data to a particular device’s communication protocol.
- UI Customization: Defines the interface and controls used to interact with the device.
By using the TLP protocol, EVVR OS provides unified management and efficient interaction between devices with different communication protocols, drastically reducing the complexity of integrating new devices.
Device Model Description
The device model ensures consistency and standardization across all devices in the system, defining common features and structures for each type of device. A device model file includes the following elements:
- Attributes: Defines the properties of a device and their behavior.
- Data Type: Specifies the data type of an attribute (e.g., boolean, integer, string).
- Label and Description: Clearly identifies the attribute’s purpose and function.
- Parameter Configuration: Includes details like read/write capabilities, value ranges, units, and default values.
- UI Display: Specifies the type of control in the user interface (e.g., switch, slider, textbox).
- Channels: Represents logical sub-devices or functional groups within a device.
- Each channel has associated attributes and descriptions of its behavior.
- Events: Describes device event types and their triggers (e.g., water leakage alarms, motion detection, door open/close).
- Static Data: Includes unchanging device information like manufacturer, model, and icons.
Example Device Model:
{
"modelId": "zigbee:Evvr.SRB01.tlp-mod",
"version": "1.0",
"categories": [
"Light",
"Zigbee"
],
"label": "In-Wall Relay Switch",
"labelI18n": {
"zh-CN": "灯"
},
"description": "An In-Wall Relay Switch.",
"descriptionI18n": {
"zh-CN": "一个可以控制的灯"
},
"widget": "tlp.a.switch.onoff",
"icon": "SRB01.png",
"icons": {
"2x": "SRB01@2x.png",
"3x": "SRB01@3x.png"
},
"traits": {
"modelNumber": {
"label": "Model Number",
"description": "Model number of the device.",
"value": "SRB01",
"constraint": {
"defaultValue": 0,
"required": false,
"type": "STRING"
}
},
"manufacturer": {
"label": "Manufacturer",
"description": "Manufacturer of the device.",
"value": "EVVR",
"constraint": {
"defaultValue": 0,
"required": false,
"type": "STRING"
}
}
},
"attributes": {
"tlp.a.switch.onoff": {
"label": "On/Off",
"labelI18n": {
"zh-CN": "开/关"
},
"attributeType": "tlp.a.onoff",
"description": "On and off state of a switch.",
"descriptionI18n": {
"zh-CN": "开关的开和关状态。"
},
"ui": "Switch",
"access": [
"READ",
"WRITE",
"NOTIFY"
],
"constraint": {
"defaultValue": 0,
"required": false,
"type": "BOOLEAN"
},
"panelShow": true,
"indicator": true
}
},
"channels": {
"lightChannel": {
"label": "Light",
"labelI18n": {
"zh-CN": "Light"
},
"description": "Light",
"descriptionI18n": {
"zh-CN": "Light"
},
"serviceType": "tlp.s.lighting",
"attributeIds": [
"tlp.a.switch.onoff"
]
}
}
}
This model describes an in-wall relay switch, specifying its attributes, channels, and associated metadata (e.g., manufacturer, model number). The attributes include a switch that is represented with a toggle UI element in the user interface.
Driver Mapping Logic
Driver mapping is the process of adapting the TLP protocol to a specific device’s communication protocol. This ensures that the device’s functionality and data are correctly represented and interact smoothly with EVVR OS. The mapping process involves:
- Binding Attributes and Events: TLP attributes and events are mapped to corresponding data and control mechanisms in the specific communication protocol (e.g., Zigbee, Z-Wave).
- Protocol Data Parsing and Packaging: This logic ensures that the data is compatible between TLP and the underlying protocol, enabling seamless communication between the device and the system.
Supports adapting to multiple protocols, such as:
- Zigbee: TLP attributes are mapped to Zigbee clusters, ensuring seamless integration of Zigbee devices into EVVR OS.
- Z-Wave: TLP attributes are mapped to Z-Wave Command Classes, enabling full support for Z-Wave devices.
This driver mapping process ensures that data transmitted between EVVR OS and the device is properly parsed and translated, providing an efficient communication layer between the system and devices.
UI Customization
The standardized device driver design in EVVR OS allows for flexible support of various protocol devices. Through customizable UI elements and interface controls, developers can tailor the user interface for each device according to its specific needs and functionality.
- Customizable Controls: UI controls for device attributes (e.g., switch, slider) can be customized based on the type of device and its attributes.
- Protocol-Specific Interfaces: Support for devices from various protocols is easily achieved through the standardized driver structure, and developers can extend this structure to include additional protocol devices as needed.
By enabling these customizations, EVVR OS provides an adaptable platform for integrating and managing a wide variety of devices, ensuring ease of use and flexibility in device management.
Web Console and App Interfaces
EVVR OS provides two main user interfaces:
1.Web Console: A comprehensive user management tool designed for detailed configuration and management tasks. Features include:
- User and Device Management: Add, edit, or delete users and devices, configure roles and permissions.
- Automation Rules: Create and edit automation rules with a graphical interface.
- Room and Dashboard Management: Organize devices into virtual rooms, create customized dashboards for real-time monitoring.
- System Configuration: Access and modify system-level settings.
2.Mobile App: A mobile-optimized user interface designed for quick, on-the-go operations and monitoring:
- Device Management: Real-time status updates, device control, and attribute management.
- Parameter Adjustment: Modify parameters of existing automation rules to meet dynamic requirements.
- Dashboard and Room Monitoring: Conveniently view room device statuses and dashboard data on mobile devices.
- Notifications and Alerts: Receive device alarms and system notifications to ensure timely delivery of critical information.
Seamless integration between the mobile app and Web Console, allowing users to flexibly choose based on their specific scenario requirements.
Custom UI
EVVR OS provides flexible H5 customization capabilities to help developers create tailored user interfaces for specific devices or scenarios. This customization enhances user experience, improves product adaptability, and adds a layer of personalization. By customizing H5 pages, users can quickly build device setup and details interfaces that meet the needs of specific use cases.
Core Features and Benefits
1.Device Setup Guide Interface
The customized H5 page can provide an intuitive setup guide for specific devices, simplifying the user configuration process. For example:
- Guiding Users: Help users complete initial device setup, such as network connection or account binding.
- Interactive Operation Steps: Display step-by-step instructions for actions like pressing device buttons or interpreting LED indicator states.
- Dynamic Validation: Validate user-input configuration information to ensure accuracy during the device setup process.
2.Device Details Interface
A dedicated details page can be customized for each device to display its core attributes and real-time status. Features include:
- Interactive Controls: Allow users to adjust device parameters via interactive UI elements like sliders, buttons, or checkboxes, improving ease of control.
- Dynamic Status Updates: Present dynamic updates of device states, such as battery level, temperature, signal strength, etc., based on the device’s characteristics.
3.Branding and Personalization
The custom interface can be designed to align with the device’s brand and functional needs, helping to maintain a consistent brand image and enhance user recognition and satisfaction.
Containerization
EVVR OS uses containerization technology to enable lightweight, rapid deployment that adapts to a wide variety of hardware devices and environmental requirements. Key components of the system run in containers, including:
- MQTT Broker
The MQTT Broker provides efficient and reliable message communication services, ensuring stable data transmission between devices and services. - Web Console
The Web Console, which provides comprehensive management functions, operates in an independent container. This enables users to manage their system through a web browser with ease. - Built-in Services
All essential services within the system, such as user management, device management, automation services, and dashboard services, are containerized. This modular approach ensures flexibility in managing and maintaining system components.
The containerized architecture allows for easy scalability, better isolation of system components, and improved maintainability across various environments.
Integration Development
EVVR OS offers flexible and open secondary development capabilities, enabling enterprises and developers to customize and integrate according to their specific needs. Integration development can be realized through two primary methods:
Service Integration and Extension
Developers can build new services based on the built-in services of EVVR OS or define their own services. By utilizing the SDKs provided in multiple languages, third-party services can be easily integrated. Once integrated, services can interact with other services within the system to ensure seamless connectivity and efficient collaboration. Developers can also expose new functionalities to client applications through Web or App functionality interfaces, extending the system’s capabilities and adapting it to diverse requirements.
Supported Programming Languages:
EVVR OS provides SDKs in C++, Python, JavaScript, and other languages, allowing developers to use their preferred programming language for integration development.
Data Communication:
All services communicate via the TLP protocol (an extension of the MQTT protocol), ensuring smooth and efficient data exchange between services within the system.
Functionality Interface Exposure:
Integrated services can interact with clients via standardized RESTful interfaces, enabling remote function calls and data presentation.
Third-party System Integration
EVVR OS offers powerful integration capabilities, making it easy for enterprises and developers to connect with third-party systems and quickly expand functionality and achieve data interconnection. With flexible SDKs and automatically generated client request code, developers can efficiently integrate with external systems.
Automatically Generated Client Code:
The multi-language SDKs of EVVR OS include code generation tools that produce client request code in the corresponding programming language, simplifying the integration process. Developers do not need to manually write complex communication logic, and can instead quickly access interfaces and invoke functions using the generated code.
Standardized Interface Integration:
Third-party systems can easily interact with EVVR OS using standardized RESTful interfaces. These interfaces are highly versatile and can be adapted to most platforms and applications, ensuring seamless integration.
Rich Language Support:
SDKs offer multi-language support (including C++, Python, JavaScript, etc.), catering to different developers’ tech stacks, which makes the integration work more efficient and flexible.
Data Interaction and Operation Execution
Developers can use the generated code or directly invoke the interfaces to easily accomplish tasks such as:
- Retrieving the status of devices and services
- Executing operations on the system or devices
- Pushing real-time events
Through these tools and functionalities, EVVR OS greatly reduces the complexity of integrating with third-party systems, providing developers with an efficient and convenient integration development experience that meets the diverse needs of business scenarios.
Device Driver Integration
EVVR OS supports the development and customization of device drivers, allowing developers to create or modify drivers based on existing templates to ensure compatibility with specific devices and protocols. Device drivers implement data mapping between the TLP protocol and various device protocols, ensuring interoperability between devices.
Device Protocol Support:
EVVR OS currently supports compatibility with a range of device protocols, including Zigbee, Z-Wave, and others. Developers can create custom device drivers as needed to support additional protocols.
Driver Development and Mapping:
Device drivers use device models and TLP protocol definitions to map logic between the TLP protocol and specific device protocols. For example, drivers map TLP protocol attributes to Zigbee Clusters or Z-Wave Command Classes.
Device Model:
Device model files define the attributes, events, and static data of a device. These models use a Device-Channel-Attribute three-layer structure to make device descriptions more standardized and general-purpose.
Through these three integration approaches, EVVR OS provides developers with a highly customizable and flexible development environment, supporting various business scenarios and device types. This enables enterprises and organizations to build intelligent systems that meet their specific needs.
Security and Privacy Protection
Data Localization:
Device and service data is stored locally by default, allowing users to operate and manage the system without relying on the cloud. This minimizes the risk of external data breaches and ensures that sensitive data remains secure within the local environment.
P2P Encrypted Communication:
For remote access, end-to-end encryption (E2EE) technology is used. The system communicates directly with devices via peer-to-peer (P2P) connections, eliminating the need for intermediary servers and reducing potential security risks associated with middlemen.
Deployment and Maintenance
EVVR OS is fully deployed through containerization, with all system services running inside containers:
No Need for Separate Service Deployment:
Users do not need to deploy individual services separately. The containerized design ensures that the system maintains consistency across various environments, simplifying deployment and reducing configuration overhead.
External Service Connections:
The system supports extending internal container functionalities by connecting to external services. This allows for seamless integration with existing user systems, offering high flexibility and adaptability.
Flexible Configuration and Update Mechanism:
EVVR OS provides a flexible configuration system and easy update mechanism, reducing ongoing maintenance costs and ensuring that the system remains up to date with minimal effort.
No Dependencies Between Services:
Services within EVVR OS are designed without dependencies on one another. This architectural design minimizes the risks to data security by limiting the scope of potential vulnerabilities.