Calibrating Your Odometry Sensor a learn.sparkfun.com tutorial

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

Introduction

The SparkFun Qwiic Optical Tracking Odometry Sensor empowers you to elevate your robot's navigation capabilities with exceptional precision and streamlined integration. This compact, all-in-one sensor leverages the power of the PAA5160E1 chip from PixArt Imaging Inc., delivering accurate dual-axis motion data across various hard floor surfaces. But that's not all! This sensor boasts a powerful built-in 6-axis Inertial Measurement Unit (IMU) and an onboard microcontroller that performs real-time sensor fusion and tracking algorithms.

added to your cart!

SparkFun Optical Tracking Odometry Sensor - PAA5160E1 (Qwiic)

In stock SEN-24904

The SparkFun Qwiic Optical Tracking Odometry Sensor empowers you to elevate a robot's navigation capabilities with precision …

$79.95

5

Favorited Favorite 56

Wish List

In this tutorial, we will be going over how to calibrate your Qwiic Optical Tracking Odometry Sensor (or "OTOS") with Arduino and Python Examples. While we recommend using the OTOS with our XRP robotics platform (specifically for FTC teams), following this guide, you will be able to use the Odometry Sensor with any robot you feel comfortable with!

If you are looking for the full Hookup Guide for the SparkFun Qwiic Optical Tracking Odometry Sensor, click the button bellow. This guide only covers sensor calibration to get you started, while the full Hookup Guide goes over every detail of the sensor.

Hardware Needed

To follow along with this tutorial, you may need the following materials. You may not need everything though depending on what you have and what robotics platform you are using. Again, while we recommend the XRP Kit, the choice is ultimately yours. Add it to your cart, read through the guide, and adjust the cart as necessary.

added to your cart!

SparkFun Optical Tracking Odometry Sensor - PAA5160E1 (Qwiic)

In stock SEN-24904

The SparkFun Qwiic Optical Tracking Odometry Sensor empowers you to elevate a robot's navigation capabilities with precision …

$79.95

5

Favorited Favorite 56

Wish List

added to your cart!

Experiential Robotics Platform (XRP) Kit - Beta

In stock KIT-22230

The XRP Robotics Platform is a hands-on, comprehensive robotics platform and includes everything needed to build and program …

$114.95

Favorited Favorite 65

Wish List

added to your cart!

SparkFun RedBoard Qwiic

In stock DEV-15123

The SparkFun RedBoard Qwiic is an Arduino-compatible development board with a built in Qwiic connector, eliminating the need …

$21.50

20

Favorited Favorite 63

Wish List

added to your cart!

Flexible Qwiic to STEMMA Cable - 500mm

In stock CAB-25596

The Qwiic to STEMMA Adapter Cable allows interoperability between the SparkFun Qwiic Connect System and the I2C based STEMMA …

$2.10

Favorited Favorite 3

Wish List

added to your cart!

Qwiic Cable - 100mm

In stock PRT-14427

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

$1.50

Favorited Favorite 43

Wish List

added to your cart!

USB Micro-B Cable - 6 Foot

In stock CAB-10215

USB 2.0 type A to Micro-B 5-pin. This is a new, smaller connector for USB devices. Micro-B connectors are about half the heig…

$5.50

15

Favorited Favorite 23

Wish List

Software Setup

Arduino

We've written a library to get you started with the SparkFun Optical Tracking Odometry Sensor. You can obtain this library through the Arduino Library Manager by searching for "SparkFun Qwiic OTOS Arduino Library" and installing the latest version from SparkFun. If you prefer downloading libraries manually, you can grab them from the GitHub Repository.

Python

In addition to the library provided above, we have written a Python script that allows you to visualize an XRP in real time. Download via the button below.

Linux/Raspberry Pi Variants

We've written a python package to get you started with the SparkFun Optical Tracking Odometry Sensor. It's been included in the SparkFun Qwiic Python package, which aggregates all Python Qwiic drivers/modules to provide a single entity for Qwiic within a Python environment. The Qwiic_Py GitHub Library ReadMe has more information on the Qwiic Python package.

If you already have your Qwiic Python package installed, you can update it with the following command:

pip install --upgrade sparkfun-qwiic

If you don't have the Qwiic Python package installed already, you can install it with the following command:

pip install sparkfun-qwiic

If you prefer to install just this package, use the following command:

pip install sparkfun-qwiic-otos

If you prefer downloading the code to build and install the package manually, you can grab them from the GitHub Repository.

XRP/MicroControllers

If you are working with the XRP or other microcontroller, pip will not work for you. Instead, you'll need to install the Qwiic_I2C_Py driver as well as the Qwiic_OTOS driver.

Install Qwiic_OTOS_Py

Qwiic_I2C_Py is a generic I2C driver we have created to work on various platforms (such as MicroPython). Our Qwiic Python device drivers take advantage of Qwiic_I2C_Py to function correctly on any of the supported platforms, so it is a required dependency to use our OTOS Python driver.

Fist, go to the Qwiic_I2C_Py repository and download it as a .zip file. Once downloaded, extract the qwiic_i2c folder within.

Connect your XRP to your computer over USB, navigate to the XRPCode IDE, and connect to your XRP. For usage information, see the XRPCode User Guide.

Create a new folder within the lib directory (right-click on the folder), and name it qwiic_i2c.

Upload the files from the previously extracted qwiic_i2c folder into the new folder you just created on the XRP. From the File menu, choose the Upload to XRP option:

Then select the extracted files:

Then choose the newly created qwiic_i2c folder on the XRP:

Uploading...

You can test to confirm correct installation by typing import qwiic_i2c followed by qwiic_i2c.get_i2c_driver().scan() in the Shell. If no errors are printed, then the Qwiic_I2C_Py driver has been installed correctly!

Install Qwiic_OTOS_Py

Fist, go to the Qwiic_OTOS_Py repository and download just the qwiic_otos.py file.

Connect your XRP to your computer over USB, navigate to the XRPCode editor, and connect to your XRP. For usage information, see the XRPCode User Guide.

Upload the qwiic_otos.py file into the lib folder on the XRP. From the File menu, choose the Upload to XRP option:

Select the qwiic_otos.py file:

Then select the lib folder on the XRP:

Updating...

You can test to confirm correct installation by typing import qwiic_otos followed by qwiic_otos.QwiicOTOS().is_connected() in the Shell. If no errors are printed, then the Qwiic_OTOS_Py driver has been installed correctly!

Testing the install:

Visualization

In addition to the package provided here, we have written a Python script that allows you to visualize the XRP in real time. Download via the button below.

Arduino Examples & Calibration

Example 1: Basic Readings

This first example just does some basic measurements to make sure everything is hooked up correctly. To find Example 1, go to File > Examples > SparkFun Qwiic OTOS > Example1_BasicReadings:

Alternatively, you can expand the link below and copy and paste the code into a shiny new Arduino sketch:

/*
    SPDX-License-Identifier: MIT

    Copyright (c) 2024 SparkFun Electronics
*/

/*******************************************************************************
    Example 1 - Basic Readings

    This example demonstrates how to read the position and heading from the
    SparkFun Qwiic Optical Tracking Odometry Sensor (OTOS).

    This example should be used to verify that the OTOS is connected and
    functioning correctly. It will just print the position and heading tracked
    by the OTOS to the serial monitor. It is recommended that you check out the
    other examples before using the OTOS in your own project.
*******************************************************************************/

#include "SparkFun_Qwiic_OTOS_Arduino_Library.h"
#include "Wire.h"

// Create an Optical Tracking Odometry Sensor object
QwiicOTOS myOtos;

void setup()
{
    // Start serial
    Serial.begin(115200);
    Serial.println("Qwiic OTOS Example 1 - Basic Readings");

    Wire.begin();

    // Attempt to begin the sensor
    while (myOtos.begin() == false)
    {
        Serial.println("OTOS not connected, check your wiring and I2C address!");
        delay(1000);
    }

    Serial.println("OTOS connected!");

    Serial.println("Ensure the OTOS is flat and stationary, then enter any key to calibrate the IMU");

    // Clear the serial buffer
    while (Serial.available())
        Serial.read();
    // Wait for user input
    while (!Serial.available())
        ;

    Serial.println("Calibrating IMU...");

    // Calibrate the IMU, which removes the accelerometer and gyroscope offsets
    myOtos.calibrateImu();

    // Reset the tracking algorithm - this resets the position to the origin,
    // but can also be used to recover from some rare tracking errors
    myOtos.resetTracking();
}

void loop()
{
    // Get the latest position, which includes the x and y coordinates, plus the
    // heading angle
    sfe_otos_pose2d_t myPosition;
    myOtos.getPosition(myPosition);

    // Print measurement
    Serial.println();
    Serial.println("Position:");
    Serial.print("X (Inches): ");
    Serial.println(myPosition.x);
    Serial.print("Y (Inches): ");
    Serial.println(myPosition.y);
    Serial.print("Heading (Degrees): ");
    Serial.println(myPosition.h);

    // Wait a bit so we don't spam the serial port
    delay(500);

    // Alternatively, you can comment out the print and delay code above, and
    // instead use the following code to rapidly refresh the data
    // Serial.print(myPosition.x);
    // Serial.print("\t");
    // Serial.print(myPosition.y);
    // Serial.print("\t");
    // Serial.println(myPosition.h);
    // delay(10);
}

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, go ahead and open a Serial Monitor. You should see something similar to the following.

Example 2: SetUnits

This example sets the desired units for linear and angular measurements. Can be either meters or inches for linear, and radians or degrees for angular. If not set, the default is inches and degrees. Note that this setting is not stored in the sensor, it's part of the library, so you need to set at the start of all your programs.

To find Example 2, go to File > Examples > SparkFun Qwiic OTOS > Example2_SetUnits:

Alternatively, you can expand the link below and copy and paste the code into a shiny new Arduino sketch:

/*
    SPDX-License-Identifier: MIT

    Copyright (c) 2024 SparkFun Electronics
*/

/*******************************************************************************
    Example 2 - Set Units

    This example demonstrates how to change the units of the SparkFun Qwiic
    Optical Tracking Odometry Sensor (OTOS).

    The OTOS library defaults to inches and degrees, but you can change the
    units to suit the needs of your project.
*******************************************************************************/

#include "SparkFun_Qwiic_OTOS_Arduino_Library.h"
#include "Wire.h"

// Create an Optical Tracking Odometry Sensor object
QwiicOTOS myOtos;

void setup()
{
    // Start serial
    Serial.begin(115200);
    Serial.println("Qwiic OTOS Example 2 - Set Units");

    Wire.begin();

    // Attempt to begin the sensor
    while (myOtos.begin() == false)
    {
        Serial.println("OTOS not connected, check your wiring and I2C address!");
        delay(1000);
    }

    Serial.println("OTOS connected!");

    Serial.println("Ensure the OTOS is flat and stationary, then enter any key to calibrate the IMU");

    // Clear the serial buffer
    while (Serial.available())
        Serial.read();
    // Wait for user input
    while (!Serial.available())
        ;

    Serial.println("Calibrating IMU...");

    // Calibrate the IMU, which removes the accelerometer and gyroscope offsets
    myOtos.calibrateImu();

    // Set the desired units for linear and angular measurements. Can be either
    // meters or inches for linear, and radians or degrees for angular. If not
    // set, the default is inches and degrees. Note that this setting is not
    // stored in the sensor, it's part of the library, so you need to set at the
    // start of all your programs.
    myOtos.setLinearUnit(kSfeOtosLinearUnitMeters);
    // myOtos.setLinearUnit(kSfeOtosLinearUnitInches);
    myOtos.setAngularUnit(kSfeOtosAngularUnitRadians);
    // myOtos.setAngularUnit(kSfeOtosAngularUnitDegrees);

    // Reset the tracking algorithm - this resets the position to the origin,
    // but can also be used to recover from some rare tracking errors
    myOtos.resetTracking();
}

void loop()
{
    // Get the latest position, which includes the x and y coordinates, plus the
    // heading angle
    sfe_otos_pose2d_t myPosition;
    myOtos.getPosition(myPosition);

    // Print measurement
    Serial.println();
    Serial.println("Position:");
    Serial.print("X (Meters): ");
    Serial.println(myPosition.x, 4);
    Serial.print("Y (Meters): ");
    Serial.println(myPosition.y, 4);
    Serial.print("Heading (Radians): ");
    Serial.println(myPosition.h, 4);

    // Wait a bit so we don't spam the serial port
    delay(500);
}

Notice the following code snippet - this is the section of code that allows you to choose your units:

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, go ahead and open a Serial Monitor. You should see something similar to the following.

Example 3: Calibration

The data from the OTOS will likely have minor scaling errors that can be calibrated out. This is especially important for the angular scalar, because an incorrect angle measurement causes the linear measurements to be rotated by the wrong angle in the firmware, which can lead to very inaccurate tracking.

To find Example 3, go to File > Examples > SparkFun Qwiic OTOS > Example3_Calibration:

Alternatively, you can expand the link below and copy and paste the code into a shiny new Arduino sketch:

/*
    SPDX-License-Identifier: MIT

    Copyright (c) 2024 SparkFun Electronics
*/

/*******************************************************************************
    Example 3 - Calibration

    This example demonstrates how to calibrate the SparkFun Qwiic Optical
    Tracking Odometry Sensor (OTOS).

    This example should be used to calibrate the linear and angular scalars of
    the OTOS to get the most accurate tracking performance. The linear scalar
    can be used to compensate for scaling issues with the x and y measurements,
    while the angular scalar can be used to compensate for scaling issues with
    the heading measurement. Note that if the heading measurement is off, that
    can also cause the x and y measurements to be off, so it's recommended to
    calibrate the angular scalar first.
*******************************************************************************/

#include "SparkFun_Qwiic_OTOS_Arduino_Library.h"
#include "Wire.h"

// Create an Optical Tracking Odometry Sensor object
QwiicOTOS myOtos;

void setup()
{
    // Start serial
    Serial.begin(115200);
    Serial.println("Qwiic OTOS Example 3 - Calibration");

    Wire.begin();

    // Attempt to begin the sensor
    while (myOtos.begin() == false)
    {
        Serial.println("OTOS not connected, check your wiring and I2C address!");
        delay(1000);
    }

    Serial.println("OTOS connected!");

    Serial.println("Ensure the OTOS is flat and stationary, then enter any key to calibrate the IMU");

    // Clear the serial buffer
    while (Serial.available())
        Serial.read();
    // Wait for user input
    while (!Serial.available())
        ;

    Serial.println("Calibrating IMU...");

    // The IMU on the OTOS includes a gyroscope and accelerometer, which could
    // have an offset. Note that as of firmware version 1.0, the calibration
    // will be lost after a power cycle; the OTOS performs a quick calibration
    // when it powers up, but it is recommended to perform a more thorough
    // calibration at the start of all your programs. Note that the sensor must
    // be completely stationary and flat during calibration! When calling
    // calibrateImu(), you can specify the number of samples to take and whether
    // to wait until the calibration is complete. If no parameters are provided,
    // it will take 255 samples and wait until done; each sample takes about
    // 2.4ms, so about 612ms total
    myOtos.calibrateImu();

    // Alternatively, you can specify the number of samples and whether to wait
    // until it's done. If you don't want to wait, you can asynchronously check
    // how many samples remain with the code below. Once zero samples remain,
    // the calibration is done!
    // myOtos.calibrateImu(255, false);
    // bool done = false;
    // while(done == false)
    // {
    //     // Check how many samples remain
    //     uint8_t samplesRemaining;
    //     myOtos.getImuCalibrationProgress(samplesRemaining);

    //     // If 0 samples remain, the calibration is done
    //     if(samplesRemaining == 0)
    //         done = true;
    // }

    // Here we can set the linear and angular scalars, which can compensate for
    // scaling issues with the sensor measurements. Note that as of firmware
    // version 1.0, these values will be lost after a power cycle, so you will
    // need to set them each time you power up the sensor. They can be any value
    // from 0.872 to 1.127 in increments of 0.001 (0.1%). It is recommended to
    // first set both scalars to 1.0, then calibrate the angular scalar, then
    // the linear scalar. To calibrate the angular scalar, spin the robot by
    // multiple rotations (eg. 10) to get a precise error, then set the scalar
    // to the inverse of the error. Remember that the angle wraps from -180 to
    // 180 degrees, so for example, if after 10 rotations counterclockwise
    // (positive rotation), the sensor reports -15 degrees, the required scalar
    // would be 3600/3585 = 1.004. To calibrate the linear scalar, move the
    // robot a known distance and measure the error; do this multiple times at
    // multiple speeds to get an average, then set the linear scalar to the
    // inverse of the error. For example, if you move the robot 100 inches and
    // the sensor reports 103 inches, set the linear scalar to 100/103 = 0.971
    myOtos.setLinearScalar(1.0);
    myOtos.setAngularScalar(1.0);

    // Reset the tracking algorithm - this resets the position to the origin,
    // but can also be used to recover from some rare tracking errors
    myOtos.resetTracking();
}

void loop()
{
    // Get the latest position, which includes the x and y coordinates, plus the
    // heading angle
    sfe_otos_pose2d_t myPosition;
    myOtos.getPosition(myPosition);

    // Print measurement
    Serial.println();
    Serial.println("Position:");
    Serial.print("X (Inches): ");
    Serial.println(myPosition.x);
    Serial.print("Y (Inches): ");
    Serial.println(myPosition.y);
    Serial.print("Heading (Degrees): ");
    Serial.println(myPosition.h);

    // Wait a bit so we don't spam the serial port
    delay(500);

}

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, go ahead and open a Serial Monitor.

Calibrating your bot requires you to move it around a bit. First, set both scalars to 1.0, then calibrate the angular scalar, then the linear scalar.

To calibrate the angular scalar, spin the robot by multiple rotations (eg. 10) to get a precise error, then set the scalar to the inverse of the error. Remember that the angle wraps from -180 to 180 degrees, so for example, if after 10 rotations counterclockwise(positive rotation), the sensor reports -15 degrees, the required scalar would be 3600/3585 = 1.004.

To calibrate the linear scalar, move the robot a known distance and measure the error; do this multiple times at multiple speeds to get an average, then set the linear scalar to the inverse of the error. For example, if you move the robot 100 inches and the sensor reports 103 inches, set the linear scalar to 100/103 = 0.971.

Example 4: SetOffsetAndPosition

This example shows how to set the offset for the sensor relative to the center of the robot. The units default to inches and degrees, but if you want to use different units, make sure you specify them before setting the offset. Without setting the offset, the OTOS will report the coordinates of itself. If the offset is set, the OTOS will instead report the coordinates of the center of your robot.

Note that the OTOS typically starts tracking from the origin, but if your robot starts at some other location, or you have another source of location information from another sensor that's more accurate, you can send the current location to the OTOS and it will continue tracking from there.

To find Example 4, go to File > Examples > SparkFun Qwiic OTOS > Example4_SetOffsetAndPosition:

Alternatively, you can expand the link below and copy and paste the code into a shiny new Arduino sketch:

/*
    SPDX-License-Identifier: MIT

    Copyright (c) 2024 SparkFun Electronics
*/

/*******************************************************************************
    Example 4 - Set Offset and Position

    This example demonstrates how to set the offset and position of the SparkFun
    Qwiic Optical Tracking Odometry Sensor (OTOS).

    If your OTOS is mounted to a robot and is not centered, you can specify the
    offset for the sensor relative to the center of the robot; rather than
    returning the position of the sensor, the OTOS will calculate and return the
    position of the robot's center. If you know where your robot is located,
    such as the starting location or from another sensor, you can send that
    position to the OTOS and it will continue to track from there.
*******************************************************************************/

#include "SparkFun_Qwiic_OTOS_Arduino_Library.h"
#include "Wire.h"

// Create an Optical Tracking Odometry Sensor object
QwiicOTOS myOtos;

void setup()
{
    // Start serial
    Serial.begin(115200);
    Serial.println("Qwiic OTOS Example 4 - Set Offset and Position");

    Wire.begin();

    // Attempt to begin the sensor
    while (myOtos.begin() == false)
    {
        Serial.println("OTOS not connected, check your wiring and I2C address!");
        delay(1000);
    }

    Serial.println("OTOS connected!");

    Serial.println("Ensure the OTOS is flat and stationary, then enter any key to calibrate the IMU");

    // Clear the serial buffer
    while (Serial.available())
        Serial.read();
    // Wait for user input
    while (!Serial.available())
        ;

    Serial.println("Calibrating IMU...");

    // Calibrate the IMU, which removes the accelerometer and gyroscope offsets
    myOtos.calibrateImu();

    // Assuming you've mounted your sensor to a robot and it's not centered,
    // you can specify the offset for the sensor relative to the center of the
    // robot. The units default to inches and degrees, but if you want to use
    // different units, specify them before setting the offset! Note that as of
    // firmware version 1.0, these values will be lost after a power cycle, so
    // you will need to set them each time you power up the sensor. For example, if
    // the sensor is mounted 5 inches to the left (negative X) and 10 inches
    // forward (positive Y) of the center of the robot, and mounted 90 degrees
    // clockwise (negative rotation) from the robot's orientation, the offset
    // would be {-5, 10, -90}. These can be any value, even the angle can be
    // tweaked slightly to compensate for imperfect mounting (eg. 1.3 degrees).
    sfe_otos_pose2d_t offset = {-5, 10, -90};
    myOtos.setOffset(offset);

    // Reset the tracking algorithm - this resets the position to the origin,
    // but can also be used to recover from some rare tracking errors
    myOtos.resetTracking();

    // After resetting the tracking, the OTOS will report that the robot is at
    // the origin. If your robot does not start at the origin, or you have
    // another source of location information (eg. vision odometry), you can set
    // the OTOS location to match and it will continue to track from there.
    sfe_otos_pose2d_t currentPosition = {0, 0, 0};
    myOtos.setPosition(currentPosition);
}

void loop()
{
    // Get the latest position, which includes the x and y coordinates, plus the
    // heading angle
    sfe_otos_pose2d_t myPosition;
    myOtos.getPosition(myPosition);

    // Print measurement
    Serial.println();
    Serial.println("Position:");
    Serial.print("X (Inches): ");
    Serial.println(myPosition.x);
    Serial.print("Y (Inches): ");
    Serial.println(myPosition.y);
    Serial.print("Heading (Degrees): ");
    Serial.println(myPosition.h);

    // Wait a bit so we don't spam the serial port
    delay(500);

}

If the sensor is mounted 5 inches to the left (negative X) and 10 inches forward (positive Y) of the center of the robot, and mounted 90 degrees clockwise (negative rotation) from the robot's orientation, the offset would be {-5, 10, -90}. These can be any value, even the angle can be tweaked slightly to compensate for imperfect mounting (eg. 1.3 degrees).

These four examples cover the basics - there are more examples to explore in the library!

Python Examples & Calibration

Download Examples

First, go to the Qwiic_OTOS_Py repository, open the examples folder, and download the example files you want to run.

Connect your XRP to your computer over US...

Moving Beyond the Ordinary With the Qwiic Alphanumeric Display a learn.sparkfun.com tutorial

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

Introduction

Sometimes you need a display that can not only share information, but also catch the attention of those passing by. LCDs are great at getting a good amount of information on a small screen, but they’re not nearly as eye-catching as an LED. Our Qwiic Alphanumeric Displays combine the best of both worlds, offering the ability to share information, combined with the eye-catching pop of LEDs. In this tutorial, We’ll show you how fast and simple it is to start displaying information on the SparkFun Alphanumeric Display, starting with the most basic, then looking at some more advanced examples.

added to your cart!

SparkFun Qwiic Alphanumeric Display Kit

Only 6 left! KIT-19297

The SparkFun Qwiic Alphanumeric Display Kit comes with six different colored, 14-segment Qwiic displays. This is your all-in-…

$54.95

1

Favorited Favorite 8

Wish List

Required Hardware

For this tutorial, you’ll only need the following components:

A Qwiic Alphanumeric Display, in the color of your choosing:

For the more advanced examples using multiple displays, you can mix and match from the individual options above, or pick up one of our kits containing multiple Qwiic Alphanumeric Displays:

And of course, you'll need a microcontroller and some Qwiic Cables to hook it all up.

Setting Up Your Alphanumeric Display

Thanks to our Qwiic system, setup could not be easier. Just follow these simple steps:

Feeling creative? You can change the order of these steps, and your setup will still work perfectly!

Installing the Required Libraries

You can install the SparkFun Qwiic Alphanumeric Display Library in either of a couple of different ways.

In the Arduino IDE, open the Library Manager (either by opening the panel of the left side of the app, or from the dropdown menu going to Sketch/Include Library/Manage Libraries). From there, search “SparkFun Qwiic Alphanumeric”, and click the “Install” button.

Use the following link, download the .ZIP file, and either extract it and install it, or use the “Add .ZIP Library” option in the IDE.

The Basics

Let’s start at the very beginning, a very good place to start. Once you’ve installed the library, you’ll be able to access all of our example code. Navigate your way to File/Examples/SparkFun Qwiic Alphanumeric Display Arduino Library/Example_01_PrintString, open it and upload it to your microcontroller. If all goes as expected, your display should be showing the work “Milk” for all to see! (Why “Milk”? Eh, why not? It’s four characters in length, shows the use of both uppercase and lowercase letters, and, well, I suppose our engineer likes milk!)

/*****************************************************************************************
 * This example tests illuminating whole 4 letter strings on the 14-segment display.
 * 
 * Priyanka Makin @ SparkFun Electronics
 * Original Creation Date: February 3, 2020
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board from SparkFun! https://www.sparkfun.com/products/16391
 * 
 * This code is Lemonadeware; if you see me (or any other SparkFun employee) at the 
 * local, and you've found our code helpful, please buy us a round!
 * 
 * Hardware Connections:
 * Attach Red Board to computer using micro-B USB cable.
 * Attach Qwiic Alphanumeric board to Red Board using Qwiic cable.
 * 
 * Distributed as-is; no warranty is given.
 ****************************************************************************************/
#include 

#include  //Click here to get the library: http://librarymanager/All#SparkFun_Qwiic_Alphanumeric_Display by SparkFun
HT16K33 display;

void setup()
{
  Serial.begin(115200);
  Serial.println("SparkFun Qwiic Alphanumeric - Example 1: Print String");

  Wire.begin(); //Join I2C bus

  if (display.begin() == false)
  {
    Serial.println("Device did not acknowledge! Freezing.");
    while (1);
  }
  Serial.println("Display acknowledged.");

  display.print("Milk");
}

void loop()
{
}

If you feel like the bright lights of the Alphanumeric Display aren’t enough to capture the attention of passersby, there’s always the option of adding a little motion to your message. Our library has a built-in function, shiftLeft() (or shiftRight()), that slides your message across the displays. Run File/Examples/SparkFun Qwiic Alphanumeric Display Arduino Library/Example_09_ScrollingString to see it in action.

/**************************************************************************************
 * This example tests scrolling functionality of alphanumeric displays.
 * 
 * Priyanka Makin @ SparkFun Electronics
 * Original Creation Date: February 26, 2020
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board from SparkFun! https://www.sparkfun.com/products/16391
 * 
 * This code is Lemonadeware; if you see me (or any other SparkFun employee) at the
 * local, and you've found our code helpful, please buy us a round!
 * 
 * Hardware Connections:
 * Attach Red Board to computer using micro-B USB cable.
 * Attach Qwiic Alphanumeric board to Red Board using Qwiic cable. 
 *  Don't close any of the address jumpers so that it defaults to address 0x70.
 * Attach a second Alphanumeric display using Qwiic cable.
 *  Close address jumper A0 so that this display's address become 0x71.
 * 
 * Distributed as-is; no warranty is given.
 *****************************************************************************************/
#include 

#include   //Click here to get the library: http://librarymanager/All#SparkFun_Qwiic_Alphanumeric_Display by SparkFun
HT16K33 display;

void setup() {
  Serial.begin(115200);
  Serial.println("SparkFun Qwiic Alphanumeric - Example 9: Scrolling String");
  Wire.begin(); //Join I2C bus

  //check if displays will acknowledge
  if (display.begin(0x70) == false)
  {
    Serial.println("Device did not acknowledge! Freezing.");
    while(1);
  }
  Serial.println("Displays acknowledged.");

  display.print("MILK");
  delay(500);
}

void loop() 
{  
  delay(300);
  display.shiftLeft();
  //Alternatively - you could also shift the string to the right
  //display.shiftRight();
}

Going Beyond the Basics

Our shift function is a fast and super-simple way to scroll text, but the length of the text is limited to four characters. (More if you’re using multiple displays, but we’ll talk about that a little later on.) So, what can you do if you want to scroll a text string that’s longer than the number of display digits you have. We just need to get a little creative with our coding.

Example - Moving text the hard way Suppose I want to try the scrolling example, but I’m lactose intolerant. I want to scroll “soy milk”, but my display is only four characters. For this, we can use a little creative manual character shifting. Take a look at the code below, and you’ll see how the eight characters (I’m including the space between the two words) make their way past the four available spaces.

/*******************************************************************************************
 * This demo shows how to manually scroll a word or words longer than four characters
 * across a digit alphanumeric display.
 * 
 * Rob Reynolds @ SparkFun Electronics
 * Original Creation Date: October 16, 2024
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board from SparkFun! https://www.sparkfun.com/products/19297
 * 
 * This code is Beerware; if you see me (or any other SparkFun employee) at the 
 * local, and you've found our code helpful, please buy us a round!
 * 
 * Hardware Connections:
 * Attach Red Board to computer using micro-B USB cable.
 * Attach Qwiic Alphanumeric board to Red Board using Qwiic cable.
 * 
 * Distributed as-is; no warranty is given.
 *****************************************************************************************/
#include 

#include   //Click here to get the library: http://librarymanager/All#SparkFun_Qwiic_Alphanumeric_Display by SparkFun
HT16K33 display;

void setup()
{
  Serial.begin(115200);
  Serial.println("SparkFun Qwiic Alphanumeric - Example 2: Turn On One Segment");
  Wire.begin(); //Join I2C bus


if (display.begin() == false)
  {
    Serial.println("Device did not acknowledge! Freezing.");
    while(1);
  }

  Serial.println("Display acknowledged.");
  delay(2000);

}

void loop()
{
  // Scroll SOY MILK past the 4 available character displays
  display.clear();
  display.print("SOY ");
  delay(1000);
  display.clear();
  display.print("OY M");
  delay(300);
  display.clear();
  display.print("Y MI");
  delay(300);
  display.clear();
  display.print(" MIL");
  delay(300);
  display.clear();
  display.print("MILK");
  delay(300);
  display.clear();
  display.print("ILK");
  delay(300);
  display.clear();
  display.print("LK");
  delay(300);
  display.clear();
  display.print("K");
  delay(300);
  display.clear();
  delay(5000);

}

Earlier, I mentioned the possibility of using multiple displays. This takes a little bit of work on the front end, but after that, using four displays is just as easy as using one.

On the rear of the display board, you’ll find a pair of jumpers labeled A0 and A1. These jumpers will allow you to change the I2C address, giving you four options.

We’ve made linking and using multiple displays incredibly simple. There are just a couple of things you need to keep in mind. In your setup(), you will, as usual, check to make sure that your I2C peripheral (in this case your Alphanumeric Display) acknowledges, like this:

if (display.begin() == false)

When using multiple displays, you simply verify that all of them acknowledge, like this:

 if (display.begin(0x70, 0x71, 0x72, 0x73) == false)

The big thing the remember here is that when daisy-chaining your displays, they do not need to be connected in numeric order. However, the order in which you verify them in your code must match their physical order, Therefore, if you are using four displays, each of a different color, once you’ve given each its own unique I2C address, you can place the colors in any order you want. Just make sure that you match their I2C address order with the order in which you verify them in your code, something like this:

if (display.begin(0x73, 0x71, 0x70, 0x72) == false) // This is perfectly acceptable

Going beyond the Expected

Sometimes it’s fun to take something, completely ignore its intended use, and turn it on its head. Or at least, on its side. I found myself wondering if I could use these Alphanumeric Modules for Vertical display. Of course, if we had single character boards, it would be simple. But with four characters per board, stacking vertically becomes a bit more of a challenge. Luckily, as we learned in Example 02 Turn On One Segment, we can control each of the fourteen segments of each character individually. What that example doesn’t show is that we can turn on multiple segments at once, allowing us to create any number of shapes. In its simplest form, you can think of the segments that make up the letter “U”. If you turn the display on its end, those same segments will give you a low, wide, letter “C”.

The code below will give you an idea of what it takes to create vertical displays.

/*******************************************************************************************
 * This example tests illuminating individual segments to create a vertical display of sorts.
 * We will also use characters that, when turned on their side, can pass for vertical displays.
 * ex using a Z as an N
 *
 * Pass in the segment
 * and digit you wish to illuminate to illuminateSegement().
 * 
 *
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board from SparkFun! https://www.sparkfun.com/products/16391
 * 
 * This code is Beerware; if you see me (or any other SparkFun employee) at the 
 * local, and you've found our code helpful, please buy us a round!
 * 
 * Hardware Connections:
 * Attach Red Board to computer using micro-B USB cable.
 * Attach Qwiic Alphanumeric board to Red Board using Qwiic cable.
 * 
 * Distributed as-is; no warranty is given.
 *****************************************************************************************/
#include 

#include   //Click here to get the library: http://librarymanager/All#SparkFun_Qwiic_Alphanumeric_Display by SparkFun
HT16K33 display;

void setup()
{
  Serial.begin(115200);
  Serial.println("SparkFun Qwiic Alphanumeric - Example 2: Turn On One Segment");
  Wire.begin(); //Join I2C bus

  //check if display will acknowledge
  if (display.begin() == false)
  {
    Serial.println("Device did not acknowledge! Freezing.");
    while(1);
  }
  Serial.println("Display acknowledged.");
  display.clear();
  delay(1000);

}

void loop()
{
  //code();
  //delay(5000);
  //name();
  //delay(5000);
  neon();
  delay(5000);
  //zone();
  //delay(5000);
}


void code()
{
  display.clear();

  display.printChar('U', 0);  // Flip it sideways, it becomes a C

  display.printChar('O', 1);  // Sometimes an O is just an O

  // On the next six lines, we illuminate specific segments to create a very wide D
  display.illuminateSegment('A', 2);
  display.illuminateSegment('B', 2);
  display.illuminateSegment('C', 2);
  display.illuminateSegment('E', 2);
  display.illuminateSegment('F', 2);
  display.illuminateSegment('G', 2);
  display.illuminateSegment('I', 2);
  // Thus endeth the creation of the sideways D

  // On the next six lines, we illuminate specific segments to create a very wide E
  display.illuminateSegment('B', 3);
  display.illuminateSegment('C', 3);
  display.illuminateSegment('D', 3);
  display.illuminateSegment('E', 3);
  display.illuminateSegment('F', 3);
  display.illuminateSegment('J', 3);
  display.illuminateSegment('M', 3);
  // Thus endeth the creation of the sideways E


  display.updateDisplay();
  delay(100);
}

void name()
{
  display.clear();

  display.printChar('Z', 0);  // Flip it sideways, it becomes an N

  // On the next six lines, we illuminate specific segments to create a very wide A
  display.illuminateSegment('A', 1);
  display.illuminateSegment('D', 1);
  display.illuminateSegment('E', 1);
  display.illuminateSegment('F', 1);
  display.illuminateSegment('J', 1);
  display.illuminateSegment('M', 1);
  // Thus endeth the creation of the sideways A

  // We will now attempt to make a sideways M
  display.illuminateSegment('A', 2);
  display.illuminateSegment('D', 2);
  display.illuminateSegment('N', 2);
  display.illuminateSegment('H', 2);
  // Thus endeth the creation of the sideways M

  // On the next six lines, we illuminate specific segments to create a very wide E
  display.illuminateSegment('B', 3);
  display.illuminateSegment('C', 3);
  display.illuminateSegment('D', 3);
  display.illuminateSegment('E', 3);
  display.illuminateSegment('F', 3);
  display.illuminateSegment('J', 3);
  display.illuminateSegment('M', 3);
  // Thus endeth the creation of the sideways E

  display.updateDisplay();
  delay(100);
}

void neon()
{
  display.clear();

  display.printChar('Z', 0);  // Flip it sideways, it becomes an N

  // On the next six lines, we illuminate specific segments to create a very wide E
  display.illuminateSegment('B', 1);
  display.illuminateSegment('C', 1);
  display.illuminateSegment('D', 1);
  display.illuminateSegment('E', 1);
  display.illuminateSegment('F', 1);
  display.illuminateSegment('J', 1);
  display.illuminateSegment('M', 1);
  // Thus endeth the creation of the sideways E

  display.printChar('O', 2);  // Sometimes an O is just an O

  display.printChar('Z', 3);  // Flip it sideways, it becomes an N

  display.updateDisplay();
  delay(100);
}

void zone()
{
  display.clear();

  // We will now attempt to make a sideways Z
  display.illuminateSegment('E', 0);
  display.illuminateSegment('F', 0);
  display.illuminateSegment('H', 0);
  display.illuminateSegment('L', 0);
  display.illuminateSegment('C', 0);
  display.illuminateSegment('B', 0);
  // Thus endeth the creation of the sideways Z

  display.printChar('O', 1);  // Sometimes an O is just an O

  display.printChar('Z', 2);  // Flip it sideways, it becomes an N

  // On the next six lines, we illuminate specific segments to create a very wide E
  display.illuminateSegment('B', 3);
  display.illuminateSegment('C', 3);
  display.illuminateSegment('D', 3);
  display.illuminateSegment('E', 3);
  display.illuminateSegment('F', 3);
  display.illuminateSegment('J', 3);
  display.illuminateSegment('M', 3);
  // Thus endeth the creation of the sideways E

  display.updateDisplay();
  delay(100);

  delay(25000);

}

And if you want to get really crazy, you can combine vertical and horizontal! Combining the display.illuminateSegment() calls with the display.printChar() calls (and making sure you assign each to their proper character number) will put you high and above all others with their simple horizontal alphanumeric displays.

/**************************************************************************************
 * This example allows for both vertical and horizontal display of characters.
 * Keep in mind that they are not designed for vertical use, so some of the characters
 * are a little off. Hey, it's the best I could do!
 * 
 * Rob Reynolds @ SparkFun Electronics
 * Original Creation Date: November 11, 2024
 * 
 * SparkFun labored with love to create this code. Feel like supporting open source hardware?
 * Buy a board from SparkFun! https://www.sparkfun.com/products/19297
 * 
 * This code is Beerware; if you see me (or any other SparkFun employee) at the
 * local, and you've found our code helpful, please buy us a round!
 * 
 * Hardware Connections:
 * Attach Red Board to computer using micro-B USB cable.
 * Attach Qwiic Alphanumeric board to Red Board using Qwiic cable. 
 *  Don't close any of the address jumpers so that it defaults to address 0x70.
 * Attach a second Alphanumeric display using Qwiic cable.
 * Close address jumper A0 so that this display's address become 0x71.
 * Close the necessary jumpers (A0 and/or A1) to change the other displays I2C
 * addresses to 0x72 znd 0x73. See hoolup guide or tutorial for specifics.
 * 
 * Distributed as-is; no warranty is given.
 *****************************************************************************************/
#include 

#include   //Click here to get the library: http://librarymanager/All#SparkFun_Qwiic_Alphanumeric_Display by SparkFun
HT16K33 display;

void setup() {
  Serial.begin(115200);
  Serial.println("SparkFun Qwiic Alphanumeric - Example 8: Multi Display");
  Wire.begin(); //Join I2C bus

  //check if displays will acknowledge
  //The first address in the begin() function should be the left-most display, traveling to the right from there
  //This is how the string will print across displays, reading from left to right.
  if (display.begin(0x70, 0x71, 0x72, 0x73) == false)
  {
    Serial.println("Device did not acknowledge! Freezing.");
    while(1);
  }
  Serial.println("Displays acknowledged.");
  display.setBrightness(15);
  display.clear();

  //display.print("*BUY MOREDISPLAYS");
}

void loop() 
{
  //display.printChar('*', 0);  // An asterisk is an asterisk from any angle!

  // We can make an arrow pointing in any direction. I'll go with Down
  //display.illuminateSegment('G', 0);
  //display.illuminateSegment('H', 0);
  //display.illuminateSegment('N', 0);
  // Thus endeth the creationNof the sideways Down Arrow


  // We will now attempt to make a sideways B
  display.illuminateSegment('A', 0);
  display.illuminateSegment('B', 0);
  display.illuminateSegment('C', 0);
  display.illuminateSegment('E', 0);
  display.illuminateSegment('F', 0);
  display.illuminateSegment('G', 0);
  display.illuminateSegment('I', 0);
  display.illuminateSegment('J', 0);
  // Thus endeth the creation of the sideways B

  // Here is how we make a sideways U
  display.illuminateSegment('A', 1);
  display.illuminateSegment('B', 1);
  display.illuminateSegment('C', 1);
  display.illuminateSegment('D', 1);
  // Thus endeth the sideways U

  // This will hopefully look like a sideways Y
  display.illuminateSegment('H', 2);
  display.illuminateSegment('I', 2);
  display.illuminateSegment('N', 2);
  // Thus endeth the sideways Y

  // We will now attempt to make a sideways M
  display.illuminateSegment('A', 4);
  display.illuminateSegment('D', 4);
  display.illuminateSegment('N', 4);
  display.illuminateSegment('H', 4);
  // Thus endeth the creation of the sideways M

  display.printChar('O', 5);  // Sometimes an O is just an O

  // We will now attempt to make a sideways R
  display.illuminateSegment('D', 6);
  display.illuminateSegment('E', 6);
  display.illuminateSegment('F', 6);
  display.illuminateSegment('H', 6);
  display.illuminateSegment('K', 6);
  display.illuminateSegment('M', 6);
  // Thus endeth the creation of the sideways R

  // On the next six lines, we illuminate specific segments to create a very wide E
  display.illuminateSegment('B', 7);
  display.illuminateSegment('C', 7);
  display.illuminateSegment('D', 7);
  display.illuminateSegment('E', 7);
  display.illuminateSegment('F', 7);
  display.illuminateSegment('J', 7);
  display.illuminateSegment('M', 7);
  // Thus endeth the creation of the sideways E

  display.printChar('D', 8);
  display.printChar('I', 9);
  display.printChar('S', 10);
  display.printChar('P', 11);
  display.printChar('L', 12);
  display.printChar('A', 13);
  display.printChar('Y', 14);
  display.printChar('S', 15);

  display.updateDisplay();

  //display.print("*BUYMOREDISPLAYS");
  //delay(1000);
  //display.clear();
  //delay(250);
  //display.print("*BUYMORESPARKFUN");
  //delay(1000);
  //display.clear();
  delay(25000);

}

Final Thoughts

LEDs are a fast and easy way to add eye-catching pizazz to any project, and, let’s face it, they make everything better. LEDs that can display information quickly go from an ornament to a very useful tool, while maintaining the allure of LEDs. The design, size, and multiple color options of these displays allow for clear visibility from a distance, making for great readability. And now that you know how simple it is to display any number (or letter!) of things to your project in bold, bright characters, your project shelf should look like the Las Vegas Strip in no time!

Or maybe that’s just me…

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

IMU Data to Motion: Tutorial for Translating Sensor Data into Real-World Movement a learn.sparkfun.com tutorial

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

Introduction

Over the Years, we’ve carried quite a number of IMUs. And why not? Inertial Motion Units are used in an incredibly broad array of products, from robots to rockets, smart watches to structural components, electronic stabilization systems to exoskeletons. IMUs combine several sensors to provide data about movement and orientation in three-dimensional space, utilizing an accelerometer and gyroscope in the case of a 6DoF sensor (six degrees of freedom), or an accelerometer, gyroscope, and magnetometer in the case of a 9DoF (nine degrees of freedom).

The Challenge: Translating Measured Movement to Motion

Monitoring and measuring this incoming data is simple, especially with our Qwiic sensors and example sketches. But let’s face it, we want to do more with our incoming motion data than just read the results on a screen. So I decided to revisit an old project build that I quickly threw together for a new product demo. Since I’ll only be using the measurements from one of the three possible sensors on a 9D0F IMU, for this project I’m going to be using one of our newer, smaller magnetometer boards to control a pair of servos, and then toss out some ideas to upgrade to a much bigger, cooler project.

added to your cart!

SparkFun Micro Magnetometer - MMC5983MA (Qwiic)

In stock SEN-19921

The SparkFun Qwiic Micro MMC5983MA Magnetometer is a micro-sized 0.75in. by 0.30in. sensor that utilizes a highly sensitive t…

$15.95

4

Favorited Favorite 11

Wish List

added to your cart!

SparkFun 9DoF IMU Breakout - ISM330DHCX, MMC5983MA (Qwiic)

In stock SEN-19895

The SparkFun 9DoF IMU Breakout combines a high-performance 6DoF IMU with the highly sensitive triple-axis magnetometer in a Q…

$39.95

1

Favorited Favorite 19

Wish List

Components Required

You can opt for a number of different servos, or a number of different microcontrollers, but here are some suggestions for a fast and simple demo.

The magnetometer - SparkFun Micro Magnetometer - MMC5983MA (Qwiic)

A microcontroller - SparkFun Redboard Qwiic

2 Servos (anything from sub-micro to giant) - Generic sub-micro servo

Power Supply for Servos (optional). Power Supplies

SparkFun Qwiic Connectors - SparkFun Qwiic Cable Kit

The Project

I’ve always been a fan of flying, and eventually of flight simulators. So of course, I’ve always wanted to build a chair frame that would move in concert with the movements of my onscreen plane, whether it’s a Cessna 172 or a Airbus H225 helicopter. So in order to do this, I want to read the movement or position of our yolk or stick. Note: I know that when it actually comes to creating a chair frame that moves based on the movement of the flight stick, the movements will need to be measured from local axes, and a magnetometer, like I’m using in this example, bases its measurements on global axes. This is just a broad look at how to translate sensor data into motion, and can then be tailored to fit the needs of each project. Planes use cables to control the ailerons and elevator, and if you’re planning on building an experimental aircraft, I’m going to suggest not using this method., but if something goes wrong on a Flight Sim build, a catastrophic control failure would, at worst, toss toss onto the floor.

For testing the concept, I’m going to translate the sensor data to a pair of small servos. I 3D printed a small rig and a tiny chair for my little lego fly-boy. The initial concept worked just fine, I only needed to tweak the limits of the servo travel.

Hardware Setup

Connecting the MMC5983MA Sensor: Connect the MMC5983MA sensor to the Arduino using the SparkFun Qwiic Connectors. Plug the Qwiic connector on the MMC5983MA into one of the Qwiic ports on the Qwiic Shield or directly on a Qwiic-compatible Arduino board.

Connecting the Servos: Servo 1 Signal to Pin 8 on Arduino Servo 2 Signal to Pin 9 on Arduino Servo Power (VCC) to an external 5V power supply (opt) Servo Ground (GND) to Arduino GND

Arduino Sketch

/*
  Movement to Motion: Using the SparkFun Micro Magnetometer (MMC5983MA) to control servo motors
  By: Rob Reynolds
  SparkFun Electronics
  Date: September 19th, 2024
  Based on original code by Nathan Seidle and Ricardo Ramos
  License: SparkFun code, firmware, and software is released under the MIT License(http://opensource.org/licenses/MIT).

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

  This example demonstrates how to take raw X/Y/Z readings from the sensor over Qwiic
  and translate them to movement through servo motors on the X and Y axes

  Hardware Connections:
  Plug a Qwiic cable into the sensor and a RedBoard
  If you don't have a platform with a Qwiic connection use the SparkFun Qwiic Breadboard Jumper
  (https://www.sparkfun.com/products/17912) Open the serial monitor at 115200 baud to see the output
*/


#include 

#include  //Click here to get the library: http://librarymanager/All#SparkFun_MMC5983MA

SFE_MMC5983MA myMag;

// Here's where we set up the servos

#include 
Servo servoPitchX; //Create object on X access
Servo servoRollY; //Create object on Y access

// initiate variables for servo positions
int rollYVal;
int pitchXVal;


void setup()
{
    Serial.begin(115200);
    Serial.println("Movement to Motion Example with the MMC5983MA");

    Wire.begin();

    if (myMag.begin() == false)
    {
        Serial.println("MMC5983MA did not respond - check your wiring. Freezing.");
        while (true)
            ;
    }

    myMag.softReset();

    Serial.println("MMC5983MA connected");

    servoPitchX.attach(8);
    servoRollY.attach(9);
}


void loop()
{
    uint32_t currentX = 0;
    uint32_t currentY = 0;
    uint32_t currentZ = 0;

    // This reads the X, Y and Z channels consecutively
    // (Useful if you have one or more channels disabled)
    currentX = myMag.getMeasurementX();
    currentY = myMag.getMeasurementY();
    currentZ = myMag.getMeasurementZ();  // Z axis/Yaw not needed for this example

    // Or, we could read all three simultaneously
    //myMag.getMeasurementXYZ(¤tX, ¤tY, ¤tZ);

    Serial.print("X axis raw value: ");
    Serial.print(currentX/1000);
    rollYVal = map(currentX/1000, 123, 133, 15, 165);
    servoRollY.write(rollYVal);
    Serial.print("\tY axis raw value: ");
    Serial.print(currentY/1000);
    pitchXVal = map(currentY/1000, 131, 119, 35, 135);
    servoPitchX.write(pitchXVal);
    Serial.print("\tZ axis raw value: ");
    Serial.println(currentZ);  //Z values are not necessary here, unless you want to add yaw on the Z axis

    Serial.println();
    delay(50); // Don't overtax the I2C
}

Explanations

1. Libraries: Wire.h: For I2C communication. SparkFunLSM6DSV16X.h: To interface with the LSM6DSV16X sensor via Qwiic. Servo.h: To control the servos.

2. Setup Function: Initializes serial communication for debugging. Initializes the IMU sensor and checks if it's detected. Attaches servos to their respective pins and sets initial positions.

3. Loop Function: Reads magnetometer data (x, y, z). Maps x and y positional values to servo angles. Constrains angles to valid ranges (for this, 15-165 and 35-135 degrees). Updates servo positions based on mapped angles. Includes a small delay for stability.

Testing and Calibration:

Upload the Sketch: Connect your Arduino to your computer and upload the sketch using the Arduino IDE.

Power the Servos: Ensure the servos are powered correctly with an external power supply. (Small servos with light lode might be able to get away with using power from teh board.)

Observe Movement: Tilt or move the IMU sensor and watch how the servos react. The servos should adjust their positions based on the x and y acceleration data from the sensor.

Troubleshooting

Troubleshooting:

IMU Not Detected: Ensure the Qwiic connections are secure and that the sensor is properly connected to the I2C bus. Check if the Qwiic shield or board is functioning correctly.

Servo Movement Issues: Verify that the mapping and constraints are correct. Make sure the servo power supply is adequate. By following this tutorial, you should be able to easily interface the SparkFun Micro 6DoF IMU Breakout - LSM6DSV16X with your Arduino using Qwiic connectors and control servos based on the sensor’s motion data.

Going Further

There are a million ways to take IMU data and translate it into motion. Hopefully this gives you a look into how easy it is to get started, and inspires you to build on this simple tutorial to create your own moving masterpiece. Happy Hacking!!

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

How to Play Mulitple Buzzers at Once a learn.sparkfun.com tutorial

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

Polyphony in Action

Simple electronic sound devices, such as the SparkFun Qwiic Buzzer can output one note at a time. For a simple beep here or a buzz there, this works just fine. However, if your project needs a little more pizzaz than a single note then you’ll have to utilize multiple buzzers at once. This is what is called Polyphony. Polyphony is simply when two or more separate tones or melodies are sounded out simultaneously. As mentioned before, Qwiic Buzzers only make one sound at a time so in order to create a polyphonic melody you would need to utilize multiple Qwiic Buzzers. This involves setting each buzzer to a different I2C address and playing different notes simultaneously, creating more complex and rich soundscapes in your projects.

In this tutorial, we'll connect three Qwiic Buzzers to a RedBoard microcontroller and play a melody, harmony, and bass part of one of the most recognizable tunes of all time; the Super Mario Bros theme!

Hardware Needed

• Three SparkFun Qwiic Buzzers
• We’ll use the SparkFun RedBoard Plus in this example but any Arduino compatible board should work.
• 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…

$8.95

22

Favorited Favorite 91

Wish List

added to your cart!

SparkFun RedBoard Plus

Only 11 left! DEV-18158

The RedBoard Plus is an Arduino-compatible development board that has everything you need in an Arduino Uno with extra perks …

$21.50

6

Favorited Favorite 28

Wish List

added to your cart!

SparkFun Qwiic Buzzer

In stock BOB-24474

The SparkFun Qwiic Buzzer adds simple beeps and buzzes to your projects via I2C. Make some noises to alert you when something…

$6.95

Favorited Favorite 5

Wish List

Connecting the Hardware

Connections are breeze with Qwiic:

1. Connect three SparkFun Qwiic Buzzers to your microcontroller via the Qwiic connectors.
2. Ensuring each buzzer has a unique I2C address is key to playing the buzzers simultaneously:
• Default addresses are 0x34, 0x35, and 0x36 for the melody, harmony, and bass buzzers, respectively.
3. Setup Simple Circuit: Use Qwiic cables to daisy-chain the buzzers to the microcontroller.

If you've been to SparkFun HQ you'll recognize our giant Nintendo controller.

Software Setup

Before you begin you'll first need to Install the Arduino IDE and SparkFun Qwiic Buzzer Arduino Library.

Installing the Qwiic Buzzer Library

• Open the Arduino IDE.
• Go to Sketch > Include Library > Manage Libraries...
• Search for "SparkFun Qwiic Buzzer Arduino Library" and install it or install from the link below.

Running the Code

1. Upload the Code:
• Connect your microcontroller to your computer.
• Open the Arduino IDE.
• Copy and paste the provided code into the IDE.
• Select the correct board and port.
• Click Upload.
2. Observe the Buzzers:
• Once the code is uploaded, the buzzers will play the Super Mario Bros theme with melody, harmony, and bass parts.

/*
* SparkFun Qwiic Buzzer Polyphony Demo
* 
* This example shows off the Qwiic Buzzer's ability
* to comtrol multiple buzzers simultaneously by
* playing a 3-part arrangement of a little bit of
* the Super Mario Bros Theme.
* 
* By Rob Reynolds @ SparkFun Electronics
* February 2024
* 
* Hardware connections:
* Connect three (3) SparkFun Qwiic Buzzers to you
* microcontroller via the Qwiic connectors.
* 
* SparkFun code, firmware, and software is released under the MIT License.
* Please see LICENSE.md for further details.
* 
* This code is released under the Beerware License. If you find this code
* useful, and see me or any other Funion at the local, buy us a beer!
* 
* Distributed as-is, with no warranty * 
* 
*/


#include   // Import the library for the Qwiic Buzzer
QwiicBuzzer melodyBuzzer; //0x34 (default)
QwiicBuzzer harmonyBuzzer; //0x35 (previously changed)
QwiicBuzzer bassBuzzer; //0x36  (previously changed)

// notes in the melody:
int melody[] = {
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_E5, 
  SFE_QWIIC_BUZZER_NOTE_C5, 
  SFE_QWIIC_BUZZER_NOTE_E5, 
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_REST,  // silence (aka "rest") 
  SFE_QWIIC_BUZZER_NOTE_G4, 
  SFE_QWIIC_BUZZER_NOTE_REST,  // silence (aka "rest")
  // "A" section starts here***********************************
  SFE_QWIIC_BUZZER_NOTE_C5, 
  SFE_QWIIC_BUZZER_NOTE_REST,  // silence (aka "rest")
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_REST,  // silence (aka "rest")
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_REST,  // silence (aka "rest")
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_AS4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_G4, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_A5,
  SFE_QWIIC_BUZZER_NOTE_F5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  // "A" section repeat starts here ***********************
  SFE_QWIIC_BUZZER_NOTE_C5, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_AS4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_G4, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_A5,
  SFE_QWIIC_BUZZER_NOTE_F5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  //"B" Section starts here**************************
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 7
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_FS5,
  SFE_QWIIC_BUZZER_NOTE_F5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 8
  SFE_QWIIC_BUZZER_NOTE_GS4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 9
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_FS5,
  SFE_QWIIC_BUZZER_NOTE_F5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 10
  SFE_QWIIC_BUZZER_NOTE_C6,
  SFE_QWIIC_BUZZER_NOTE_C6,
  SFE_QWIIC_BUZZER_NOTE_C6,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 11
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_FS5,
  SFE_QWIIC_BUZZER_NOTE_F5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 12
  SFE_QWIIC_BUZZER_NOTE_GS4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 13
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C5,    //measure 14
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
};

// Notes in the harmony
int harmony[] = {
  SFE_QWIIC_BUZZER_NOTE_FS4,
  SFE_QWIIC_BUZZER_NOTE_FS4,
  SFE_QWIIC_BUZZER_NOTE_FS4, 
  SFE_QWIIC_BUZZER_NOTE_FS4, 
  SFE_QWIIC_BUZZER_NOTE_FS4, 
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,   
  SFE_QWIIC_BUZZER_NOTE_G3, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  // "A" section starts here*********************************
  SFE_QWIIC_BUZZER_NOTE_E4, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_CS4,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_C4, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  // "A" section repeat starts here*********************************
  SFE_QWIIC_BUZZER_NOTE_E4, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_CS4,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_C4, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_A4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  //"B" Section starts here**************************
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 7
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 8
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 9
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 10
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_G5,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 11
  SFE_QWIIC_BUZZER_NOTE_E5,
  SFE_QWIIC_BUZZER_NOTE_DS5,
  SFE_QWIIC_BUZZER_NOTE_D5,
  SFE_QWIIC_BUZZER_NOTE_B4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C5,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 12
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_G4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_REST,  //measure 13
  SFE_QWIIC_BUZZER_NOTE_GS4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_E4,    //measure 14
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
  SFE_QWIIC_BUZZER_NOTE_REST,
};

// notes in the bass:
int bass[] = {
  SFE_QWIIC_BUZZER_NOTE_D3,
  SFE_QWIIC_BUZZER_NOTE_D3,
  SFE_QWIIC_BUZZER_NOTE_D3, 
  SFE_QWIIC_BUZZER_NOTE_D3, 
  SFE_QWIIC_BUZZER_NOTE_D3, 
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_REST,   
  SFE_QWIIC_BUZZER_NOTE_G2, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  // "A" section starts here**********************************
  SFE_QWIIC_BUZZER_NOTE_G3, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_E3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_F3,
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_FS3,
  SFE_QWIIC_BUZZER_NOTE_F3,
  SFE_QWIIC_BUZZER_NOTE_E3, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_A3,
  SFE_QWIIC_BUZZER_NOTE_B3,
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_REST,
  // "A" section starts here**********************************
  SFE_QWIIC_BUZZER_NOTE_G3, 
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_E3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_C3,
  SFE_QWIIC_BUZZER_NOTE_REST,  
  SFE_QWIIC_BUZZER_NOTE_F3,
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_FS3,
  SFE_QWIIC_BUZZER_NOTE_F3,
  SFE_QWIIC_BUZZER_NOTE_E3, //TRIPLETS START
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_F4,
  SFE_QWIIC_BUZZER_NOTE_D4,
  SFE_QWIIC_BUZZER_NOTE_E4,
  SFE_QWIIC_BUZZER_NOTE_C4,
  SFE_QWIIC_BUZZER_NOTE_A3,
  SFE_QWIIC_BUZZER_NOTE_B3,
  SFE_QWIIC_BUZZER_NOTE_G3,
  SFE_QWIIC_BUZZER_NOTE_REST,
  // "B" section starts here ***************************************
  // Numbers indicate note durations, just for my reference when writing
  SFE_QWIIC_BUZZER_NOTE_C3,    //4  measure 7
  SFE_QWIIC_BUZZER_NOTE_REST,  //8 
  SFE_QWIIC_BUZZER_NOTE_G3,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_C4,    //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_F3,    //4  measure 8
  SFE_QWIIC_BUZZER_NOTE_REST,  //16
  SFE_QWIIC_BUZZER_NOTE_REST,  //16
  SFE_QWIIC_BUZZER_NOTE_C4,    //8
  SFE_QWIIC_BUZZER_NOTE_C4,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_F3,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_C3,    //4  measure 9
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_G3,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_G3,    //8
  SFE_QWIIC_BUZZER_NOTE_C4,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //2  measure 10
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_G3,    //4
  SFE_QWIIC_BUZZER_NOTE_C3,    //4  measure 11
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_G3,    //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_C4,    //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_F3,    //4  measure 12
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_C4,    //8
  SFE_QWIIC_BUZZER_NOTE_C4,    //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_F3,    //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //4
  SFE_QWIIC_BUZZER_NOTE_C3,    //4  measure 13
  SFE_QWIIC_BUZZER_NOTE_GS3,   //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_AS3,   //4
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_C4,    //4  measure 14
  SFE_QWIIC_BUZZER_NOTE_REST,  //8
  SFE_QWIIC_BUZZER_NOTE_G3,    //8
  SFE_QWIIC_BUZZER_NOTE_G3,    //4
  SFE_QWIIC_BUZZER_NOTE_C3,    //4
};


// note durations: 4 = quarter note, 8 = eighth note, etc.:
int marioNoteDurations[] = {
  8, 4, 4, 8, 4,    4, 4, 4, 4,
  4, 8, 4, 8, 4,    8, 4, 4, 8, 4,    6, 6, 6, 4, 8, 4,    4, 8, 8, 4, 8,
  4, 8, 4, 8, 4,    8, 4, 4, 8, 4,    6, 6, 6, 4, 8, 4,    4, 8, 8, 4, 8,  //start "B" section next line
  4, 8, 8, 8, 8, 8, 8,    8, 8, 8, 8, 8, 8, 8, 8,    4, 8, 8, 8, 8, 8, 8,    8, 4, 8, 4, 4,
  4, 8, 8, 8, 8, 8, 8,    8, 8, 8, 8, 8, 8, 8, 8,    4, 4, 8, 4, 8,     4, 8, 8, 4, 4
  // The extended spaces above aren't necessary, I use them to separate measures
  // simply to help me keep the music more clear. Very helpful for debugging!
};

void setup() {
  Serial.begin(115200);
  Serial.println("Qwiic Buzzer Super Mario Bros Sample");
  Wire.begin(); //Join I2C bus
  melodyBuzzer.begin(0x34);
  harmonyBuzzer.begin(0x35);
  bassBuzzer.begin(0x36);

/*  
  // These are good for testing, I commented them out when I moved the project to stand-alone

  //check if buzzer will connect over I2C
  if (buzzer1.begin() == false) {
    Serial.println("Buzzer 1 did not connect! Freezing.");
    while (1);
  }

  else if (buzzer2.begin() == false) {
    Serial.println("Buzzer 2 did not connect! Freezing.");
    while (1);
  }

  else if (buzzer3.begin() == false) {
    Serial.println("Buzzer 3 did not connect! Freezing.");
    while (1);
  }

*/
  Serial.println("Buzzers connected.");

  Serial.println("Buzzing Melody now...");
  play_melody();
}

void loop() {
  // do nothing here
  // we just play the melody once during setup above.
}

void play_melody()
{
    // iterate over the notes of the melody:
  for (int thisNote = 0; thisNote < 103; thisNote++) {  // 51 for A section only (repeated), 97 for entire demo for total melody/harmony notes, add 8 rests to bass

    // to calculate the note duration, take one second divided by the note type.
    //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
    int melodyNoteDuration = 1000 / marioNoteDurations[thisNote];  // change number to change tempo. <1000 = faster; >1000 = slower

    melodyBuzzer.configureBuzzer(melody[thisNote], melodyNoteDuration, SFE_QWIIC_BUZZER_VOLUME_MAX);
    melodyBuzzer.on();

    harmonyBuzzer.configureBuzzer(harmony[thisNote], melodyNoteDuration, SFE_QWIIC_BUZZER_VOLUME_MAX);
    harmonyBuzzer.on();

    bassBuzzer.configureBuzzer(bass[thisNote], melodyNoteDuration, SFE_QWIIC_BUZZER_VOLUME_MAX);
    bassBuzzer.on();



    // to distinguish the notes, set a minimum time between them.
    // the note's duration + 30% seems to work well:
    int pauseBetweenNotes = melodyNoteDuration * 1.30;
    delay(pauseBetweenNotes);
  }
}

Code Explanation

The code for this project can be a little intense as each individual sound that is made over 3 buzzers is a line of code. Our very own Rob Reynolds went through the painstaking process of working with figuring out each tone and octive needed for the Super Mario Brother's theme music. You can read all about his efforts here.

Key Points in the Code

1. Making sure the library is included: #include
2. Initialize Buzzers: Define three and assign each for melody, harmony, and bass.
3. Play Melody Function: Configure each buzzer to play its respective part in the song.

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

How To Take Multiple RFID Readings Simultaneously a learn.sparkfun.com tutorial

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

Introduction

In this tutorial, we'll show you how to set up the SparkFun Simultaneous RFID Reader to take multiple, if not nearly unlimited, RFID readings simultaneously by connecting either the M7E Hecto or M6E Nano directly to your computer using a USB-C connection and running Universal Reader Assistant (URA) software, which provides a simple and effective interface for configuring and managing your RFID reader. This is really useful for applications like measuring attendance at events, as well livestock management etc.

added to your cart!

SparkFun Simultaneous RFID Reader - M7E Hecto

In stock WRL-24738

The SparkFun M7E Hecto Simultaneous RFID Reader simplifies reading UHF RFID tags (EPCglobal Gen 2) with its powerful M7E-HECT…

$299.95

Favorited Favorite 15

Wish List

Required Hardware

To complete this project, you will need the following components:

• SparkFun Simultaneous RFID Reader - M7E Hecto or...

• SparkFun Simultaneous RFID Reader - M6E Nano (older version)

• Reversible USB A to C Cable - 0.3m

• A computer with a USB-C port (running Windows, which is required for URA software)

• RFID Tags - we offer a bunch of different types, check out the link to see what works best for your application

For this simple setup, you do not need a microcontroller. However, in many (maybe most) practical applications, it would make sense to connect the RFID Reader to a microcontroller and add an antenna so you could take readings remotely without your computer in front of you and extend the range (which goes up to 3 or 4 feet in this example). Users who prefer to communicate with the RFID reader using the Serial PTH header should solder either wires or header pins to connect them to a 3.3V microcontroller, such as our RedBoard Artemis. Check out our Hookup Guide for instructions on how to do this.

Setting Up Your Simultaneous RFID Reader

To connect the RFID reader directly to your computer via USB-C. Follow these steps:

• Connect the USB-C Cable: Plug the USB-C end of the cable into the RFID reader and the USB-A end into your computer. This connection will provide both power and data communication between the RFID reader and your computer.

• Check the UART Selection Switch: Ensure that the UART selection switch on the RFID reader is in the correct position for USB operation. This is crucial for proper communication with the software.

How to Download and Install Universal Reader Assistant (URA)

With the hardware set up, you can now move on to using the Universal Reader Assistant to interact with your RFID reader.

The Universal Reader Assistant (URA) software is a powerful tool designed to help you make full use of the capabilities of your SparkFun Simultaneous RFID Reader. Unfortunately, as mentioned, the URA is only available for Windows.

Setting Up the URA

• Download the URA: Visit the ThingMagic website to download the Universal Reader Assistant. Ensure you choose the correct version (32-bit or 64-bit) based on your Windows operating system.
• Install the URA: Once the download is complete, open the installer and follow the instructions provided by the installation wizard.

Using the Software

• Connect Your RFID Reader: Make sure your Simultaneous RFID Reader is connected to your computer via USB. Open the Universal Reader Assistant after the installation is complete.
• Connection Wizard: Upon opening URA, you will be greeted by the Connection Wizard menu. Here, you can select the reader type and the port your RFID reader is connected to. (If you're familiar with the setup, you can skip this selection and move directly to the main menu. Otherwise, select the correct port for your RFID reader and click "Next.")

• Connect to the Reader: The Connection Wizard should display your RFID reader's settings. You can click "Connect & Read" to start scanning tags immediately or "Connect" to access the main window without starting the read operation.

URA Features and Tips

Exploring URA Features

The main window of the Universal Reader Assistant offers a wide range of settings and status options for the M6E Nano or M7E Hecto RFID readers. Here are some key features you can explore.

Read/Write Options: Adjust the RFID reader's power level, read/write settings, and other operational parameters.

Final Thoughts

By following this tutorial, you’ve (hopefully) successfully set up your SparkFun Simultaneous RFID Reader to take multiple RFID readings directly through a USB connection using your computer. The Universal Reader Assistant software allows you to explore the full potential of your RFID reader, making it a powerful tool for various RFID applications. Happy hacking!

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

Detecting Colors with the SparkFun Tristimulus Color Sensor a learn.sparkfun.com tutorial

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

Introduction

In this tutorial, we'll show you how to use the SparkFun Tristimulus Color Sensor - OPT4048DTSR (Qwiic) to detect and classify colors based on their CIE XYZ color space values. The sensor is capable of measuring the color intensity in the X, Y, and Z channels, which correspond to red, green, and blue components in a simplified form.

added to your cart!

SparkFun Tristimulus Color Sensor - OPT4048DTSR (Qwiic)

34 available SEN-22638

The SparkFun Qwiic Tristimulus Color Sensor is built around the OPT4048 High Speed High Precision Tristimulus XYZ Color Senso…

$9.95

Favorited Favorite 6

Wish List

added to your cart!

SparkFun Mini Tristimulus Color Sensor - OPT4048DTSR (Qwiic)

In stock SEN-22639

The SparkFun Mini Tristimulus Color Sensor - OPT4048DTSR (Qwiic) is built around the OPT4048 High Speed High Precision Tristi…

$10.50

Favorited Favorite 2

Wish List

If you are looking for the full Hookup Guide for the SparkFun Tristimulus Color Sensor - OPT4048DTSR (Qwiic), click the button bellow. This guide only covers a simple project to get you started quickly, while the full Hookup Guide goes over every detail of the sensor.

Hardware Needed

To follow this experiment, you will need the following materials. While this is a simple project we wanted to make sure that you have everything you need to get started before we get to the code. For this simple project we chose the RedBoard Qwiic but you could choose from many of our development boards such as the Qwiic Pro Micro as well.

Software Setup

Installing the Required Libraries

• Install the SparkFun OPT4048 Library: Open the Arduino IDE and navigate to Sketch > Include Library > Manage Libraries. In the Library Manager, search for "OPT4048" and install the latest version from SparkFun.

Read Measurements with a Serial Monitor

Now that we've installed the Arduino library, it's time to upload our first sketch to make sure everything is working properly and you are able to read basic measurements with your Serial Monitor in the Arduino IDE.

For this example you will need the SparkFun Tristimulus Color Sensor - OPT4048DTSR (Qwiic), a SparkFun RedBoard Qwiic, a Qwiic Cable, and a USB Micro-B Cable.

Using the Qwiic system, assembling the hardware is simple. Connect the RedBoard to one of the SparkFun Tristimulus Color Sensor Qwiic ports using your Qwiic cables (please remember to insert this cable in the correct orientation). Then connect the RedBoard to your computer via the MicroUSB cable and voila! You're ready to rock!

Alternatively, you can copy and paste the code below into a shiny new Arduino sketch:

#include "SparkFun_OPT4048.h"  // Include the SparkFun OPT4048 library
#include   // Include the Wire library for I2C communication

SparkFun_OPT4048 colorSensor;  // Create an instance of the OPT4048 color sensor

void setup() {
 Serial.begin(115200);  // Initialize serial communication at 115200 baud
 Serial.println("OPT4048 Color Sensing Example");  // Print a message to the serial monitor

 Wire.begin();  // Initialize the I2C bus

 if (!colorSensor.begin()) {  // Try to initialize the color sensor
   Serial.println("OPT4048 not detected - check wiring or I2C address!"); 
   while (1);  // Enter an infinite loop to halt the program
 }

 colorSensor.setBasicSetup();  // Apply basic setup configuration to the sensor

 Serial.println("Sensor initialized and ready!");  // Print a success message
}

void loop() {
  float x = colorSensor.getCIEx();  // Get the CIE X value from the sensor
  float y = colorSensor.getCIEy();  // Get the CIE Y value from the sensor
  float z = 1 - x - y;  // Approximate the CIE Z value (this is a simplification)

  Serial.print("CIEx: ");  // Print label for CIE X value
  Serial.print(x, 4);  // Print CIE X value with 4 decimal places
  Serial.print(" CIEy: ");  // Print label for CIE Y value
  Serial.print(y, 4);  // Print CIE Y value with 4 decimal places
  Serial.print(" CIEz: ");  // Print label for CIE Z value
  Serial.print(z, 4);  // Print approximated CIE Z value with 4 decimal places

  String detectedColor = classifyColor(x, y, z);  // Classify the color based on CIE values
  Serial.print(" Detected color: ");  // Print label for detected color
  Serial.println(detectedColor);  // Print the classified color

  delay(600);  // Wait for 600ms before the next reading (3 channels * 200ms conversion time)
}

String classifyColor(float x, float y, float z) {
  float total = x + y + z;  // Calculate the sum of x, y, and z
  float r = x / total;  // Calculate the relative red component
  float g = y / total;  // Calculate the relative green component
  float b = z / total;  // Calculate the relative blue component

  // The following if statements check the RGB ratios to classify the color
  if (r > 0.4 && g < 0.3 && b < 0.3) return "Red";
  if (r < 0.3 && g > 0.4 && b < 0.3) return "Green";
  if (r < 0.3 && g < 0.3 && b > 0.4) return "Blue";
  if (r > 0.3 && g > 0.3 && b < 0.3) return "Yellow";
  if (r > 0.3 && g < 0.3 && b > 0.3) return "Purple";
  if (r < 0.3 && g > 0.3 && b > 0.3) return "Cyan";
  if (r > 0.3 && g > 0.3 && b > 0.3) return "White";
  if (r < 0.1 && g < 0.1 && b < 0.1) return "Black";

  return "Unknown";  // If no color matches, return "Unknown"
}

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, go ahead and open a Serial Monitor. Set the baud rate to 115200. You should see output like this:

Interpreting the Results

• CIEx, CIEy, CIEz: These are the values from the CIE 1931 color space which represent the color's chromaticity.
• Detected Color: Based on the values, the code attempts to classify the color into a basic category like "Red," "Green," "Blue," etc.

The CIEx and CIEy values are going to fall somewhere between 0 and 1. Page 35 of the datasheet gives more detail on this, but generally speaking, you can map the predominant color of the space you're measuring using the following:

For more information on the CIE and CIY values, refer to the CIE 1931 Color Space Wiki Page.

If you see unexpected values or the sensor isn’t detected, double-check your wiring and ensure the sensor is properly connected to the I2C bus.

Conclusion

You've successfully set up the SparkFun Tristimulus Color Sensor to classify colors based on CIE XYZ values. This tutorial provides a foundation for more advanced color detection projects. You can now expand on this knowledge to create sophisticated color analysis systems or integrate the sensor into larger, more complex projects.

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

GeoFence Treasure Hunt With Artemis Global Tracker a learn.sparkfun.com tutorial

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

The Story

The Artemis Global Tracker is a highly functional sensor device with professional grade pressure, humidity, and temperature sensing with the onboard TE MS8607 PHT sensor, and location data through the onboard u-blox ZOE-M8Q GNSS receiver. It can also be programmed with the Arduino IDE through the Artemis processor and transfer information through the Iridium Satellite Network due to the Iridium 9603N Short Burst Data modem. The goal of this project is to demonstrate the ease of working with this device, and the accuracy and potential of its onboard sensors, specifically the GNSS receiver.

This project will use the Artemis Global Tracker (AGT) to create a “Treasure Game” in which the player begins the game, the AGT will randomly select a position in a 20 meter radius (designated the “treasure spot”), and the onboard LED will blink faster as the player moves toward the “treasure spot” - winning when they find it exactly. In this way, the onboard LED will lead the player to the “treasure spot”. This game will also transfer location information to a computer using the Iridium Satellite Network, meaning it could be played even where no WIFI or wireless data is accessible.

The Components

NOTE: To connect to the Iridium Satellite Network requires a monthly fee of $17 and a purchase of credits, however, you can pick and choose the periods to access the network.

The Setup

The first step in the development setup is the software setup. If you have not programmed with the Arduino IDE before, SparkFun made a great introductory guide to setup with the Artemis module which can be found here. It notes the need to add the Artemis module within the Arduino IDE boards manager using the following link:

https://raw.githubusercontent.com/sparkfun/Arduino_Apollo3/main/package_sparkfun_apollo3_index.json

You will also need to add the following libraries to the Arduino IDE: SparkFun u-blox GNSS Arduino Library, IridiumSBDi2c. If you want to make use of the PHT sensor, you will also need the SparkFun PHT MS8607 Arduino Library. These can all be found within the Arduino Library Manager.

To begin development, you will need to connect the Artemis Global Tracker to your device with the Arduino IDE using the USB-C cable, and select the designated board (RedBoard Artemis ATP).

The Logic

The code enables the GNSS module funcitonality, finds the current longitude and latitude of the AGT device, randomly generates a target distance and angle based on the current location, and begins blinking the onboard LED with intervals relating to the distance between the current location and target location. We will also mark the location of a 30 meter radius around the starting location using the “addGeofence” function from the SparkFun u-blox GNSS Arduino Library. If the device leaves this radius while playing the game, the player will lose. The treasure position is chosen by randomly selecting a distance between 15 and 30 meters and a distance between 0 and 360 degrees from the starting position.

The magic here involves calculating distances and angles with spherical coordinates. The game should be playable on a large (potentially worldly) scale, which means no assuming the Earth is flat. Therefore, from two sets of spherical coordinates (the initial and current position of the AGT device), we need to compute the effective spherical angle and distance between them. Through research, making use of the haversine and bearing equations, where the haversine function calculates the distance between the two positions and the bearing function calculates the angle, seemed like the best approach. They work as follows:

Haversine Distance Function

// GET COORDINATE DISTANCE - HAVERSINE FORMULA

double getCoordinateDistance(long La1, long Lo1, double La2, long Lo2) {
    double radius = 6.3781e6;  // radius of the Earth (meters)
    // conversion to radians
    double rla1 = La1*(1E-7) * (PI/180);
    double rla2 = La2*(1E-7) * (PI/180);
    double rlo1 = Lo1*(1E-7) * (PI/180);
    double rlo2 = Lo2*(1E-7) * (PI/180);

    double a = sin((rla2-rla1)/2) * sin((rla2-rla1)/2) + cos(rla1) * cos(rla2) * sin((rlo2 - rlo1)/2) * sin((rlo2 - rlo1)/2);

    double b = 2 * atan2(sqrt(a), sqrt(1-a));

    return radius * b;

Bearing Angle Function

// GET COORDINATE ANGLE (BEARING) HELPER
long getCoordinateBearing(long La1, long Lo1, long La2, long Lo2) {
    double rLa1 = La1*(1E-7) * (PI/180);
    double rLa2 = La2*(1E-7) * (PI/180);
    double rLo1 = Lo1*(1E-7) * (PI/180);
    double rLo2 = Lo2*(1E-7) * (PI/180);

    double y = sin(rLo2-rLo1) * cos(rLa2);
    double x = cos(rLa1) * sin(rLa2) - sin(rLa1)*cos(rLa2)*cos(rLo2-rLo1);

    return (atan2(y, x) * (180/PI)); // returns angle between -180 and 180

The necessity of these functions becomes apparent once you learn about the system of spherical coordinates. Longitudinal values may work as expected, associated with a vertical position on a sphere. However, Latitudinal distances become difficult to calculate since each longitudinal value forces each horizontal cross-section of the Earth to be a different sized circle.

With these functions, we calculate the current positions angle and distance from the initial position, essentially creating polar coordinates. Once the distance between the target and current polar coordinates reaches a certain threshold (within 2 meters), the treasure has been found! The distance to the target is also made aware to the player visually through an LED meter as shown in the demo. In order to find this distance we use the polar distance formula as shown:

As the player gets closer to the goal position, the onboard LED blinks faster and faster until it stays lit when the treasure is found. Also, the AGT is writing to the Arduino Serial Monitor with the current player positions, the goal positions, and a message demonstrating how close the player is to the treasure (“hotter”, “colder, etc)

The Result

Finally, once the treasure is found, the AGT connects to the iridium satellite network and sends an HTTP POST request with the success message to any destination. The AGT does not need wifi connection for this request: the satellite network does this for you after you make an account with Ground Control and connect the iridium device on the AGT. I made a temporary site on Webhook.site which automatically sets up an endpoint to receive HTTP requests. Here’s an example message after I played the game and won!

The Iridium network can also estimate the approximate location of the message based on the positioning of the satellite themselves.

The Code

Here, we have the main loop function which combines the logic above with functions that interact with the AGT hardware.

// MAIN LOOP FUNCTION
void loop() {

 if (WIN) {

   Serial.println(F("YOU FOUND THE TREASURE!!"));
   signalVictory();
   while (true) {
     delay(2000);
     Serial.println(F("YOU FOUND THE TREASURE!!"));
   }

 } else {
   geofenceState currentGeofenceState; // Create storage for the geofence state
   boolean result = myGNSS.getGeofenceState(currentGeofenceState);
   Serial.print(F("getGeofenceState returned: ")); // Print the combined state
   Serial.print(result); // Get the geofence state

   if (!result) // If getGeofenceState did not return true
   {
     Serial.println(F(".")); // Tidy up
     return; // and go round the loop again
   }

   // Print the Geofencing status
   // 0 - Geofencing not available or not reliable; 1 - Geofencing active
   Serial.print(F(". status is: "));
   Serial.print(currentGeofenceState.status);

   // Print the numFences
   Serial.print(F(". numFences is: "));
   Serial.print(currentGeofenceState.numFences);

   // Print the state of the geofence
   // 0 - Unknown; 1 - Inside; 2 - Outside
   Serial.print(F(". The geofence stats is: "));
   Serial.print(currentGeofenceState.states[0]);

   byte fenceStatus = digitalRead(geofencePin); // Read the geofence pin
   digitalWrite(LED, !fenceStatus); // Set the LED (inverted)
   Serial.print(F(". Geofence pin (PIO14) is: ")); // Print the pin state
   Serial.print(fenceStatus);
   Serial.println(F("."));


   // GET CURRENT POSITION
   curr_lat = myGNSS.getLatitude(); // Get the latitude in degrees * 10^-7
   curr_long = myGNSS.getLongitude(); // Get the longitude in degrees * 10^-7
   curr_angle = (getCoordinateBearing(latitude, longitude, curr_lat, curr_long) + 180) % 360;
   curr_distance = getCoordinateDistance(latitude, longitude, curr_lat, curr_long);

   Serial.print(F("Current Latitude: "));
   Serial.print(curr_lat);
   Serial.print(F(". Current Longitude: "));
   Serial.println(curr_long);

   Serial.print(F("Goal Angle: "));
   Serial.print(goal_angle);
   Serial.print(F(". Goal Distance: "));
   Serial.println(goal_distance);

   Serial.print(F("Current Angle: "));
   Serial.print(curr_angle);
   Serial.print(F(". Current Distance: "));
   Serial.println(curr_distance);

   score = sqrt(curr_distance * curr_distance + goal_distance * goal_distance - 2 * goal_distance * curr_distance * cos((curr_angle * (2*PI/360)) - (goal_angle * (2*PI/360))));
   Serial.print(F("Current Score: "));
   Serial.print(score);

   if (score < 2) {
     WIN = true;
   } if (score < 5) {
     Serial.println(F(": HOT!!"));
   } else if (score < 12) {
     Serial.println(F(": Warmerrr..."));
   } else if (score < 20) {
     Serial.println(F(": Room Temp"));
   } else {
     Serial.println(F(": Ice Cold..."));
   }
   Serial.println();

 }

 digitalWrite(LED, LOW);
 delay(score*5);
 digitalWrite(LED, HIGH);
 delay(score*5);
}

Once the player finds the treasure, the victory function runs, which connects the AGT to the Iridium network and sends a victory message.

void signalVictory() {
  int signalQuality = -1;
  int err;

  pinMode(LED, OUTPUT); // Make the LED pin an output

  gnssOFF(); // Disable power for the GNSS
  pinMode(gnssBckpBatChgEN, INPUT); // GNSS backup batttery charge control
  pinMode(geofencePin, INPUT); // Configure the geofence pin as an input
  pinMode(iridiumPwrEN, OUTPUT); // Configure the Iridium Power Pin
  digitalWrite(iridiumPwrEN, LOW); // Disable Iridium Power
  pinMode(superCapChgEN, OUTPUT); // Configure the super capacitor charger enable pin
  digitalWrite(superCapChgEN, LOW); // Disable the super capacitor charger
  pinMode(iridiumSleep, OUTPUT); // Iridium 9603N On/Off (Sleep) pin
  digitalWrite(iridiumSleep, LOW); // Put the Iridium 9603N to sleep
  pinMode(iridiumRI, INPUT); // Configure the Iridium Ring Indicator as an input
  pinMode(iridiumNA, INPUT); // Configure the Iridium Network Available as an input
  pinMode(superCapPGOOD, INPUT); // Configure the super capacitor charger PGOOD input

  modem.endSerialPort();

  // Enable the supercapacitor
  Serial.println(F("Enabling the supercapacitor charger..."));
  digitalWrite(superCapChgEN, HIGH);
  delay(1000);
  // wait for the capacitor to charge
  while (digitalRead(superCapPGOOD) == false)
  {
    Serial.println(F("Waiting for supercapacitors to charge..."));
    delay(1000);
  }
  Serial.println(F("Supercapacitors charged!"));

  // Enable power for the 9603N (Iridium Connection)
  Serial.println(F("Enabling 9603N power..."));
  digitalWrite(iridiumPwrEN, HIGH); // Enable Iridium Power
  delay(1000);
  modem.setPowerProfile(IridiumSBD::USB_POWER_PROFILE);

  // Startup the modem
  Serial.println(F("Starting modem..."));
  err = modem.begin();
  if (err != ISBD_SUCCESS)
  {
    Serial.print(F("Begin failed: error "));
    Serial.println(err);
    if (err == ISBD_NO_MODEM_DETECTED)
    Serial.println(F("No modem detected: check wiring."));
    return;
  }

  // Test the signal quality.
  err = modem.getSignalQuality(signalQuality);
  if (err != ISBD_SUCCESS)
  {
    Serial.print(F("SignalQuality failed: error "));
    Serial.println(err);
    return;
  }
  modem.useMSSTMWorkaround(false);

  Serial.print(F("On a scale of 0 to 5, signal quality is currently "));
  Serial.print(signalQuality);
  Serial.println(F("."));

  // Send the message
  Serial.println(F("Trying to send the message.  This might take several minutes."));
  err = modem.sendSBDText("YOU FOUND THE TREASURE!!");
  if (err != ISBD_SUCCESS)
  {
    Serial.print(F("sendSBDText failed: error "));
    Serial.println(err);
    if (err == ISBD_SENDRECEIVE_TIMEOUT)
    Serial.println(F("Try again with a better view of the sky."));
  }

  // POWER DOWN IRIDIUM CONNECTION

  // Clear the Mobile Originated message buffer
  Serial.println(F("Clearing the MO buffer."));
  err = modem.clearBuffers(ISBD_CLEAR_MO); // Clear MO buffer
  if (err != ISBD_SUCCESS)
  {
    Serial.print(F("clearBuffers failed: error "));
    Serial.println(err);
  }

  // Power down the modem
  Serial.println(F("Putting the 9603N to sleep."));
  err = modem.sleep();
  if (err != ISBD_SUCCESS)
  {
    Serial.print(F("sleep failed: error "));
    Serial.println(err);
  }

  Serial.println(F("Disabling 9603N power..."));
  digitalWrite(iridiumPwrEN, LOW); // Disable Iridium Power

  Serial.println(F("Disabling the supercapacitor charger..."));
  digitalWrite(superCapChgEN, LOW); // Disable the super capacitor charger

  Serial.println(F("Game Complete!"));
}

Next Steps

All of these components together creates a fun hide and seek game with your Artemis Global Tracker! There are many ways one could extend this example and create a higher functioning game. For one, you could create a website designed to take a POST request after a player wins the game and show stats from the game (ex: time until find, score, etc.). Also, you could add hardware components along with the AGT to graphically show game stats for the user while playing. For example, an LED meter would be a great way to show live score updates to the player.

Acknowledgements

This project could not have happened without the documentation and examples from the Sparkfun AGT examples repository found here. Some of Sparkfun’s setup functions and definitions were necessary in the working game, and can be found in the resulting code.

This tutorial was created and engineered by Jameson Koonce, a Computer Engineering Student at the University of Illinois at Urbana-Champaign.

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

Display Distance Measurements On an OLED a learn.sparkfun.com tutorial

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

Introduction

This tutorial will take your SparkFun Qwiic Ultrasonic Distance Sensor to the next level by adding a cool little OLED display. With this upgrade, your robot (or you!) won't just be able to measure distances, you'll be able to see them in real time on the screen!

added to your cart!

SparkFun Ultrasonic Distance Sensor - TCT40 (Qwiic)

In stock SEN-24805

The TCT40 distance sensor is great for non-contact distance readings from 2cm to 400cm. This unit adds a pair of Qwiic connec…

$9.95

Favorited Favorite 6

Wish List

If you are looking for the full Hookup Guide for the SparkFun Ultrasonic Distance Sensor - TCT40 (Qwiic), click the button bellow. This guide only covers a simple project to get you started quickly, while the full Hookup Guide goes over every detail of the sensor.

Hardware Needed

To follow this experiment, you will need the following materials. While this is a simple project we wanted to make sure that you have everything you need to get started before we get to the code. For this simple project we chose the RedBoard Qwiic but you could choose from many of our development boards such as the Qwiic Pro Micro as well.

added to your cart!

SparkFun Ultrasonic Distance Sensor - TCT40 (Qwiic)

In stock SEN-24805

The TCT40 distance sensor is great for non-contact distance readings from 2cm to 400cm. This unit adds a pair of Qwiic connec…

$9.95

Favorited Favorite 6

Wish List

added to your cart!

SparkFun RedBoard Qwiic

In stock DEV-15123

The SparkFun RedBoard Qwiic is an Arduino-compatible development board with a built in Qwiic connector, eliminating the need …

$21.50

20

Favorited Favorite 63

Wish List

added to your cart!

SparkFun Qwiic OLED Display (0.91 in., 128x32)

In stock LCD-24606

The SparkFun Qwiic OLED Display can display up to four lines of text and features 128x32 pixels in a small 0.91in. (diagonal)…

$10.95

1

Favorited Favorite 17

Wish List

added to your cart!

Qwiic Cable - 100mm

In stock PRT-14427

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

$1.50

Favorited Favorite 43

Wish List

added to your cart!

Qwiic Cable - 100mm

In stock PRT-14427

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

$1.50

Favorited Favorite 43

Wish List

added to your cart!

USB Micro-B Cable - 6 Foot

In stock CAB-10215

USB 2.0 type A to Micro-B 5-pin. This is a new, smaller connector for USB devices. Micro-B connectors are about half the heig…

$5.50

15

Favorited Favorite 23

Wish List

Software Setup

SparkFun has written a library to work with the SparkFun Ultrasonic Distance Sensor Qwiic Board. You can obtain this library by clicking on the button below, or by downloading it from the GitHub Repository.

Read Measurements with a Serial Monitor

Now that we've installed the Arduino library, it's time to upload our first sketch to make sure everything is working properly and you are able to read basic measurements with your Serial Monitor in the Arduino IDE.

For this example you will need the SparkFun Ultrasonic Distance Sensor - TCT40 (Qwiic), a SparkFun RedBoard Qwiic, a Qwiic Cable, and a USB Micro-B Cable.

Using the Qwiic system, assembling the hardware is simple. Connect the RedBoard to one of the Ultrasonic Distance Sensor Qwiic ports using your Qwiic cables (please remember to insert this cable in the correct orientation). Then connect the RedBoard to your computer via the MicroUSB cable and voila! You're ready to rock!

To find Example 1, go to File > Examples > SparkFun Qwiic Ultrasonic Arduino Library > Example1_BasicReadings:

Alternatively, you can copy and paste the code below into a shiny new Arduino sketch:

/* SparkFun Ulrasonic Distance Sensor - Example 1 Basic Distance Sensing
     * 
     * Product: 
     *  *  SparkFun Qwiic Ultrasonic Distance Sensor - HC-SR04 (SEN-1XXXX)
     *  *  https://www.sparkfun.com/1XXXX
     * 
     * Written By: Elias Santistevan
     * Date: 06/2024
     *
     * SPDX-License-Identifier: MIT
     *
     * Copyright (c) 2024 SparkFun Electronics
     */

    #include "SparkFun_Qwiic_Ultrasonic_Arduino_Library.h"

    // Create an ultrasonic sensor object
    QwiicUltrasonic myUltrasonic;

    // Here we set the device address. Note that an older version of the Qwiic
    // Ultrasonic firmware used a default address of 0x00. If yours uses 0x00,
    // you'll need to change the address below. It is also recommended to run
    // Example 2 to change the address to the new default.
    uint8_t deviceAddress = kQwiicUltrasonicDefaultAddress; // 0x2F
    // uint8_t deviceAddress = 0x00;

    void setup()
    {
      // Start serial
      Serial.begin(115200);
      Serial.println("Ultrasonic Distance Sensor Example 1 - Basic Readings");

      Wire.begin();

      // Attempt to begin the sensor
      while (myUltrasonic.begin(deviceAddress) == false)
      {
        Serial.println("Ultrasonic sensor not connected, check your wiring and I2C address!");
        delay(2000);
      }

      Serial.println("Ultrasonic sensor connected!");
    }

    void loop()
    {
      uint16_t distance = 0;
      myUltrasonic.triggerAndRead(distance);

      // Print measurement
      Serial.print("Distance (mm): ");
      Serial.println(distance);

      //Serial.println("Distance (cm): "); 
      //Serial.print((distance / 10.0), 2);         

      //Serial.println("Distace (in): "); 
      //Serial.print((distance / 25.4), 2);         

      // Wait a bit
      delay(250);
    }

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, go ahead and open a Serial Monitor. You should see something similar to the following.

Display Measurements On an OLED

Let's add in an LCD screen to display our measurements. For this example you will need another Qwiic Cable and the SparkFun Qwiic OLED Display (0.91 in., 128x32). Again, the Qwiic system makes this example quite literally plug and play. Use Qwiic cables to make your hardware setup look like this:

To display the sensor readings on the connected Qwiic OLED, we will need to install the SparkFun Qwiic OLED library. You can install this library to automatically in the Arduino IDE's Library Manager by searching for "SparkFun Qwiic OLED". Or you can manually download it from the GitHub repository.

To find Example 2, go to File > Examples > SparkFun Qwiic Ultrasonic Arduino Library > Example2_OLED_Distance:

Alternatively, you can copy and paste the code below into a shiny new Arduino sketch:

/* SparkFun Ulrasonic Distance Sensor - Example 2 Basic Distance Sensing on an OLED Display
  * 
   * Products: 
   *  *  SparkFun Qwiic Ultrasonic Distance Sensor - HC-SR04 (SEN-1XXXX)
   *  *  https://www.sparkfun.com/1XXXX
   *  *  SparkFun Qwiic Narrow OLED Display (LCD-1XXXX)
   *  *  https://www.sparkfun.com/1XXXX
   *
   * Link to OLED library: https://github.com/sparkfun/SparkFun_Qwiic_OLED_Arduino_Library
   * 
   * Written By: Elias Santistevan
   * Date: 06/2024
   *
   * SPDX-License-Identifier: MIT
   *
   * Copyright (c) 2024 SparkFun Electronics
   */

  #include "SparkFun_Qwiic_OLED.h"
  // For the narrow LED, I prefer the slightly larger font included in the OLED library.
  // This is completely optional and can be deleted or commented out. By default the font
  // is slightly smaller. 
  #include "res/qw_fnt_8x16.h"
  #include "SparkFun_Qwiic_Ultrasonic_Arduino_Library.h"

  // Create an ultrasonic sensor object
  QwiicUltrasonic myUltrasonic;
  // Creat an OLED object
  QwiicNarrowOLED myOLED;

  char distanceBuff[4] = {}; 
  String distanceStr = "";
  int centerX; 
  int centerY; 

  // Here we set the device address. Note that an older version of the Qwiic
  // Ultrasonic firmware used a default address of 0x00. If yours uses 0x00,
  // you'll need to change the address below. It is also recommended to run
  // Example 2 to change the address to the new default.
  uint8_t deviceAddress = kQwiicUltrasonicDefaultAddress; // 0x2F
  // uint8_t deviceAddress = 0x00;

  void setup()
  {

    Serial.begin(115200); // Default config settings
    Serial.println("Ultrasonic Distance Sensor - Example 4 - Distance on an OLED Display");
    Wire.begin();

    while (myOLED.begin() == false) {
      Serial.println("OLED sensor not connected, check your wiring and I2C address!");
      delay(1000);
    }
    while(myUltrasonic.begin(deviceAddress) == false)
    {
      Serial.println("Ultrasonic sensor not connected, check your wiring and I2C address!");
      delay(1000);
    }

    String hello = "Hello, Ultrasonic!";

    // This is good for the narrow OLED screen. You can also just remove this 
    // and it will default to a slightly smaller font. 
    myOLED.setFont(QW_FONT_8X16);

    // This will center the text onto the screen. 
    int x0 = (myOLED.getWidth() - myOLED.getStringWidth(hello)) / 2;
    int y0 = (myOLED.getHeight() - myOLED.getStringHeight(hello)) / 2;

    myOLED.text(x0, y0, hello);

    // There's nothing on the screen yet - Now send the graphics to the device
    myOLED.display();
    delay(2000);
  }

  void loop() 
  {
    uint16_t distance = 0;
    myUltrasonic.triggerAndRead(distance);

    // Convert distance, which is an integer, to char so that we can print it.
    snprintf(distanceBuff, 6, "%d", distance);

    // Put the distance in a string so that we can also print "mm".
    distanceStr = distanceBuff; 
    distanceStr += "mm";

    myOLED.erase();
    centerX = (myOLED.getWidth() - myOLED.getStringWidth(distanceStr)) / 2;
    centerY = (myOLED.getHeight() - myOLED.getStringHeight(distanceStr)) / 2;
    myOLED.text(centerX, centerY, distanceStr);
    myOLED.display();

    delay(250);
  }

Make sure you've selected the correct board and port in the Tools menu and then hit the upload button. Once the code has finished uploading, you should see something similar to the following.

Try moving an object (like your hand or a dinosaur) closer to the sensor - notice the output of the OLED shows you how close the object is! Grr. Rawr!

Resources and Going Further

There are more examples in the Arduino Library that allow you to change the I2C address or use the Trigger and Echo Pins. Feel free to check them out!

Suggested Reading

If you aren’t familiar with the the preceding concepts, we recommend checking out these tutorials to gain a little background knowledge.

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

Fading with the MOSFET Power Switch and Buck Regulator a learn.sparkfun.com tutorial

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

Introduction

This tutorial will guide you through using the SparkFun MOSFET Power Switch and Buck Regulator (Low-Side) with your Arduino projects. This handy board combines a MOSFET switch for controlling high-power loads (up to 12V) with a built-in buck regulator that conveniently provides stable 3.3V power for your Arduino.

We'll explore various functionalities, starting with basic on/off control and progressing to creating dimming effects for LEDs and controlling motors with variable speeds. By the end, you'll be able to safely manage powerful components and add exciting features to your Arduino projects!

added to your cart!

SparkFun MOSFET Power Switch and Buck Regulator (Low-Side)

In stock COM-23979

The MOSFET Power Switch and Buck Regulator (Low-Side) can be powered with up to 12V and control up to 10A, all while providin…

$14.95

2

Favorited Favorite 9

Wish List

If you are looking for the full Hookup Guide for the SparkFun MOSFET Power Switch and Buck Regulator (Low-Side), click the button bellow. This guide only covers a simple project to get you started quickly, while the full Hookup Guide goes over every detail of the sensor.

Hardware Needed

To follow this experiment, you will need the following materials. While this is a simple project we wanted to make sure that you have everything you need to get started before we get to the code. For this simple project we chose the ESP32 IoT RedBoard Development Board.

added to your cart!

SparkFun MOSFET Power Switch and Buck Regulator (Low-Side)

In stock COM-23979

The MOSFET Power Switch and Buck Regulator (Low-Side) can be powered with up to 12V and control up to 10A, all while providin…

$14.95

2

Favorited Favorite 9

Wish List

added to your cart!

SparkFun IoT RedBoard - ESP32 Development Board

In stock WRL-19177

The IoT RedBoard is an ESP32 WROOM-equipped development board that has everything you need in an Arduino Uno with extra perks…

$29.95

8

Favorited Favorite 27

Wish List

added to your cart!

LED RGB Strip - Bare (1m)

In stock COM-12021

These are bare non-addressable 1 meter long RGB LED strips that come packed with 60 5060 LEDs per meter. As these are bare LE…

$10.95

1

Favorited Favorite 10

Wish List

added to your cart!

Wall Adapter Power Supply - 12VDC, 600mA (Barrel Jack)

In stock TOL-15313

This is a high quality AC to DC 'wall wart' which produces a regulated output of 12VDC at up to 600mA.

$6.50

Favorited Favorite 10

Wish List

added to your cart!

DC Barrel Jack Adapter - Male

Out of stock PRT-10287

This adapter allows you to connect a barrel jack connector to bare wires. One end has screw terminals and the other has a 5.5…

$3.50

Favorited Favorite 19

Wish List

added to your cart!

DC Barrel Jack Adapter - Female

In stock PRT-10288

This adapter allows you to connect a barrel jack connector to bare wires. One end has screw terminals and the other has a 5.5…

$3.50

1

Favorited Favorite 25

Wish List

added to your cart!

Mini Photocell

In stock SEN-09088

This is a very small light sensor. A photocell changes (also called a [photodetector](http://en.wikipedia.org/wiki/Photodetec…

$1.60

7

Favorited Favorite 76

Wish List

added to your cart!

Trimpot 10K Ohm with Knob

In stock COM-09806

This 10K trimmable potentiometer has a small knob built right in and it's breadboard friendly to boot!

$1.05

6

Favorited Favorite 56

Wish List

added to your cart!

Breadboard - Self-Adhesive (White)

In stock PRT-12002

This is your tried and true white solderless breadboard. It has 2 power buses, 10 columns, and 30 rows - a total of 400 tie i…

$5.50

48

Favorited Favorite 104

Wish List

added to your cart!

Reversible USB A to C Cable - 0.8m

In stock CAB-15425

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

$5.50

2

Favorited Favorite 6

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…

$4.50

2

Favorited Favorite 12

Wish List

added to your cart!

Resistor 10K Ohm 1/4 Watt PTH - 20 pack (Thick Leads)

In stock PRT-14491

These are your run-of-the-mill 1/4 Watt, +/- 5% tolerance PTH resistors. Commonly used in breadboards and other prototyping a…

$1.25

Favorited Favorite 13

Wish List

Software Setup

SparkFun has written a library to work with the SparkFun MOSFET Power Switch and Buck Regulator. You can obtain this library by clicking on the button below, or by downloading it from the GitHub Repository.

Fading

In this example, we will slowly turn on the load and then slowly turn it off using the N-channel MOSFET. This example is better with a DC motor and 12V LED. You will typically want the solenoid to be fully turned on/off.

For this example you will need the SparkFun IoT RedBoard - ESP32 Development Board, a USB-C Cable, the SparkFun MOSFET Power Switch and Buck Regulator (Low-Side), a Mini Screwdriver, M/M Jumper Wires, an RGB LED Strip, and a [12V Wall Adapter Power Supply](12V Wall Adapter Power Supply).

Hardware Hookup

You will need to connect everything as explained earlier. For this particular example, we will use one channel from a 12V RGB LED strip as shown in the circuit diagram below.

Your setup should look similar to the image below without the power supply.

Upload Code

To upload code, insert the USB cable into the IoT RedBoard - ESP32.

Copy the following code and paste it in the Arduino IDE. If you have not already, select your Board (in this case, the SparkFun ESP32 IoT RedBoard), and associated COM port. Then hit the upload button.

/******************************************************************************
  Example: Fading
  Modified By: Ho Yun "Bobby" Chan
  SparkFun Electronics
  Date: October 27th, 2023
  License: MIT. See license file for more information but you can
  basically do whatever you want with this code.

  This example is based on Arduino's fade example. It has been modified
  so that it can be used for the SparkFun IoT RedBoard- ESP32 but it can be
  used with any Arduino that has a PWM pin. The load (DC motor,
  or 12V LED) will slowly turn on and off. This code will be more useful for
  users connecting a DC motor or nonaddressable LED so that you can partially
  turn on/off the load.

  Users can also open the Serial Monitor at 115200 to check on
  the status of the button for debugging.

  Feel like supporting open source hardware?
  Buy a board or component from SparkFun!

      SparkFun MOSFET Power Switch and Buck Regulator (Low-Side): https://www.sparkfun.com/products/23979
      SparkFun IoT RedBoard - ESP32 Development Board: https://www.sparkfun.com/products/19177
      Hobby Motor - Gear: https://www.sparkfun.com/products/11696
      Blower - Squirrel Cage (12V): https://www.sparkfun.com/products/11270
      12V LED RGB Strip - Bare (1m): https://www.sparkfun.com/products/12021
      Wall Adapter 12V/600mA, (Barrel Jack): https://www.sparkfun.com/products/15313

  Distributed as-is; no warranty is given.
******************************************************************************/

int loadPin = 16;

// the setup function runs once when you press reset or power the board
void setup() {

//Initialize Serial for Debugging if there is no built-in LED
Serial.begin(115200);
Serial.println("Analog fade in and out to slowly turn on/off load!");

// Set up the load pin to be an output and turn it off:
pinMode(loadPin, OUTPUT);
analogWrite(loadPin, 255);

Serial.println("OFF");

}  //END SETUP

// the loop function runs over and over again forever
void loop() {

Serial.println("<===== FADE IN =====>");
// fade in from min to max in increments of 5 points:
for (int fadeValue = 255; fadeValue >= 0; fadeValue -= 5) {
// sets the value (range from 0 to 255):
analogWrite(loadPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);

Serial.println(fadeValue);
}

Serial.println("<===== FADE OUT =====>");
// fade out from max to min in increments of 5 points:
for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5) {
// sets the value (range from 0 to 255):
analogWrite(loadPin, fadeValue);
// wait for 30 milliseconds to see the dimming effect
delay(30);

Serial.println(fadeValue);
}

}  //END LOOP

What You Should See

Once the code has uploaded, disconnect the USB cable from the IoT RedBoard - ESP32. Then insert the barrel jack from a power supply to the MOSFET Power Switch and Buck Regulator's barrel jack connector. In this case, we used a 12V wall adapter power supply.

The load will slowly turn on and slowly turn off. This will loop forever until power is removed from the board. If necessary, disconnect the 3.3V jumper wire from the IoT RedBoard - ESP32, reconnect the USB cable, and open the Arduino Serial Monitor at 115200 baud for debugging purposes.

While this example was used to turn on one channel of a 12V RGB LED strip, you could also use this example with a DC motor. Try using a potentiometer (or any 3.3V analog sensor) with the map() function to adjust the speed of the motor.

12V RGB LED Strip

In this example, we will control all three channels of the RGB LED strip. Since we've already hooked up a 12V RGB LED strip before, we will also a circuit with a potentiometer to cycle between each color and a photoresistor to turn on the LEDs whenever the light is below a certain light level. The following example code is based on the SparkFun Inventor's Kit v4.1 Night Light example.

Parts Needed

Grab the following quantities of each part listed to build this circuit:

• 1x SparkFun IoT RedBoard - ESP32 Development Board
• 1x USB-C Cable
• 3x SparkFun MOSFET Power Switch and Buck Regulator (Low-Side)
• 1x SparkFun Mini Screwdriver
• 19x M/M Jumper Wires*
• 1x Breadboard
• 1x 10kΩ Potentiometer with Knob
• 1x Mini Photocell
• 1x 10kΩ Resistor
• 1x 12V RGB LED Strip
• 1x DC Barrel Jack Adapter - Male
• 3x DC Barrel Jack Adapter - Female
• 1x 12V Wall Adapter

Hardware Hookup

For this particular example, we will use three channels from a 12V RGB LED strip while also including a similar circuit from the SparkFun Inventor's Kit v4.1. The circuit diagram is shown below.

Keep in mind that instead of the RedBoard with ATmega328P, we are using the IoT RedBoard with ESP32. Since the hardware is different, the following code was modified:

- analog and PWM pins were redefined in the example code
- threshold was modified due to the ADC's higher reso...