TCP Integration

Overview
Prerequisites
Create Converter templates
- Uplink Converter template
- Downlink Converter template
Create Integration template
Modify the Edge Root Rule chain for Downlinks
Assign Integration to Edge
Installing and running external TCP Integration
Send uplink message
Send a downlink message
Next steps

Overview

TCP Integration allows data to be streamed to ThingsBoard Edge from devices that use a TCP transport protocol, and converts payloads from these devices to the ThingsBoard Edge format.

To learn more, review the integration diagram:

Prerequisites

In this tutorial, we will use:

ThingsBoard Edge Professional Edition;
TCP Integration: The integration that runs externally and is connected to the ThingsBoard Edge instance.
echo command: To display a line of text, and redirect its output to the netcat (nc) utility.
netcat (nc) utility: To establish TCP connections, receive data from there, and transmit it.

Let’s assume that we have a sensor which is sending current temperature and humidity readings. Our sensor device SN-002 publishes its temperature and humidity readings to TCP Integration on port 10560 on the machine where TCP Integration is running.

For demonstration purposes, we assume that our device is smart enough to send data in 3 different payload types:

Text: The payload is

SN-002,default,temperature,25.7\n\rSN-002,default,humidity,69

JSON: The payload is:

[
  {
    "deviceName": "SN-002",
    "deviceType": "default",
    "temperature": 25.7,
    "humidity": 69
  }
]

Binary: The binary payload is (in HEX string):

\x30\x30\x30\x30\x11\x53\x4e\x2d\x30\x30\x32\x64\x65\x66\x61\x75\x6c\x74\x32\x35\x2e\x37\x00\x00\x00

The bytes description in this payload is following:
- 0-3 bytes: \x30\x30\x30\x30 - These are the “dummy” bytes. They show how to skip certain prefix bytes in your payload and are included as an example.
- 4 byte: \x11 - The payload length. If we convert it to decimal, it is 17. So, in this case, our payload is limited to 17 bytes from the incoming TCP frame.
- 5-10 bytes: \x53\x4e\x2d\x30\x30\x32 - The device name. If we convert it to text, it is SN-002.
- 11-17 bytes: \x64\x65\x66\x61\x75\x6c\x74 - The device type. If we convert it to text, it is default.
- 18-21 bytes: \x32\x35\x2e\x37 - The temperature telemetry. If we convert it to text, it is 25.7.
- 22-24 bytes: \x00\x00\x00 - These are the “dummy” bytes. We will ignore them because the payload size is 17 bytes (from 5 to 21 byte). These bytes are included as an example.

Select the payload type based on your device capabilities and business cases.

Create Converter templates

To create Converter and Integration templates, log in to the Cloud instance as Tenant administrator.

Uplink Converter template

Before creating the Integration template, create an Uplink and Downlink converter templates in Converters templates section.

The uplink data converter is needed to convert the incoming data from the device into the format required for display on ThingsBoard Edge.

Log in to the Cloud and go to the Edge management > Converter templates section. To create a Converter template, click the “Add data converter” button (the + icon) and select the “Create new converter” option.
In the “Add data converter” pop-up window:
- Name: Enter the name of the data converter.
- Type: Select the “Uplink” converter type from the drop-down menu.
- To view the events, enable Debug mode.
- function Decoder: Enter a script to parse and transform data.
- Click the “Add” button.

Select the device payload type to use for a decoder configuration:

Text payload

JSON payload

Binary payload

Now copy & paste the following script to the Decoder function section:

/** Decoder **/

// decode payload to string
var strArray = decodeToString(payload);
var payloadArray = strArray.replace(/\"/g, "").replace(/\s/g, "").split(',');

var telemetryKey = payloadArray[2];
var telemetryValue = payloadArray[3]; 

var telemetryPayload = {};
telemetryPayload[telemetryKey] = telemetryValue;

// Result object with device attributes/telemetry data
var result = {
    deviceName: payloadArray[0],
    deviceType: payloadArray[1],
    telemetry: telemetryPayload,
    attributes: {}
  };

/** Helper functions **/

function decodeToString(payload) {
   return String.fromCharCode.apply(String, payload);
}

return result;

The purpose of the decoder function is to parse the incoming data and metadata to a format that ThingsBoard can consume. deviceName and deviceType are required, while attributes and telemetry are optional. attributes and telemetry are flat key-value objects. Nested objects are not supported.

Now copy & paste the following script to the Decoder function section:

/** Decoder **/

// decode payload to JSON
var data = decodeToJson(payload);

// Result object with device/asset attributes/telemetry data

var deviceName = data.deviceName;
var deviceType = data.deviceType;
var result = {
   deviceName: deviceName,
   deviceType: deviceType,
   attributes: {},
   telemetry: {
       temperature: data.temperature,
       humidity: data.humidity
   }
};

/** Helper functions **/

function decodeToString(payload) {
   return String.fromCharCode.apply(String, payload);
}

function decodeToJson(payload) {
   // covert payload to string.
   var str = decodeToString(payload);

   // parse string to JSON
   var data = JSON.parse(str);
   return data;
}

return result;

Now copy & paste the following script to the Decoder function section:

/** Decoder **/

// decode payload to string
var payloadStr = decodeToString(payload);

// decode payload to JSON
// var data = decodeToJson(payload);

var deviceName = payloadStr.substring(0,6);
var deviceType = payloadStr.substring(6,13);

// Result object with device/asset attributes/telemetry data
var result = {
   deviceName: deviceName,
   deviceType: deviceType,
   attributes: {},
   telemetry: {
       temperature: parseFloat(payloadStr.substring(13,17))
   }
};

/** Helper functions **/

function decodeToString(payload) {
   return String.fromCharCode.apply(String, payload);
}

function decodeToJson(payload) {
   // covert payload to string.
   var str = decodeToString(payload);

   // parse string to JSON
   var data = JSON.parse(str);
   return data;
}

return result;

You can change the function Decoder while creating the converter or after creating it:

If the converter has already been created, click it to open the “Data converter details” window.
Click the “Edit” buton (the pencil icon) to edit the data converter.
Copy the configuration example or create your own converter configuration and paste it into the “function Decoder” field.
To save the changes, click the “Save” button (the checkmark icon).

Downlink Converter template

Also create the Downlink Converter Template in the Converter Templates section.

On the Edge management > Converter templates section page, click the “Add data converter” button (the + icon) to create another Converter template, and select the “Create new converter” option.
In the “Add data converter” pop-up window:
- Name: Enter the name of the data converter.
- Type: Select the “Downlink” converter type from the drop-down menu.
- To view the events, enable Debug mode.
- function Decoder: Enter a script to parse and transform data.
- Click the “Add” button.

You can customize a downlink according to your configuration. Let’s consider an example where we send an attribute update message. An example of a downlink converter:

// Encode downlink data from incoming Rule Engine message

// msg - JSON message payload downlink message json
// msgType - type of message, for ex. 'ATTRIBUTES_UPDATED', 'POST_TELEMETRY_REQUEST', etc.
// metadata - list of key-value pairs with additional data about the message
// integrationMetadata - list of key-value pairs with additional data defined in Integration executing this converter

var result = {

    // downlink data content type: JSON, TEXT or BINARY (base64 format)
    contentType: "JSON",

    // downlink data
    data: JSON.stringify(msg),

    // Optional metadata object presented in key/value format
    metadata: {
    }
};

return result;

Create Integration template

Now that the Uplink and Downlink converter templates have been created, it is possible to create the Integration:

Go to the Edge management > Integration templates section, click the “Add new integration” button (the + icon) and select the “Create new integration” option.
In the “Add integration” pop-up window and fill out the “Basic settings” block:
- Integration type: Select the “TCP” integration type from the drop-down menu.
- Name: Enter the name of the integration.
In the “Uplink data converter” block:
- Select the “Select existing” tab.
- Uplink data converter: Select the uplink data converter from the drop-down menu.
In the “Downlink data converter” block:
- Select the “Select existing” tab.
- Downlink data converter: Select the uplink data converter from the drop-down menu.
In the “Connection” block:
- Handler Configuration: Select the device payload type from the drop-down menu.

We keep other options by default, but there is a short description of them:

Max number of pending connects on the socket: The maximum queue length for incoming connection indications (a request to connect) is set by the backlog parameter. If a connection indication arrives when the queue is full, the connection is denied.
Size of the buffer for inbound socket: Specifies the size (in kilobytes) of the socket’s data receive buffer.
Size of the buffer for outbound socket: Specifies the size (in kilobytes) of the socket’s data send buffer.
Enable sending of keep-alive messages on connection-oriented sockets: When enabled, the socket will periodically send keep-alive probes across the network to the peer, to ensure that the connection remains active.
Forces a socket to send the data without buffering (disable Nagle’s buffering algorithm): Disables Nagle’s algorithm on the socket, ensuring that data is sent immediately rather than waiting for a larger amount of data to accumulate.

Select the device payload type for Handler Configuration:

Text payload

JSON payload

Binary payload

To parse payload properly, please make sure that next values are set:

Max Frame Length - the maximum length of the decoded frame. An exception will be thrown if the length of the frame exceeds this value; Leave it by default for this demo - 128;
Strip Delimiter - whether the decoded frame should strip out the delimiter or not. Please check it to drop newline delimiter from the payload;
Message Separator - specify it to System Line Separator - in this case newline symbol will be used as delimiter;

To parse payload properly, please make sure that next values are set:

Max Frame Length - the maximum length of the decoded frame. An exception will be thrown if the length of the frame exceeds this value; Leave it by default for this demo - 128;
Length Field Offset - the offset of the length field. In our case length field is 5th byte in the payload \x30\x30\x30\x30 \x11 \x53…. So set it to 4;
Length Field Length - the length of the length field. In our case length of the length field is 1 byte …\x30 \x11 \x53…. So set it to 1;
Length Adjustment (the compensation value to add to the value of the length field) - the compensation value to add to the value of the length field. In our case we don’t need this compensation, as length field contains correct value - 17 bytes. So leave it 0;
Number of first bytes to strip out from the decoded frame - the number of first bytes to strip out from the decoded frame. We need to skip first 5 bytes from the decoded payload, to get our data - \x30\x30\x30\x30\x11 \x53\x4e\x2d\x30…. So set it to 5;

Modify the Edge Root Rule chain for Downlinks

We can send a downlink message to the device from the Rule chain using the rule node. To send downlink via integration, modify the Edge Root Rule chain.

For example, create an integration downlink node and set the ‘Attributes updated’ link to it. When changes are made to the device attribute, the downlink message is sent to the integration.

Assign Integration to Edge

Once the converter and integration templates are created, we can assign the Integration template to the Edge.

Go to the Edge management > Instances section and click the Manage edge integrations button.
On the Integration page, click the "Assign to edge" button. In the "Assign the Integration to the Edge" pop-up window, select the integration from the drop-down menu and click the "Assign" button.
Login to your ThingsBoard Edge instance and go to the Integrations center > Integrations section. Confirm the TCP integration on the Edge.

Go to the <b>Edge management > Instances</b> section and click the <b>Manage edge integrations</b> button. — Go to the **Edge management > Instances** section and click the **Manage edge integrations** button.

On the Integration page, click the <b>"Assign to edge"</b> button. In the <b>"Assign the Integration to the Edge"</b> pop-up window, select the integration from the drop-down menu and click the <b>"Assign"</b> button. — On the Integration page, click the **"Assign to edge"** button. In the **"Assign the Integration to the Edge"** pop-up window, select the integration from the drop-down menu and click the **"Assign"** button.

Login to your <b>ThingsBoard Edge</b> instance and go to the <b>Integrations center > Integrations</b> section. Confirm the <b>TCP integration</b> on the <b>Edge</b>. — Login to your **ThingsBoard Edge** instance and go to the **Integrations center > Integrations** section. Confirm the **TCP integration** on the **Edge**.

Installing and running external TCP Integration

To install the remote TCP Integration service on a local or separate machine, select the appropriate platform.

Docker on Linux or Mac OS

Docker on Windows

Ubuntu

CentOS/RHEL Server

To run the integration via Docker, make sure you have installed Docker CE

Execute the following command to pull the image:

docker pull thingsboard/tb-pe-tcp-udp-integration:4.0.1PE

Create a volume for the integration logs (799 is the user ID of the non-root ThingsBoard Docker user):

mkdir -p ~/.tb-pe-tcp-udp-integration-logs && sudo chown -R 799:799 ~/.tb-pe-tcp-udp-integration-logs

Execute the following command to run the integration:

docker run -it -p 10560:10560 -v ~/.tb-pe-tcp-udp-integration-logs:/var/log/tb-tcp-udp-integration  \-e "RPC_HOST=mytbedge" -e "RPC_PORT=9090" \
-e "INTEGRATION_ROUTING_KEY=YOUR_ROUTING_KEY"  -e "INTEGRATION_SECRET=YOUR_SECRET" \
--name my-tb-pe-tcp-udp-integration --network NETWORK_NAME \
--restart always thingsboard/tb-pe-tcp-udp-integration:4.0.1PE

Where:

mytbedge: The host name of the ThingsBoard Edge service.
9090: The integration port. It is configured by the INTEGRATIONS_RPC_PORT environment variable in the tb-edge.yml file.
-p 10560:10560: Connect a local port 10560 to exposed internal port 10560 for the TCP integration.
YOUR_ROUTING_KEY: Replace it with the actual integration routing key.
YOUR_SECRET: Replace it with the actual integration secret.
docker run: The command to run this container.
-it: Attaches a terminal session with current ThingsBoard remote integration process output.
-v ~/.tb-pe-tcp-udp-integration-logs:/var/log/tb-tcp-udp-integration: Mounts the host’s dir ~/.tb-pe-tcp-udp-integration-logs to ThingsBoard remote integration logs directory.
–name tb-pe-tcp-udp-integration: Set the local name for the integration.
–network NETWORK_NAME: The network name in which the mytbedge service operates. Replace the NETWORK_NAME value with the actual network name.
- To check the network name, run the following command:
```
1
docker network ls
```
–restart always: The command automatically starts ThingsBoard Integration if the system reboots and restarts in case of failure.
thingsboard/tb-pe-tcp-udp-integration:4.0.1PE: The docker image.

After executing this command, you can open the logs located here: ~/.tb-pe-tcp-udp-integration-logs. You should be able to see INFO log messages containing your latest integration configuration that arrived from the server.

To keep the container running in the background but detach from the session terminal, press the key sequence Ctrl+p followed by Ctrl+q.

Reattaching, stop and start commands

To reattach to the terminal (to see ThingsBoard remote integration logs), run:

docker attach my-tb-pe-tcp-udp-integration

To stop the container:

docker stop my-tb-pe-tcp-udp-integration

To start the container:

docker start my-tb-pe-tcp-udp-integration

Troubleshooting

NOTE If you observe errors related to DNS issues, for example

127.0.1.1:53: cannot unmarshal DNS message

You may configure your system to use Google public DNS servers. See corresponding Linux and Mac OS instructions.

To run the integration via Docker, make sure you have installed Docker Toolbox for Windows

Windows users should use a docker-managed volume for the remote integration logs. Before executing docker, create the docker volume (for ex. tb-tcp-udp-integration-logs). Open the Docker Quickstart Terminal and run the following command:

docker volume create tb-pe-tcp-udp-integration-logs

Run the integration using the following command:

docker run -it -p 10560:10560 -v tb-pe-tcp-udp-integration-logs:/var/log/tb-tcp-udp-integration `-e "RPC_HOST=mytbedge" -e "RPC_PORT=9090" `
-e "INTEGRATION_ROUTING_KEY=YOUR_ROUTING_KEY"  -e "INTEGRATION_SECRET=YOUR_SECRET" `
--name my-tb-pe-tcp-udp-integration --network edge_docker_default `
--restart always thingsboard/tb-pe-tcp-udp-integration:4.0.1PE

Where:

mytbedge: The host name of the ThingsBoard Edge service.
9090: The integration port. It is configured by the INTEGRATIONS_RPC_PORT environment variable in the tb-edge.yml file.
-p 10560:10560: Connect a local port 10560 to exposed internal port 10560 for the TCP integration.
YOUR_ROUTING_KEY: Replace it with the actual integration routing key.
YOUR_SECRET: Replace it with the actual integration secret.
docker run: The command to run this container.
-it: Attaches a terminal session with current ThingsBoard remote integration process output.
-v tb-pe-tcp-udp-integration-logs:/var/log/tb-tcp-udp-integration: Mounts the host’s dir ~/.tb-pe-tcp-udp-integration-logs to ThingsBoard remote integration logs directory.
–name tb-pe-tcp-udp-integration: Set the local name for the integration.
–network edge_docker_default: The network name in which the mytbedge service operates.
–restart always: The command automatically starts ThingsBoard Integration if the system reboots and restarts in case of failure.
thingsboard/tb-pe-tcp-udp-integration:4.0.1PE The docker image.

To keep the container running in the background but detach from the session terminal, press the key sequence Ctrl+p followed by Ctrl+q.

Reattaching, stop and start commands

To reattach to the terminal (to see ThingsBoard remote integration logs), run:

docker attach my-tb-pe-tcp-udp-integration

To stop the container:

docker stop my-tb-pe-tcp-udp-integration

To start the container:

docker start my-tb-pe-tcp-udp-integration

Troubleshooting

NOTE If you observe errors related to DNS issues, for example

127.0.1.1:53: cannot unmarshal DNS message

You may configure your system to use Google public DNS servers

Install Java 17 (OpenJDK)

ThingsBoard service is running on Java 17. To install OpenJDK 17, follow these instructions

sudo apt update && sudo apt install openjdk-17-jdk-headless

Configure your operating system to use OpenJDK 17 by default. You can configure the default version by running the following command:

sudo update-alternatives --config java

To check the installed Java version on your system, use the following command:

java -version

The expected result is:

openjdk version "17.x.xx" 
OpenJDK Runtime Environment (...)
OpenJDK 64-Bit Server VM (...)

Download the installation package:

wget https://dist.thingsboard.io/tb-tcp-udp-integration-4.0.1pe.deb

Install the integration as a service:

sudo dpkg -i tb-tcp-udp-integration-4.0.1pe.deb

Open the file for editing:

sudo nano /etc/tb-tcp-udp-integration/conf/tb-tcp-udp-integration.conf

Locate the following configuration block:

# UNCOMMENT NEXT LINES AND PUT YOUR CONNECTION PARAMETERS:
# export RPC_HOST=thingsboard.cloud
# export RPC_PORT=9090
# export INTEGRATION_ROUTING_KEY=YOUR_INTEGRATION_KEY
# export INTEGRATION_SECRET=YOUR_INTEGRATION_SECRET

Enter your configuration parameters:

RPC_HOST: Use the Edge instance’s IP address, or localhost if it’s running on the same machine.
9090: The integration port. It is configured by the INTEGRATIONS_RPC_PORT environment variable in the tb-edge.yml file.
YOUR_ROUTING_KEY: Replace it with the actual integration routing key.
YOUR_SECRET: Replace it with the actual integration secret.

Make sure to uncomment the export statement. See the example below:

# UNCOMMENT NEXT LINES AND PUT YOUR CONNECTION PARAMETERS:
export RPC_HOST=127.0.0.1 # THE IP ADDRESS OF YOUR EDGE INSTANCE
export RPC_PORT=9090
export INTEGRATION_ROUTING_KEY=b75**************************34d
export INTEGRATION_SECRET=vna**************mik

Start the ThingsBoard integration:

sudo service tb-tcp-udp-integration start

Advanced configuration

You can find and update additional configuration parameters in the tb-tcp-udp-integration.conf file.

To open the file for editing, use the following command:

sudo nano /etc/tb-tcp-udp-integration/conf/tb-tcp-udp-integration.conf

After updating the configuration, you can check the logs in /var/log/tb-tcp-udp-integration/ to verify that the integration is running correctly. Look for INFO log messages that show the latest integration configuration received from the server.

Install Java 17 (OpenJDK)

ThingsBoard service is running on Java 17. Follow this instructions to install OpenJDK 17:

sudo dnf install java-17-openjdk-headless

Please don’t forget to configure your operating system to use OpenJDK 17 by default. You can configure which version is the default using the following command:

sudo update-alternatives --config java

You can check the installation using the following command:

java -version

Expected command output is:

openjdk version "17.x.xx"
OpenJDK Runtime Environment (...)
OpenJDK 64-Bit Server VM (build ...)

Download the installation package:

wget https://dist.thingsboard.io/tb-tcp-udp-integration-4.0.1pe.rpm

Install the integration as a service:

sudo rpm -Uvh tb-tcp-udp-integration-4.0.1pe.rpm

Open the file for editing:

sudo nano /etc/tb-tcp-udp-integration/conf/tb-tcp-udp-integration.conf

Locate the following configuration block:

# UNCOMMENT NEXT LINES AND PUT YOUR CONNECTION PARAMETERS:
# export RPC_HOST=thingsboard.cloud
# export RPC_PORT=9090
# export INTEGRATION_ROUTING_KEY=YOUR_INTEGRATION_KEY
# export INTEGRATION_SECRET=YOUR_INTEGRATION_SECRET

Enter your configuration parameters:

RPC_HOST: Use the Edge instance’s IP address, or localhost if it’s running on the same machine.
9090: The integration port. It is configured by the INTEGRATIONS_RPC_PORT environment variable in the tb-edge.yml file.
YOUR_ROUTING_KEY: Replace it with the actual integration routing key.
YOUR_SECRET: Replace it with the actual integration secret.

Make sure to uncomment the export statement. See the example below:

# UNCOMMENT NEXT LINES AND PUT YOUR CONNECTION PARAMETERS:
export RPC_HOST=127.0.0.1 # THE IP ADDRESS OF YOUR EDGE INSTANCE
export RPC_PORT=9090
export INTEGRATION_ROUTING_KEY=b75**************************34d
export INTEGRATION_SECRET=vna**************mik

Start the ThingsBoard integration:

sudo service tb-tcp-udp-integration start

Advanced configuration

You can find and update additional configuration parameters in the tb-tcp-udp-integration.conf file.

To open the file for editing, use the following command:

sudo nano /etc/tb-tcp-udp-integration/conf/tb-tcp-udp-integration.conf

Send uplink message

Once the ThingsBoard TCP Integration has been created, the TCP server starts, and then it waits for data from the devices.

To send the uplink message, select the device payload type:

Text payload

JSON payload

Binary payload

The command to send a message to the TCP server that is running on localhost (127.0.0.1) will look like this:

echo -e 'SN-002,default,temperature,25.7' | nc -q0 127.0.0.1 10560

We can also send multiple messages in one string, separated by Message Separator (System Line Delimiter). Newline delimiter (\n) will be used to split payload into multiple messages.

In this case, the command will look like this:

echo -e 'SN-002,default,temperature,25.7\nSN-002,default,humidity,69' | nc -q1 -w1 127.0.0.1 10560

The command to send a message to the TCP server that is running on localhost (127.0.0.1) will look like this:

echo -e -n '{"deviceName": "SN-002", "deviceType": "default", "temperature": 25.7, "humidity": 69}' | nc -q1 -w1 127.0.0.1 10560

The command to send a message to the TCP server that is running on localhost (127.0.0.1) will look like this:

echo -e -n '\x30\x30\x30\x30\x11\x53\x4e\x2d\x30\x30\x32\x64\x65\x66\x61\x75\x6c\x74\x32\x35\x2e\x37\x00\x00\x00' | nc -q1 -w1 127.0.0.1 10560

To view the received time-series data, go to the Entities > Devices section, click the device and select the “Latest telemetry” tab:

The received data can be viewed in the Uplink converter:

Go to the Integrations center > Data converters section and click the Uplink converter.
On the “Data converter details” page, select the “Events” tab.
View the message details in the “In” and “Out” columns.

Send a downlink message

To check the downlink functionality. Let’s add the firmware shared attribute:

Go to the Entities > Devices section, click the device to open the “Device details” page.
Select the “Attributes” tab and the “Shared attributes” scope.
To add the firmware attribute, click the “Add” button and enter the configuration parameters.

To confirm the downlink message sent to the device, go to the Integrations center > Integrations section, click the TCP integration and select the “Events” tab:

To see the downlink response, select and send another message to the TCP integration:

Text payload
Text payload
(multiple messages)
JSON payload
Binary payload

echo -e 'SN-002,default,temperature,25.7' | nc 127.0.0.1 10560

echo -e 'SN-002,default,temperature,25.7\nSN-002,default,humidity,69' | nc -w60 127.0.0.1 10560

echo -e -n '{"deviceName": "SN-002", "deviceType": "default", "temperature": 25.7, "humidity": 69}' | nc -w60 127.0.0.1 10560

echo -e -n '\x30\x30\x30\x30\x11\x53\x4e\x2d\x30\x30\x32\x64\x65\x66\x61\x75\x6c\x74\x32\x35\x2e\x37\x00\x00\x00' | nc -w60 127.0.0.1 10560

An example of the message sent to the device and the response from ThingsBoard Edge in the terminal:

Next steps

Getting started guide - Provide quick overview of main ThingsBoard Edge features. Designed to be completed in 15-30 minutes:
Installation guides - Learn how to setup ThingsBoard Edge on various available operating systems and connect to ThingsBoard Server.
Edge Rule Engine:
- Rule Chain Templates - Learn how to use ThingsBoard Edge Rule Chain Templates.
- Provision Rule Chains from cloud to edge - Learn how to provision edge rule chains from cloud to edge.
Security:
- gRPC over SSL/TLS - Learn how to configure gRPC over SSL/TLS for communication between edge and cloud.
Features:
- Edge Status - Learn about Edge Status page on ThingsBoard Edge.
- Cloud Events - Learn about Cloud Events page on ThingsBoard Edge.
Use cases:
- Manage alarms and RPC requests on edge devices - This guide will show how to generate local alarms on the edge and send RPC requests to devices connected to edge:
- Data filtering and traffic reduce - This guide will show how to send to cloud from edge only filterd amount of device data:
Roadmap - ThingsBoard Edge roadmap.