Getting Started with Microsoft Azure and CircuitPython

by Liz Clark

published July 05, 2022, last updated July 05, 2022

posted in Sensors/ Temperature & Humidity Feather CircuitPython Internet of Things - IOT LCDs & Displays/ Graphic TFTs

Save Download

Updated

Beginner

Project guide

Overview

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

Adafruit ESP32-S2 TFT Feather

Adafruit BME680

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.

Adafruit ESP32-S2 TFT Feather - 4MB Flash, 2MB PSRAM, STEMMA QT

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...

guides with product

Out of Stock

Adafruit BME688 - Temperature, Humidity, Pressure and Gas Sensor

The long-awaited BME688 from Bosch gives you all the environmental sensing you want in one small package. This little sensor...

guides with product

$19.95

In Stock

Add to Cart

Lithium Ion Polymer Battery - 3.7v 2500mAh

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

Add to Cart

STEMMA QT / Qwiic JST SH 4-Pin Cable - 50mm Long

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...

Out of Stock

Angled shot of coiled pink and purple USB cable with USB A and USB C connectors.

Pink and Purple Woven USB A to USB C Cable - 1 meter long

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

Add to Cart

Black Nylon Screw and Stand-off Set with M2.5 Threads, kit box

Black Nylon Machine Screw and Stand-off Set – M2.5 Thread

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...

guides with product

$16.95

In Stock

Add to Cart

Text editor powered by tinymce.

3D Printing

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.

featherTFTstand.zip

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.

Text editor powered by tinymce.

Create a Microsoft Azure Account

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.

Text editor powered by tinymce.

Create an IoT Central 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.

Text editor powered by tinymce.

Connect Your Device

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.

temperature___humidity_InkedconnectDeviceSecrets_LI.jpg

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!

Text editor powered by tinymce.

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.

Download the latest version of CircuitPython for this board via circuitpython.org

install_circuitpython_on_most_boards_CircuitPython_downloaded.jpg

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 you do not see the LED turning purple, you will need to reinstall the UF2 bootloader. See the Factory Reset page in this guide for details.

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!

Text editor powered by tinymce.

Coding the Feather ESP32-S2 TFT Azure Display

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.

Download Project Bundle

Copy Code

# 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
import adafruit_connection_manager
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
import adafruit_max1704x
#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 = adafruit_connection_manager.get_radio_socketpool(wifi.radio)
ssl_context = adafruit_connection_manager.get_radio_ssl_context(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
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller
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, ssl_context, 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(i2c)
battery_monitor = adafruit_max1704x.MAX17048(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.root_group = 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)

# 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
import adafruit_connection_manager
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
import adafruit_max1704x
#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 = adafruit_connection_manager.get_radio_socketpool(wifi.radio)
ssl_context = adafruit_connection_manager.get_radio_ssl_context(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
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller
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, ssl_context, 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(i2c)
battery_monitor = adafruit_max1704x.MAX17048(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.root_group = 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.

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:

Download File

Copy Code

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',
     }

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.

Download File

Copy Code

# 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

# 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.

Download File

Copy Code

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!")

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.

Download File

Copy Code

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

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.

Download File

Copy Code

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.root_group = group

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.root_group = 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.

Download File

Copy Code

azure_clock = 750
feather_clock = 30

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.

Download File

Copy Code

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

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.

Download File

Copy Code

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

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.

Download File

Copy Code

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

time.sleep(1)

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.

Download File

Copy Code

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

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

Text editor powered by tinymce.

Edit the Data Template

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.

Text editor powered by tinymce.

Create a Dashboard

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.

Text editor powered by tinymce.

Create Alerts

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).

Text editor powered by tinymce.