Edge computing is a distributed computing architecture that moves the computation of applications, data, and services from the central nodes of the network to logically located edge nodes. Edge computing breaks down large services that were originally handled entirely by central nodes into smaller, more manageable parts, which are then distributed to edge nodes for processing.
Edge computing-based IoT solutions can be architecturally divided into: sensing and control layer, network layer, agile controller, and application layer.
The sensing and control layer comprises numerous sensors, control components (such as switches), and measurement components (such as meters), as well as communication components. These communication components may be independent or integrated with other components.
Network Layer: Primarily responsible for convergence and interconnection, its functions include network connectivity and management, edge computing for on-site processing, and ensuring the local survival of services. Local survival and on-site processing are crucial for the Internet of Things (IoT) , especially for large-scale industrial and civilian facilities. Furthermore, protocol conversion is another important function of this layer. The IoT field has numerous protocols, accumulated from various industries, necessitating protocol conversion at the gateway to uniformly carry data over the IP network for external transmission.
Agile Controller: Processes data from the gateway in a unified manner and sends it up to the application layer. It also manages the lower-layer network, sensors, control components, measurement components, and computing resources, providing automated tools for network deployment and configuration.
Business application layer: Integrates various industry applications.
IoTSuite, an IoT solution with "two ends and one cloud"
With the booming development of the Internet of Things (IoT), the number of users and devices connected to the internet is increasing. Whether it's individual users or IoT devices, they are generating massive amounts of data every moment. This ever-increasing data volume demands ever-stronger device responsiveness and computing power. Traditional methods of connecting devices to central servers incur significant costs due to network latency and bandwidth limitations, and devices cannot instantly connect to the cloud and central servers via the network.
To address these issues, Tencent Cloud has proposed IoTSuite, a "two-ends-one-cloud" IoT solution that helps enable rapid IoT connectivity for devices. The platform provides standard TLS 1.2 and two-way authentication to protect the security of the connection between the device and the cloud. For devices with limited computing power, dynamic tokens are used to achieve one key per device, enabling secure two-way communication between the device, the cloud, and the application.
As shown in the diagram above, the Tencent Cloud IoT platform comprises a three-layer architecture: the platform core processing layer, the device connectivity layer, and the application connectivity layer. The platform core processing layer provides a unified cloud-based central control and management platform, offering features such as data templates, log storage, shadow services, and a rules engine. The device connectivity layer and application connectivity layer provide encapsulated firmware SDKs and application SDKs through open APIs, integrating with different industry applications upwards and connecting to various sensors, terminals, and central control gateway devices downwards, enabling cross-hardware device access.
The platform provides comprehensive development support, including embedded firmware SDKs for devices, open API interfaces in the cloud, and integrated SDKs for user applications. The communication platform between devices and the cloud encapsulates standard communication protocols such as MQTT, CoAP, and HTTP, supporting connection methods including 2G/4G/NB/LoRa/Wi-Fi. Simultaneously, the application side provides MQTT, WebSocket, and HTTP protocols and middleware, facilitating integration for various applications such as enterprise applications and mobile applications.
Device firmware SDK
It provides device access SDKs based on Linux, Android and mainstream RTOS, supports various communication modules including 2/3/4G, WIFI, LoRa and NB-IoT communication modes, SOC development boards and SIP development boards, and encapsulates a complete set of interfaces for cloud authentication and communication. It supports multiple protocols such as MQTT/CoAP/WebSocket and can be ported to run on different hardware environments.
Application SDK
The SDK encapsulates the communication process between the APP application and Tencent Cloud IoT Development Center, including device configuration, network access, discovery, connection, control, status reporting, alarms, and fault notifications. Using the SDK allows users to quickly complete APP development, thereby reducing the burden of complex protocols and error handling.
Open Communication Cloud API
It provides advanced device data services, including device access, account management, device binding, remote monitoring and upgrades, and offers corresponding cloud API calls for users to access and use. It also connects to the interfaces of various cloud products such as Tencent Cloud Big Data and AI to meet customers' data usage needs according to their own business requirements.
The entire framework, from product creation and device function settings to data command uploading and distribution, data storage, and application in the deployment environment, essentially implements all the components required for device IoT. Overall, based on the Tencent Cloud IoTSuite IoT cloud platform with its "two ends and one cloud" architecture, it can achieve multiple functions including device access, device management, data analysis and processing, data visualization, and terminal intelligence.
How to implement edge computing?
Tencent Cloud IoT Edge Computing Architecture
There are two main paths to implementing edge computing based on the Internet of Things. One is the microservice upgrade model, which simply means allowing users to run applications on the edge platform and providing an open programming environment, similar to the software-defined path in recent years. The other is the penetration of the edge into the cloud, which uses edge capabilities to penetrate into the core products and services of the cloud, such as the edgeization of databases, computing, storage, and security.
Tencent Cloud's IoT Edge Computing Solution primarily provides a local service for IoT edge devices, addressing issues such as high availability, real-time performance, bandwidth limitations, and privacy in IoT application scenarios. Tencent Cloud IoT Edge Computing offers device management, message sending and receiving, local computing, caching, and synchronization capabilities, enabling localized IoT device management and communication at the edge.
Simultaneously, combined with Tencent Cloud SCF serverless function agent, users only need to complete the business logic code writing, runtime configuration, and message rule configuration in the cloud, and then distribute them to networked devices. On the device, the system will automatically complete the code and configuration synchronization, cloud function execution, and provide capabilities such as message sending and receiving, caching, and message synchronization with the cloud. When data is generated, the underlying IoT devices report the data to the smart gateway device, triggering the execution of the cloud function, processing the data offline, and then distributing the offline processed data to the underlying IoT devices through the local IoT gateway. The most important part of the data computation and processing mainly runs in the cloud function.
In the future, we will package more intelligent services, such as image recognition, into SCF cloud functions, gradually replacing the current SDK model. Intelligent applications can be developed by calling cloud functions.
Execution environment: Serverless Cloud Functions (SCF)
Serverless Cloud Function (SCF) is a serverless execution environment provided by Tencent Cloud. It hosts user code and uses user-configured triggers to automatically execute user applications based on the trigger's event. SCF cloud functions are executed by event triggers, which are typically triggered by other product resource objects such as COSBucket, CMQTopic queues, timers, and IoT devices.
Cloud functions primarily manage user computations. Users submit their code and configurations to the cloud function platform. Here, "code" refers to a single piece of code or a code package. "Configuration" has two aspects: one is the configuration of the function's runtime environment, including the environment used, required memory, timeout, etc.; the other is the configuration of the triggers.
Because the entire Function-as-a-Service operates on a trigger-based basis, triggering requires an event source, which is generated through association with other Tencent Cloud products. For example, the COS object storage product is associated with COS buckets. When a user uploads or deletes an image, an event is generated, which triggers the execution of the cloud function.
For example, when connecting to an API gateway, it can also serve as an event source. After a user's HTTP request arrives at the gateway, the API gateway will forward the request as an event to the cloud function, triggering the execution of the cloud function. After receiving the request, the cloud function will process it and generate a response for the user.
The diagram above illustrates the computation process of cloud functions. Users first submit their code and configuration to the cloud function platform for storage. Once an event occurs, a function instance is launched for each event, enabling triggered execution. The user function only runs when a real event occurs; only when the user code is running does the cloud function perform data calculations and cost calculations.
Because functions are managed, users are unaware of where their instances are running. The cloud function platform has a large pool of computing resources behind it. After a user instance is triggered, an available location is randomly selected from the resource pool, and the user's function instance is put into operation at that location. Therefore, the entire scheduling process, or the function scaling process after an event, is handled by the platform. The value brought by cloud functions mainly includes four points:
Simplified architecture: The function-granular microservice architecture naturally decouples the various functions of the system, allowing for the combination of proprietary and external services like building blocks, and realizing a WYSIWYG backend service.
Simplified development: No need to worry about underlying hardware configuration, OS, service start-up and shutdown, network transmission and reception, fault recovery, service scaling, etc. Just write the core business logic to achieve true code as a service;
Simplified Operations and Maintenance: No need to worry about service deployment, server maintenance, security management, scaling configuration, etc., and applications can be seamlessly upgraded, achieving a painless switch to DevOps mode.
Reduced expenses: There are no idle costs. Billing is based solely on the size of function resources, execution time, and number of executions. Compared to the average utilization rate of 5% to 15% for cloud servers, the price advantage is significant, achieving the most thorough on-demand billing.
The Internet of Things (IoT) primarily interacts with devices. Cloud functions, managed and scheduled by a platform, can be deployed to user devices. Through cloud functions, users can run applications on edge platforms, facilitating edge computing on devices. Developers only need to write core code and configure the code's execution conditions to perform real-time file and data processing.
How are hardware devices connected?
Connect to IoT Suite
Because the main functions are integrated into IoT Suite, hardware device integration is relatively simple; you only need to obtain the SDK, configure the development environment, and port the relevant files.
SDK Acquisition
git clone https://github.com/tencentyun/tencent-cloud-iosuite-embedded-c.git
Development Environment
SDK testing and verification in a Linux environment primarily uses Ubuntu 16.04, gcc-5.4 (gcc-4.7+ is recommended), and Python 2.7.12+ (for code generation and console command-line scripts). Install the cmake tool from http://www.cmake.org/download/
Compile and run
a. Execute the command to compile the example program.
cd tencent-cloud-iosuite-embedded-c
mkdir-pbuild
cd build
cmake../
make
b. After compilation, the key outputs and explanations in the build directory are as follows:
bin
|--demo_mqtt#MQTT cloud service connection demo program
|--demo_shadow#Shadow device operation demonstration program
|--iotsuite_app#General Data Template Demo Program
|--light# RGB LED Light Demo Program Based on Data Template
lib
--libtc_iot_suite.a# The core layer of the SDK, libtc_iot_hal and libtc_iot_common provide the ability to connect to cloud services.
--libtc_iot_common.a#SDK basic utility library, responsible for HTTP, JSON, base64 parsing and encoding/decoding functions.
The `libtc_iot_hal.a` file is the hardware and operating system abstraction for the SDK, responsible for functions such as memory, timers, and network interaction.
c. Execute the example program
cd bin
#Run the demo program
./demo_mqtt
#or
./iotsuite_app
Transplantation Instructions
The SDK abstracts and defines the Hardware and Operating System Platform Abstraction Layer (HAL layer), which encapsulates the dependent functions such as memory, timers, network transmission and interaction in the HAL layer (corresponding library libtc_iot_hal). When porting across platforms, the relevant functions must first be adapted or implemented according to the hardware and operating system of the corresponding platform.
The header and source file code structure related to platform porting is as follows:
include/platform/
|--linux# Create separate directories for different platforms or systems
||--tc_iot_platform.h #Include platform-related definitions or system header files
|--tc_iot_hal_network.h# Network-related definitions
|--tc_iot_hal_os.h# Definitions related to operating system memory, timestamps, etc.
|--tc_iot_hal_timer.h# Timer-related definitions
src/platform/
--CMakeLists.txt
|--linux
--CMakeLists.txt
|--tc_iot_hal_net.c# Implementation of TCP Unencrypted Direct Connection Network Interface
|--tc_iot_hal_os.c# Memory and Timestamp Implementation
|--tc_iot_hal_timer.c# Timer-related implementation
|--tc_iot_hal_tls.c#Implementation of TLS Encrypted Network Interface
The HAL layer provided in the C-SDK is a reference implementation based on POSIX-compliant systems such as Linux, but it is not tightly coupled and does not require implementation to conform to the POSIX interface. During porting, it can be flexibly adjusted according to the target system. All HAL layer functions are declared in include/platform/tc_iot_hal*.h, and all functions are prefixed with tc_iot_hal.
Edge computing using IoTSuit and SCF
Taking the setup of an electronic fence application as an example, users can quickly develop it in just five simple steps:
When a device is created in the cloud, the cloud will assign a device identifier, a communication channel, and configuration authentication information to the device.
Write the electronic fence message processing function and configure message forwarding rules;
Bind devices to functions, bind devices to rules;
Install the edge computing agent in the device, configure the device identifier, authentication information, and communication channel information;
Once the agent is activated, the cloud sends the geofence function to the local machine, and the verification function and rules take effect at the edge.
