Open-source IoT Platform

Device management, data collection, processing and visualization
for your IoT projects
Learn about Thingsboard

Tuesday, May 9, 2017

ThingsBoard v1.2.3 Release

We are pleased to announce today the availability of ThingsBoard v1.2.3 release that includes minor improvements and critical bug fixes.

What’s new:

Improvements:
  • Public dashboards;
  • Added support of custom headers for REST API Call Plugin;
  • Spline interpolation for timeseries charts;
  • Devices UI: show assigned customer name in device card;
  • Dashboards UI: show assigned customer name in dashboard card;
  • Add back navigation ability in customer profile view in full-screen mode;
  • Show server version on dashboard panel;
  • CORS support;
  • Chinese language.

Bug fixes:
  • Fixed windows installation script;
  • Fixed legend values selection/deselection for multiple devices;
  • Fixed selection of UI widget from bundle when adding new widget to dashboard;
  • Fixed shared attributes update subscription API;
  • Fixed Time Plugin to support timezone operations.

      Availability

      ThingsBoard v1.2.3 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World guide or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

      Friday, March 24, 2017

      Thingsboard 1.2.2 Release

      We are pleased to announce today the availability of Thingsboard 1.2.2 release that includes minor improvements and critical bug fixes.

      What’s new:

      Improvements:
      • IE browser support.
      • Ability to change language in user profile.
      • Korean localization.
      Bug fixes:
      • Fixed widget creation in Google Chrome.
      • Fixed session management for Gateway MQTT session.
      • Minor UI bug fixes.

        Availability

        Thingsboard 1.2.2 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World guide or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

        Thursday, March 23, 2017

        Thingsboard IoT Gateway now supports Sigfox integration


        We are pleased to announce today the availability of Thingsboard IoT Gateway v1.2. This release includes some bug fixes and integration with Sigfox. Now you are able to stream data from Sigfox Backend to Thingsboard for reliable and efficient storage, visualization and analytics.

        Thingsboard IoT Gateway 1.2 is available for download via the open source repository hosted on GitHub. To get started with the gateway try our Getting Started guide. In order to upgrade previous Thingsboard IoT Gateway installation follow the upgrade instructions.

        Thursday, March 16, 2017

        Thingsboard 1.2.1 Release

        We are pleased to announce today the availability of Thingsboard 1.2.1 release that includes minor improvements and critical bug fixes.

        What’s new:

        Improvements:
        • Fixed activation links for new users.
        • Switch dashboards using dashboard toolbar.
        • Import/export for plugins, rules, widget bundles and widget types.
        • Separate dispatchers for system and tenant rule/plugin actors.
        • Tenant is now able to see assigned and unassigned dashboards on the Dashboards page.
        • Windows build from sources.
        Bug fixes:
        • Fixed activation links for new users.
        • Fixed REST API to fetch time-series data
        • Fixed RPC and Table widgets functionality.

          Availability

          Thingsboard 1.2.1 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World guide or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

          Thursday, March 9, 2017

          Thingsboard 1.2.0 Release

          We are pleased to announce today the availability of Thingsboard 1.2 release that includes numerous UI improvements, data aggregation functionality, bug fixes and more.

          What’s new:

          • UI Improvements:
            • Global time selector.
            • Bar Chart widget.
            • Advanced legend integrated to Timeseries chart.
            • Advanced Tooltips.
            • Significant refactoring of widgets library API.
            • Zoom-in ability for timeseries charts.
          • Real-time data aggregation to speedup historical queries.
          • Ability to configure device aliases based on the name filter or predefined devices list.
          • Ability to switch devices in the dashboards.
          • Ability to setup default dashboard for user.
          • Ability to choose fullscreen by default for the dashboard.
          • Automatic updates checking feature.
          • Gateway MQTT API improvement for RPC and Attributes.

          Availability

          Thingsboard 1.2 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World guide or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

          Thursday, February 9, 2017

          Load testing of MQTT servers using Java, Maven and Gatling

          The rapid growth of IoT market dramatically increased the popularity of MQTT protocol. MQTT is supported by the most popular IoT platforms and is used for data collection, push notifications, real-time messaging and other.

          We would like to share our experience with running performance tests against MQTT servers in this article. We are going to concentrate on the tools that we used to generate load on the server. The results of the performance tests for our platform will be published as a separate post.

          Gatling

          We have chosen Gatling as a framework to run our test due to a number of reasons:

          • Generates beautiful reports out-of-the-box.
          • High performance and low overhead.
          • Easy setup of load scenarios.
          • Scalability of simulations.

          Unfortunately Gatling.io framework doesn’t support MQTT protocol out-of-the-box. At the same time Gatling is an open-source framework and we have found an unofficial MQTT plugin.

          Gatling MQTT Plugin

          Gatling-MQTT plugin was developed by Muneyuki Noguchi and at the moment it is hosted on GitHub under Apache 2.0 License. We have started implementation of Thingsboard performance testing project using Gatling and Gatling-MQTT plugin. Some time later we have realized that the plugin doesn’t support scenarios that we would like to verify and the behaviour of default scenario is not something that we have expected.

          The problem with the default scenario of the unofficial Gatling-MQTT plugin is that each time when some data is published, client waits for reply from server and sends MQTT disconnect. So, the message sequence looks like this:

          image

          This approach is very resource consuming and gives minimal benefits comparing to HTTP or other protocols. This behaviour is normal for HTTP requests-response model, but not for MQTT. The typical MQTT session is maintained for certain time and multiple MQTT publish messages are sent and received between client and MQTT broker. Of course, there are other types of MQTT messages, but they were out of scope for our tests. In our scenario, load testing of the IOT platform must be done in the following way:

          image

          So once we have connected a device to the IOT platform that acts as an MQTT broker, we will reuse session and publish MQTT messages using the same session. Sure, the session could be recreated at some point, but not every time we would like to publish a message to the server.

          In order to support this scenario, we have decided not to implement something new from the scratch, but rather to use Gatling-MQTT plugin as a base and considering fact that this is open-source we are free to modify the software as we wish to meet our needs.

          Gatling MQTT Plugin Fork

          We have done the fork of Gatling-MQTT plugin, spent some time on investigation how the plugin was constructed, modified it and added Connect, Publish and Disconnect actions as separate steps.

          Now we were able to support the expected scenario. The extended version of Gatling-MQTT plugin is located here Extended Gatling-MQTT.

          Finally, we were able to implement the scenario that suits our needs. The Gatling simulation below will create separate MQTT session for 10 simulated devices and will send 100 publish messages for each session.

          MqttSimulation.scala

          class MqttSimulation extends Simulation {
              val mqttConfiguration = mqtt
                  // MQTT broker
                  .host("tcp://localhost:1883")
              
              val connect = exec(mqtt("connect")
                  .connect())
              
              // send 100 publish MQTT messages
              val publish = repeat(100) {
                  exec(mqtt("publish")
                      // topic: "foo"
                      // payload: "Hello"
                      // QoS: AT_LEAST_ONCE (1)
                      // retain: false
                      .publish("foo", "Hello", QoS.AT_LEAST_ONCE, retain = false))
                      // 1 seconds pause between sending messages
                      .pause(1000 milliseconds)
                  }
              
              val disconnect = exec(mqtt("disconnect")
                .disconnect())
              
              val scn = scenario("MQTT Test")
                .exec(connect, publish, disconnect)
              
              setUp(scn
                  // linearly connect 10 devices over 1 second 
                  // and send 100 publish messages
                  .inject(rampUsers(10) over (1 seconds))
              ).protocols(mqttConfiguration)
          }
          

          Performance tests project

          Our performance test project is hosted on GitHub. It is mainly written in Java and uses Maven as a build tool. Gatling and Gatling-MQTT plugin are written in Scala, and use SBT tool for building sources and running tests. But here, at Thingsboard, we are more Java guys than Scala, that’s why we have implemented custom Java code that connects to the platform, creates a device, warms it up and provides the credentials id string back:

          MqttSimulation.scala

          // get the device credential ids of the created devices
          val deviceCredentialsIds: Array[String] = MqttStressTestTool.createDevices(testParams).asScala.toArray
          

          MqttStressTestTool.java

          RestClient restClient = new RestClient(params.getRestApiUrl());
          // login to the Thingsboard server
          restClient.login(params.getUsername(), params.getPassword());
          for (int i = 0; i < params.getDeviceCount(); i++) {
              // create device using REST API
              Device device = restClient.createDevice("Device " + UUID.randomUUID());
              // get credentials from the created device
              DeviceCredentials credentials = restClient.getCredentials(device.getId());
              // store in the array that eventually will be used by Simulation class    
              deviceCredentialsIds.add(credentials.getCredentialsId());
              String[] mqttUrls = params.getMqttUrls();
              String mqttURL = mqttUrls[i % mqttUrls.length];
              MqttStressTestClient client = new MqttStressTestClient(results, mqttURL, credentials.getCredentialsId());
              // connect to the server and do the warm up 
              client.connect().waitForCompletion();
              client.warmUp(data);
              client.disconnect();
          }
          Thread.sleep(1000);
          

          The list of credential ids is used in MqttSimulation.scala file to do the stress test itself:

          // get the device credential ids of the created devices
          val deviceCredentialsIds: Array[String] = MqttStressTestTool.createDevices(testParams).asScala.toArray
          
          // provide device credential id as username during the connection phase to the Thingsboard server
          val mqttConf = mqtt
              .host(testParams.getMqttUrls.head)
              .userName("${deviceCredentialsId}")
          
          val connect = exec(mqtt("connect").connect())
          
          val publish = repeat(testParams.getPublishTelemetryCount.toInt) {
              exec(mqtt("publish") 
                  // publish single message and verify that it was delivered at least once
                  .publish("v1/devices/me/telemetry", "{\"temp\":73.2}", QoS.AT_LEAST_ONCE, retain = false))
                  .pause(testParams.getPublishTelemetryPause milliseconds)
          }
          
          val disconnect = exec(mqtt("disconnect").disconnect())
          // create map of device credential ids of the connected devices  
          // and use it as a feeder in the scenario
          val deviceCredentialsIdsFeeder = deviceCredentialsIds.map( x => {Map("deviceCredentialsId" -> x)})
          
          val scn = scenario("Scenario Name")
              // go over the map and take column deviceCredentialsId as username
              .feed(deviceCredentialsIdsFeeder)
              .exec(connect, publish, disconnect)
          
          setUp(scn
              .inject(rampUsers(deviceCredentialsIds.length) over (1 seconds))
          ).protocols(mqttConf)
          

          For the guys who prefer Java and Maven there is a maven plugin - gatling-maven-plugin:

          <plugin>
              <groupId>io.gatling</groupId>
              <artifactId>gatling-maven-plugin</artifactId>
          </plugin>
          

          This plugin finds Simulation files in your project, compiles and runs them. Results will be stored inside of the target folder in a pretty format that you are able to inspect after the run:

          image

          image

          image

          To run the tests you simply can type:

          mvn clean install gatling:execute
          

          Summary

          In general, we have described our approach how we have generated high load on our IoT platform and verified that it provides good results.

          We will share the results of Thingsboard IoT platform performance tests in the next post.

          Also, we’ll describe code changes, improvements and instances tuning that we have done to achieve processing of more than 1 million MQTT messages per minute. These are basically the first steps for us in the direction of performance testing of the platform, and any feedback regarding this approach is more than welcome.

          We hope that the experience provided will help you to verify your solutions against load specifications that you expect to see in the production. Stay tuned by subscribing to our twitter, blog or by starring our project on Github.

          Tuesday, February 7, 2017

          Thingsboard IoT Gateway Release

          We are pleased to announce today the availability of Thingsboard IoT Gateway - an open-source solution that allows you to integrate devices connected to existing legacy and third-party systems with Thingsboard.

          Gateway features:

          • OPC-UA extension to collect data from devices that are connected to OPC-UA servers.
          • MQTT extension to collect data that is published to external MQTT brokers.
          • Persistence of collected data to guarantee data delivery in case of network and hardware failures.
          • Automatic reconnect to Thingsboard cluster.
          • Simple yet powerful mapping of incoming data and messages to unified format.

          Availability

          Thingsboard IoT Gateway 1.0 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard IoT Gateway try our getting started guide.

          Thingsboard 1.1.0 Release

          We are pleased to announce today the availability of Thingsboard 1.1.0, minor release that includes functionality to import-export widgets and dashboards, bug fixes and more.

          What’s new:

          • X.509 Certificates support as client credentials options
          • Map widgets improvements
          • Timeseries table widget
          • HTML card widget
          • MQTT API for Thingsboard Gateway
          • Windows installation package
          • Improved websocket connection handling and security
          • Bug fixes

          Availability

          Thingsboard 1.1.0 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World guide or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

          Tuesday, January 10, 2017

          Thingsboard 1.0.3 Minor Release

          We are pleased to announce today the availability of Thingsboard 1.0.3, minor release that includes functionality to import-export widgets and dashboards, bug fixes and more.

          What’s new:

          • Ability to import & export dashboards to JSON
          • Ability to import & export widgets to JSON in dashboard edit mode
          • Bug fixes

          Availability

          Thingsboard 1.0.3 is available for download via the open source repository hosted on GitHub. To get started with Thingsboard try our Hello World app or watch Getting Started Video. In order to upgrade previous Thingsboard installation follow the upgrade instructions.

          Thursday, January 5, 2017

          Temperature upload over MQTT using Raspberry Pi and DHT22 sensor

          Thingsboard is an open-source server-side platform that allows you to monitor and control IoT devices. It is free for both personal and commercial usage and you can deploy it anywhere. If this is your first experience with the platform we recommend to review what-is-thingsboard page and getting-started guide.

          This sample application performs collection of temperature and humidity values produced by DHT22 sensor and further visualization on the real-time web dashboard. Collected data is pushed via MQTT to Thingsboard server for storage and visualization. The purpose of this application is to demonstrate Thingsboard data collection API and visualization capabilities.

          The DHT22 sensor is connected to Raspberry Pi. Raspberry Pi offers a complete and self-contained Wi-Fi networking solution. Raspberry Pi push data to Thingsboard server via MQTT protocol by using paho mqtt python library. Data is visualized using built-in customizable dashboard. The application that is running on Raspberry Pi is written on python which is quite simple and easy to understand.

          The video below demonstrates the final result of this tutorial.





          Once you complete this sample/tutorial, you will see your sensor data on the following dashboard.

          image

          Prerequisites

          You will need to Thingsboard server up and running. Use either Live Demo or Installation Guide to install Thingsboard.

          List of hardware and pinouts

          image

          image

          • Resistor (between 4.7K and 10K)

          • Breadboard

          • 2 female-to-female jumper wires

          • 10 female-to-male jumper wires

          • 3 male-to-male jumper wire

          Wiring schemes

          DHT-22 Pin Raspberry Pi Pin
          DHT-22 Data Raspberry Pi GPIO 4
          DHT-22 VCC Raspberry Pi 3.3V
          DHT-22 GND (-) Raspberry Pi GND

          Finally, place a resistor (between 4.7K and 10K) between pin number 1 and 2 of the DHT sensor.

          The following picture summarizes the connections for this project:

          image

          Thingsboard configuration

          Note Thingsboard configuration steps are necessary only in case of local Thingsboard installation. If you are using Live Demo instance all entities are pre-configured for your demo account. However, we recommend to review this steps because you will still need to get device access token to send requests to Thingsboard.

          Provision your device

          This step contains instructions that are necessary to connect your device to Thingsboard.

          Open Thingsboard Web UI (http://localhost:8080) in browser and login as tenant administrator

          Goto “Devices” section. Click “+” button and create device with name “DHT22 Demo Device”.

          image

          Once device created, open its details and click “Manage credentials”. Copy auto-generated access token from the “Access token” field. Please save this device token. It will be referred to later as $ACCESS_TOKEN.

          image

          Click “Copy Device ID” in device details to copy your device id to clipboard. Paste your device id to some place, this value will be used in further steps.

          Provision your dashboard

          This step contains instructions that are necessary to provision new dashboard with map widgets to Thingsboard.

          Open “Terminal” and download file containing demo dashboard JSON:

          curl -L https://thingsboard.io/docs/samples/raspberry/resources/dht22_temp_dashboard.json > dht22_temp_dashboard.json
          

          Update dashboard configuration with your device Id (obtained in previous step) by issuing the following command:

          sed -i "s/{DEVICE_ID}/<your device id>/" dht22_temp_dashboard.json
          

          Obtain JWT token by issuing login POST command:

          curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' -d '{"username":"[email protected]", "password":"tenant"}' 'http://localhost:8080/api/auth/login'
          

          You will receive response in the following format:

          {"token":"$YOUR_JSON_TOKEN", "refreshToken": "$REFRESH_TOKEN"}
          

          copy $YOUR_JSON_TOKEN to some place. Note that it will be valid for 15 minutes by default.

          Execute dashboard upload command:

          curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' --header 'X-Authorization: Bearer $YOUR_JSON_TOKEN' -d "@dht22_temp_dashboard.json" 'http://localhost:8080/api/dashboard'
          

          Programming the Raspberry Pi

          MQTT library installation

          Following command will install MQTT Python library:

          sudo pip install paho-mqtt
          

          Adafruit DHT library installation

          Install python-dev package:

          sudo apt-get install python-dev
          

          Downloading and install the Adafruit DHT library:

          git clone https://github.com/adafruit/Adafruit_Python_DHT.git
          cd Adafruit_Python_DHT
          sudo python setup.py install
          

          Application source code

          Our application consists of single python script that is well commented. You will need to modify THINGSBOARD_HOST constant to match your Thingsboard server installation IP address or hostname. Use “demo.thingsboard.io” if you are using live demo server.

          The value of ACCESS_TOKEN constant corresponds to sample DHT22 demo device. If you are using live demo server - get the access token for pre-provisioned “DHT22 Demo Device”.

          resources/mqtt-dht22.py
          import os
          import time
          import sys
          import Adafruit_DHT as dht
          import paho.mqtt.client as mqtt
          import json
          
          THINGSBOARD_HOST = 'demo.thingsboard.io'
          ACCESS_TOKEN = 'DHT22_DEMO_TOKEN'
          
          # Data capture and upload interval in seconds. Less interval will eventually hang the DHT22.
          INTERVAL=2
          
          sensor_data = {'temperature': 0, 'humidity': 0}
          
          next_reading = time.time() 
          
          client = mqtt.Client()
          
          # Set access token
          client.username_pw_set(ACCESS_TOKEN)
          
          # Connect to Thingsboard using default MQTT port and 60 seconds keepalive interval
          client.connect(THINGSBOARD_HOST, 1883, 60)
          
          client.loop_start()
          
          try:
              while True:
                  humidity,temperature = dht.read_retry(dht.DHT22, 4)
                  humidity = round(humidity, 2)
                  temperature = round(temperature, 2)
                  print(u"Temperature: {:g}\u00b0C, Humidity: {:g}%".format(temperature, humidity))
                  sensor_data['temperature'] = temperature
                  sensor_data['humidity'] = humidity
          
                  # Sending humidity and temperature data to Thingsboard
                  client.publish('v1/devices/me/telemetry', json.dumps(sensor_data), 1)
          
                  next_reading += INTERVAL
                  sleep_time = next_reading-time.time()
                  if sleep_time > 0:
                      time.sleep(sleep_time)
          except KeyboardInterrupt:
              pass
          
          client.loop_stop()
          client.disconnect()
          

          Running the application

          This simple command will launch the application:

          python mqtt-dht22.py
          

          Data visualization

          Finally, open Thingsboard Web UI. You can access this dashboard by logging in as a tenant administrator.

          In case of local installation:

          In case of live-demo server:

          • login: your live-demo username (email)
          • password: your live-demo password

          See live-demo page for more details how to get your account.

          Go to “Devices” section and locate “DHT22 Demo Device”, open device details and switch to “Latest telemetry” tab. If all is configured correctly you should be able to see latest values of “temperature” and “humidity” in the table.

          image

          After, open “Dashboards” section then locate and open “DHT22: Temperature & Humidity Demo Dashboard”. As a result you will see two digital gauges and two time-series charts displaying temperature and humidity level (similar to dashboard image in the introduction).

          Next steps

          Browse other samples or explore guides related to main Thingsboard features:

          ESP8266 GPIO control over MQTT using Thingsboard

          Thingsboard is an open-source server-side platform that allows you to monitor and control IoT devices. It is free for both personal and commercial usage and you can deploy it anywhere. If this is your first experience with the platform we recommend to review what-is-thingsboard page and getting-started guide.

          This sample application will allow you to control GPIO of your ESP8266 device using Thingsboard web UI. We will observe GPIO control using Leds connected to the pins. The purpose of this application is to demonstrate Thingsboard RPC capabilities.

          The application that is running on ESP8266 is written using Arduino SDK which is quite simple and easy to understand. ESP8266 offers a complete and self-contained Wi-Fi networking solution. ESP8266 push data to Thingsboard server via MQTT protocol by using PubSubClient library for Arduino. Current GPIO state and GPIO control widget is visualized using built-in customizable dashboard.

          The video below demonstrates the final result of this tutorial.





          Prerequisites

          You will need to Thingsboard server up and running. Use either Live Demo or Installation Guide to install Thingsboard.

          List of hardware and pinouts

          image

          • USB to TTL

            image

            image

          • Breadboard

          • 2 female-to-female jumper wires

          • 7 female-to-male jumper wires

          • 2 Leds

          • 3.3V power source (for example 2 AA batteries)

          Wiring schemes

          Programming/flashing schema

          ESP8266 Pin USB-TTL Pin
          ESP8266 VCC USB-TTL VCC +3.3V
          ESP8266 CH_PD USB-TTL VCC +3.3V
          ESP8266 GND (-) USB-TTL GND
          ESP8266 GPIO 0 USB-TTL GND
          ESP8266 RX USB-TTL TX
          ESP8266 TX USB-TTL RX
          LED 1 Pin USB-TTL Pin
          cathode USB-TTL GND
          LED 1 Pin ESP8266 Pin
          anode ESP8266 GPIO 2

          The following picture summarizes the connections for this project in programming/debug mode:

          image

          Final schema (Battery Powered)

          ESP8266 Pin 3.3V power source
          ESP8266 VCC VCC+
          ESP8266 CH_PD VCC+
          ESP8266 GND (-) VCC-
          LED 1 Pin ESP8266 Pin
          anode ESP8266 GPIO 2
          LED 1 Pin 3.3V power source
          cathode VCC-
          LED 2 Pin ESP8266 Pin
          anode ESP8266 GPIO 0
          LED 2 Pin 3.3V power source
          cathode VCC-

          The final picture:

          image

          Thingsboard configuration

          Note Thingsboard configuration steps are necessary only in case of local Thingsboard installation. If you are using Live Demo instance all entities are pre-configured for your demo account. However, we recommend to review this steps because you will still need to get device access token to send requests to Thingsboard.

          Provision your device

          This step contains instructions that are necessary to connect your device to Thingsboard.

          Open Thingsboard Web UI (http://localhost:8080) in browser and login as tenant administrator

          Goto “Devices” section. Click “+” button and create device with name “ESP8266 Demo Device”.

          image

          Once device created, open its details and click “Manage credentials”. Copy auto-generated access token from the “Access token” field. Please save this device token. It will be referred to later as $ACCESS_TOKEN.

          image

          Click “Copy Device ID” in device details to copy your device id to clipboard. Paste your device id to some place, this value will be used in further steps.

          Provision your dashboard

          This step contains instructions that are necessary to provision new dashboard with map widgets to Thingsboard.

          Open “Terminal” and download file containing demo dashboard JSON:

          curl -L https://thingsboard.io/docs/samples/esp8266/resources/esp8266_gpio_dashboard.json > esp8266_gpio_dashboard.json
          

          Update dashboard configuration with your device Id (obtained in previous step) by issuing the following command:

          sed -i "s/{DEVICE_ID}/<your device id>/" esp8266_gpio_dashboard.json
          

          Obtain JWT token by issuing login POST command:

          curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' -d '{"username":"[email protected]", "password":"tenant"}' 'http://localhost:8080/api/auth/login'
          

          You will receive response in the following format:

          {"token":"$YOUR_JSON_TOKEN", "refreshToken": "$REFRESH_TOKEN"}
          

          copy $YOUR_JSON_TOKEN to some place. Note that it will be valid for 15 minutes by default.

          Execute dashboard upload command:

          curl -X POST --header 'Content-Type: application/json' --header 'Accept: application/json' --header 'X-Authorization: Bearer $YOUR_JSON_TOKEN' -d "@esp8266_gpio_dashboard.json" 'http://localhost:8080/api/dashboard'
          

          Programming the ESP8266

          Step 1. ESP8266 and Arduino IDE setup.

          In order to start programming ESP8266 device you will need Arduino IDE installed and all related software.

          Download and install Arduino IDE.

          After starting arduino, open from the ‘file’ menu the preferences.

          image

          Fill in the “Additional board managers URL” this url: http://arduino.esp8266.com/stable/package_esp8266com_index.json

          Close the screen by the OK button.

          Now we can add the board ESP8266 using the board manager.

          Click in the menu tools the menu option Board: “Most likely Arduino UNO”. There you will find the first option “Board Manager”.

          Type in the search bar the 3 letters ESP. Locate and click on “esp8266 by ESP8266 Community”. Click on install and wait for a minute to download the board.

          image

          Note that this tutorial was tested with the “esp8266 by ESP8266 Community” version 2.3.0.

          In the menu Tools “Board “Most likely Arduino UNO” three new boards are added.

          Select “Generic ESP8266 Module”.

          Prepare your hardware according to the Programming/flashing schema. Connect USB-TTL adapter with PC.

          Select in the menu Tools, port the corresponding port of the USB-TTL adapter. Open the serial monitor (by pressing CTRL-Shift-M or from the menu Tools). Set the key emulation to “Both NL & CR” and the speed to 115200 baud. This can be set in the bottom of terminal screen.

          Step 2. Install Arduino libraries.

          Open Arduino IDE and go to Sketch -> Include Library -> Manage Libraries. Find and install the following libraries:

          Note that this tutorial was tested with the following versions of the libraries:

          • PubSubClient 2.6
          • ArduinoJson 5.8.0

          Step 3. Prepare and upload sketch.

          Download and open esp8266-gpio-control.ino sketch.

          Note You need to edit following constants and variables in the sketch:

          • WIFI_AP - name of your access point
          • WIFI_PASSWORD - access point password
          • TOKEN - the $ACCESS_TOKEN from Thingsboard configuration step.
          • thingsboardServer - Thingsboard HOST/IP address that is accessable within your wifi network. Specify “demo.thingsboard.io” if you are using live demo server.
          resources/esp8266-gpio-control.ino
          #include <ArduinoJson.h>
          #include <PubSubClient.h>
          #include <ESP8266WiFi.h>
          
          #define WIFI_AP "YOUR_WIFI_AP"
          #define WIFI_PASSWORD "YOUR_WIFI_PASSWORD"
          
          #define TOKEN "ESP8266_DEMO_TOKEN"
          
          #define GPIO0 0
          #define GPIO2 2
          
          #define GPIO0_PIN 3
          #define GPIO2_PIN 5
          
          char thingsboardServer[] = "demo.thingsboard.io";
          
          WiFiClient wifiClient;
          
          PubSubClient client(wifiClient);
          
          int status = WL_IDLE_STATUS;
          
          // We assume that all GPIOs are LOW
          boolean gpioState[] = {false, false};
          
          void setup() {
            Serial.begin(115200);
            // Set output mode for all GPIO pins
            pinMode(GPIO0, OUTPUT);
            pinMode(GPIO2, OUTPUT);
            delay(10);
            InitWiFi();
            client.setServer( thingsboardServer, 1883 );
            client.setCallback(on_message);
          }
          
          void loop() {
            if ( !client.connected() ) {
              reconnect();
            }
          
            client.loop();
          }
          
          // The callback for when a PUBLISH message is received from the server.
          void on_message(const char* topic, byte* payload, unsigned int length) {
          
            Serial.println("On message");
          
            char json[length + 1];
            strncpy (json, (char*)payload, length);
            json[length] = '\0';
          
            Serial.print("Topic: ");
            Serial.println(topic);
            Serial.print("Message: ");
            Serial.println(json);
          
            // Decode JSON request
            StaticJsonBuffer<200> jsonBuffer;
            JsonObject& data = jsonBuffer.parseObject((char*)json);
          
            if (!data.success())
            {
              Serial.println("parseObject() failed");
              return;
            }
          
            // Check request method
            String methodName = String((const char*)data["method"]);
          
            if (methodName.equals("getGpioStatus")) {
              // Reply with GPIO status
              String responseTopic = String(topic);
              responseTopic.replace("request", "response");
              client.publish(responseTopic.c_str(), get_gpio_status().c_str());
            } else if (methodName.equals("setGpioStatus")) {
              // Update GPIO status and reply
              set_gpio_status(data["params"]["pin"], data["params"]["enabled"]);
              String responseTopic = String(topic);
              responseTopic.replace("request", "response");
              client.publish(responseTopic.c_str(), get_gpio_status().c_str());
              client.publish("v1/devices/me/attributes", get_gpio_status().c_str());
            }
          }
          
          String get_gpio_status() {
            // Prepare gpios JSON payload string
            StaticJsonBuffer<200> jsonBuffer;
            JsonObject& data = jsonBuffer.createObject();
            data[String(GPIO0_PIN)] = gpioState[0] ? true : false;
            data[String(GPIO2_PIN)] = gpioState[1] ? true : false;
            char payload[256];
            data.printTo(payload, sizeof(payload));
            String strPayload = String(payload);
            Serial.print("Get gpio status: ");
            Serial.println(strPayload);
            return strPayload;
          }
          
          void set_gpio_status(int pin, boolean enabled) {
            if (pin == GPIO0_PIN) {
              // Output GPIOs state
              digitalWrite(GPIO0, enabled ? HIGH : LOW);
              // Update GPIOs state
              gpioState[0] = enabled;
            } else if (pin == GPIO2_PIN) {
              // Output GPIOs state
              digitalWrite(GPIO2, enabled ? HIGH : LOW);
              // Update GPIOs state
              gpioState[1] = enabled;
            }
          }
          
          void InitWiFi() {
            Serial.println("Connecting to AP ...");
            // attempt to connect to WiFi network
          
            WiFi.begin(WIFI_AP, WIFI_PASSWORD);
            while (WiFi.status() != WL_CONNECTED) {
              delay(500);
              Serial.print(".");
            }
            Serial.println("Connected to AP");
          }
          
          
          void reconnect() {
            // Loop until we're reconnected
            while (!client.connected()) {
              status = WiFi.status();
              if ( status != WL_CONNECTED) {
                WiFi.begin(WIFI_AP, WIFI_PASSWORD);
                while (WiFi.status() != WL_CONNECTED) {
                  delay(500);
                  Serial.print(".");
                }
                Serial.println("Connected to AP");
              }
              Serial.print("Connecting to Thingsboard node ...");
              // Attempt to connect (clientId, username, password)
              if ( client.connect("ESP8266 Device", TOKEN, NULL) ) {
                Serial.println( "[DONE]" );
                // Subscribing to receive RPC requests
                client.subscribe("v1/devices/me/rpc/request/+");
                // Sending current GPIO status
                Serial.println("Sending current GPIO status ...");
                client.publish("v1/devices/me/attributes", get_gpio_status().c_str());
              } else {
                Serial.print( "[FAILED] [ rc = " );
                Serial.print( client.state() );
                Serial.println( " : retrying in 5 seconds]" );
                // Wait 5 seconds before retrying
                delay( 5000 );
              }
            }
          }
          

          Connect USB-TTL adapter to PC and select the corresponding port in Arduino IDE. Compile and Upload your sketch to device using “Upload” button.

          After application will be uploaded and started it will try to connect to Thingsboard node using mqtt client and upload current GPIOs state.

          Autonomous operation

          When you have uploaded the sketch, you may remove all the wires required for uploading including USB-TTL adapter and connect your ESP8266 and LEDs directly to power source according to the Final wiring schema.

          Troubleshooting

          In order to perform troubleshooting you should assemble your hardware according to the Programming/flashing schema. Then connect USB-TTL adapter with PC and select port of the USB-TTL adapter in Arduino IDE. Finally open “Serial Monitor” in order to view debug information produced by serial output.

          Data visualization

          Finally, open Thingsboard Web UI. You can access this dashboard by logging in as a tenant administrator.

          In case of local installation:

          In case of live-demo server:

          • login: your live-demo username (email)
          • password: your live-demo password

          See live-demo page for more details how to get your account.

          Once logged in, open Dashboards->ESP8266 GPIO Demo Dashboard page. You should observe demo dashboard with GPIO control and status panel for your device. Now you can switch status of GPIOs using control panel. As a result you will see LEDs status change on device and on the status panel.

          Below is the screenshot of the “ESP8266 GPIO Demo Dashboard”.

          image

          Next steps

          Browse other samples or explore guides related to main Thingsboard features:

          Tuesday, January 3, 2017

          Raspberry Pi GPIO control using Android Things and Thingsboard

          Thingsboard is an open-source server-side platform that allows you to monitor and control IoT devices. It is free for both personal and commercial usage and you can deploy it anywhere. If this is your first experience with the platform we recommend to review what-is-thingsboard page and getting-started guide.

          This sample application will allow you to control GPIO of your Raspberry Pi device using Thingsboard RPC widgets. We will observe GPIO control using Leds connected to the pins. The purpose of this application is to demonstrate Thingsboard RPC capabilities.

          Raspberry Pi will use simple Android Things application that will connect to Thingsboard server via MQTT and listen to RPC commands. Current GPIO state and GPIO control widget is visualized using built-in customizable dashboard.

          The video below demonstrates the final result of this tutorial.





          Prerequisites

          You will need to Thingsboard server up and running. Use either Live Demo or Installation Guide to install Thingsboard.

          List of hardware and pinouts

          • Raspberry Pi - we will use Raspberry Pi 3 Model B but you can use any other model.

          • 11 Leds with corresponding resistors

          • 13 female-to-male jumper wires

          Wiring schema

          Since our application will allow to control state of all available GPIO pins, we recommend to attach some LEDs to those pins for visibility. You can use this basic instruction or another one to wire some LEDs. Below is sample wiring schema used in this tutorial.

          image

          Programming the Raspberry Pi

          Flashing the Android Things image

          First you need to flash Android Things image to your Raspberry Pi board using this guide. After finishing this guide make sure that your board has Internet access and accessible via adb tool.

          Android Things development environment

          Before starting with application introduced in this tutorial you need to prepare development environment to work with Android Things applications. Follow instructions from the official guide to build and deploy your first Android Things application.

          Application source code

          Now you should obtain source code of the GpioControlSample application from Thingsboard sanples GitHub repository. You can do this by issuing the following git clone command:

          git clone https://github.com/thingsboard/samples
          

          Open cloned samples folder and navigate to android-things/GpioControlSample.

          Open GpioControlActivity.java file located at app/src/main/java/org/thingsboard/sample/gpiocontrol folder.

          You will need to modify THINGSBOARD_HOST constant to match your Thingsboard server installation IP address or hostname. Use “demo.thingsboard.io” if you are using live demo server.

          The value of ACCESS_TOKEN constant corresponds to sample Raspberry Pi device in pre-provisioned demo data. If you are using live demo server - get the access token for pre-provisioned “Raspberry Pi Demo Device”.

          Running the application

          Make sure that your Raspberry device is accessible via adb tool:

          adb devices
          

          Navigate to GpioControlSample application folder and deploy application to the device:

          ./gradlew assembleDebug
          adb push ./app/build/outputs/apk/app-debug.apk /data/local/tmp/org.thingsboard.sample.gpiocontrol
          adb shell pm install -r "/data/local/tmp/org.thingsboard.sample.gpiocontrol"
          

          Or you can use other options to deploy Android application:

          Finally you can start the application by issuing the following adb command:

          adb shell am start -n "org.thingsboard.sample.gpiocontrol/org.thingsboard.sample.gpiocontrol.GpioControlActivity" -a android.intent.action.MAIN -c android.intent.category.LAUNCHER
          

          Data visualization

          In order to simplify this guide we have included “Raspberry PI GPIO Demo Dashboard” to the demo data that is available in each thingboard installation. Of course, you can modify this dashboard: tune, add, delete widgets, etc. You can access this dashboard by logging in as a tenant administrator.

          In case of local installation:

          In case of live-demo server:

          • login: your live-demo username (email)
          • password: your live-demo password

          See live-demo page for more details how to get your account.

          Once logged in, open Dashboards->Raspberry PI GPIO Demo Dashboard page. You should observe demo dashboard with GPIO control and status panel for your device. Now you can switch status of GPIOs using control panel. As a result you will see LEDs status change on device and on the status panel.

          Below is the screenshot of the “Raspberry PI GPIO Demo Dashboard”.

          image

          Next steps

          Browse other samples or explore guides related to main Thingsboard features: