smôl ARTIC R2 Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t2056

Introduction

smôl is a new board format and, as the name suggests, they're really small!

added to your cart!

smôl ARTIC R2

15 available SPX-18618

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$199.95

FavoritedFavorite0

Wish List

The smôl ARTIC R2 Peripheral Board is a complete satellite transceiver for the ARGOS satellite network.

When we designed our ARGOS Satellite Transceiver Shield - ARTIC R2, we knew that people would want to use it for applications like wildlife tracking. In fact, all programs using ARGOS have to be related in some way or other to environmental protection, awareness or study, or to protecting human life. But what if you want to develop something much smaller? Say, a small dart for whale tracking, or a small backpack for avian tracking. Or you just need your battery to last for months. smôl is designed to meet those needs.

Each smôl board measures just 1.60" by 0.42" (40.6mm by 10.7mm). We made the boards just wide enough so we could squeeze USB-C and 16-way Flexible Printed Circuit (FPC) connectors on there. Some of the boards have components on both top and bottom layers which again helps keep the boards small.

smôl boards are designed to stack one on top of the other, using 16-way 0.5mm-pitch FPCs to provide the interconnect from one board to the next. Each board has an IN FPC connector on the bottom layer and an OUT FPC connector on the top layer. The boards stack in a zig-zag daisy chain; signals and power are passed from one board to the next up and down the chain through the FPCs.

Required Materials

As a minimum, you're going to need a suitable antenna:

added to your cart!

ARGOS Omnidirectional Antenna - 401MHz

In stock WRL-17523

Designed for transmit and receive at 401MHz, this quarter-wave antenna is the perfect partner for our ARGOS ARTIC R2 satellit…

$6.95

FavoritedFavorite0

Wish List

The ARTIC R2 Peripheral Board is part of the smôl ecosystem. Why not pair it with one of the smôl Processor Boards?

added to your cart!

smôl ESP32

In stock SPX-18619

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

To be able to reduce the sleep current below 10µA, you're going to want to pair the ESP32 with one of our intelligent smôl Power Boards:

added to your cart!

smôl Power Board AAA

In stock SPX-18621

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

added to your cart!

smôl Power Board LiPo

In stock SPX-18622

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

Of course, a satellite tracking system needs to know where it is. Why not add a smôl ZOE-M8Q GNSS board to your smôl ecosystem?

added to your cart!

smôl ZOE-M8Q

Out of stock SPX-18623

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$39.95

FavoritedFavorite0

Wish List

Don't forget that you will need Flexible Printed Circuits to connect your smôl boards together. You're going to need one FPC per board. Our 36mm FPC is the perfect length if you want the smôl boards to stack neatly, one on top of the other.

added to your cart!

smôl 36mm 16-way Flexible Printed Circuit

In stock CAB-18731

This is the 36mm 16-way 0.5mm-pitch Flexible Printed Circuit used to interconnect smôl boards. *** _**smôl** is an ec…

$0.95

FavoritedFavorite0

Wish List

Need to do some prototyping with smôl? Or want to connect your smôl stack to another Qwiic board? The smôl Header is perfect for that:

added to your cart!

smôl Header

In stock SPX-18620

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$2.95

FavoritedFavorite0

Wish List

Suggested Reading

This is the hookup guide for the smôl ARTIC R2 Peripheral Board. Click the button below if you want to find out more about smôl itself.

We recommend taking a look through the following tutorials if you are not familiar with the concepts covered in them:

ARGOS & ARTIC R2

Is your project linked to environmental protection, awareness or study, or to protecting human life? Perhaps you are developing a wildlife tracker, ocean buoy, environmental monitoring system or need to transfer emergency medical information? Do you need to be able to transmit and receive data anywhere? If so, this is the smôl product for you! Our smôl ARTIC R2 allows you to send and receive short bursts of data via the ARGOS satellite network, anywhere on Earth including the Polar regions.

The ARGOS satellite system has been around for quite a while. It was created in 1978 by the French Space Agency (CNES), the National Aeronautics and Space Administration (NASA) and the National Oceanic and Atmospheric Administration (NOAA), originally as a scientific tool for collecting and relaying meteorological and oceanographic data around the world. Today, ARGOS is revolutionising satellite communication, adding a constellation of 25 nanosatellites to complement the 7 traditional satellites carrying ARGOS instrumentation. The first of these, ANGELS, is already in operation and SparkFun were among the first users to transmit data to ANGELS in October 2020. When the constellation is complete, there will be a maximum of 10-15 minutes between satellite passes.

The ARTIC R2 is an integrated, low-power, small-size ARGOS 2/3/4 single chip transceiver. ARTIC implements a message based wireless interface. For satellite uplink communication, ARTIC will encode, modulate and transmit provided user messages. For downlink communication, ARTIC will lock to the downstream, demodulate and decode and extract the satellite messages. The ARTIC can transmit signals in frequency bands around 400MHz and receive signals in the bands around 466MHz, in accordance with the ARGOS satellite system specifications.

The smôl ARTIC R2 has been tested and certified by Kinéis. Compared to other satellite communication systems, the smôl ARTIC R2 has a much lower current draw and will work with a very simple, very lightweight quarter-wave wire antenna. The ARTIC R2 chipset on our board operates from 3.3V and the on-board flash memory enables fast boot times. If you don’t need the full transmit power, or want to conserve your battery life, you can transmit at reduced power too thanks to opto-isolated gain control.

Our Arduino Library makes it really easy to get up and running with ARGOS. We’ve provided a full set of examples which will let you: configure the ARTIC R2 chipset; predict the next satellite pass; receive allcast and individually-coded messages; transmit messages using ARGOS 2, 3 and 4 encoding. There are dedicated examples for the smôl ARTIC R2.

Hardware Overview

In this section we'll cover what's included on the smôl ARTIC R2 Peripheral Board.

ARTIC R2

The heart of the smôl ARTIC R2 is, of course, the ARTIC R2 transceiver itself. This is a clever chip containing a Digital Signal Processor (DSP) which modulates transmit messages and demodulates received messages. The DSP can boot from on-board flash memory or from an external microcontroller via SPI. When transmitting, it produces a 1mW (0dBm) output signal which is fed to a separate power amplifier.

Our Arduino Library does all of the heavy lifting for you. By default, the library will tell the ARTIC R2 DSP to boot from the on-board flash memory. However, by changing one line of code, you can instead boot via SPI with your microcontroller providing the firmware for the DSP.

RF Amplifier

During transmit, the RFPA0133 power amplifier boosts the 0dBm (1mW) signal from the ARTIC R2.

By default, the amplifier uses full gain and boosts the signal to approximately 25.8dBm (380mW). If you are using ARGOS 2 or 3 modulation and are transmitting from a 'noisy' environment, like a city, then you are probably going to need to use full power to ensure your messages get through. However, if you are using ARGOS 4 modulation and/or are transmitting from a 'quiet' environment, like the tundra or the ocean, then you will be able to transmit at reduced power.

Gain Control

There are two ways to reduce the smôl ARTIC R2 transmit power. You can adjust the gain through software and the on-board opto-isolated gain control circuit.

Our Arduino Library can reduce the gain for you. If you call:

language:c
myARTIC.attenuateTXgain(true);

from inside your code, the opto-isolator will pull the RFPA0133's G8 pin low, reducing the gain by approximately 5dB. This also has the advantage of reducing the transmit current by approximately 80mA.

If you are experimenting with ARGOS 4 modulation, you may want to reduce the gain even further. You can do that by opening the split-pad jumper next to the opto-isolator. Opening the jumper will pull the RFPA0133's G16 pin low and will reduce the gain by approximately 11dB. If you haven't used jumpers before, please check out our tutorial.

Flash Memory

If you turn the smôl ARTIC R2 over, you will be able to see the small flash memory chip.

During production testing at SparkFun, we program the flash memory with the ARTIC R2 firmware (ARTIC006) and a Platform ID allocated by CLS. You will need to register the Platform ID on your ARGOS account to activate it.

GPIO Expander

The larger chip on the bottom of the board is a PCA9536 I²C GPIO expander.

smôl only supports two GPIO signals, so we added a separate I²C GPIO expander to allow the ARTIC R2 RESETB, INT1 and BOOT signals, plus the RF amplifier G8 pin, to be controlled via I²C.

You won't need to communicate with the GPIO expander directly, our Arduino Library will do that for you, we're just letting you know why that chip is there.

Antenna

The antenna connection for the ARTIC R2 is u.FL.

Check out our tutorial if you haven't used u.FL before:

Current Draw

If you are using the smôl ARTIC R2 to develop your own wildlife tracker, you will of course be very interested in how much current the board draws.

The fantastic Otii Arc Power Analyzer has allowed us to capture the ARTIC R2's exact peak transmit current draw at all four gain settings, and to study the average current drawn when the chip is idle. We've used this data to help optimize the code in this example to extend the battery life as much as possible when using the smôl ARTIC R2 with the smôl ESP32 Processor Board, smôl ZOE-M8Q GNSS Board and the smôl Power Board LiPo.

Maximum Gain (G16 High, G8 High)

The picture below shows the current draw captured by Otii Arc for a complete transmit cycle using this example. The gain here is set to maximum.

At the start of the transmit cycle, the ESP32 Processor Board is woken up by the Power Board. It turns on the ZOE-M8Q GNSS board and waits for a fix. The current draw here is approximately 100mA for ~10 seconds.

Once the ESP32 has a location fix, it can calculate the time of the next ARGOS satellite pass. The power board woke the ESP32 up 1 minute before the start of the next pass, so the ESP32 goes in and out of light sleep for the next ~30 seconds.

The ARTIC R2 is powered on at the 40 second mark and the first of five transmits takes place just after the one minute mark.

The code example transmits five times on each satellite pass. The gap between the transmits is 90 seconds with a mandatory ±10% jitter. In between, you can see the ESP32 going in and out of light sleep with the ARTIC R2 being powered up 20-30 seconds before the next transmit is due.

The phenomenal data captured by Otii Arc allows us to zoom right in on the transmit itself and capture the true maximum current draw:

It's then child's play to extract the data we need!

Current Draw Summary

Below is a summary of the peak transmit current draw for the four ARTIC R2 gain settings. The RFPA0133 G8 pin is controlled by software. The G16 pin is controlled by the split-pad jumper. The smôl stack was powered by a 3.7V LiPo battery.

Please note: the Peak TX Current in this table is the total peak current drawn by the ESP32 + ARTIC R2 + Power Amplifier during the actual transmit

Otii Arc lets us collect the other data we need:

• LiPo Battery Voltage: 3.7V
• Average Current Draw during a complete 5*TX transmit cycle (maximum gain): 29.9mA
• Average Current Draw during a complete 5*TX transmit cycle (minimum gain): 24.9mA
• Average continuous ESP32 + ZOE-M8Q GNSS Current Draw: 97mA
• Current Draw during deep sleep: 6.4µA
• Power Consumption during a complete 5*TX transmit cycle (maximum gain): 13.3mWh
• Power Consumption during a complete 5*TX transmit cycle (minimum gain): 11.1mWh

We can then use this data to predict the battery life based on the transmit power and the number of transmissions per day. The satellite pass-prediction code in our Arduino Library can calculate the timing of the satellite passes with the highest elevation each day to maximize the chance of the transmission being received. Transmitting five times per day at maximum power, we could expect a 2000mAh battery to last approximately 530 days! Even the modest 400mAh battery pictured below should last for more than 100 days.

smôl Specifics

Interfaces:

• SPI and I²C
  • SPI Chip Select: CS0 (via waterfalling)
  • PCA9536 GPIO Expander I²C Address: 0x41

GPIO:

• Uses GPIO0 for power control (via waterfalling)
• Leave GPIO0 floating or pull low to disable power for the ARTIC R2
• Pull GPIO0 high to enable power for the ARTIC R2
• Power is controlled automatically via the SparkFun ARTIC R2 Arduino Library

Arduino Example: Satellite Detection

If you are using the smôl ESP32 Processor Board, you are going to want to install the CP210x USB Driver and Arduino Boards Package for the ESP32 first. Please see the smôl ESP32 Hookup Guide for more details.

The smôl ARTIC R2 peripheral board is fully compatible with the SparkFun ARGOS ARTIC R2 Arduino Library. You can install the library through the Arduino IDE Library Manager by searching for SparkFun ARGOS ARTIC. Alternatively, you can grab the library from GitHub or can download it as a zip file by clicking the button below:

The library contains tried-and-tested dedicated examples for the smôl ARTIC R2. The code below is a stripped-down version of Example3_SatelliteDetection. Copy and paste the code into a new window in the Arduino IDE and upload to the ESP32. The ARTIC R2 will try to detect a satellite for up to 10 minutes. You may wish to log into the ARGOS website and predict when the next satellite pass will take place before running this example.

language:c
#include <Wire.h> //Needed for I2C to ARTIC R2 GPIO
#include <SPI.h>
#include "SparkFun_ARGOS_ARTIC_R2_Arduino_Library.h" // http://librarymanager/All#SparkFun_ARGOS_ARTIC_R2
ARTIC_R2 myARTIC;

int CS_Pin = 5;            // smôl CS0 = ESP32 Pin 5
int ARTIC_PWR_EN_Pin = 27; // smôl GPIO0 = ESP32 Pin 27

void setup()
{
  Serial.begin(115200);
  Serial.println(F("ARGOS smôl ARTIC R2 Example"));

  Serial.println(F("ARTIC R2 is booting..."));

  Wire.begin(); // Needed to communicate with the I2C GPIO chip on the smôl ARTIC R2
  SPI.begin();

  //myARTIC.enableDebugging(); // Uncomment this line to enable debug messages on Serial

  // Begin the ARTIC: enable power and boot from flash
  if (myARTIC.beginSmol(CS_Pin, ARTIC_PWR_EN_Pin) == false)
  {
    Serial.println("ARTIC R2 not detected. Please check the smôl stack-up and flexible circuits. Freezing...");
    while (1)
      ; // Do nothing more
  }

  Serial.println(F("ARTIC R2 boot was successful."));

  myARTIC.setTCXOControl(1.8, true); // Set the TCXO voltage to 1.8V and autoDisable to 1

  myARTIC.setSatelliteDetectionTimeout(600); // Set the satellite detection timeout to 600 seconds

  Serial.println(F("Starting satellite detection..."));

  // Start satellite detection
  // The ARTIC will start looking for a satellite for the specified amount of time.
  myARTIC.sendMCUinstruction(INST_SATELLITE_DETECTION);
}

void loop()
{
  delay(1000);

  // Read the ARTIC R2 status register
  ARTIC_R2_Firmware_Status status;
  myARTIC.readStatusRegister(&status);

  // Check the interrupt 2 flag. This will go high if satellite detection times out
  if (status.STATUS_REGISTER_BITS.DSP2MCU_INT2)
  {
    Serial.println(F("INT2 pin is high. Satellite detection has timed out!"));
  }
  // Check the interrupt 1 flag. This will go high when a satellite is detected
  else if (status.STATUS_REGISTER_BITS.DSP2MCU_INT1)
  {
    Serial.println(F("INT1 pin is high. Satellite detected!"));
  }

  // Check the instruction progress
  // checkMCUinstructionProgress will return true if the instruction is complete
  ARTIC_R2_MCU_Instruction_Progress progress;
  boolean instructionComplete = myARTIC.checkMCUinstructionProgress(&progress);

  if (instructionComplete)
  {
    Serial.println(F("Satellite detection is complete! Freezing..."));
    while (1)
      ; // Do nothing more
  }
}

Troubleshooting

Resources and Going Further

For more information about the smôl ARTIC R2, check out the following links:

smôl ARTIC R2 Documentation:

• Schematic
• Eagle Files
• ARGOS Chipset Info Sheet
• ARTIC R2 User Datasheet v1.1
• GitHub Hardware Repo
• Arduino Examples
• SparkFun ARGOS ARTIC R2 Arduino Library

smôl Documentation:

• smôl Hookup Guide

learn.sparkfun.com | CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

smôl Power Board AAA Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t2059

Introduction

smôl is a new board format and, as the name suggests, they're really small!

added to your cart!

smôl Power Board AAA

In stock SPX-18621

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

The smôl Power Board AAA is an intelligent power board for smôl. It is designed to provide 3.3V power for your smôl stack from one or two AAA or AA alkaline (non-rechargeable) batteries. If you need a rechargeable solution, check out the smôl Power Board LiPo.

Each smôl board measures just 1.60" by 0.42" (40.6mm by 10.7mm). We made the boards just wide enough so we could squeeze USB-C and 16-way Flexible Printed Circuit (FPC) connectors on there. Some of the boards have components on both top and bottom layers which again helps keep the boards small.

smôl boards are designed to stack one on top of the other, using 16-way 0.5mm-pitch FPCs to provide the interconnect from one board to the next. Each board has an IN FPC connector on the bottom layer and an OUT FPC connector on the top layer. The boards stack in a zig-zag daisy chain; signals and power are passed from one board to the next up and down the chain through the FPCs.

Required Materials

As a minimum, you're going to need a battery holder or JST-PH cable to go with your power board:

added to your cart!

micro:bit Battery Holder - 2xAAA (JST-PH)

In stock PRT-15101

This is a unique two-cell AAA battery holder built specifically for the BBC micro:bit. The 6" (~150mm) cable has been termina…

$1.95

FavoritedFavorite10

Wish List

added to your cart!

JST Jumper 2 Wire Assembly

In stock PRT-09914

This is a simple two wire cable. Great for jumping from board to board or just about anything else. There is a 2-pin JST conn…

$0.95

3

FavoritedFavorite33

Wish List

added to your cart!

Battery Holder - 2xAA (JST-PH)

In stock PRT-14299

This is a unique two-cell AA battery holde. The 6" (~150mm) cable has been terminated with a JST-PH connector.

$1.50

FavoritedFavorite21

Wish List

added to your cart!

Barrel Jack to 2-pin JST

In stock TOL-08734

Two pin JST connector to a 2.1x 5.5mm barrel jack, 6.25 inch long jumper cable. We use this cable to adapt from a wall power …

$2.95

1

FavoritedFavorite18

Wish List

The Power Board AAA is part of the smôl ecosystem. Why not pair it with one of the smôl Processor Boards and a Peripheral Board?

added to your cart!

smôl ARTIC R2

15 available SPX-18618

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$199.95

FavoritedFavorite0

Wish List

added to your cart!

smôl ESP32

In stock SPX-18619

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

added to your cart!

smôl ZOE-M8Q

Out of stock SPX-18623

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$39.95

FavoritedFavorite0

Wish List

Don't forget that you will need Flexible Printed Circuits to connect your smôl boards together. You're going to need one FPC per board. Our 36mm FPC is the perfect length if you want the smôl boards to stack neatly, one on top of the other.

added to your cart!

smôl 36mm 16-way Flexible Printed Circuit

In stock CAB-18731

This is the 36mm 16-way 0.5mm-pitch Flexible Printed Circuit used to interconnect smôl boards. *** _**smôl** is an ec…

$0.95

FavoritedFavorite0

Wish List

Need to do some prototyping with smôl? Or want to connect your smôl stack to a Qwiic board? The smôl Header is perfect for that:

added to your cart!

smôl Header

In stock SPX-18620

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$2.95

FavoritedFavorite0

Wish List

Suggested Reading

This is the hookup guide for the smôl Power Board AAA. Click the button below if you want to find out more about smôl itself.

We recommend taking a look through the following tutorials if you are not familiar with the concepts covered in them:

Hardware Overview

In this section we'll cover what this board does and what is included on the smôl Power Board AAA.

What Does This Board Do?

What does this board do? Excellent question! Let's answer that right now.

The main job of the Power Board is to provide power for your smôl ecosystem. smôl is designed to be both small in size and small on current draw. The Power Board plays a critical role in reducing the current draw of smôl as much as possible. This board has a TPS61200 switching regulator on it and is designed to boost the voltage from one or two AAA or AA alkaline cells up to 3.3V. But it also comes with an ATtiny43 AVR microcontroller on it. This is an intelligent power board for the smôl ecosystem!

When you want your project to go into a low power or deep sleep state, it is standard practice to put your processor into the lowest power state it offers. But you may find that the current draw is still something like 100µA to 500µA depending on which processor you are using. Then there is the quiescent current drawn by the voltage regulator. The quiescent current is the current drawn by the regulator when it is on but has no load attached. Again, it varies from regulator to regulator but you may find this adds another 55µA to your current draw. Those little currents add up and reduce your battery life considerably.

With smôl, we took a new approach. The Power Board takes control and provides the 3.3V power for the whole smôl stack. When instructed to by the Processor Board, the on-board ATtiny microcontroller will turn off that power completely and then put itself into a low power sleep state for a pre-defined interval. Sleep intervals from a few 10's of milliseconds to several days are possible. We have used the fantastic Otii Arc Power Analyzer to help us reduce the sleep current to just 12µA. Yes, you read that right, 12 microamps! smôl makes it possible for your battery life to be measured in months not days!

Battery Connector

By far the biggest component on the board is the JST-PH connector for the battery.

ATtiny43U AVR Microcontroller

The smôl Power Board AAA is an intelligent power board. The on-board ATtiny43U microcontroller can monitor the battery voltage and other parameters. When the Processor Board requests it to, the ATtiny43 will turn off the smôl 3.3V power completely and place itself into deep sleep for a pre-defined interval. This is what makes it possible to reduce the sleep current to just 12µA.

The ATtiny43U may seem a strange choice, but actually it is the perfect choice for this board. We use it because it has a built-in boost converter and can operate directly from voltages as low as 0.7V. It does not need a separate voltage regulator.

Our SparkFun smôl Power Board Arduino Library does all of the heavy lifting for you, making it easy to communicate with the ATtiny through simple function calls.

A Note About Temperature Sensing

The ATtiny43 has a built-in temperature sensor, which can be accessed via the SparkFun smôl Power Board Arduino Library. However, the quoted typical accuracy of the sensor is ±10°C. Yes, plus or minus ten degrees C. The sensor measurement requires external calibration to be useful.

Voltage Regulator

The smôl Power Board AAA has a TPS61200 switching regulator on-board. That's the same regulator we use on our LiPower - Boost Converter. It can deliver approximately 550mA when boosting 1.5V up to 3.3V, and approximately 1500mA when boosting 3.0V up to 3.3V. It can be switched off completely by the ATtiny43U microcontroller, avoiding the 55µA quiescent current draw.

FPC Connections

Like all of our smôl boards, the Power Board AAA is equipped with two 16-way 0.5mm-pitch Flexible Printed Circuit connectors. FPCs are used to link the smôl boards together in a daisy-chain.

The pin-out for the smôl Power Board AAA is as follows:

The IN and OUT pin connections are identical on the smôl Power Board AAA. (That's not always true on smôl Peripheral Boards. Check the appropriate Peripheral Board Hookup Guide for full details.)

The order in which you connect smôl boards is important. However, because the Power Board AAA only uses I²C communication, it can be placed anywhere in the stack. Please see the smôl Hookup Guide for more details.

smôl Specifics

Interface:

• Interface: I²C
  • ATtiny43U Default Address: 0x50

PROC_PWR_EN:

• PROC_PWR_EN:
  • The power board pulls PROC_PWR_EN low to disable the regulator on the processor board

Arduino Example: Battery Voltage

If you are using the smôl ESP32 Processor Board, you are going to want to install the CP210x USB Driver and Arduino Boards Package for the ESP32 first. Please see the smôl ESP32 Hookup Guide for more details.

The smôl Power Boards have their own Arduino Library to make communicating with the board as simple as calling a function. You can install the library through the Arduino IDE Library Manager by searching for SparkFun smol power. Alternatively, you can grab the library from GitHub or can download it as a zip file by clicking the button below:

You are also going to need to install the SparkFun MAX1704x Fuel Gauge Arduino Library. The smôl Power Board AAA does not have a fuel gauge on it, but the library does need it to provide support for the smôl Power Board LiPo. Again, you can install this library through the Arduino IDE Library Manager by searching for SparkFun MAX1704x. Alternatively, you can grab the library from GitHub or can download it as a zip file by clicking the button below:

The Power Board library contains a set of tried-and-tested examples which will work with both the smôl Power Board AAA and the smôl Power Board LiPo. There is only one line of code to change when switching from one to the other.

The following code is a simplified version of Example2_BatteryVoltage. Upload the code onto your processor board and open the Serial Monitor or a terminal emulator at 115200 baud to see the output.

language:c
#include <Wire.h>

#include <SparkFun_MAX1704x_Fuel_Gauge_Arduino_Library.h> // Click here to get the library: http://librarymanager/All#SparkFun_MAX1704x_Fuel_Gauge_Arduino_Library
#include <SparkFun_smol_Power_Board.h> //Click here to get the library:  http://librarymanager/All#SparkFun_smol_Power_Board

smolPowerAAA myPowerBoard;

void setup()
{
  Serial.begin(115200);
  while (!Serial)
    ; // Wait for the user to open the Serial console
  Serial.println(F("smôl Power Board example"));
  Serial.println();

  Wire.begin();

  if (myPowerBoard.begin() == false) // Begin communication with the power board using the default I2C address (0x50) and the Wire port
  {
    Serial.println(F("Could not communicate with the power board. Please check the I2C connections. Freezing..."));
    while (1)
      ;
  }

  // Select VCC as the voltage reference - see the full example for more details
  myPowerBoard.setADCVoltageReference(SFE_SMOL_POWER_USE_ADC_REF_VCC);

  float voltage = myPowerBoard.getBatteryVoltage(); // Read the battery voltage from the ATtiny43U
  Serial.print(F("The battery voltage reads as: "));
  Serial.println(voltage);

  if (voltage == -99.0)
  {
    Serial.println(F("A voltage of -99.0V indicates an error."));
  }
}

void loop()
{
  //Nothing to do here
}

Troubleshooting

If your smôl stack is not communicating, it is probably in deep sleep. When the Power Board is commanded into deep sleep by the Processor Board, the only way it will wake it up again is when the sleep interval expires. You cannot wake or reset the system via the USB interface.

Removing and re-inserting the battery connection will reset the power board and wake it up again.

We did not include a reset button on the smôl Power Board to keep the board as small as possible. However, you can reset it via the ISP programming test points on the bottom of the board. Briefly connect RESET to GND to reset the board.

Resources and Going Further

For more information about the smôl Power Board AAA, check out the following links:

smôl Power Board AAA Documentation:

• Schematic
• Eagle Files
• GitHub Hardware Repo
• SparkFun smôl Power Board Arduino Library
• Arduino Examples

Boost Regulator:

• Datasheet (TPS61200)

Microcontroller:

• Datasheet (ATtiny43U)

smôl Documentation:

• smôl Hookup Guide

learn.sparkfun.com | CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

smôl Header Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t2058

Introduction

smôl is a new board format and, as the name suggests, they're really small!

added to your cart!

smôl Header

In stock SPX-18620

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$2.95

FavoritedFavorite0

Wish List

Need to do some prototyping with smôl? Or want to connect your smôl stack to a Qwiic board or your favorite SPI sensor? The smôl Header is the perfect solution!

Required Materials

If you want to connect a Qwiic board to your smôl stack, you're going to need some Qwiic cables:

added to your cart!

SparkFun Qwiic Cable Kit

In stock KIT-15081

To make it even easier to get started, we've assembled this Qwiic Cable Kit with a variety of Qwiic cables from 50mm to 500mm…

$7.95

12

FavoritedFavorite42

Wish List

added to your cart!

Qwiic Cable - 50mm

In stock PRT-14426

This is a 50mm long 4-conductor cable with 1mm JST termination. It’s designed to connect Qwiic enabled components together …

$0.95

FavoritedFavorite25

Wish List

added to your cart!

Flexible Qwiic Cable - Female Jumper (4-pin)

In stock CAB-17261

This polarized I2C cable insulation is made from silicon making it more flexible than our original Qwiic cable particularly i…

$1.50

FavoritedFavorite1

Wish List

added to your cart!

Qwiic Cable - Breadboard Jumper (4-pin)

In stock PRT-14425

This is a jumper adapter cable that comes pre-terminated with a female Qwiic JST connector on one end and a breadboard hookup…

$1.50

FavoritedFavorite32

Wish List

If you're prototyping with smôl, you may need:

added to your cart!

Break Away Headers - Straight

In stock PRT-00116

A row of headers - break to fit. 40 pins that can be cut to any size. Used with custom PCBs or general custom headers.

$1.50

20

FavoritedFavorite122

Wish List

added to your cart!

Breadboard - Classic

In stock PRT-00112

Your first exposure to electrical engineering - the bread board. Who knew it would bring so much frustration? This is your …

$9.95

17

FavoritedFavorite26

Wish List

added to your cart!

Jumper Wires Premium 6" M/M Pack of 10

In stock PRT-08431

This is a SparkFun exclusive! These are 155mm long, 26 AWG jumpers with male connectors on both ends. Use these to jumper fro…

$3.95

2

FavoritedFavorite11

Wish List

added to your cart!

Breadboard - Mini Modular (Red)

In stock PRT-12044

This red Mini Breadboard is a great way to prototype your small projects! With 170 tie points there's just enough room to bui…

$3.95

FavoritedFavorite11

Wish List

The Header is part of the smôl ecosystem. Why not pair it with one of the smôl Processor Boards?

added to your cart!

smôl ESP32

In stock SPX-18619

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

To be able to reduce the sleep current below 10µA, you're going to want to pair the ESP32 with one of our intelligent smôl Power Boards:

added to your cart!

smôl Power Board AAA

In stock SPX-18621

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

added to your cart!

smôl Power Board LiPo

In stock SPX-18622

Our RedBoards are great. But don't they sometimes seem a little **_BIG_**?! Enter **smôl**, a new range of boards which a…

$17.95

FavoritedFavorite0

Wish List

Don't forget that you will need Flexible Printed Circuits to connect your smôl boards together. You're going to need one FPC per board. Our 36mm FPC is the perfect length if you want the smôl boards to stack neatly, one on top of the other.

added to your cart!

smôl 36mm 16-way Flexible Printed Circuit

In stock CAB-18731

This is the 36mm 16-way 0.5mm-pitch Flexible Printed Circuit used to interconnect smôl boards. *** _**smôl** is an ec…

$0.95

FavoritedFavorite0

Wish List

Suggested Reading

This is the hookup guide for the smôl Header. Click the button below if you want to find out more about smôl itself.

We recommend taking a look through the following tutorials if you are not familiar with the concepts covered in them:

Hardware Overview

smôl boards are designed to stack one on top of the other, using 16-way 0.5mm-pitch Flexible Printed Circuits (FPCs). We really like FPCs and we're using them on more and more of our products. But they can be a bit tricky when it comes to prototyping or if you want to connect other devices to your smôl stack. The smôl Header is here to help!

FPC Connections

Like all of our smôl boards, the Header is equipped with a 16-way 0.5mm-pitch Flexible Printed Circuit connector. The pin-out for the smôl Header connector is as follows:

Breakout Pins

You've got full access to all the smôl pins, so connecting your favorite SPI board to smôl is as easy as plug-and-play! The smôl Header breaks out all 16 smôl connections in good old 0.1" format. The hole pattern is the same as an old school 16-pin 0.3" Dual-In line Package (DIP). Perfect for soldering header pins to and then pushing into standard breadboard.

Qwiic Connector

We've included a Qwiic connector too, so you can attach your favorite Qwiic boards to your smôl stack qwiicly and easily.

Qwiic (I²C) Pull-ups

The Header also includes pull-up resistors for the I²C SDA and SCL signals. You can disconnect the resistors if required by opening the dual split-pad jumper links.

If you haven't used jumpers before, please check out our tutorial.

Troubleshooting

Resources and Going Further

For more information about the smôl Header, check out the following links:

smôl Header Documentation:

• Schematic
• Eagle Files
• GitHub Hardware Repo
• Dimensions

smôl Documentation:

• smôl Hookup Guide

learn.sparkfun.com | CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

Qwiic ToF Imager - VL53L5CX Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t2002

Introduction

The Qwiic ToF Imager - VL53L5CX is here! This little breakout board is built around ST Electronics' VL53L5CX; a state of the art, Time-of-Flight (ToF), multizone ranging sensor enhancing the ST FlightSense product family. This chip integrates a SPAD array, physical infrared filters, and diffractive optical elements (DOE) to achieve the best ranging performance in various ambient lighting conditions with a range of cover glass materials.

Multizone distance measurements are possible up to 8x8 zones with a wide 63° diagonal FoV which can be reduced by software. Thanks to ST Histogram patented algorithms, the VL53L5CX is able to detect different objects within the FoV. The Histogram also provides immunity to cover glass crosstalk beyond 60 cm.

Ideal for 3D room mapping, obstacle detection for robotics, gesture recognition, IoT, laser-assisted autofocus, and AR/VR enhancement, the Qwiic connector on this sensor makes integration easy.

added to your cart!

SparkFun Qwiic ToF Imager - VL53L5CX

In stock SEN-18642

The SparkFun Qwiic ToF Imager is built around VL53L5CX from ST Electronics; a state of the art, Time-of-Flight (ToF), multizo…

$24.95

FavoritedFavorite1

Wish List

Required Materials

To follow along with this tutorial, you will need the following materials. You may not need everything though depending on what you have. Add it to your cart, read through the guide, and adjust the cart as necessary.

Suggested Reading

If you aren't familiar with the Qwiic system, we recommend reading here for an overview.

Qwiic Connect System

We would also recommend taking a look at the following tutorials if you aren't familiar with them.

Hardware Overview

VL53L5CX

STMicroelectronics' VL53L5CX is a state of the art, time-of-flight (ToF), laser-ranging sensor with an 8x8 multizone range and a wide field of view. To see more details, refer to the datasheet.

Qwiic Connectors

Our Qwiic Ecosystem makes sensors pretty much plug and play. There are two Qwiic connectors on either side of the Qwiic Air Velocity Sensor board to provide power and I²C connectivity simultaneously.

The unshifted I²C address of the board is 0x52.

Power

Ideally power will be supplied by the Qwiic connector, but if you wish to supply your own power, pins have been broken out along the bottom side of the board labeled 3V3 and GND. The input voltage range should be between 2.7-3.3V.

I²C

The I²C pins break out the functionality of the Qwiic connectors. Depending on your application, you can connect to these pins via the plated through holes for SDA and SCL.

INT and RST

The interrupt pin is the interrupt output and defaults to an open-drain output. A 47 kΩ pull-up resistor to IOVDD is included.

The reset pin is the I²C interface reset pin and is active high. It is pulled to ground with a 47 kΩ resistor.

LP, VDDIO, & VDDA

LP is a low power enable pin. Drive this pin to logic 0 to disable the I²C comms to reduce power consumption. Drive this pin to logic 1 to enable I²C comms. This pin is typically only needed when you need to change the I2C address in multidevice systems. A 47 kΩ pull-up resistor to IOVDD is included so it can be left unconnected.

VDDIO/VDDA: These pins are used as an alternate power supply. By default, VDDIO and VDDA are tied together but by opening the PSU jumper they can be isolated. A user must then provide separate VDDIO and VDDA supplies. This is most applicable for users who want to use IO voltages (1.8, 2.8, or 3.3V) separate from AVDD voltages (2.8 or 3.3V) for maximum power reduction.

Jumpers

PSU

By default, VDDIO and VDDA are tied together. Cutting the PSU jumper will isolate the power rails. A user must then provide separate VDDIO and VDDA supplies. This is most applicable for users who want to use IO voltages (1.8, 2.8, or 3.3V) separate from AVDD voltages (2.8 or 3.3V) for maximum power reduction.

INT

Cut the INT jumper to remove the 47 kΩ pull-up resistor from the INT pin.

I²C

The SparkFun Qwiic ToF Imager Sensor has two 2.2 kΩ pull-up resistors attached to the I²C bus by default. If multiple sensors are connected to the bus with the pull-up resistors enabled the parallel equivalent resistance may create too strong of a pull-up for the bus to operate correctly. As a general rule of thumb, disable all but one pair of pull-up resistors if multiple devices are connected to the bus. If you need to disconnect the pull-up resistors they can be removed by cutting the traces on the corresponding jumper highlighted below.

LED

If minimal power consumption is a concern, or you just don't want that Power LED on the front of the board to light up, go ahead and cut this jumper.

Board Outline

This sensor measures 1" x 1".

Hardware Hookup

Using the Qwiic system, assembling the hardware is simple. All you need to do is connect your VL53L5CX Imager Breakout to your chosen development board with a Qwiic cable or adapter cable. If Qwiic is not your thing, or if your dev board doesn't have one built in you can always solder directly to the I²C pins. If you are not using a Qwiic-enabled board, make sure your input voltage and logic are either running at 3.3V or you are shifting the logic level from whatever logic your controller runs at to 3.3V.

Software Setup and Programming

We've written a simple Arduino library to quickly get started reading data from the Qwiic ToF Imager. Install the library through the Arduino Library Manager tool by searching for "SparkFun VL53L5CX". Users who prefer to manually install it can get the library from the GitHub Repository or download the ZIP by clicking the button below:

Example1_DistanceArray

Hook up your ToF imager to your Artemis Thing Plus via the Qwiic cables, and click "File>Examples>SparkFun VL53L5CX Arduino Library>Example1_DistanceArray".

We'll assume that you have selected the board (in this case the SparkFun Artemis Thing Plus) and the correct COM port at this point. If you have the code open, hit the upload button. Otherwise, copy and paste the following into the Arduino IDE, make sure to select the correct board and COM port, and then upload:

language:c
/*
  Read an 8x8 array of distances from the VL53L5CX
  By: Nathan Seidle
  SparkFun Electronics
  Date: October 26, 2021
  License: MIT. See license file for more information but you can
  basically do whatever you want with this code.

  This example shows how to read all 64 distance readings at once.

  Feel like supporting our work? Buy a board from SparkFun!
  https://www.sparkfun.com/products/18642

*/

#include <Wire.h>

#include <SparkFun_VL53L5CX_Library.h> //http://librarymanager/All#SparkFun_VL53L5CX

SparkFun_VL53L5CX myImager;
VL53L5CX_ResultsData measurementData; // Result data class structure, 1356 byes of RAM

int imageResolution = 0; //Used to pretty print output
int imageWidth = 0; //Used to pretty print output

void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("SparkFun VL53L5CX Imager Example");

  Wire.begin(); //This resets to 100kHz I2C

  Serial.println("Initializing sensor board. This can take up to 10s. Please wait.");
  if (myImager.begin() == false)
  {
    Serial.println(F("Sensor not found - check your wiring. Freezing"));
    while (1) ;
  }

  myImager.setResolution(8*8); //Enable all 64 pads

  imageResolution = myImager.getResolution(); //Query sensor for current resolution - either 4x4 or 8x8
  imageWidth = sqrt(imageResolution); //Calculate printing width

  myImager.startRanging();
}

void loop()
{
  //Poll sensor for new data
  if (myImager.isDataReady() == true)
  {
    if (myImager.getRangingData(&measurementData)) //Read distance data into array
    {
      //The ST library returns the data transposed from zone mapping shown in datasheet
      //Pretty-print data with increasing y, decreasing x to reflect reality
      for (int y = 0 ; y <= imageWidth * (imageWidth - 1) ; y += imageWidth)
      {
        for (int x = imageWidth - 1 ; x >= 0 ; x--)
        {
          Serial.print("\t");
          Serial.print(measurementData.distance_mm[x + y]);
        }
        Serial.println();
      }
      Serial.println();
    }
  }

  delay(5); //Small delay between polling
}

Open up your Serial Monitor, make sure the baud rate is set appropriately, and you should see something like the following:

Example2_FastStartup

Hook up your ToF imager to your Artemis Thing Plus via the Qwiic cables, and click "File>Examples>SparkFun VL53L5CX Arduino Library>Example2_FastStartup".

We'll assume that you have selected the board (in this case the SparkFun Artemis Thing Plus) and the correct COM port at this point. If you have the code open, hit the upload button. Otherwise, copy and paste the following into the Arduino IDE, make sure to select the correct board and COM port, and then upload:

language:c
/*
  Read an 8x8 array of distances from the VL53L5CX
  By: Nathan Seidle
  SparkFun Electronics
  Date: October 26, 2021
  License: MIT. See license file for more information but you can
  basically do whatever you want with this code.

  This example shows how to setup the I2C bus to minimize the amount
  of time taken to init the sensor.

  At each power on reset, a staggering 86,000 bytes of firmware have to be sent to the sensor.
  At 100kHz, this can take ~9.4s. By increasing the clock speed, we can cut this time down to ~1.4s.

  Two parameters can be tweaked: 

    Clock speed: The VL53L5CX has a max bus speed of 400kHz but we have had success up to 1MHz.

    Max transfer size: The majority of Arduino platforms default to 32 bytes. If you are using one 
    with a larger buffer (ESP32 is 128 bytes for example), this can help decrease transfer times a bit.

  Measurements:
    Default 100kHz clock and 32 byte transfer: 9.4s
    400kHz, 32 byte transfer: 2.8s
    400kHz, 128 byte transfer: 2.5s
    1MHz, 32 byte transfer: 1.65s
    1MHz, 128 byte transfer: 1.4s

  Feel like supporting our work? Buy a board from SparkFun!
  https://www.sparkfun.com/products/18642

*/

#include <Wire.h>

#include <SparkFun_VL53L5CX_Library.h> //http://librarymanager/All#SparkFun_VL53L5CX

SparkFun_VL53L5CX myImager;
VL53L5CX_ResultsData measurementData; // Result data class structure, 1356 byes of RAM

int imageResolution = 0; //Used to pretty print output
int imageWidth = 0; //Used to pretty print output

void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("SparkFun VL53L5CX Imager Example");

  Wire.begin(); //This resets I2C bus to 100kHz
  Wire.setClock(400000); //Sensor has max I2C freq of 400kHz 
  //Wire.setClock(1000000); //Run sensor out of spec

  //myImager.setWireMaxPacketSize(128); //Increase default from 32 bytes to 128 - not supported on all platforms

  Serial.println("Initializing sensor board. This can take up to 10s. Please wait.");

  //Time how long it takes to transfer firmware to sensor
  long startTime = millis();
  bool startup = myImager.begin();
  long stopTime = millis();

  if (startup == false)
  {
    Serial.println(F("Sensor not found - check your wiring. Freezing"));
    while (1) ;
  }

  Serial.print("Firmware transfer time: ");
  float timeTaken = (stopTime - startTime) / 1000.0;
  Serial.print(timeTaken, 3);
  Serial.println("s");

  myImager.setResolution(8*8); //Enable all 64 pads

  imageResolution = myImager.getResolution(); //Query sensor for current resolution - either 4x4 or 8x8
  imageWidth = sqrt(imageResolution); //Calculate printing width

  myImager.startRanging();
}

void loop()
{
  //Poll sensor for new data
  if (myImager.isDataReady() == true)
  {
    if (myImager.getRangingData(&measurementData)) //Read distance data into array
    {
      //The ST library returns the data transposed from zone mapping shown in datasheet
      //Pretty-print data with increasing y, decreasing x to reflect reality
      for (int y = 0 ; y <= imageWidth * (imageWidth - 1) ; y += imageWidth)
      {
        for (int x = imageWidth - 1 ; x >= 0 ; x--)
        {
          Serial.print("\t");
          Serial.print(measurementData.distance_mm[x + y]);
        }
        Serial.println();
      }
      Serial.println();
    }
  }

  delay(5); //Small delay between polling
}

Open up your Serial Monitor, make sure the baud rate is set appropriately, and you should see something like the following:

Example3_SetFrequency

Hook up your ToF imager to your Artemis Thing Plus via the Qwiic cables, and click "File>Examples>SparkFun VL53L5CX Arduino Library>Example3_SetFrequency".

We'll assume that you have selected the board (in this case the SparkFun Artemis Thing Plus) and the correct COM port at this point. If you have the code open, hit the upload button. Otherwise, copy and paste the following into the Arduino IDE, make sure to select the correct board and COM port, and then upload:

language:c
/*
  Read an 8x8 array of distances from the VL53L5CX
  By: Nathan Seidle
  SparkFun Electronics
  Date: October 26, 2021
  License: MIT. See license file for more information but you can
  basically do whatever you want with this code.

  This example shows how to increase output frequency.

  Default is 1Hz.
  Using 4x4, min frequency is 1Hz and max is 60Hz
  Using 8x8, min frequency is 1Hz and max is 15Hz

  Feel like supporting our work? Buy a board from SparkFun!
  https://www.sparkfun.com/products/18642

*/

#include <Wire.h>

#include <SparkFun_VL53L5CX_Library.h> //http://librarymanager/All#SparkFun_VL53L5CX

SparkFun_VL53L5CX myImager;
VL53L5CX_ResultsData measurementData; // Result data class structure, 1356 byes of RAM

int imageResolution = 0; //Used to pretty print output
int imageWidth = 0; //Used to pretty print output

void setup()
{
  Serial.begin(115200);
  delay(1000);
  Serial.println("SparkFun VL53L5CX Imager Example");

  Wire.begin(); //This resets I2C bus to 100kHz
  Wire.setClock(400000); //Sensor has max I2C freq of 400kHz

  Serial.println("Initializing sensor board. This can take up to 10s. Please wait.");
  if (myImager.begin() == false)
  {
    Serial.println(F("Sensor not found - check your wiring. Freezing"));
    while (1) ;
  }

  myImager.setResolution(8 * 8); //Enable all 64 pads

  imageResolution = myImager.getResolution(); //Query sensor for current resolution - either 4x4 or 8x8
  imageWidth = sqrt(imageResolution); //Calculate printing width

  //Using 4x4, min frequency is 1Hz and max is 60Hz
  //Using 8x8, min frequency is 1Hz and max is 15Hz
  bool response = myImager.setRangingFrequency(15);
  if (response == true)
  {
    int frequency = myImager.getRangingFrequency();
    if (frequency > 0)
    {
      Serial.print("Ranging frequency set to ");
      Serial.print(frequency);
      Serial.println(" Hz.");
    }
    else
      Serial.println(F("Error recovering ranging frequency."));
  }
  else
  {
    Serial.println(F("Cannot set ranging frequency requested. Freezing..."));
    while (1) ;
  }

  myImager.startRanging();
}

void loop()
{
  //Poll sensor for new data
  if (myImager.isDataReady() == true)
  {
    if (myImager.getRangingData(&measurementData)) //Read distance data into array
    {
      //The ST library returns the data transposed from zone mapping shown in datasheet
      //Pretty-print data with increasing y, decreasing x to reflect reality
      for (int y = 0 ; y <= imageWidth * (imageWidth - 1) ; y += imageWidth)
      {
        for (int x = imageWidth - 1 ; x >= 0 ; x--)
        {
          Serial.print("\t");
          Serial.print(measurementData.distance_mm[x + y]);
        }
        Serial.println();
      }
      Serial.println();
    }
  }

  delay(5); //Small delay between polling
}

Open up your Serial Monitor, make sure the baud rate is set appropriately, and you should see something like the following:

Troubleshooting

Resources and Going Further

Now that you've successfully got your Qwiic ToF sensor up and running, it's time to incorporate it into your own project!

For more information, check out the resources below:

• Schematic
• Eagle Files
• Datasheet
• Board Dimensions
• GitHub
• Library GitHub

Need some inspiration for your next project? Check out some of these related tutorials:

learn.sparkfun.com | CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

MicroMod Environmental Function Board Hookup Guide a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t2001

Introduction

The SparkFun MicroMod Environmental Function Board adds additional sensing options to the MicroMod Processor Boards. This function board includes three sensors to monitor air quality (SGP40), humidity & temperature (SHTC3), and CO₂ concentrations (STC31) in your indoor environment. To make it even easier to use, all communication is over the MicroMod's I²C bus! In this tutorial, we will go over how to connect the board and read the sensors.

added to your cart!

SparkFun MicroMod Environmental Function Board

In stock SEN-18632

The MicroMod Environmental Function Board includes three sensors to monitor air quality, humidity / temperature, & CO2 concen…

$149.95

FavoritedFavorite0

Wish List

Required Materials

To follow along with this tutorial, you will need the following materials at a minimum. You may not need everything though depending on what you have. Add it to your cart, read through the guide, and adjust the cart as necessary.

added to your cart!

Reversible USB A to C Cable - 2m

In stock CAB-15424

These 2m cables have minor modifications that allow them to be be plugged into their ports regardless of orientation on the U…

$7.95

FavoritedFavorite4

Wish List

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

FavoritedFavorite7

Wish List

added to your cart!

Pocket Screwdriver Set

In stock TOL-12891

What should every hacker have available to them? That's right, a screwdriver (you have to get into those cases somehow). What…

$3.95

5

FavoritedFavorite18

Wish List

added to your cart!

microSD Card - 1GB (Class 4)

In stock COM-15107

For the times when all you need is a basic SD card this is the card for you. 1GB capacity is plenty to store MP3s or log envi…

$4.95

FavoritedFavorite6

Wish List

added to your cart!

SparkFun MicroMod Main Board - Single

In stock DEV-18575

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

$14.95

FavoritedFavorite0

Wish List

added to your cart!

SparkFun MicroMod Environmental Function Board

In stock SEN-18632

The MicroMod Environmental Function Board includes three sensors to monitor air quality, humidity / temperature, & CO2 concen…

$149.95

FavoritedFavorite0

Wish List

MicroMod Main Board

To hold the processor and function boards, you will need one Main board. Depending on your application, you may choose to have either one or two function boards.

added to your cart!

SparkFun MicroMod Main Board - Single

In stock DEV-18575

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

$14.95

FavoritedFavorite0

Wish List

added to your cart!

SparkFun MicroMod Main Board - Double

In stock DEV-18576

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

$17.95

FavoritedFavorite0

Wish List

MicroMod Function Board

To add additional functionality to your Processor Board, you'll want to include one or two function boards when connecting them to the Main Board. Besides the MicroMod Environmental Function Board which this tutorial is focused on, you may descide to add the WiFi Function Board to the mix. Make sure to adjust the cart and include the MicroMod Main Board - Double as opposed to the Single when using two Function Boards. Check out the SparkFun catalog for other function boards.

added to your cart!

SparkFun MicroMod WiFi Function Board - ESP32

In stock WRL-18430

The SparkFun MicroMod ESP32 Function Board adds additional wireless options to MicroMod Processor Boards that do not have tha…

$14.95

FavoritedFavorite0

Wish List

added to your cart!

SparkFun MicroMod Environmental Function Board

In stock SEN-18632

The MicroMod Environmental Function Board includes three sensors to monitor air quality, humidity / temperature, & CO2 concen…

$149.95

FavoritedFavorite0

Wish List

Tools

You will need a screw driver to secure the Processor and Function boards.

added to your cart!

SparkFun Mini Screwdriver

In stock TOL-09146

This is just your basic reversible screwdriver - pocket sized! Both flat and phillips heads available. Comes with pin clip an…

$0.95

3

FavoritedFavorite7

Wish List

Suggested Reading

If you aren't familiar with the MicroMod ecosystem, we recommend reading here for an overview.

MicroMod Ecosystem

If you aren’t familiar with the following concepts, we also recommend checking out a few of these tutorials before continuing. Make sure to check the respective hookup guides for your processor board and function board to ensure that you are installing the correct USB-to-serial converter. You may also need to follow additional instructions that are not outlined in this tutorial to install the appropriate software.

Hardware Overview

This section goes over the important features on the MicroMod Environmental Function Board. Of course, we recommend checking out the Resources and Going Further for more information on each sensor.

Power

To power the board, you will need to apply power to a SparkFun Main Board. Power applied will connect to the Function Board's VIN pin, which will be regulated down for the rest of the board with the AP2112 3.3V/600mA voltage regulator.

SGP40

The board includes the Sensirion SGP40 sensor IC which measures air quality. The reserved I²C address for the SGP40 is 0x59. For easy reference, the default address for the SGP40 is labeled on the board.

SHTC3

The board includes the Sensirion SHTC3 sensor IC which measures humidity and temperature. The reserved I²C address for the SHTC3 is 0x70. For easy reference, the default address for the SHTC3 is labeled on the board.

STC31

The board includes the Sensirion STC31 sensor IC which measures CO₂ concentrations in N₂ and CO₂ in air. The reserved I²C address for the STC31 is 0x29. For easy reference, the default address for the STC31 is labeled on the board.

EEPROM

The board includes an I²C EEPROM. Unfortunately, this is not available for the user and was meant to hold board specific information.

LED

There is one LED to indicate when there is power available. You can disable the LED with the PWR jumper

Jumpers

The following jumpers are included to configure the board.

• PWR - By default, the jumper with the label PWR is closed. This jumper connects the 3.3V line and LED. Cutting this jumper will disable the LED.
• I²C Pull-up Resistors - By default, this three way jumper labeled I2C is closed and connects two pull-up resistors to the I²C data lines. If you have many devices on your I²C data lines, then you may consider cutting these two jumpers.
• STC31 Address Selection - There are three jumpers available on the board to adjust the STC31's address. By default, the jumpers are open. The alternative addresses for the sensor are 0x2A, 0x2B, and 0x2C. To select the address, you will need to close the jumper by adding a solder blob to one of the solder jumpers.

MicroMod Function Board Pinout

Depending on your window size, you may need to use the horizontal scroll bar at the bottom of the table to view the additional pin functions. Note that the M.2 connector pins on opposing sides are offset from each other as indicated by the bottom pins where it says (Not Connected)*. There is no connection to pins that have a "-" under the primary function.

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

Board Dimensions

The board uses the standard MicroMod Function Board size which measures about 1.50"x2.56".

Hardware Hookup

If you have not already, make sure to check out the Getting Started with MicroMod: Hardware Hookup for information on inserting your Processor and Function Boards to the Main Board.

After securing the Processor and Function Board to the Main Board, your setup should look like the image below. Connect a USB Type C Cable to begin programming your Processor Board. In this case, we used the MicroMod Main Board - Single, MicroMod Artemis Processor, and MicroMod Environmental Function Board.

Software Installation

Arduino Board Definitions

We'll assume that you installed the necessary board files and drivers for your Processor Board. In this case, we used the MicroMod Artemis Processor Board which uses the CH340 USB-to-serial converter. If you are using a Processor Board, make sure to check out its hookup guide for your Processor Board.

Arduino Library

The SparkFun SGP40, SHTC3, and STC3X Arduino libraries can be downloaded with the Arduino library manager by searching 'SparkFun SGP40,' 'SHTC3,' and 'STC3X'. Or you can grab the zip here from each respective GitHub repository (SGP40, SHTC3, STC3X) to manually install:

Arduino Example

Example 1: Reading SHTC3, STC31, and SGP40

Below is the combined example to read SHTC3, STC31, and SGP40.

language:c
/******************************************************************************

  WRITTEN BY: Ho Yun "Bobby" Chan
  @ SparkFun Electronics
  DATE: 10/19/2021
  GITHUB REPO: https://github.com/sparkfun/MicroMod_Environmental_Sensor_Function_Board
  DEVELOPMENT ENVIRONMENT SPECIFICS:
    Firmware developed using Arduino IDE v1.8.12

  ========== DESCRIPTION==========
  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!

  Note: You may need to wait about ~5 minutes after starting up the code before VOC index
  has any values.

  ========== HARDWARE CONNECTIONS ==========
  MicroMod Artemis Processor Board => MicroMod Main Board => MicroMod Environmental Function Board (with SHTC3, STC31, and SGP40)

  Feel like supporting open source hardware?
  Buy a board from SparkFun!
       MicroMod MicroMod Artemis Processor   | https://www.sparkfun.com/products/16401
       MicroMod Main Board - Single          | 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

  LICENSE: This code is released under the MIT License (http://opensource.org/licenses/MIT)

******************************************************************************/



#include <Wire.h>

#include "SparkFun_SHTC3.h" //Click here to get the library: http://librarymanager/All#SparkFun_SHTC3
SHTC3 mySHTC3; // Create an object of the SHTC3 class

#include "SparkFun_STC3x_Arduino_Library.h" //Click here to get the library: http://librarymanager/All#SparkFun_STC3x
STC3x mySTC3x; // Create an object of the mySTC3x class

#include "SparkFun_SGP40_Arduino_Library.h" // Click here to get the library: http://librarymanager/All#SparkFun_SGP40
SGP40 mySGP40; //Create an object of the SGP40 class

float RH = 0.00; // Variable to keep track of SHTC3 temperature compensation for the STC31
float temperature = 0.00; // Variable to keep track of SHTC3 relative humidity compensation for the STC31






void setup() {

  Serial.begin(115200);
  //while (!Serial) ; // Wait for Serial Monitor/Plotter to open for Processors with Native USB (i.e. SAMD51)
  Serial.println(F("Initializing Combined Example w/ SGP40, SHTC3, and STC31."));
  Wire.begin();

  //mySTC3x.enableDebugging(); // Uncomment this line to get helpful debug messages on Serial
  //mySGP40.enableDebugging(); // Uncomment this line to print useful debug messages to Serial



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

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

  if (mySGP40.begin() == false)
  {
    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) == false)
  {
    Serial.println(F("Could not set the binary gas! Freezing..."));
    while (1)
      ; // Do nothing more
  }



  //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
  }

  //In case the ‘Set temperature command’ has been used prior to the measurement command,
  //the temperature value given out by the STC31 will be that one of the ‘Set temperature command’.
  //When the ‘Set temperature command’ has not been used, the internal temperature value can be read out.
  temperature = mySHTC3.toDegC(); // "toDegC" returns the temperature as a floating point number in deg C
  Serial.print(F("Setting STC3x temperature to "));
  Serial.print(temperature, 2);
  Serial.print(F("C was "));
  if (mySTC3x.setTemperature(temperature) == false)
    Serial.print(F("not "));
  Serial.println(F("successful"));

  RH = mySHTC3.toPercent(); // "toPercent" returns the percent humidity as a floating point number
  Serial.print(F("Setting STC3x RH to "));
  Serial.print(RH, 2);
  Serial.print(F("% was "));
  if (mySTC3x.setRelativeHumidity(RH) == false)
    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."));

} //end setup()






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("RH = "));
  Serial.print(RH);

  Serial.print(F("%, T = "));
  Serial.print(mySHTC3.toDegF());                           // "toDegF" return the temperature as a flaoting point number in deg F
  Serial.print(F(" deg F, "));

  temperature = mySHTC3.toDegC();                           // "toDegC" returns the temperature as a floating point number in deg C
  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) == false)
    Serial.print(F("Unable to set STC31 Relative Humidity with SHTC3."));

  if (mySTC3x.setTemperature(temperature) == false)
    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
  {
    Serial.println(mySTC3x.getCO2(), 2);
  }
  else
  {
    Serial.print(mySTC3x.getCO2(), 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 Index is: "));
  Serial.println(mySGP40.getVOCindex()); //Get the VOC Index using the default RH (50%) and T (25C)



  //================================
  //=========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

}//end loop()





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;
  }
}

Example 2: Reading SHTC3, STC31, and SGP40 in CSV

Below is the same combined code but formatted for CSV.

language:c
/******************************************************************************

  WRITTEN BY: Ho Yun "Bobby" Chan
  @ SparkFun Electronics
  DATE: 10/19/2021
  GITHUB REPO: https://github.com/sparkfun/MicroMod_Environmental_Sensor_Function_Board
  DEVELOPMENT ENVIRONMENT SPECIFICS:
    Firmware developed using Arduino IDE v1.8.12

  ========== DESCRIPTION==========
  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/Plotter at 115200 baud to view the readings!

  Note: You may need to wait about ~5 minutes after starting up the code before VOC index
  has any values.

  ========== HARDWARE CONNECTIONS ==========
  MicroMod Artemis Processor Board => MicroMod Main Board => MicroMod Environmental Function Board (with SHTC3, STC31, and SGP40)

  Feel like supporting open source hardware?
  Buy a board from SparkFun!
       MicroMod MicroMod Artemis Processor   | https://www.sparkfun.com/products/16401
       MicroMod Main Board - Single          | https://www.sparkfun.com/products/18575
       MicroMod Environmental Function Board | https://www.sparkfun.com/products/18632

  You can also get the sensors individually.
       SHTC3 | https://www.sparkfun.com/products/16467
       STC31 | https://www.sparkfun.com/products/18385
       SGP40 | https://www.sparkfun.com/products/17729

  LICENSE: This code is released under the MIT License (http://opensource.org/licenses/MIT)

******************************************************************************/



#include <Wire.h>

#include "SparkFun_SHTC3.h" //Click here to get the library: http://librarymanager/All#SparkFun_SHTC3
SHTC3 mySHTC3; // Create an object of the SHTC3 class

#include "SparkFun_STC3x_Arduino_Library.h" //Click here to get the library: http://librarymanager/All#SparkFun_STC3x
STC3x mySTC3x; // Create an object of the STC3x class

#include "SparkFun_SGP40_Arduino_Library.h" // Click here to get the library: http://librarymanager/All#SparkFun_SGP40
SGP40 mySGP40; //Create an object of the SGP40 class

float RH = 0.00; // Variable to keep track of SHTC3 temperature compensation for the STC31
float temperature = 0.00; // Variable to keep track of SHTC3 relative humidity compensation for the STC31

//Debug mode, comment one of these lines out using a syntax
//for a single line comment ("//"):
#define DEBUG 0     //0 = Output for Serial Plotter, CSV
//#define DEBUG 1     //1 = Output for Serial Monitor





void setup() {

  Serial.begin(115200);
  //while (!Serial) ; // Wait for Serial Monitor/Plotter to open for Processors with Native USB (i.e. SAMD51)


#if DEBUG
  Serial.println(F("Initializing Combined Example w/ SGP40, SHTC3, and STC31."));
#else
  Serial.println(F("RH,degF,degC,SHTC3_Valid,RH_Compensate_Valid,degC_Compensate_Valid,CO2%,STC31_Valid,VOC_Index"));
#endif

  Wire.begin();

  //mySTC3x.enableDebugging(); // Uncomment this line to get helpful debug messages on Serial
  //mySGP40.enableDebugging(); // Uncomment this line to print useful debug messages to Serial



  if (mySHTC3.begin() != SHTC3_Status_Nominal)
  {
#if DEBUG
    Serial.println(F("SHTC3 not detected. Please check wiring. Freezing..."));
#endif
    while (1)
      ; // Do nothing more
  }

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

  if (mySGP40.begin() == false)
  {
#if DEBUG
    Serial.println(F("SGP40 not detected. Check connections. Freezing..."));
#endif
    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) == false)
  {
#if DEBUG
    Serial.println(F("Could not set the binary gas! Freezing..."));
#endif
    while (1)
      ; // Do nothing more
  }



  //We can compensate for temperature and relative humidity using the readings from the SHTC3

  if (mySHTC3.update() != SHTC3_Status_Nominal) // Request a measurement
  {
#if DEBUG
    Serial.println(F("Could not read the RH and T from the SHTC3! Freezing..."));
#endif
    while (1)
      ; // Do nothing more
  }

  //In case the ‘Set temperature command’ has been used prior to the measurement command,
  //the temperature value given out by the STC31 will be that one of the ‘Set temperature command’.
  //When the ‘Set temperature command’ has not been used, the internal temperature value can be read out.
  temperature = mySHTC3.toDegC(); // "toDegC" returns the temperature as a floating point number in deg C
#if DEBUG
  Serial.print(F("Setting STC3x temperature to "));
  Serial.print(temperature, 2);
  Serial.print(",");
  Serial.print(F("C was "));
#endif

  if (mySTC3x.setTemperature(temperature) == false) {
#if DEBUG
    Serial.print(F("not "));
#endif
  }
#if DEBUG
  Serial.println(F("successful"));
#endif

  RH = mySHTC3.toPercent(); // "toPercent" returns the percent humidity as a floating point number

#if DEBUG
  Serial.print(F("Setting STC3x RH to "));
  Serial.print(RH, 2);
  Serial.print(",");
  Serial.print(F("% was "));
#endif

  if (mySTC3x.setRelativeHumidity(RH) == false) {
#if DEBUG
    Serial.print(F("not "));
#endif
  }
#if DEBUG
  Serial.println(F("successful"));
#endif



  //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;

#if DEBUG
  Serial.print(F("Setting STC3x pressure to "));
  Serial.print(pressure);
  Serial.print(F("mbar was "));
#endif

  if (mySTC3x.setPressure(pressure) == false) {
#if DEBUG
    Serial.print(F("not "));
#endif
  }
#if DEBUG
  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."));
#endif

} //end setup()





void loop() {


  //==============================
  //======DEBUG TURNED ON=========
  //==============================
#if DEBUG
  //==============================
  //==========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("RH = "));
  Serial.print(RH);

  Serial.print(F("%, T = "));
  Serial.print(mySHTC3.toDegF());                           // "toDegF" return the temperature as a flaoting point number in deg F
  Serial.print(F(" deg F, "));

  temperature = mySHTC3.toDegC();                           // "toDegC" returns the temperature as a floating point number in deg C
  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) == false)
    Serial.print(F("Unable to set STC31 Relative Humidity with SHTC3."));

  if (mySTC3x.setTemperature(temperature) == false)
    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
  {
    Serial.println(mySTC3x.getCO2(), 2);
  }
  else
  {
    Serial.print(mySTC3x.getCO2(), 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 Index is: "));
  Serial.println(mySGP40.getVOCindex()); //Get the VOC Index using the default RH (50%) and T (25C)





  //==============================
  //=====DEBUG TURNED OFF=========
  //==============================
#else
  //==============================
  //==========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();
  Serial.print(RH);
  Serial.print(",");
  Serial.print(mySHTC3.toDegF());
  Serial.print(",");
  temperature = mySHTC3.toDegC();                           // "toDegC" returns the temperature as a floating point number in deg C
  Serial.print(temperature);
  Serial.print(",");

  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.print("1");                                         //Sample data good, no need to output a message
    Serial.print(",");
  }
  else
  {
    Serial.print("0");                                         //Sample data bad, no need to output a message
    Serial.print(",");
  }



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


  if (mySTC3x.setRelativeHumidity(RH) == false)
  {
    //Serial.print(F("Unable to set STC31 Relative Humidity with SHTC3."));
    Serial.print("0");
    Serial.print(",");
  }
  else
  {
    Serial.print("1");
    Serial.print(",");
  }

  if (mySTC3x.setTemperature(temperature) == false)
  {
    //Serial.println(F("Unable to set STC31 Temperature with SHTC3."));
    Serial.print("0");
    Serial.print(",");
  }
  else
  {
    Serial.print("1");
    Serial.print(",");
  }

  if (mySTC3x.measureGasConcentration())                   // measureGasConcentration will return true when fresh data is available
  {
    Serial.print(mySTC3x.getCO2(), 2);
    Serial.print(",");
    Serial.print("1");                                     //Fresh Data
    Serial.print(",");
  }
  else
  {
    Serial.print(mySTC3x.getCO2(), 2);
    Serial.print(",");
    Serial.print("0");                                     //Data not fresh
    Serial.print(",");
  }



  //==============================
  //==========READ SGP40==========
  //==============================
  //minimum update rate = 1Hz

  Serial.println(mySGP40.getVOCindex()); //Get the VOC Index using the default RH (50%) and T (25C)

#endif



  //================================
  //=========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 algorithm expects a sample rate of 1Hz

}//end loop()





void errorDecoder(SHTC3_Status_TypeDef message)                             // The errorDecoder function prints "SHTC3_Status_TypeDef" resultsin 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;
  }
}

Troubleshooting

Resources and Going Further

Now that you've successfully got your MicroMod Environmental Function Board up and running, it's time to incorporate it into your own project! For more information, check out the resources below:

• Schematic (PDF)
• Eagle Files (ZIP)
• Board Dimensions (PNG)
• SGP40
  • SGP40 Datasheet (PDF)
  • VOC Index for Experts (PDF)
  • SGP40 Design In Guide (PDF)
  • SGP40 Quick Testing Guide (PDF)
• SHTC3
  • SHTC3 Datasheet (PDF)
• STC31
  • STC31 Datasheet (PDF)
  • STC Field Calibration Guide (PDF)
  • STC Design-In Guide (PDF)
• Arduino Libraries
  • SGP40
  • SHTC3
  • STC3X
• GitHub Hardware Repo
• SFE Product Showcase

Need some inspiration for your next project? Check out some of these related tutorials with MicroMod:

learn.sparkfun.com | CC BY-SA 3.0 | SparkFun Electronics | Niwot, Colorado

1W LoRa MicroMod Function Board a learn.sparkfun.com tutorial

Available online at: http://sfe.io/t1996

Introduction

The 1W LoRa MicroMod Function Board adds LoRa capabilities to your MicroMod project. It is intended to be used in conjunction with a MicroMod processor board and a MicroMod main board, which provides the electrical interface between a processor board and the function board(s).

added to your cart!

SparkFun MicroMod LoRa Function Board

In stock WRL-18573

The SparkFun MicroMod LoRa Function Board provides LoRA and LoRaWAN capabilities to your MicroMod project.

$39.95

FavoritedFavorite0

Wish List

Match up the board's M.2 edge connector to the slot of the M.2 connector and secure the function board with the screws provided with the main board.

Utilizing the 915M30S LoRa module from EBYTE, which is a 1W (30dBm) transceiver based around the SX1276 from Semtech. There is a robust edge mount RP-SMA connector for large LoRa (915MHz) antennas; with modification, a U.FL connector is also available. We've successfully tested a 12 miles line-of-sight transmission with this module (user results may vary).

With the MicroMod standardization, users no longer need to cross-reference schematics with datasheets, while fumbling around with jumper wires. Simply, match up the function board's M.2 edge connector to the slot of the M.2 connector on the main board and secure the function board with screws. All connections are hardwired to compatible pins of the processor board and the pin connections are standardized for the processor boards.

Required Materials

To get started, users will need a few of the items listed below. (You may already have a some of these items; read through the guide and modify your cart accordingly.)

MicroMod Processor Board

A processor board is required for the MicroMod system to operate. Users can choose a processor board, based upon their needs, to attach to the MicroMod M.2 connector of the main board. Below, are few options:

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

FavoritedFavorite7

Wish List

added to your cart!

SparkFun MicroMod ESP32 Processor

Out of stock WRL-16781

This board combines Espressif's ESP32 with our M.2 connector interface to bring a power-packed processor board into our Micro…

$16.95

FavoritedFavorite4

Wish List

added to your cart!

SparkFun MicroMod nRF52840 Processor

In stock WRL-16984

The SparkFun MicroMod nRF52840 Processor offers a powerful combination of ARM Cortex-M4 CPU and 2.4 GHz Bluetooth transceiver…

$19.95

FavoritedFavorite5

Wish List

added to your cart!

SparkFun MicroMod STM32 Processor

24 available DEV-17713

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

$14.95

FavoritedFavorite2

Wish List

MicroMod Main Board

A main board provides the electrical connections between the function and processor boards to operate. Users can choose a main board based upon their needs. Below, are few options:

added to your cart!

SparkFun MicroMod Main Board - Single

In stock DEV-18575

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

$14.95

FavoritedFavorite0

Wish List

added to your cart!

SparkFun MicroMod Main Board - Double

In stock DEV-18576

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

$17.95

FavoritedFavorite0

Wish List

Required Hardware

A Phillips screw driver is necessary to attach the processor board and function board(s) to the main board. Additionally, a USB-C cable is needed to connect the main board to a computer. The LoRa function board also requires a LoRa antenna for the transceiver to operate.

added to your cart!

USB 3.1 Cable A to C - 3 Foot

In stock CAB-14743

USB C is fantastic. But until we have converted all our hubs, chargers, and ports over to USB C this is the cable you're goin…

$4.95

3

FavoritedFavorite7

Wish List

added to your cart!

SparkFun Mini Screwdriver

In stock TOL-09146

This is just your basic reversible screwdriver - pocket sized! Both flat and phillips heads available. Comes with pin clip an…

$0.95

3

FavoritedFavorite7

Wish List

Below, is a selection of our 915MHz frequency band RP-SMA antennas.

added to your cart!

Pycom LoRa and Sigfox Antenna Kit - 915MHz

Out of stock WRL-14676

This universal Antenna Kit can also be used with LoPy, SiPy, LoPy4, and FiPy IoT development boards to talk over LoRa and Sig…

$11.95

FavoritedFavorite6

Wish List

added to your cart!

915MHz LoRa Antenna RP-SMA - 1/2 Wave 2dBi

In stock WRL-14876

Increase your range with this 1/2 wave duck antenna. Designed for 860 to 960MHz it is ideal for distant LoRa nodes. Utilizes …

$7.95

FavoritedFavorite1

Wish List

added to your cart!

915MHz LoRa Antenna RP-SMA - 1/4 Wave 2dBi

In stock WRL-14875

A small 1/4 wave rubber duck antenna for LoRa or other 860-960MHz communication. Antenna has a center frequency of 915MHz and…

$8.95

FavoritedFavorite2

Wish List

Optional Hardware

A LoRa gateway provides internet connection for LoRaWAN network. Below are a few options from our LoRa product category.

Nebra Outdoor HNT Hotspot Miner (915MHz)

Out of stock WRL-17844

Join The People's Network and help provide hundreds of square miles of wireless network coverage on Helium LongFi™ (LoRaWAN…

10

FavoritedFavorite44

Wish List

LoRa Raspberry Pi 4 Gateway with Enclosure

Out of stock WRL-16447

This LoRa Gateway has 8 channels, 15km line of sight range, & comes assembled with everything necessary for easy deployment i…

3

FavoritedFavorite7

Wish List

Nebra Indoor HNT Hotspot Miner (915MHz)

Pre-Order WRL-17843

Join The People's Network and help provide hundreds of square miles of wireless network coverage on Helium LongFi™ (LoRaWAN…

13

FavoritedFavorite71

Wish List

Users can also use other LoRa boards for peer-to-peer communication. Below are a few options from our LoRa product category.

added to your cart!

SparkFun Pro RF - LoRa, 915MHz (SAMD21)

In stock WRL-15836

The SparkFun Pro RF is a LoRa®-enabled wireless board that marries a SAMD21 and a long-range RFM95W to make a compact and ea…

$31.50

FavoritedFavorite10

Wish List

added to your cart!

SparkFun LoRa Thing Plus - expLoRaBLE

In stock WRL-17506

The SparkFun expLoRaBLE Thing Plus is a Feather form-factor development board with the NM180100 system in package (SiP), from…

$49.95

1

FavoritedFavorite15

Wish List

added to your cart!

Interface Cable RP-SMA to U.FL

In stock WRL-00662

Commonly used to attach WiFi, Bluetooth, or nRFxxx based devices to a 2.4GHz antenna.

$4.95

1

FavoritedFavorite13

Wish List

added to your cart!

915MHz LoRa Antenna RP-SMA - 1/4 Wave 2dBi

In stock WRL-14875

A small 1/4 wave rubber duck antenna for LoRa or other 860-960MHz communication. Antenna has a center frequency of 915MHz and…

$8.95

FavoritedFavorite2

Wish List

To modify the jumpers, users will need soldering equipment and/or a knife.

added to your cart!

Solder Lead Free - 100-gram Spool

In stock TOL-09325

This is your basic spool of lead free solder with a water soluble resin core. 0.031" gauge and 100 grams. This is a good spoo…

$8.95

7

FavoritedFavorite33

Wish List

added to your cart!

Chip Quik No-Clean Flux Pen - 10mL

In stock TOL-14579

This 10mL no-clean flux pen from Chip Quik is great for all of your solder, de-solder, rework, and reflow purposes!

$7.95

4

FavoritedFavorite30

Wish List

added to your cart!

Weller WLC100 Soldering Station

32 available TOL-14228

The WLC100 from Weller is a versatile 5 watt to 40 watt soldering station that is perfect for hobbyists, DIYers and students.…

$67.95

2

FavoritedFavorite16

Wish List

added to your cart!

Hobby Knife

In stock TOL-09200

It's like an Xacto knife, only better. We use these extensively when working with PCBs. These small knives work well for cutt…

$2.95

2

FavoritedFavorite17

Wish List

Suggested Reading

The MicroMod ecosystem is a unique way to allow users to customize their project to their needs. Click on the banner below for more information.

For users who aren't familiar with the following concepts, we also recommend reading the following tutorials before continuing.

Hardware Overview

Board Dimensions

The overall board dimensions are roughly 65 x 35 mm with an approximate 6 mm protrusion of the RP-SMA antenna connector.

M.2 Edge Connector and Screw Slots

Like other function and processor boards, there is a polarized M.2 edge connector, which provides a standardized electrical connection. The attachment points for the screws prevent users from connecting a processor board into a function board slot and vice-versa.

Power

There is a power status LED to help make sure that your LoRa function board is getting (5V) power. Power is provided through the (MicroMod) M.2 edge connector. The LoRa module is meant to run on 5V with 3.3V logic levels. A jumper is available on the back of the board to remove power to the LED for low-power applications (see the Jumpers section below).

E19-915M30S LoRa Module

The Chengdu Ebyte E19-915M30S RF transceiver module is a 1W 915MHz LoRa module, based on the SX1276 from Semtech. It is FCC, CE, and RoHS certified and has been tested up to a range of 10km by the manufacturer. PLease refer to the datasheet for more details.

Pin Connections

Below is a table of the pin connections available on the E19-915M30S RF transceiver module. However, not all the pins listed are utilized by the LoRa function board (see the Function Board Pinout Table section below).

MicroMod Edge Connector

The MicroMod M.2 edge connector provides a standardized interface for the pin connection of a function board.

Function Board Pinout Table

The tables below outline the pin on the M2. edge connector and their functions.

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