There are many IoT platforms out there, including Adafruit's own Adafruit.IO, but if you want to build really big projects or run a business using IoT, you'll need to use a platform that provides support for projects that scale. Microsoft Azure has resources for these types of applications and the best news is that you can use it with CircuitPython.

This guide will walk you through how to get started with Microsoft Azure using a Feather ESP32-S2 TFT and a BME688 sensor to monitor temperature, humidity and air pressure. The data is logged to Microsoft Azure every fifteen minutes and can be viewed on a dashboard.

The guide's pages are organized in the order needed to successfully use Microsoft Azure with CircuitPython. You'll need to follow the setup steps for Microsoft Azure before running the CircuitPython code.

The Feather ESP32-S2 TFT's screen displays the data from the BME688 sensor, battery life and the timestamp for the last time the data was sent to Microsoft Azure.

The project is battery-powered so you can place it exactly where you want it. A large 2500mAh battery provides a very long runtime before needing to recharge.

Prerequisite Guides

Parts

Adafruit ESP32-S2 TFT Feather powered on by a USB- C power source displaying the product tittle in a red, yellow, green, white and blue.
We've got a new machine here at Adafruit, it can uncover your deepest desires. Don't believe me? I'll turn it on right now to prove it to you! What, you want unlimited...
$24.95
In Stock
Angled shot of BME688 sensor breakout.
The long-awaited BME688 from Bosch gives you all the environmental sensing you want in one small package. This little sensor...
$19.95
In Stock
Lithium Ion Polymer Battery 3.7v 2500mAh with JST 2-PH connector
Lithium-ion polymer (also known as 'lipo' or 'lipoly') batteries are thin, light, and powerful. The output ranges from 4.2V when completely charged to 3.7V. This...
$14.95
In Stock
Angled of of JST SH 4-Pin Cable.
This 4-wire cable is 50mm / 1.9" long and fitted with JST SH female 4-pin connectors on both ends. Compared with the chunkier JST PH these are 1mm pitch instead of 2mm, but...
$0.95
In Stock
Angled shot of coiled pink and purple USB cable with USB A and USB C connectors.
This cable is not only super-fashionable, with a woven pink and purple Blinka-like pattern, it's also made for USB C for our modernized breakout boards, Feathers, and...
$2.95
In Stock
Black Nylon Screw and Stand-off Set with M2.5 Threads, kit box
Totaling 380 pieces, this M2.5 Screw Set is a must-have for your workstation. You'll have enough screws, nuts, and hex standoffs to fuel your maker...
$16.95
In Stock

The project may be mounted on a 3D printed stand, described below. The stand consists of two parts: the Feather mounting stand and the battery cover. Both parts print with no supports.

The STL files can be downloaded directly here.

The Feather mounting stand has mounting holes for the Feather ESP32-S2 TFT and the BME688 STEMMA board.

The stand has a jaunty angle for better viewing of the Feather's TFT screen.

Behind the mounting board is a slot for a battery to sit. The battery lid fits loosely over the slot and has a cutout for the battery wire.

Before you can get started with Microsoft Azure, you need to create an account. There are multiple tiers of accounts, including a free version. 

Go to the Microsoft Azure website and click on Try Azure for Free.

Click on Start Free to proceed in creating a free account.

You can create a new account, sign-in with your Microsoft account or sign-in with your GitHub account.

After signing in, you'll be prompted to enter your information.

Even with the free account, you do need to enter a payment method. Nothing is charged unless you change settings later.

After entering all of your information, your Azure account setup will be complete. You can navigate to the Azure portal to get started with creating an application.

There are two Azure IoT options: IoT Hub and IoT Central. In this guide, you'll be using IoT Central, which is the simpler of the two options to get started with.

After logging into Microsoft Azure, in the Azure Portal homepage search for "IoT Central" and navigate to IoT Central Applications

Create a new application by clicking on Create.

On the Basics page, you'll enter details about your application. The Application URL is how you will access your application's homepage.

After creating the application, the deployment of the app will begin. Once it finishes, you'll see a message that deployment is complete. Then, click on Go To Resource.

This brings you to your application's overview page. Click on the link on the right-hand side of the screen to view your app.

The link brings you to your app's homepage. Here you can connect devices, create dashboards, view data and control all aspects of the app.

If you are on a free plan, then your data will only be accessible for 7 days. After 7 days, your data and application are deleted unless you convert to a paid plan.

After creating your application, you'll connect a device instance for your development board that you'll be connecting to Azure with CircuitPython. This process will create the keys you need to include in your secrets.py file.

To connect your device, click on the blue New button.

This opens the new device screen. Name your device. The device ID will be identical to the name. Then click Create.

You'll see your device appear under the All devices list. Click on your device.

Click on Connect.

This opens the Device connection groups window that has all of your secret connection keys. You will need the ID scope, Device ID and Primary key for your secrets.py file.

Now you're ready to connect to Microsoft Azure with CircuitPython!

CircuitPython is a derivative of MicroPython designed to simplify experimentation and education on low-cost microcontrollers. It makes it easier than ever to get prototyping by requiring no upfront desktop software downloads. Simply copy and edit files on the CIRCUITPY drive to iterate.

CircuitPython Quickstart

Follow this step-by-step to quickly get CircuitPython running on your board.

Click the link above to download the latest CircuitPython UF2 file.

Save it wherever is convenient for you.

Plug your board into your computer, using a known-good data-sync cable, directly, or via an adapter if needed.

Double-click the reset button (highlighted in red above), and you will see the RGB status LED(s) turn green (highlighted in green above). If you see red, try another port, or if you're using an adapter or hub, try without the hub, or different adapter or hub.

For this board, tap reset and wait for the LED to turn purple, and as soon as it turns purple, tap reset again. The second tap needs to happen while the LED is still purple.

If double-clicking doesn't work the first time, try again. Sometimes it can take a few tries to get the rhythm right!

A lot of people end up using charge-only USB cables and it is very frustrating! Make sure you have a USB cable you know is good for data sync.

You will see a new disk drive appear called FTHRS2BOOT.

 

Drag the adafruit_circuitpython_etc.uf2 file to FTHRS2BOOT.

The BOOT drive will disappear and a new disk drive called CIRCUITPY will appear.

That's it!

Once you've finished setting up your Feather ESP32-S2 TFT with CircuitPython, you can access the code and necessary libraries by downloading the Project Bundle.

To do this, click on the Download Project Bundle button in the window below. It will download as a zipped folder.

# SPDX-FileCopyrightText: 2022 Liz Clark for Adafruit Industries
# SPDX-License-Identifier: MIT

import time
import json
import supervisor
import simpleio
import vectorio
import board
import terminalio
import rtc
import socketpool
import wifi
import displayio
import adafruit_ntp
from adafruit_display_text import bitmap_label,  wrap_text_to_lines
from adafruit_bitmap_font import bitmap_font
from adafruit_azureiot import IoTCentralDevice
import adafruit_bme680
from adafruit_lc709203f import LC709203F, PackSize


# Get wifi details and more from a secrets.py file
try:
    from secrets import secrets
except ImportError:
    print("WiFi secrets are kept in secrets.py, please add them there!")
    raise

print("Connecting to WiFi...")
wifi.radio.connect(secrets["ssid"], secrets["password"])

print("Connected to WiFi!")

#  ntp clock - update tz_offset to your timezone
pool = socketpool.SocketPool(wifi.radio)
ntp = adafruit_ntp.NTP(pool, tz_offset=-4)
rtc.RTC().datetime = ntp.datetime

if time.localtime().tm_year < 2022:
    print("Setting System Time in UTC")
    rtc.RTC().datetime = ntp.datetime

else:
    print("Year seems good, skipping set time.")

cal = ntp.datetime
year = cal[0]
mon = cal[1]
day = cal[2]
hour = cal[3]
minute = cal[4]

# To use Azure IoT Central, you will need to create an IoT Central app.
# You can either create a free tier app that will live for 7 days without an Azure subscription,
# Or a standard tier app that will last for ever with an Azure subscription.
# The standard tiers are free for up to 2 devices
#
# If you don't have an Azure subscription:
#
# If you are a student, head to https://aka.ms/FreeStudentAzure and sign up, validating with your
#  student email address. This will give you $100 of Azure credit and free tiers of a load of
#  service, renewable each year you are a student
#
# If you are not a student, head to https://aka.ms/FreeAz and sign up to get $200 of credit for 30
#  days, as well as free tiers of a load of services
#
# Create an Azure IoT Central app by following these
# instructions: https://aka.ms/CreateIoTCentralApp
# Add a device template with telemetry, properties and commands, as well as a view to visualize the
# telemetry and execute commands, and a form to set properties.
#
# Next create a device using the device template, and select Connect to get the
# device connection details.
# Add the connection details to your secrets.py file, using the following values:
#
# 'id_scope' - the devices ID scope
# 'device_id' - the devices device id
# 'device_sas_key' - the devices primary key
#
# The adafruit-circuitpython-azureiot library depends on the following libraries:
#
# From the Adafruit CircuitPython Bundle
# (https://github.com/adafruit/Adafruit_CircuitPython_Bundle):
# * adafruit-circuitpython-minimqtt
# * adafruit-circuitpython-requests
# Create sensor object, communicating over the board's default I2C bus
i2c = board.I2C()  # uses board.SCL and board.SDA
bme680 = adafruit_bme680.Adafruit_BME680_I2C(i2c, debug=False)

# change this to match the location's pressure (hPa) at sea level
bme680.sea_level_pressure = 1013.25

# Create an IoT Hub device client and connect
esp = None
pool = socketpool.SocketPool(wifi.radio)
device = IoTCentralDevice(
    pool, esp, secrets["id_scope"], secrets["device_id"], secrets["device_primary_key"]
)

print("Connecting to Azure IoT Central...")
device.connect()

print("Connected to Azure IoT Central!")

temperature_offset = -5

# Create sensor object, using the board's default I2C bus.
battery_monitor = LC709203F(board.I2C())

# Update to match the mAh of your battery for more accurate readings.
# Can be MAH100, MAH200, MAH400, MAH500, MAH1000, MAH2000, MAH3000.
# Choose the closest match. Include "PackSize." before it, as shown.
battery_monitor.pack_size = PackSize.MAH2000

temp = int((bme680.temperature * 9/5) + (32 + temperature_offset))
humidity = int(bme680.relative_humidity)
pressure = int(bme680.pressure)
battery = battery_monitor.cell_percent

#  display setup
display = board.DISPLAY

palette0 = displayio.Palette(2)
palette0[0] = 0x00FF00
palette0[1] = 0xFF0000

#  load bitmap
bitmap = displayio.OnDiskBitmap("/bmeTFT.bmp")
tile_grid = displayio.TileGrid(bitmap, pixel_shader=bitmap.pixel_shader)
group = displayio.Group()
group.append(tile_grid)
#  rectangle for battery life monitor
#  vectorio allows for resizing in the loop
rect = vectorio.Rectangle(pixel_shader=palette0, width=22, height=10, x=12, y=116, color_index = 0)
group.append(rect)
#  bitmap font
font_file = "/roundedHeavy-26.bdf"
font = bitmap_font.load_font(font_file)
#  text elements
temp_text = bitmap_label.Label(font, text="%0.1f° F" % temp, x=20, y=80, color=0xFFFFFF)
humid_text = bitmap_label.Label(font, text="%0.1f %%" % humidity, x=95, y=80, color=0xFFFFFF)
press_text = bitmap_label.Label(font, text="%0.2f" % pressure, x=170, y=80, color=0xFFFFFF)
time_text = bitmap_label.Label(terminalio.FONT,
            text="\n".join(wrap_text_to_lines
            ("Data sent on %s/%s/%s at %s:%s" % (mon,day,year,hour,minute), 20)),
            x=125, y=105, color=0xFFFFFF)
group.append(temp_text)
group.append(humid_text)
group.append(press_text)
group.append(time_text)
display.show(group)

#  clock to count down to sending data to Azure
azure_clock = 500
#  clock to count down to updating TFT
feather_clock = 30


while True:
    try:
		#  read BME sensor
        temp = int((bme680.temperature * 9/5) + (32 + temperature_offset))
        humidity = int(bme680.relative_humidity)
        pressure = int(bme680.pressure)
		#  log battery %
        battery = battery_monitor.cell_percent
		#  map range of battery charge to rectangle size on screen
        battery_display = round(simpleio.map_range(battery, 0, 100, 0, 22))
		#  update rectangle to reflect battery charge
        rect.width = int(battery_display)
		#  if below 20%, change rectangle color to red
        if battery_monitor.cell_percent < 20:
            rect.color_index = 1
		#  when the azure clock runs out
        if azure_clock > 500:
            print("getting ntp date/time")
            cal = ntp.datetime
            year = cal[0]
            mon = cal[1]
            day = cal[2]
            hour = cal[3]
            minute = cal[4]
            time.sleep(2)
            print("getting msg")
			#  pack message
            message = {"Temperature": temp,
                       "Humidity": humidity,
                       "Pressure": pressure,
                       "BatteryPercent": battery}
            print("sending json")
            device.send_telemetry(json.dumps(message))
            print("data sent")
            clock_view = "%s:%s" % (hour, minute)
            if minute < 10:
                clock_view = "%s:0%s" % (hour, minute)
            print("updating time text")
            time_text.text="\n".join(wrap_text_to_lines
            ("Data sent on %s/%s/%s at %s" % (mon,day,year,clock_view), 20))
			#  reset azure clock
            azure_clock = 0
		#  when the feather clock runs out
        if feather_clock > 30:
            print("updating screen")
            temp_text.text = "%0.1f° F" % temp
            humid_text.text = "%0.1f %%" % humidity
            press_text.text = "%0.2f" % pressure
			#  reset feather clock
            feather_clock = 0
		#  if no clocks are running out
		#  increase counts by 1
        else:
            feather_clock += 1
            azure_clock += 1
		#  ping azure
        device.loop()
	#  if something disrupts the loop, reconnect
    # pylint: disable=broad-except
    except (ValueError, RuntimeError, OSError, ConnectionError) as e:
        print("Network error, reconnecting\n", str(e))
        supervisor.reload()
        continue
	#  delay
    time.sleep(1)
    print(azure_clock)

Upload the Code and Libraries to the Feather ESP32-S2 TFT

After downloading the Project Bundle, plug your Feather ESP32-S2 TFT into the computer's USB port with a known good USB data+power cable. You should see a new flash drive appear in the computer's File Explorer or Finder (depending on your operating system) called CIRCUITPY. Unzip the folder and copy the following items to the Feather ESP32-S2 TFT's CIRCUITPY drive. 

  • lib folder
  • roundedHeavy-26.bdf
  • bmeTFT.bmp
  • code.py

Your Feather ESP32-S2 TFT CIRCUITPY drive should look like this after copying the lib folder, the bmeTFT.bmp image file, the roundedHeavy-26.bdf bitmap font file, and the code.py file.

circuitpy

secrets.py

You will need to create and add a secrets.py file to your CIRCUITPY drive. Your secrets.py file will need to include the following information:

secrets = {
    'ssid' : 'YOUR-SSID-HERE',
    'password' : 'YOUR-SSID-PASSWORD-HERE',
    'id_scope' : 'YOUR-AZURE-ID-SCOPE-HERE',
    'device_id' : 'YOUR-AZURE-DEVICE-ID-HERE',
    'device_primary_key' : 'YOUR-AZURE-DEVICE-PRIMARY-KEY-HERE',
     }

You'll gather your ID scope, device ID and device primary key from your device connection groups page in your Azure application. Make sure to refer to the Connect Your Device page in this guide to see the process for accessing the keys.

How the CircuitPython Code Works

The code begins by connecting to WiFi and grabbing the date and time using the adafruit_ntp library. The tz_offset can be set to your local timezone.

# Get wifi details and more from a secrets.py file
try:
    from secrets import secrets
except ImportError:
    print("WiFi secrets are kept in secrets.py, please add them there!")
    raise

print("Connecting to WiFi...")
wifi.radio.connect(secrets["ssid"], secrets["password"])

print("Connected to WiFi!")

pool = socketpool.SocketPool(wifi.radio)
ntp = adafruit_ntp.NTP(pool, tz_offset=-4)
rtc.RTC().datetime = ntp.datetime

Connect to Microsoft Azure

Next, a connection is established with Microsoft Azure.

esp = None
pool = socketpool.SocketPool(wifi.radio)
device = IoTCentralDevice(
    pool, esp, secrets["id_scope"], secrets["device_id"], secrets["device_primary_key"]
)

print("Connecting to Azure IoT Central...")
device.connect()

print("Connected to Azure IoT Central!")

I2C Setup

The BME688 sensor is setup, along with the onboard battery monitor. Variables are created to hold the values of the sensor and the battery monitor. An equation is used to convert the temperature to Fahrenheit.

i2c = board.I2C()  # uses board.SCL and board.SDA
bme680 = adafruit_bme680.Adafruit_BME680_I2C(i2c, debug=False)

# change this to match the location's pressure (hPa) at sea level
bme680.sea_level_pressure = 1013.25

temperature_offset = -5

# Create sensor object, using the board's default I2C bus.
battery_monitor = LC709203F(board.I2C())

# Update to match the mAh of your battery for more accurate readings.
# Can be MAH100, MAH200, MAH400, MAH500, MAH1000, MAH2000, MAH3000.
# Choose the closest match. Include "PackSize." before it, as shown.
battery_monitor.pack_size = PackSize.MAH2000

temp = int((bme680.temperature * 9/5) + (32 + temperature_offset))
humidity = int(bme680.relative_humidity)
pressure = int(bme680.pressure)
battery = battery_monitor.cell_percent

DisplayIO Setup

There are a series of displayio elements being used. The background bitmap has the vector icons for the environmental readings and the battery. Label text elements using a bitmap_font are added in the code to display the readings from the BME688.

A vectorio.Rectangle is using to show battery life since the size of the rectangle can be changed in the loop. It also uses a special Palette that includes green and red. Once the battery life goes below a certain threshold, the rectangle is shown as red.

display = board.DISPLAY

palette0 = displayio.Palette(2)
palette0[0] = 0x00FF00
palette0[1] = 0xFF0000

bitmap = displayio.OnDiskBitmap("/bmeTFT.bmp")
tile_grid = displayio.TileGrid(bitmap, pixel_shader=bitmap.pixel_shader)
group = displayio.Group()
group.append(tile_grid)
rect = vectorio.Rectangle(pixel_shader=palette0, width=22, height=10, x=12, y=116, color_index = 0)
group.append(rect)
font_file = "/roundedHeavy-26.bdf"
font = bitmap_font.load_font(font_file)
temp_text = bitmap_label.Label(font, text="%0.1f° F" % temp, color=0xFFFFFF)
temp_text.x = 20
temp_text.y = 80
humid_text = bitmap_label.Label(font, text="%0.1f %%" % humidity, color=0xFFFFFF)
humid_text.x = 95
humid_text.y = 80
press_text = bitmap_label.Label(font, text="%0.2f" % pressure, color=0xFFFFFF)
press_text.x = 170
press_text.y = 80
time_text = bitmap_label.Label(terminalio.FONT, 
            text="\n".join(wrap_text_to_lines("Data sent on %s/%s/%s at %s:%s" % (mon,day,year,hour,minute), 20)), 
            color=0xFFFFFF)
time_text.x = 125
time_text.y = 105
group.append(temp_text)
group.append(humid_text)
group.append(press_text)
group.append(time_text)
display.show(group)

Clocks

There are two variables setup for time keeping, azure_clock and feather_clock. The azure_clock counts down to sending data to Microsoft Azure and the feather_clock counts down to updating the TFT screen.

azure_clock = 750
feather_clock = 30

The Loop - Sending Data to Microsoft Azure

Once the azure_clock count is reached, the data is packed into a JSON message that is sent to Microsoft Azure. ntp.datetime is used to grab the date and time that the message is being sent. The time_text element is updated to display this timestamp. Finally, the azure_clock is reset to 0.

if azure_clock is 750:
           print("getting msg")
            message = {"Temperature": temp,
                       "Humidity": humidity,
                       "Pressure": pressure,
                       "BatteryPercent": battery}
            print("sending json")
            device.send_telemetry(json.dumps(message))
            print("data sent")
            print("getting ntp date/time")
            cal = ntp.datetime
            year = cal[0]
            mon = cal[1]
            day = cal[2]
            hour = cal[3]
            minute = cal[4]
            time.sleep(2)
            clock_view = "%s:%s" % (hour, minute)
            if minute < 10:
                clock_view = "%s:0%s" % (hour, minute)
            print("updating time text")
            time_text.text="\n".join(wrap_text_to_lines("Data sent on %s/%s/%s at %s" % (mon,day,year,clock_view), 20))
            azure_clock = 0

Updating the TFT

Once the feather_clock count is reached, the TFT screen is updated with the current values from the BME688 and the battery_monitor. The feather_clock is then reset to 0.

if feather_clock is 30:
      temp = int((bme680.temperature * 9/5) + (32 + temperature_offset))
      humidity = int(bme680.relative_humidity)
      pressure = int(bme680.pressure)
      battery = battery_monitor.cell_percent
      battery_display = round(simpleio.map_range(battery, 0, 100, 0, 22))
      rect.width = int(battery_display)
      if battery_monitor.cell_percent < 20:
        rect.color_index = 1
      print("updating screen")
      temp_text.text = "%0.1f° F" % temp
      humid_text.text = "%0.1f %%" % humidity
      press_text.text = "%0.2f" % pressure
      feather_clock = 0

Keeping Count

Every second, the feather_clock and azure_clock counts are increased by 1. device.loop() is also called to poll for messages from Microsoft Azure.

feather_clock += 1
azure_clock += 1
device.loop()

time.sleep(1)

Reconnect

If there is a connection error, a connection is reestablished with your WiFi network and Microsoft Azure.

except (ValueError, RuntimeError, OSError) as e:
        print("Connection error, reconnecting\n", str(e))
        wifi.radio.enabled = False
        wifi.radio.enabled = True
        wifi.radio.connect(secrets["ssid"], secrets["password"])
        device.reconnect()
        continue

The device's template organizes and categorizes the incoming data so that it can be logged properly.

At the top of your device's page, click on Manage template -> Auto-create template.

If you've already logged data from the Feather ESP32-S2 TFT, then the template will be auto-filled with the data that you sent to Microsoft Azure which was previously categorized as unmodeled data.

You can also add the data types that you want to collect by clicking Add capability. The display name is how the data will be categorized on Azure. The name has to match the string in the JSON message that is sent from the CircuitPython code. Capability type needs to match the type of data that is going to be received. If you are receiving sensor data, then you will select Telemetry. 

Make sure to click Save when you're done editing your template.

You can create visual dashboards to display your data for easy viewing.

Navigate to the Dashboards page and click Edit.

In edit mode, a tile menu opens on the left. You can drag and drop different tiles into the main dashboard space. There's a variety of graph and display types to choose from.

The tile will be empty when you first bring it to the dashboard. You can click on the pencil icon to edit the tile to display your data.

The title will be displayed above the tile. You can configure the chart's axes and legend.

 

To bring the data into the tile, you'll select your device from the dropdown. Then, add Capability to bring in different data streams. 

Click Update and you should see your data populate the tile.

You can add as many tiles as you want to fully customize your dashboard.

You can create Rules to alert you about certain data thresholds. These alerts can be emailed to you or setup with webhooks.

Navigate to the Rules page on the side menu bar.

Click on New to create a new rule.

First, you'll need to name the alert and toggle the Enable option to turn it on. Then you can select your device to receive alerts about.

You'll setup conditions for the rule. You can have the rule be triggered if all or some of the conditions are true. The Time aggregation option can limit the number of alerts you receive. For example, if you select 60 minutes then you will only be alerted once per hour if a condition is true.

Under Telemetry, you'll select the data feed to monitor, as well as an operator; such as less than, equal to, etc. Under Value, you'll enter the value to watch for.

You can enter multiple telemetry options depending on what you're monitoring for. For example, you could monitor humidity to make sure it never dips below or above certain amounts.

Under Actions, you'll select either an email or webhook alert.

The email will let you know which rule has been triggered with the timestamp.

The webhook option allows you to integrate your application with other Azure and Microsoft services, including Microsoft Flow (also referred to as Power Automate).

Attach M2.5 standoffs to the mounting holes with M2.5 screws.

Secure the Feather ESP32-S2 TFT and BME688 STEMMA board to the standoffs with M2.5 screws.

Connect the BME688 to the Feather ESP32-S2 TFT with a STEMMA QT cable.

Insert a battery into the battery slot. Plug the battery into the Feather ESP32-S2 TFT's JST battery plug.

Place the battery cover over the battery, sliding the battery's wire through the cover's slot. That completes the assembly!

Power up the Feather ESP32-S2 TFT with either a fully charged LiPo battery or a USB cable to start displaying and logging your data!

You'll see the current data from the BME688 updated on the TFT screen every 30 seconds.

When battery life runs low, the battery icon will show as red.

You can use all of the Microsoft Azure IoT Central application options to expand on your project with dashboards, alerts, data exports and webhooks. 

This guide was first published on Jul 05, 2022. It was last updated on 2022-07-05 09:06:55 -0400.