Don't see your favorite hardware here? Rest assured the Notecard works with virtually every MCU and SBC available. If you can't figure out how to complete this tutorial let us know in our forum and we can help you out.

Introduction

This tutorial should take approximately 40-50 minutes to complete.

In this tutorial, you'll learn how to take sensor readings from a Device and send readings to your Notecard and the Blues Notehub. You'll use CircuitPython running on a Adafruit HUZZAH32 wired up to Notecarrier A hardware. If you would like to use a different language, board, or Notecarrier, modify the dropdowns at the top of this guide. And if you get stuck at any point, the full source code for each example is available on GitHub.

The tutorial uses mock sensor readings for simplicity, but feel free to hook up a physical sensor of your choice and use that instead.

Set up Hardware

First, you'll need to get all of your hardware connected. Follow the instructions below to connect your Adafruit HUZZAH32 and Notecard mounted on a Notecarrier A.

In order to complete this guide, you'll need the following:

• Notecard mounted to Notecarrier A.

• Any CircuitPython-capable Microcontroller (MCU) with Feather headers. We'll be using the Adafruit HUZZAH32, but any MCU with a CircuitPython bootloader and binary will do.

• Follow the ESP32-specific instructions for burning the bootloader and flashing the CircuitPython binary to your device. If you're using the Adafruit HUZZAH32, update your board to the latest version of CircuitPython. (We recommend using the "Open Installer" method and using the Web Workflow to use the CircuitPython Code Editor).

• Micro USB to USB-A cable.

Connect the Adafruit HUZZAH32 to your Notecard

Now, let's connect your Notecard using a Serial connection.

1. Connect V+ from the Notecarrier A to the USB pin on your Adafruit HUZZAH32.

   

2. Connect GND from the Notecarrier A to a GND pin on your Adafruit HUZZAH32.

   

3. Connect TX from the Notecarrier A to the RX pin on your Adafruit HUZZAH32.

   

4. Connect RX from the Notecarrier A to the TX pin on your Adafruit HUZZAH32.

   

5. Plug the USB cable directly into your Adafruit HUZZAH32, which will allow you to flash firmware to your device.

NOTE: Make extra sure you've plugged in the jumper wires next to the TX and RX pins on the Feather. The pin names are actually printed underneath the pin they're referring to, and mis-wiring will cause a serial error of notecard not responding without much else to help debug the actual issue.

Create a Notehub Project

Now that your hardware is all connected, let's create a new Notehub project to receive sensor readings from your Notecard.

1. Navigate to notehub.io and log-in, or create a new account.

2. Using the New Project card, give your project a name and ProductUID.

   

   note

   The ProductUID must be globally unique, so we recommend a namespaced name like "com.your-company.your-name:your_product".

3. Take note of your ProductUID. This identifier is used by Notehub to associate your Notecard to your project.

   

Write Firmware

Now you're ready to write some firmware. When communicating with the Notecard, you can manually send requests using the Serial write function and passing-in JSON objects, or use the note-python library (the recommended path).

Configure your Notecard

Install the Notecard Python Library

1. To use the note-python library, you'll first need to download or clone it from the GitHub repo.

   

2. Unzip the archive and upload the notecard directory into the lib directory using the CircuitPython Code Editor.

   

3. Add an import for the library at the top of your code.py file.

   Python
   COPY

   import notecard

Set up Your Notecard

1. Add some additional imports to the top of your code.py file:

   Python
   COPY

   import board
   import busio
   import time
   import json

2. Add a definition for your ProductUID using the value you specified when creating your Notehub project.

   Python
   COPY

   productUID = "com.your-company.your-name:your_product"

3. Configure the serial connection to your Notecard, and write a newline to clear its buffer. Initialize the serial connection to the Notecard using the OpenSerial function.

   Python
   COPY

   serial = busio.UART(board.TX, board.RX, baudrate=9600)
   card = notecard.OpenSerial(serial)

4. Now, we'll configure the Notecard. Using the hub.set request, we associate this Notecard with the ProductUID of your project and set the Notecard to operate in continuous mode, which indicates that the device should immediately make a connection to Notehub and keep it active.

   Python
   COPY

   req = {"req": "hub.set"}
   req["product"] = productUID
   req["mode"] = "continuous"
   rsp = card.Transaction(req)

   The lines above build-up a JSON object by adding two string values for product and mode, and then fires the request off to the Notecard with the Transaction function.

5. Click the "Save + Run" button in the CircuitPython Code Editor to flash this code to your device.

6. The serial monitor will open automatically. If everything has been connected and configured properly, you'll see a few debug messages, including the JSON object you sent, as well as the response from the Notecard: {}.

   

Read from the Sensor

Now that you've configured your MCU to communicate with the Notecard, let's grab some pseudo sensor readings, where the temperature comes from the onboard temperature sensor of the Notecard and the humidity is a random number.

1. To generate psuedo sensor readings you'll use the notecard-pseudo-sensor library. Start by downloading or cloning the library from its GitHub repo.

   

2. Unzip the archive and upload the notecard_pseudo_library directory into the lib directory using the CircuitPython Code Editor.

   

3. Add an import for the library at the top of your code.py file.

   Python
   COPY

   import notecard_pseudo_sensor

4. Configure the pseudo sensor with a reference to the Notecard you created earlier.

   Python
   COPY

   sensor = notecard_pseudo_sensor.NotecardPseudoSensor(card)

5. Add the following code block to the bottom of your code.py file. This takes a mock temperature and humidity reading before sleeping for 15 seconds and repeating the process.

   Python
   COPY

   while True:
      temp = sensor.temp()
      humidity = sensor.humidity()
      print("\nTemperature: %0.1f C" % temp)
      print("Humidity: %0.1f %%" % humidity)
   
      time.sleep(15)

5. Click the "Save + Run" button in the CircuitPython Code Editor to flash this code to your device.

6. The serial monitor will open automatically. Every 15 seconds, you'll see new debug statements and sensor readings.

   JSON
   COPY

   {"req": "card.temp"}
   {"value":26.25,"calibration":-1.0}
   
   Temperature: 26.3 C
   Humidity: 47.0 %

Send Sensor Readings to the Notecard

Now that we're getting sensor readings, let's send these to our Notecard.

1. To send a sensor reading to the Notecard, we'll need to construct a new JSON request to the note.add API that includes a new Notefile name (sensors.qo), sets the sync field to true to instruct the Notecard to sync to Notehub immediately, and finally, sets the body to the sensor temperature and humidity. Add the following in while loop right after the print commands to print out readings.

   Python
   COPY

   req = {"req": "note.add"}
   req["file"] = "sensors.qo"
   req["sync"] = True
   req["body"] = { "temp": temp, "humidity": humidity}
   rsp = card.Transaction(req)
   print(rsp)

2. Click the "Save + Run" button in the CircuitPython Code Editor to flash this code to your device. After restart, the Serial monitor will update to display the response from the note.add request (the total number of Notes in the notefile) each time you add a new reading.

   JSON
   COPY

   {"req": "card.temp"}
   {"value":26.375,"calibration":-1.0}
   
   Temperature: 26.4 C
   Humidity: 46.5 %
   {"req": "note.add", "body": {"humidity": 46.5156, "temp": 26.375}, "sync": true, "file": "sensors.qo"}
   {"total":1}

View Data in Notehub

Once you start capturing readings, your Notecard will initiate a connection to Notehub and will start transferring Notes. Depending on signal strength and coverage in your area, it may take a few minutes for your Notecard to connect to Notehub and transfer data.

1. Return to notehub.io and open your project. You should see your notecard in the Devices view.

   

2. Now, click on the Events left menu item. Once your sensor Notes start syncing, they'll show up here.

   

Use Environment Variables

Environment variables are a Notehub state and settings management feature that allow you to set variables in key-value pairs, and intelligently synchronize those values across devices and fleets of devices.

In this section you'll learn how environment variables work by creating a variable that determines how often your firmware should take sensor readings.

Using Environment Variables in Firmware

The Notecard provides a set of requests for working with environment variables. The most common of these requests is env.get, which allows you to retrieve the value of an environment variable.

Complete the steps below to use the env.get request to retrieve and use the reading_interval environment variable.

1. First, adjust your existing hub.set configuration to set the sync argument to true. When sync is true, the Notecard synchronizes inbound environment variable changes as soon as they're made in Notehub.

   Python
   COPY

   req = {"req": "hub.set"}
   req["product"] = productUID
   req["mode"] = "continuous"
   req["sync"] = True # add this line
   rsp = card.Transaction(req)

2. Next, place the following new function before the existing while True loop.

   Python
   COPY

   # This function assumes you’ll set the reading_interval environment variable to
   # a positive integer. If the variable is not set, set to 0, or set to an invalid
   # type, this function returns a default value of 60.
   def get_sensor_interval():
      sensor_interval_seconds = 60
      req = {"req": "env.get"}
      req["name"] = "reading_interval"
      rsp = card.Transaction(req)
      if rsp and rsp["text"] and int(rsp["text"]) > 0:
         sensor_interval_seconds = int(rsp["text"])
      return sensor_interval_seconds

3. Finally, find the existing time.sleep(15) line in your while True loop, and replace it with the code below.

   Python
   COPY

   sensor_interval_seconds = get_sensor_interval()
   print(f"Delaying {sensor_interval_seconds} seconds")
   time.sleep(sensor_interval_seconds)

Your firmware now uses the reading_interval environment variable to determine how many seconds to delay in between sensor readings.

If you save this code, after restart you should see your device using the default reading_interval value of 60 seconds.

Setting an Environment Variable

Now we have our device programmed to retrieve an Environment Variable from Notehub, we will create that variable. Environment variables can be set in the Notehub UI or through the Notehub API. In this tutorial you'll learn how to set the values through the Notehub UI. If you'd like to instead set environment variables through the Notehub API, refer to environment variable requests in the Project API.

1. Return to your Notehub project, go the the Devices page, and double click your device. You should see a screen that looks like this.

   

2. Click the Environment tab.

3. Under the Device environment variables header, define a new environment variable named reading_interval and set its value to 30.

   

Now that you have an environment variable set you should see it immediately reflected on your device.

And with that, you've used your first environment variable on your Notecard! To see the real power of environment variables in action, try returning to Notehub and updating your device's reading_interval with your serial monitor open. Your firmware will retrieve the updated value and start using it immediately.

Next Steps

Congratulations! You've successfully connected your Adafruit HUZZAH32 to your Notecard and built a basic IoT project.

If you're following the Blues Quickstart, next we recommend learning how to send (and visualize) your data in a cloud application:

1. Use the Notecard to Send Data
2. Set Up Your Microcontroller
3. Build Your First IoT App With Blues
4. Send Data to Your Cloud

At any time, if you find yourself stuck, please reach out on the community forum.