Cellular Function Board - Blues Wireless Notecarrier

Introduction

The SparkFun Cellular Function Board - Blues Wireless Notecarrier features the Notecard from Blues Wireless. The Notecard is unique among cellular modules as it has a built-in SIM card and includes a 10 year subscription and 500MB of data included in the price. The Notecard module also comes with integrated cellular, SIM, onboard GPS, 3-axis accelerometer with an on-chip temperature sensor. On top of that, the Notecard features outboard device firmware updates (DFU) meaning you can reprogram a connected Processor remotely through Blues' Notehub service! There are some limitations to this process so make sure to read further in this guide for more information on how to properly perform Outboard device firmware updates.

added to your cart!

SparkFun MicroMod Cellular Function Board - Blues Wireless Notecarrier

20 available WRL-20409

The SparkFun Notecarrier Cellular Function Board adds a cellular modem to the MicroMod ecosystem using the Notecard - NOTE-NB…

$119.95 $64.95

Favorited Favorite 8

Wish List

The MicroMod Cellular Function Board includes everything you need : a carrier board (Blues calls them Notecarriers) and the globally enabled NB-IoT & LTE-M M.2 based module (Blues calls them Notecards).

Required Materials

The following materials are necessary for following along with this guide (check out our all inclusive, starter kit). All Function Boards require a Main Board and Processor to connect to each other. Depending on your application, you may need a Single or Dual Main Board:

SparkFun Blues Wireless MicroMod Starter Kit

Retired KIT-21702

The SparkFun Blues Wireless MicroMod Starter Kit provides every part needed to get you connected and start prototyping with t…

Retired

Favorited Favorite 3

Wish List

added to your cart!

SparkFun MicroMod Main Board - Double

25 available DEV-20595

The MicroMod Main Board is a specialized carrier board that allows you to interface a MicroMod Processor Board with up to two…

$19.95

Favorited Favorite 8

Wish List

added to your cart!

SparkFun MicroMod Main Board - Single

In stock DEV-20748

The MicroMod Main Board is a specialized carrier board that allows you to interface a MicroMod Processor Board with a single …

$15.95

Favorited Favorite 5

Wish List

A Processor Board is needed to act as a host controller for the Function Board:

added to your cart!

SparkFun MicroMod Artemis Processor

In stock DEV-16401

Featuring the Artemis Module, this processor is capable of machine learning, Bluetooth, I2C, GPIO, PWM, SPI & packaged to fit…

$14.95

1

Favorited Favorite 22

Wish List

added to your cart!

SparkFun MicroMod STM32 Processor

In stock DEV-21326

The SparkFun MicroMod STM32 Processor Board is ready to rock your MicroMod world with its ARM® Cortex®-M4 32-bit RISC core!

$16.50

Favorited Favorite 5

Wish List

You'll also need a cellular and GNSS antenna:

added to your cart!

GPS Embedded Antenna SMA

20 available GPS-00177

Embedded antenna for small, mobile applications. Basic unpackaged antenna with LNA. 5inch cable terminated with standard male…

$12.95

Favorited Favorite 10

Wish List

added to your cart!

PCB Antenna - U.FL (2.4GHz)

In stock WRL-18086

This small form-factor antenna offers a 2.4GHz frequency range.

$1.50

Favorited Favorite 3

Wish List

added to your cart!

Molex Flexible GNSS Antenna - U.FL (Adhesive)

In stock GPS-15246

A flexible, paper-thin GNSS Antenna with a U.FL connector and an adhesive backing.

$4.50

1

Favorited Favorite 11

Wish List

added to your cart!

LTE Hinged External Antenna - 698MHz-2.7GHz, SMA Male

In stock CEL-16432

Molex LTE/5G Cellular External Antennas are designed for 2G/3G/4G/5G modules and devices.

$7.50

Favorited Favorite 4

Wish List

The Notecard Module uses u.Fl connectors for both antenna connections so, depending on your choice of antennas, you may also need an adapter cable like these:

added to your cart!

SMA to U.FL Cable - 150mm

In stock WRL-18568

This SMA to U.FL Cable is commonly used to connect boards with the compact U.FL connector to an enclosure wall. This allows a…

$1.95

Favorited Favorite 3

Wish List

added to your cart!

Interface Cable SMA to U.FL - 100mm

In stock WRL-09145

This is a 4" connector cable that interfaces U.FL RF connectors to regular SMA connectors. This cable is commonly used to con…

$5.50

3

Favorited Favorite 19

Wish List

Interface Cable U.FL to SMA - 100mm

Retired WRL-18154

A U.FL to SMA (jack) bulkhead straight connector with a 1.32 mm diameter cable.

Retired

Favorited Favorite 1

Wish List

Suggested Reading

The MicroMod ecosystem is a unique way to allow users to customize their project to their needs. If you aren't familiar with the MicroMod system, click on the banner below for more information.

You may also want to go through the tutorials below if you are not familiar with the concepts covered in them:

Hardware Overview

Let's take a closer look at the Notecard module and other hardware present on this Function Board.

Blues Wireless Notecard - NOTE_NBGL-500

The Blues Wireless Notecard module offers a low-power cellular connection from a connected device to the cloud through either the Notehub service or alternate cellular service with a supported external SIM. The module has a built-in SIM card that includes a 10 year subscription and 500MB of data in the initial purchase price. The built-in SIM on the Notecard works in over 140 countries with varying levels of cellular coverage, for a complete list of compatible countries, refer to the Cellular Service section of the Notecard datasheet. The Cellular Function Board ships with the NOTE_NBGL-500 Notecard which operates over narrowband global networks (LTE-M, NB-IoT and GPRS).

The Notecard uses the BG95-M3 cellular module with integrated GNSS from Quectel. The GNSS supports GPS, GLONASS, BeiDou, Galileo and QZSS constellations. The Notecard also has an on-board 3-axis accelerometer with an on-chip temperature sensor. For a complete overview of the Notecard, refer to the datasheet.

USB-C Connector

The USB-C connector provides a direct serial interface with the Notecard over a USB connection.

This connection allows you to use the Notecard with Blues Wireless' browser-based CLI, Notecard Playground. This CLI is very helpful for configuring and testing the Notecard quickly over USB. Those who prefer to download and use the CLI application locally can find it here.

Nano-SIM Slot

The Function board includes a Nano-SIM slot for users who prefer to use their own nano SIM card instead of the built-in one on the Notecard module.

Enabling the external SIM capability requires updating several settings on the Notecard. Refer to this guide from Blues Wireless for detailed instructions for configuring the Notecard to work with an external SIM card. Reminder, this Function Board uses the NOTE_NBGL-500 Notecard so it only supports narrowband LTE networks (no 3G or 4G networks).

AUX UART PTH Header

The Function Board routes the auxiliary UART pins used for Outboard DFU on the Notecard to a 0.1"-spaced PTH header along with the Auxiliary Enable pin.

This interface allows for users to connect directly to the Notecard's auxiliary UART (AUX RX and AUX TX) as well as the Auxiliary Enable pin to toggle the auxiliary UART. The Function Board also routes the AUX1 to a pushbutton labeled "USRBTN" to allow for a user-configurable manual input on that pin.

LEDs

The board has three power indication LEDs labeled VIO, VIN, and AEN as well as a WS2812 RGB LED tied to the Notecard's AUX2 pin.

• VIO - 3.3V I/O voltage status. LED turns on when 3.3V from the MicroMod connector is present.
• VIN - Notecard power status. LED turns on when the Notecard is powered.
• AEN - Auxiliary UART status. LED turns on when the AEN pin is pulled HIGH to enable the auxiliary UART on the Notecard.
• RGB - AUX2 RGB LED. The data input for the WS2812 LED connects to AUX2 on the Notecard to allow for user-configured LED statuses. The data input also connects to F5 on the Function Board's MicroMod M.2 connector for users who prefer to manipulate the LED through a connected Processor.

The Notecard has two LEDs. The green LED reports modem activity and the red LED reports user activity.

Solder Jumpers

The Function Board has eight solder jumpers labeled: SHLD, VIO_LED, PWR_LED, AUX_EN_LED, RGB, ANT_PWR, WP, and MEAS

The table below outlines the jumpers labels, functions, default states and any notes regarding their behavior.

MicroMod Pinout

As mentioned previously, we recommend using this Function Board with the latest versions of the MicroMod Single Main Board and Double Main Board as the revisions benefit this Function Board and the recommended STM32 Processor. Check out the MicroMod Main Board Hookup Guide v2 for details on all changes made to these Main Boards. The tables below outline the complete MicroMod Pinout and pins used by the Cellular Function Board:

• Cellular Function Board Pinout Table
• MicroMod General Processor Pinout Table
• MicroMod General Pin Descriptions

Board Dimensions

This Function Board matches the standard Function Board footprint but as the Notecard module stacks on top of it, it's vertical profile is larger than most other Function Boards.

Hardware Assembly

If you're not familiar with assembling boards using the MicroMod connection system, head over to the MicroMod Main Board Hookup Guide for information on inserting and securing your MicroMod Processor and Function Boards to the Main Board:

Notecard Assembly

This Function Board requires a bit more assembly than others as you'll need to attach the Notecard to your Function Board along with the antennas. The Notecard uses the same M.2 connector as the MicroMod ecosystem so just connect it as you would do with other MicroMod M.2 connections.

Antenna Connection

The antenna connections on the Notecard use u.Fl connectors. Depending on your antenna choice, you may need an adapter like this. For tips on how to properly use a u.Fl connector, this tutorial can help.

Completed Assembly

Our Arduino example for this Function Board demonstrates how to send environmental data from an Environmental Function Board mounted on the Double Main Board with the Cellular Function Board. The photo below shows a completed MicroMod assembly for that example:

Software Setup

Using the Cellular Function Board in the MicroMod ecosystem requires a few software setup steps before getting started.

Blues Wireless Software

Blues Wireless has several software support packages to help communicate between the Notecard and connected Processor and to communicate between the Notecard and the cloud.

Notehub

Blues Wireless' Notehub.io is a service that routes data from a Notecard to the cloud. Notehub works with a wide range of cloud options like AWS, Azure, Google Cloud. In addition, Notehub can route data to an IoT messaging platform like MQTT or a custom HTTP/HTTPS endpoint. Notehub requires an account tied to your Notecard so make sure to register if you do not have one already.

Once your account is created and verified, click the "Create Project" button in the top right of the page to start a new Project for your Notecard. This opens a pop-up on the page where you enter a Project Name, unique ID and select the billing account tied to the Project. By default, this selects the billing acount tied to your Notehub account but you can select other options in the drop-down menu. Once you have everything selected, select "Create Project".

Blues Wireless Documentation

This tutorial only does a cursory dive into using Notehub with the Function Board. For all the information you'll ever need for Notehub, Blues has written a host of tutorials covering the basics of Notehub as well as how to route data to a wide variety of platforms so be sure to check them out here:

Blues Note Arduino Library

The Blues Note Arduino Library allows users to communicate with a Notecard using the Arduino IDE over serial and I²C. To install the library using the Arduino Library Manager tool, navigate to the Tools menu and click "Manage Libraries" (you can also use the keyboard shortcut of Ctrl + Shift + I) and search for "note-arduino". Users who prefer to manually install the library can find it here on GitHub or you can click the button below to download a ZIP of the library:

Notecard CLI

Blues also offers two options for getting right to work with the Notecard with their in-browser terminal Notecard Playground (Note: the in-browser terminal only runs on Chrome, Opera or Edge browsers). The CLI is also available as a traditional application for download here.

Using the CLI only requires a USB-C cable connecting the Cellular Function Board to your computer. The CLI should automatically detect the Notecard and appear as a selectable device in the drop-down menu in the CLI.

Environmental Function Board Libraries

The Arduino Example in the following section requires the SparkFun Arduino libraries for the SGP40, SHTC3 and STC3X sensors on the Environmental Function Board. Install them with the Arduino Library manager tool by opening it and searching "SparkFun SGP40", "SHTC3" and "STC3X". If you prefer to manually install them you can download them from their GitHub repositories (SGP40, SHTC3, STC3X) or click the buttons below to download a ZIP of the libraries:

Processor Arduino Board Definitions and Driver

Make sure you go through the Hookup Guide for your chosen Processor Board to install the latest Arduino board definitions and any necessary drivers:

Pin Connection Table

The table below helps show which pins the Function Board connects to depending on the slot it is connected to on a Main Board (Note: The Single Main Board connection is Slot 0):

Arduino Example

In this section we'll use the MicroMod assembly built in the Hardware Assembly section to use the Notecard to send temperature, pressure, air quality and CO₂ data recorded by the Environmental Function Board to notehub.io.

Arduino Code

The example configures the Notecard to receive data over I²C sent to the Processor from the Environmental Fucntion Board. The main loop retrieves data from all three sensors and every fifteen seconds creates a tells the Notecard send the data to notehub.io every fifteen seconds to be recorded as events in the Notehub Project created in the Software Setup section.

Copy the code below into a new sketch in Arduino. Select your board (the example assumes a MicroMod STM32 Processor Board is used) and port and click the Upload button:

language:c
/**
 * @file
 * @brief This example collects sensor data and posts it to NoteHub.
 * @copyright SPDX-License-Identifier: MIT
 * @author Alex Brudner, SparkFun Electronics
 * @date 2022-11-02
 * @note Based on Example01 from the MicroMod Environmental Function Board by 
 * Ho Yun "Bobby" Chan. This example code combines example codes from the 
 * SHTC3, STC31, and SGP40 libraries. Most of the steps to obtain the 
 * measurements are the same as the example code. Generic object names were 
 * renamed (e.g. mySensor => mySGP40 and mySTC3x).
 *
 *    Example 1: Basic Relative Humidity and Temperature Readings  w/ SHTC3
 *       Written by Owen Lyke
 *    Example 2: PHT (SHTC3) Compensated CO2 Readings w/ STC31
 *       Written by Paul Clark and based on earlier code by Nathan Seidle
 *    Example 1: Basic VOC Index w/ SGP40
 *       Written by Paul Clark
 *
 * Open a Serial Monitor at 115200 baud to view the readings too!
 *
 * Note: You may need to wait about ~5 minutes after starting up the code 
 * before VOC index
 * has any values.
 *
 * ========== HARDWARE CONNECTIONS ==========
 * MicroMod STM32 Processor Board => MicroMod Main Board => MicroMod 
 *  Environmental Function Board (with SHTC3, STC31, and SGP40)
 * MicroMod STM32 Processor Board => MicroMod Main Board => MicroMod 
 *  Function Board Blues Wireless Notecarrier
 *
 * Feel like supporting open source hardware?
 * Buy a board from SparkFun!
 *      MicroMod Function Board Blues Wireless Notecarrier  
 *        | https://www.sparkfun.com/products/20409
 *      MicroMod STM32 Processor                            
 *        | https://www.sparkfun.com/products/16401
 *      MicroMod Main Board - Double                        
 *        | https://www.sparkfun.com/products/18575
 *      MicroMod Environmental Function Board               
 *        | https://www.sparkfun.com/products/18632
 *
 * You can also get the sensors individually.
 *
 *      Qwiic SHTC3 | https://www.sparkfun.com/products/16467
 *      Qwiic STC31 | https://www.sparkfun.com/products/18385
 *      Qwiic SGP40 | https://www.sparkfun.com/products/17729
 */

/* Notecard Includes */
#include <Arduino.h>
#include <Wire.h>
#include <Notecard.h>

/* Sensor Includes */
#include <SparkFun_SHTC3.h>
#include <SparkFun_STC3x_Arduino_Library.h>
#include <SparkFun_SGP40_Arduino_Library.h>

#define PRODUCT_UID "com.your-company.your-name:your_product"

/* Instantiate Notecard class */
Notecard notecard;
int ncUpdateCtr = 0;

/* Instantiate sensor interface classes */
SHTC3 mySHTC3;
STC3x mySTC3x;
SGP40 mySGP40;

float rh = 0.0;           // Relative Humidity from the SHTC3
float temperature = 0.0;  // Temperature from the SHTC3
float co2 = 0.0;          // %CO2 from STC3
int32_t voc = 0;          // VOC index from SGP40

void setup() {
  /* Begin Serial communications */
  delay(2500);
  Serial.begin(115200);
  Serial.println(F("Begin - MicroMod Notecarrier Example 01: Sensor Data."));
  notecard.setDebugOutputStream(Serial);

  /* Begin I2C communications */
  Wire.begin();

  /* Initialize Notecard */
  notecard.begin();

  /* Configure Notecard */
  J *req = notecard.newRequest("hub.set");
  JAddStringToObject(req, "product", PRODUCT_UID);
  JAddStringToObject(req, "mode", "continuous");
  notecard.sendRequest(req);

  /* Find and initialize sensors */
  if (mySHTC3.begin() != SHTC3_Status_Nominal)
  {
    Serial.println(F("SHTC3 not detected. Please check wiring. Freezing..."));
    while (1)
      ; // Do nothing more
  }

  if (!mySTC3x.begin())
  {
    Serial.println(F("STC3x not detected. Please check wiring. Freezing..."));
    while (1)
      ; // Do nothing more
  }

  if (!mySGP40.begin())
  {
    Serial.println(F("SGP40 not detected. Check connections. Freezing..."));
    while (1)
      ; // Do nothing more
  }

  /**
   * We need to tell the STC3x what binary gas and full range we are using
   * Possible values are:
   * STC3X_BINARY_GAS_CO2_N2_100   : Set binary gas to CO2 in N2.  
   *    Range: 0 to 100 vol%
   * STC3X_BINARY_GAS_CO2_AIR_100  : Set binary gas to CO2 in Air. 
   *    Range: 0 to 100 vol%
   * STC3X_BINARY_GAS_CO2_N2_25    : Set binary gas to CO2 in N2.  
   *    Range: 0 to 25 vol%
   * STC3X_BINARY_GAS_CO2_AIR_25   : Set binary gas to CO2 in Air. 
   *    Range: 0 to 25 vol% 
   */
  if (!mySTC3x.setBinaryGas(STC3X_BINARY_GAS_CO2_AIR_25))
  {
    Serial.println(F("ST3x - Could not set the binary gas! Freezing..."));
    while (1)
      ; // Do nothing more
  }

  /**
   * Get an initial measurement so we can compensate for temperature and 
   * relative humidity using the readings from the SHTC3 
   */
  if (mySHTC3.update() != SHTC3_Status_Nominal) // Request a measurement
  {
    Serial.println(F("Could not read the RH and T from the SHTC3! \\
Freezing..."));
    while (1)
      ; // Do nothing more
  }

  /**
   * Configure STC31 temperature compensation based on previous measurement.
   * In case the ‘Set temperature command’ has been used prior to the above 
   * measurement command, this will set a new temperature compensation point.
   */
  temperature = mySHTC3.toDegC(); 
  Serial.print(F("Setting STC3x temperature to "));
  Serial.print(temperature, 2);
  Serial.print(F("C was "));
  if (!mySTC3x.setTemperature(temperature))
    Serial.print(F("not "));
  Serial.println(F("successful"));

  /**
   * Configure STC31 humidity compensation based on previous measurement.
   * In case the ‘Set humidity command’ has been used prior to the above 
   * measurement command, this will set a new humidity compensation point.
   */
  rh = mySHTC3.toPercent();
  Serial.print(F("Setting STC3x RH to "));
  Serial.print(rh, 2);
  Serial.print(F("% was "));
  if (!mySTC3x.setRelativeHumidity(rh))
    Serial.print(F("not "));
  Serial.println(F("successful"));

  /** 
   * If we have a pressure sensor available, we can compensate for ambient 
   * pressure too.
   * As an example, let's set the pressure to 840 mbar (== SF Headquarters) 
   */
  uint16_t pressure = 840;
  Serial.print(F("Setting STC3x pressure to "));
  Serial.print(pressure);
  Serial.print(F("mbar was "));
  if (mySTC3x.setPressure(pressure) == false)
    Serial.print(F("not "));
  Serial.println(F("successful"));

  Serial.println(F("Note: Relative humidity and temperature compensation for the STC31 will be updated frequently in the main loop() function."));

}

void loop() {

  //================================
  //==========READ SHTC3============
  //================================
  /* minimum update rate = ~100Hz */

  SHTC3_Status_TypeDef result = mySHTC3.update();           // Call "update()" to command a measurement, wait for measurement to complete, and update the RH and T members of the object

  rh = mySHTC3.toPercent();                                 // "toPercent" returns the percent humidity as a floating point number
  Serial.print(F("RelH: "));
  Serial.print(rh);
  Serial.println(F("%"));

  temperature = mySHTC3.toDegC();
  Serial.print(F("T: "));
  Serial.print(temperature);
  Serial.print(F(" deg C"));

  if (mySHTC3.lastStatus == SHTC3_Status_Nominal)           // You can also assess the status of the last command by checking the ".lastStatus" member of the object
  {
    Serial.println("");                                         //Sample data good, no need to output a message
  }
  else {
    Serial.print(F(",     Update failed, error: "));        //notify user if there is an error
    errorDecoder(mySHTC3.lastStatus);
    Serial.println("");
  }



  //==============================
  //==========READ STC31==========
  //==============================
  /* minimum update rate = 1Hz */


  if (!mySTC3x.setRelativeHumidity(rh))
    Serial.print(F("Unable to set STC31 Relative Humidity with SHTC3."));

  if (!mySTC3x.setTemperature(temperature))
    Serial.println(F("Unable to set STC31 Temperature with SHTC3."));


  Serial.print(F("CO2(%): "));

  if (mySTC3x.measureGasConcentration())                   // measureGasConcentration will return true when fresh data is available
  {
    co2 = mySTC3x.getCO2();
    Serial.println(co2, 2);
  }
  else
  {
    co2 = mySTC3x.getCO2();
    Serial.print(co2, 2);
    Serial.println(F(",     (old STC3 sample reading, STC31 was not able to get fresh data yet)"));  //output this note to indicate  when we are not able to obtain a new measurement
  }



  //==============================
  //==========READ SGP40==========
  //==============================
  /* minimum update rate = 1Hz */
  Serial.print(F("VOC: "));
  voc = mySGP40.getVOCindex(rh, temperature);
  Serial.println(voc); 

  /* Update the notecard about every 15s.*/
  if(++ncUpdateCtr >= 14)
  {
    ncUpdateCtr = 0;
    //==============================
    //=========UPLOAD DATA==========
    //==============================
    J *req = notecard.newRequest("note.add");
    if (req != NULL) {
      JAddStringToObject(req, "file", "sensors.qo");
      JAddBoolToObject(req, "sync", true);

      J *body = JCreateObject();
      if (body != NULL) {
        JAddNumberToObject(body, "temperature", temperature);
        JAddNumberToObject(body, "humidity", rh);
        JAddNumberToObject(body, "CO2%", co2);
        JAddNumberToObject(body, "VOC", voc);
        JAddItemToObject(req, "body", body);
      }

      notecard.sendRequest(req);
    }    
  }

  //================================
  //=========SPACE & DELAY==========
  //================================
  Serial.println("");// Uncomment this line to add some space between readings for the Serial Monitor
  delay(1000); //Wait 1 second - the Sensirion VOC and CO2 algorithms expects a sample rate of 1Hz

}

void errorDecoder(SHTC3_Status_TypeDef message)                             // The errorDecoder function prints "SHTC3_Status_TypeDef" results in a human-friendly way
{
  switch (message)
  {
    case SHTC3_Status_Nominal : Serial.print("Nominal"); break;
    case SHTC3_Status_Error : Serial.print("Error"); break;
    case SHTC3_Status_CRC_Fail : Serial.print("CRC Fail"); break;
    default : Serial.print("Unknown return code"); break;
  }
}

Notehub Project

First we'll return to the Notehub project created in the Software Setup section. If you haven't already, open notehub.io and open your Project. Your Notecard should appear in the devices listed.

Now open the Events tab and you should see a list of events printed out in the window assuming your Notes have synced.

This is just a basic example of transmitting data with the Notecard. From here you can route data to any of the supported cloud platforms. Head over to Blues Wireless' routing tutorials for detailed instructions on how to do that.

Outboard Device Firmware Update

Now that we're familiar with routing data through the Notecard to notehub.io, we'll demo one of the Notecard's most unique features; outboard device firmware updates (DFU). Outboard DFU's allow the Notecard to upload firmware to a connected Processor Board remotely from any location with a cellular signal. In this section we'll use notehub and Arduino to upload a new sketch to an STM32 Processor v20.

Configure Notecard for Outboard DFU

The Outboard DFU setting should be enabled on your Notecard by default but if you want to make sure send the following request to it through the Notecard CLI: {"req":"dfu.status","on":true}.

Next, enable the Notecard to flash the STM32 Processor with the binary we'll create later with the card.dfu request. Since we're flashing the STM32 Processor, the request should look something like this: {"req":"card.dfu","name":"stm32","on":true}.

Generate the Firmware Binary

With Outboard DFU enabled, we need to generate and locate the binary file created by Arduino for the firmware to be uploaded to the STM32 Processor. Open the Arduino IDE and copy the code below into a blank sketch. Alternatively, you can find it in the examples folder of the Function Board's Hardware Github Repo.

language:c
/**
 * @file Example02_Outboard_DFU.ino
 * @brief This example performs an Outboard Device Firmware Update.
 * @copyright SPDX-License-Identifier: MIT
 * @author Alex Brudner, SparkFun Electronics
 * @date 2022-11-02
 * @note Based on the DFU example from Blues Wireless. See
 * https://github.com/blues/note-outboard-dfu
 * 
 * ========== HARDWARE CONNECTIONS ==========
 * MicroMod STM32 Processor Board => MicroMod Main Board => MicroMod 
 *  Function Board Blues Wireless Notecarrier
 *
 * Feel like supporting open source hardware?
 * Buy a board from SparkFun!
 *      MicroMod Function Board Blues Wireless Notecarrier  
 *        | https://www.sparkfun.com/products/20409
 *      MicroMod STM32 Processor                            
 *        | https://www.sparkfun.com/products/16401
 *      MicroMod Main Board - Double                        
 *        | https://www.sparkfun.com/products/18575
 */

#include <Arduino.h>
#include <Notecard.h>

#define PRODUCT_UID "com.your-company.your-name:your_product"

int ledPin = LED_BUILTIN;

Notecard notecard;

void setup()
{
    pinMode(ledPin, OUTPUT);

    /* Begin Serial communications */
    Serial.begin(115200);
    Serial.println(F("Begin - MicroMod Notecarrier Example 02: Outboard DFU"));
    notecard.setDebugOutputStream(Serial);

    /* Begin Serial communications */
    Wire.begin();
    notecard.begin();

    /* Configure Notecard */
    J *req = notecard.newRequest("hub.set");
    JAddStringToObject(req, "product", PRODUCT_UID);
    JAddStringToObject(req, "mode", "continuous");
    JAddStringToObject(req, "sn", "stm32-micromod-v20-SN0001");
    notecard.sendRequest(req);

    /* Configure DFU settings */
    req = notecard.newRequest("card.dfu");
    JAddStringToObject(req, "name", "stm32-bi"); /* bi == boot inversion */
    JAddBoolToObject(req, "on", true);
    notecard.sendRequest(req);
}

void loop()
{
    /* Fast Blink LED while waiting for DFU. */
    Serial.println("Hello, world!");
    digitalWrite(ledPin, HIGH);
    delay(100);
    digitalWrite(ledPin, LOW);
    delay(400);
}

During verification, Arduino creates a temporary folder with this binary file along with other necessary metadata. On Windows, this is commonly in a filepath similar to: Users/"Your Username"/AppData/Local/Temp. When you open the Temp folder, you may have several folders titled arduino_build_######. If you can't find it there or use another operating system, Arduino prints the file location in the output data during the compilation step with "Verbose Output" enabled.

Open the folder containing the binary file, we'll need file location later. Alternatively, you can copy/paste it into a more easily accessible location.

Upload Binary to Notehub

Now we need to upload the binary file of the firmware to Notehub.io. Log in to your Notehub account if you have not already and navigate to the "Firmware" option below "Settings". Click the Firmware File field and navigate to the firmware binary location and click "Open". This page also includes the ability to add any notes regarding the firmware update as well as any metadata you wish to include with it. We'll skip both of those for now in this demo.

With the firmware saved to Notehub, go back to the Devices page.

Update Device Firmware

Select your Notecard and select to the "Host Firmware" tab. Next, click the "Update" button on the far right of the screen and it should open a prompt asking you to confirm you want to update the firmware. Click "Proceed", select the firmware from the list (in our case it will only include the "Example02_Outboard_DFU" binary) and click "Apply".

Your Notecard should automatically start to try and update the new firmware. You can watch the status of the firmware update in the "Host Firmware" tab.

Now that you're familiar with how to perform Outboard DFU's, you can upload your own custom firmware to your Processor.

Troubleshooting

Notecard CLI Helpful Commands

The Notecard CLI has a lot of helpful commands for debugging and troubleshooting all sorts of issues with the Notecard. Below is a list of just a few commands we find particularly helpful as starting points for troubleshooting but for a complete list as well as tutorials on how to use them, head over to Blues Wireless' Developers Page.

Simply connect the Cellular Function Board - Blues Wireless Notecarrier to your computer via the USB-C connector on the Function Board and open the Notecard CLI either in a browser or on your computer to start troubleshooting your board directly:

• '{"req": "card.version"}' - Request returns information on the Notecard version including the hardware version, device ID, name and firmware version.
• '{"req": "card.wireless"}' - Returns cellular connection data such as RSRP/RSRQ, RSSI, modem and band type and much more. Very helpful for diagnosing cellular activity issues.
• '{"req:" "hub.sync"}' - Manually sync the Notecard with Notehub. Pair this with the following request to view the synchronization status of the Notecard with Notehub.
• '{"req": "hub.sync.status"} - Returns helpful information about the status of communication between the Notecard and Notehub.

Notecard Firmware Version and Updating

If you run into any issues with features on notehub.io such as Outboard DFU the first thing we recommend checking is your Notecard firmware version. Verify the firmware version on the Notecard supports the features you are attempting to use and if needed, update the firmware on Notehub. You can find a step-by-step tutorial for updating Notecard firmware here.

Outboard DFU Hardware Limitations

As mentioned previously, Outboard DFU with the Cellular Function Board - Blues Wireless Notecarrier only works with specific MicroMod hardware:

• SparkFun MicroMod Main Board - Single v21 or SparkFun MicroMod Main Board - Double v22
• STM32 v20 Processor

This feature may work on other Processors in the future and we will update this guide when and if those Processors are added. Note, the previous versions of both MicroMod Main Boards do not support Outboard DFU with the Cellular Function Board - Blues Wireless Notecarrier.

General Troubleshooting

Resources and Going Further

That's all for this tutorial. For more information on the MicroMod Cellular Function Board - Blues Wirless Notecard, take a look at the resources below:

Cellular Function Board Resources:

• Schematic
• Eagle Files
• Board Dimensions
• GitHub Hardware Repo
• SFE Product Showcase

Blues Wireless Resources:

• Notecard NOTE-NBGL-500 Datasheet
• Notecard CLI
• Notehub Walkthrough
• Blues Note Arduino Library
• Blues Note Python Library

MicroMod Resources:

• Getting Started with MicroMod
• Designing with MicroMod
• MicroMod Info Page
• MicroMod Forums