SparkFun Arduino UNO R4 WiFi Qwiic Kit Hookup Guide a learn.sparkfun.com tutorial

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

Introduction

The SparkFun Arduino UNO R4 WiFi Qwiic Kit is a great way to get started with Arduino and the Qwiic-connect system. This kit includes everything you need to build a WiFi-enabled project, including an Arduino UNO R4 board, an assortment of Qwiic-enabled sensors and input boards, a Qwiic OLED Display, and a variety of other components to get you connected. Hooking up a handful of inputs and outputs to a Arduino UNO R4 has never been so easy.

The UNO universe expands with the Arduino UNO R4 WiFi: the same industry-standard form factor at 5V operating voltage, but with the enhanced performance of a RA4M1 32-bit microcontroller by Renesas with ESP32-S3-MINI coprocessor – for increased computational power, memory and speed – as well as WiFi® and Bluetooth® connectivity, a 12 x 8 LED matrix, and a Qwiic connector.

The SparkFun Arduino UNO R4 WiFi Qwiic Kit is a great way to learn about Arduino, WiFi, and electronics. With this kit, you can build your own WiFi-enabled projects and start connecting your devices to the Internet of Things.

added to your cart!

SparkFun Arduino UNO R4 WiFi Qwiic Kit

Pre-Order KIT-22641

The SparkFun Arduino UNO R4 WiFi Qwiic Kit has everything you need to start using the UNO R4 WiFi and Qwiic ecosystem togethe…

$99.95

FavoritedFavorite1

Wish List

Parts List

To follow this experiment, you will need the following materials. If you did not order the kit, you may need some of the items here. You may not need everything though, depending on what you have. Add it to your cart, read through the guide, and adjust the cart as necessary.

Suggested Reading

If you aren’t familiar with the following concepts, we recommend checking out these tutorials before continuing.

Qwiic Connect System

The Arduino Uno R4 Wifi Board

This board is jam packed with functionality. We'll cover some of the basics here, but to read about the full shebang, refer to the Product Reference Manual.

Microcontroller

The Arduino UNO R4 board is equipped with a powerful RA4M1 series 32-bit microcontroller from Renesas, which offers increased processing power, memory, and on-board peripherals. Importantly, these enhancements do not compromise compatibility with existing shields and accessories, nor do they require any changes to the standard form factor or 5V operating voltage.

ESP32-S3-MINI CoProcessor

The UNO R4 WiFi features an ESP32-S3-MINI coprocessor that enhances the capabilities of the RA4M1 microcontroller. With WiFi and Bluetooth connectivity, this board allows makers to easily connect to the internet and create IoT projects.

Power

You can provide power via the USB-C connector or the Barrel Jack. A USB-C cable is included in the kit, the Barrel Jack can be purchased separately. The RA4M1's operating voltage is fixed at 5 V, whereas the ESP32-S3 module is 3.3 V. Communication between these two MCUs are performed via a logic level translator (TXB0108DQSR).

LED Matrix

The UNO R4 WiFi includes a bright 12x8 red LED matrix (96 dots total). This feature is ideal for creative projects using animations or for plotting sensor data, without the need for any additional hardware.

Qwiic Connector

The UNO R4 WiFi includes an industry-standard Qwiic I²C connector that facilitates quick prototyping. With a wide variety of compatible modules that can be connected over I²C, makers can easily create custom projects and expand the capabilities of the UNO R4 WiFi.

GPIO

The board features 14 digital I/O ports, 6 analog channels, dedicated pins for I²C, SPI and UART connections. The pins on either side of the board are highlighted here.

Their functionality is shown below; for more details, refer to the Product Reference Manual.

Installing Arduino

The following steps are a basic overview of getting started with the Arduino IDE. For more detailed, step-by-step instructions for setting up the Arduino IDE on your computer, please check out the following tutorial.

Download the Arduino IDE

In order to get your microcontroller up and running, you'll need to download the newest version of the Arduino software first (it's free and open source!).

This software, known as the Arduino IDE, will allow you to program the board to do exactly what you want. It’s like a word processor for writing code.

Connecting the Arduino UNO R4 WiFi

Use the USB cable provided in the kit to connect the Arduino UNO R4 to one of your computer’s USB inputs.

Install the Arduino Uno R4 Board Definition

If you haven't already done so, make sure you have the Board Definitions installed for the Arduino Uno R4 boards. Go up to the Tools menu, hover over Board, and select Boards Manager. Type in Arduino R4, and you should see the following. Click Install to install the board defs.

Select Your Board: Arduino Uno R4

Before we can start jumping into the experiments, there are a couple adjustments we need to make. This step is required to tell the Arduino IDE which of the many Arduino boards we have. Go up to the Tools menu. Then hover over Board and subsequently the Arduino UNO R4 Boards menus, and make sure Arduino Uno R4 WiFi is selected.

Select a Serial Port

Next up we need to tell the Arduino IDE which of our computer's serial ports the microcontroller is connected to. For this, again go up to Tools, then hover over Port and select your Arduino Uno R4 WiFi's serial port.

Software

We have compiled a set of examples to show how the basics work on this board. You can download the examples here:

These are just the ino files. Each of the examples requires a separate library to be installed. Each example in this guide will walk you through installing the required library. Let's get hacking!

Example 1: Qwiic LED Button

This first example shows how the Qwiic LED Button can be hooked up and programmed to pulse while pressed.

Library Installation

In order for this example to work, you'll need to also install the library for the SparkFun Qwiic Button. The easiest way to install this library is to search for SparkFun Qwiic Button in the Arduino Library Manager tool. You can also manually install the Qwiic Button Library from the GitHub Repository or you can download it by clicking the button below.

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example - Pulse When Pressed

The following example is taken from Example 3 of the SparkFun Qwiic Button library and is titled "Pulse When Pressed". The code connects the Qwiic Button to the I²C bus and runs the Button LED through a configured sequence when the button is pressed. The code configures the LED settings for brightness, cycleTime and offTime to pulse the Button LED while it is pressed. Try playing around with these settings to change the behavior of the LED.

language:c
/******************************************************************************
  Checks whether the button is pressed, and light it up if it is! Also prints
  status to the serial monitor.

  Fischer Moseley @ SparkFun Electronics
  Original Creation Date: July 24, 2019

  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 the Qwiic Shield to your Arduino/Photon/ESP32 or other
  Plug the button into the shield
  Print it to the serial monitor at 115200 baud.

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

#include <SparkFun_Qwiic_Button.h>
QwiicButton button;
//Define LED characteristics
uint8_t brightness = 250;   //The maximum brightness of the pulsing LED. Can be between 0 (min) and 255 (max)
uint16_t cycleTime = 1000;   //The total time for the pulse to take. Set to a bigger number for a slower pulse, or a smaller number for a faster pulse
uint16_t offTime = 200;     //The total time to stay off between pulses. Set to 0 to be pulsing continuously.

void setup() {
  Serial.begin(115200);
  Serial.println("Qwiic button examples");
  Wire1.begin(); //Join I2C bus

  //check if button will acknowledge over I2C
  if (button.begin(SFE_QWIIC_BUTTON_DEFAULT_ADDRESS, Wire1) == false) {
    Serial.println("Device did not acknowledge! Freezing.");
    while (1);
  }
  Serial.println("Button acknowledged.");
  button.LEDoff();  //start with the LED off
}

void loop() {
  //check if button is pressed, and tell us if it is!
  if (button.isPressed() == true) {
    Serial.println("The button is pressed!");
    button.LEDconfig(brightness, cycleTime, offTime);
    while (button.isPressed() == true)
      delay(10);  //wait for user to stop pressing
    Serial.println("The button is not pressed.");
    button.LEDoff();
  }
  delay(20); //let's not hammer too hard on the I2C bus
}

Notice that the code uses Wire1. The Qwiic connector on the Arduino UNO R4 WiFi Board is connected to a secondary I²C bus on this board, IIC0. This connector is 3.3V only, connecting higher voltages may damage your board. To initialize this bus, use Wire1.begin() instead.

You should have the correct board and port selected, as per the Software section of this guide. Upload the code, and when you press the button you should see the button pulse as below:

Example 2: Qwiic Twist

Library Installation

We’ve written an easy to use Arduino library that covers the gamut of features on the Qwiic Twist. The easiest way to install the library is by searching SparkFun Twist within the Arduino library manager. We’ve even got a tutorial on installing an Arduino library if you need it. You can also manually install the Qwiic Twist library by downloading a zip:

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example - Basic Readings

This example is a basic one from the SparkFun Twist Library and just prints the number of times the knob has been turned to the serial output.

language:c
/*
  Read and interact with the SparkFun Qwiic Twist digital RGB encoder
  By: Nathan Seidle
  SparkFun Electronics
  Date: December 3rd, 2018
  License: MIT. See license file for more information but you can
  basically do whatever you want with this code.

  This example prints the number of steps the encoder has been twisted.

  Feel like supporting open source hardware?
  Buy a board from SparkFun! https://www.sparkfun.com/products/15083

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

#include "SparkFun_Qwiic_Twist_Arduino_Library.h" //Click here to get the library: http://librarymanager/All#SparkFun_Twist
TWIST twist;                                      //Create instance of this object

void setup()
{
  Serial.begin(115200);
  Serial.println("Qwiic Twist Example");

  if (twist.begin(Wire1) == false)
  {
    Serial.println("Twist does not appear to be connected. Please check wiring. Freezing...");
    while (1)
      ;
  }
}

void loop()
{
  Serial.print("Count: ");
  Serial.print(twist.getCount());

  if (twist.isPressed())
    Serial.print(" Pressed!");

  Serial.println();

  delay(10);
}

As before, you should have the correct board and port selected in the Tools menu. Go ahead and upload the code, and open a Serial Monitor. You should see something like the below:

Example 3: Qwiic OLED

Library Installation

The easiest way to install the Qwiic OLED library is to search for SparkFun Qwiic OLED in the Arduino Library Manager tool. You can also manually install the Qwiic OLED Library from the SparkFun Qwiic OLED Arduino GitHub Repository. Alternatively, you can download by clicking the button below.

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example

The following example is taken from Example 1 of the SparkFun Qwiic OLED library and is titled "Hello".

language:c
/*

  Example-01_Hello.ino

  This demo shows the basic setup of the OLED library, generating simple graphics and displaying
  the results on the target device.

   Micro OLED             https://www.sparkfun.com/products/14532
   Transparent OLED       https://www.sparkfun.com/products/15173
   "Narrow" OLED          https://www.sparkfun.com/products/17153

  Written by Kirk Benell @ SparkFun Electronics, March 2022

  Repository:
     https://github.com/sparkfun/SparkFun_Qwiic_OLED_Arduino_Library

  Documentation:
     https://sparkfun.github.io/SparkFun_Qwiic_OLED_Arduino_Library/

  SparkFun code, firmware, and software is released under the MIT License(http://opensource.org/licenses/MIT).
*/

#include <SparkFun_Qwiic_OLED.h> //http://librarymanager/All#SparkFun_Qwiic_Graphic_OLED

// The Library supports three different types of SparkFun boards. The demo uses the following
// defines to determine which device is being used. Uncomment the device being used for this demo.

// QwiicMicroOLED myOLED;
// QwiicTransparentOLED myOLED;
QwiicNarrowOLED myOLED;


void setup()
{
    Serial.begin(115200);
    Serial.println("Running OLED example");

    Wire1.begin();

    // Initalize the OLED device and related graphics system
    if (myOLED.begin(Wire1) == false)
    {
        Serial.println("Device begin failed. Freezing...");
        while (true)
            ;
    }
    Serial.println("Begin success");

    // Do a simple test - fill a rectangle on the screen and then print hello!

    // Fill a rectangle on the screen that has a 4 pixel board
    myOLED.rectangleFill(4, 4, myOLED.getWidth() - 8, myOLED.getHeight() - 8);

    String hello = "hello"; // our message

    // Center our message on the screen. Get the screen size of the "hello" string,
    // calling the getStringWidth() and getStringHeight() methods on the oled

    // starting x position - screen width minus string width  / 2
    int x0 = (myOLED.getWidth() - myOLED.getStringWidth(hello)) / 2;

    // starting y position - screen height minus string height / 2 
    int y0 = (myOLED.getHeight() - myOLED.getStringHeight(hello)) / 2;

    // Draw the text - color of black (0)
    myOLED.text(x0, y0, hello, 0);

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

    // That's it - HELLO!
}

void loop()
{
    delay(1000); // Do nothing
}

As before, make sure you select the correct board and port in the tools menu. Upload the code, and you should see something like the image below.

Play with the settings, make your OLED say different things!

Example 4: Qwiic Ambient Light Sensor (VEML6030)

Library Installation

The Qwiic Ambient Light Sensor (VEML6030) library will give you the full functionality of the sensor and provides example code to get the most our of your project. You can obtain these libraries through the Arduino Library Manager by searching SparkFun Ambient Light Sensor. The second option is to download the ZIP file below from its GitHub repository to manually install.

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example

In this example, we'll get you comfortable with gathering ambient light and setting two vital properties of the sensor's ability to read light: the gain and the integration time. These two properties determine the resolution (accuracy) of the reading and the available ranges of light that you can read! For example, a gain of 1/8 and 800ms integration time cannot read anything above 3775 Lux. This means you'll max out your sensor outdoors but would be a proper setting for dim rooms due to it's higher resolution.

language:c
/*
  This example code will walk you through how to read ambient light values.
  Chances are good that you'll use this sensor in various environments so it'll
  also walk you through setting the gain and integration time that allow for
  different ranges of lux values. For example using the default gain of 100ms
  gives you a maximum reading of 30,199 Lux. This is great for daylight
  readings but not DIRECT sun. Higher integration times mean higher
  resoultions but lower lux values and vice versa: the lowest integration time
  and lowest gain should be used for mid day direct light. Check our hookup
  guide for more information. 

  SparkFun Electronics
  Author: Elias Santistevan
  Date: July 2019

    License: This code is public domain but if you use this and we meet someday, get me a beer! 

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

*/

#include <Wire.h>
#include "SparkFun_VEML6030_Ambient_Light_Sensor.h"

#define AL_ADDR 0x48

SparkFun_Ambient_Light light(AL_ADDR);

// Possible values: .125, .25, 1, 2
// Both .125 and .25 should be used in most cases except darker rooms.
// A gain of 2 should only be used if the sensor will be covered by a dark
// glass.
float gain = .125;

// Possible integration times in milliseconds: 800, 400, 200, 100, 50, 25
// Higher times give higher resolutions and should be used in darker light. 
int timeLength = 100;
long luxVal = 0; 

void setup(){

  Wire1.begin();
  Serial.begin(115200);

  if(light.begin(Wire1))
    Serial.println("Ready to sense some light!"); 
  else
    Serial.println("Could not communicate with the sensor!");

  // Again the gain and integration times determine the resolution of the lux
  // value, and give different ranges of possible light readings. Check out
  // hoookup guide for more info. 
  light.setGain(gain);
  light.setIntegTime(timeLength);

  Serial.println("Reading settings..."); 
  Serial.print("Gain: ");
  float gainVal = light.readGain();
  Serial.print(gainVal, 3); 
  Serial.print(" Integration Time: ");
  int timeVal = light.readIntegTime();
  Serial.println(timeVal);

}

void loop(){

  luxVal = light.readLight();
  Serial.print("Ambient Light Reading: ");
  Serial.print(luxVal);
  Serial.println(" Lux");  
  delay(1000);

}

Make sure you have the correct board and port selected, and upload the code. Open a Serial Monitor and you should see something like the below:

Example 5: Triple Axis Accelerometer Breakout - BMA400 (Qwiic)

Library Installation

The SparkFun BMA400 Arduino Library is based off the API for the sensor from Bosch to let users get started reading data from the sensor and using the various interrupt options. Install the library through the Arduino Library Manager tool by searching for "SparkFun BMA400". Users who prefer to manually install the library can download a copy of it from the GitHub repository by clicking the button below:

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example

This example demonstrates how to set the BMA400 up to communicate basic motion data over I²C.

language:c
#include <Wire.h>
#include "SparkFun_BMA400_Arduino_Library.h"

// Create a new sensor object
BMA400 accelerometer;

// I2C address selection
uint8_t i2cAddress = BMA400_I2C_ADDRESS_DEFAULT; // 0x14
//uint8_t i2cAddress = BMA400_I2C_ADDRESS_SECONDARY; // 0x15

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

    // Initialize the I2C library
    Wire1.begin();

    // Check if sensor is connected and initialize
    // Address is optional (defaults to 0x14)
    while(accelerometer.beginI2C(i2cAddress, Wire1) != BMA400_OK)
    {
        // Not connected, inform user
        Serial.println("Error: BMA400 not connected, check wiring and I2C address!");

        // Wait a bit to see if connection is established
        delay(1000);
    }

    Serial.println("BMA400 connected!");
}

void loop()
{
    // Get measurements from the sensor. This must be called before accessing
    // the acceleration data, otherwise it will never update
    accelerometer.getSensorData();

    // Print acceleration data
    Serial.print("Acceleration in g's");
    Serial.print("\t");
    Serial.print("X: ");
    Serial.print(accelerometer.data.accelX, 3);
    Serial.print("\t");
    Serial.print("Y: ");
    Serial.print(accelerometer.data.accelY, 3);
    Serial.print("\t");
    Serial.print("Z: ");
    Serial.println(accelerometer.data.accelZ, 3);

    // Pause
    delay(2000);
}

Select your Board and Port and click Upload. Open the serial monitor after the upload completes with the baud set to 115200 to watch motion data print out.

Move the sensor around in different directions and watch the acceleration data change with the motion.

Example 6: Qwiic Atmospheric Sensor (BME280)

Library Installation

We've written a library to easily get setup and take readings from the Qwiic Atmospheric Sensor, which you can install through the Arduino Library Manager. Search for SparkFun BME280 Arduino Library and you should be able to install the latest version. If you prefer manually downloading the libray from the GitHub repository, you can grab it here:

Hardware Hookup

Plug one end of the Qwiic connector into the Qwiic port on the breakout board, and the other end into the Qwiic connector on the Arduino Uno R4 WiFi board like so:

Software Example

This basic example configures an BME280 on the I²C bus and reports out the data to the Serial Monitor at a baud rate of 115200 baud.

language:c
/*
  Get basic environmental readings from the BME280
  By: Nathan Seidle
  SparkFun Electronics
  Date: March 9th, 2018
  License: This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license).

  Feel like supporting our work? Buy a board from SparkFun!
  https://www.sparkfun.com/products/14348 - Qwiic Combo Board
  https://www.sparkfun.com/products/13676 - BME280 Breakout Board

  This example shows how to read humidity, pressure, and current temperature from the BME280 over I2C.

  Hardware connections:
  BME280 -> Arduino
  GND -> GND
  3.3 -> 3.3
  SDA -> A4
  SCL -> A5
*/

#include <Wire.h>

#include "SparkFunBME280.h"
BME280 mySensor;

void setup()
{
  Serial.begin(115200);
  Serial.println("Reading basic values from BME280");

  Wire1.begin();

  if (mySensor.beginI2C(Wire1) == false) //Begin communication over I2C
  {
    Serial.println("The sensor did not respond. Please check wiring.");
    while(1); //Freeze
  }
}

void loop()
{
  Serial.print("Humidity: ");
  Serial.print(mySensor.readFloatHumidity(), 0);

  Serial.print(" Pressure: ");
  Serial.print(mySensor.readFloatPressure(), 0);

  Serial.print(" Alt: ");
  //Serial.print(mySensor.readFloatAltitudeMeters(), 1);
  Serial.print(mySensor.readFloatAltitudeFeet(), 1);

  Serial.print(" Temp: ");
  //Serial.print(mySensor.readTempC(), 2);
  Serial.print(mySensor.readTempF(), 2);

  Serial.println();

  delay(50);
}

Select your Board and Port and click Upload. Open the serial monitor after the upload completes with the baud set to 115200 to watch data print out.

Troubleshooting

Resources and Going Further

This is a basic guide to get you started with your SparkFun Arduino UNO R4 WiFi Kit. For more information, check out the resources below:

Qwiic LED Button

• Schematic (PDF)
• Eagle Files (ZIP)
• Board Dimensions (PNG)
• Qwiic Button Arduino Library
• GitHub Hardware Repo

Qwiic Twist

• Schematic (PDF)
• Eagle (ZIP)
• Qwiic Twist Register Map
• SparkFun Qwiic Twist Arduino Library
• GitHub Hardware Repo - For Qwiic Twist that includes the firmware for the ATtiny84

Qwiic OLED

• Schematic (PDF)
• Eagle Files (ZIP)
• Quick Start Guide
• SparkFun Arduino Library

Qwiic Ambient Light Sensor (VEML6030)

• Schematic (PDF)
• Eagle Files (ZIP)
• Datasheet (PDF)
• SparkFun Ambient Light Sensor Arduino LIbrary
• GitHub Hardware Repo

Triple Axis Accelerometer Breakout - BMA400 (Qwiic)

• Schematic (PDF)
• Eagle Files (ZIP)
• Board Dimensions (PNG)
• Datasheet (BMA400)
• BMA400 Arduino Library
• GitHub Hardware Repo

Qwiic Atmospheric Sensor (BME280)

• Schematic (PDF)
• Eagle Files (ZIP)
• BME280 Datasheet
• SparkFun BME280 Arduino Library
• GitHub Hardware Repo

Need help getting started with Arduino and I²C? Check out these resources:

• Arduino I²C Scanner Example
• Arduino Wire Library Reference Page
• Arduino Wire Library (In-Depth) Reference
• Qwiic Info Page

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

FavoritedFavorite1

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.

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

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

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)

In stock SEN-22638

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

$9.95

FavoritedFavorite3

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

FavoritedFavorite1

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 <Wire.h>  // 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

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

FavoritedFavorite7

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.

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 resolution
- logic is reversed due to the transistors

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.

/*
12V RGB LED Nightlight Example

Turns an 12V RGB strip LED on or off based on the light level read by a photoresistor.
Change colors by turning the potentiometer. This example is based off the SparkFun
Inventor's Kit v4.2 RGB Night-Light Example:

  https://learn.sparkfun.com/tutorials/sparkfun-inventors-kit-experiment-guide---v41

Note 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 redifined
  - threshold was modified due to the ADC's higher resolution
  - logic is reversed due to the transistors

WARNING: Since the IoT RedBoard with ESP32 has a system voltage of 3.3V, the logic levels
is 3.3V instead of 5V on the RedBoard with ATmega328P. Thus, the analog reference voltage
for the potentiometer and photoresistor is 3.3V. Make sure you are using 3.3V!

This sketch was written by SparkFun Electronics, with lots of help from the Arduino community.
This code is completely free for any use.

*/

int photoresistor = A4;          //variable for storing the photoresistor value
int potentiometer = A5;          //this variable will hold a value based on the position of the knob
int threshold = 3000;            //if the photoresistor reading is lower than this value the light will turn on
                             /*Note: The ESP32's ADC resolution is bigger. The max is 4095. In a bright room
                             with your finger covering the sensor, the threshold was about 3000. In a dimly
                             lit room, the threshold was about 1000. You will need to adjust this value when
                             installing it in a room. Just make sure to make it a little more than the thresholed
                             of the room. Try adding a button and some code  to save the threshold value! */

//LEDs are connected to these pins
int RedPin = 16;
int GreenPin = 17;
int BluePin = 25;

void setup() {
Serial.begin(115200);           //start a serial connection with the computer
Serial.println("12V RGB LED Strip Nightlight!");

//set the LED pins to output
pinMode(RedPin, OUTPUT);
pinMode(GreenPin, OUTPUT);
pinMode(BluePin, OUTPUT);

} //END SETUP

void loop() {

photoresistor = analogRead(A4);         //read the value of the photoresistor
potentiometer = analogRead(A5);         //read the value of the potentiometer

Serial.print("Photoresistor value:");
Serial.print(photoresistor);          //print the photoresistor value to the serial monitor
Serial.print("  Potentiometer value:");
Serial.println(potentiometer);          //print the potentiometer value to the serial monitor

if (photoresistor < threshold) {        //if it's dark (the photoresistor value is below the threshold) turn the LED on
//These nested if statements check for a variety of ranges and
//call different functions based on the current potentiometer value.
//Those functions are found at the bottom of the sketch.

/*Note: We divided 4095 by 7 colors and had a window of about 585. For users
        Adding more colors, try dividing 4095 by the total number and adjust
        eac condition statement*/

if (potentiometer > 0 && potentiometer <= 585)
  red();
if (potentiometer > 585 && potentiometer <= 1170)
  orange();
if (potentiometer > 1170 && potentiometer <= 1755)
  yellow();
if (potentiometer > 1755 && potentiometer <= 2340)
  green();
if (potentiometer > 2340 && potentiometer <= 2925)
  cyan();
if (potentiometer > 2925 && potentiometer <= 3510)
  blue();
if (potentiometer > 3510)
  magenta();
}
else {                                //if it isn't dark turn the LED off

turnOff();                            //call the turn off function

}

delay(100);                             //short delay so that the printout is easier to read

} //END LOOP

void red () {

//set the LED pins to values that make red
analogWrite(RedPin, 0);
analogWrite(GreenPin, 255);
analogWrite(BluePin, 255); 
}
void orange () {

//set the LED pins to values that make orange
analogWrite(RedPin, 0);
analogWrite(GreenPin, 128);
analogWrite(BluePin, 255);
}
void yellow () {

//set the LED pins to values that make yellow
analogWrite(RedPin, 0);
analogWrite(GreenPin, 0);
analogWrite(BluePin, 255);
}
void green () {

//set the LED pins to values that make green
analogWrite(RedPin, 255);
analogWrite(GreenPin, 0);
analogWrite(BluePin, 255);
}
void cyan () {

//set the LED pins to values that make cyan
analogWrite(RedPin, 255);
analogWrite(GreenPin, 0);
analogWrite(BluePin, 0);
}
void blue () {

//set the LED pins to values that make blue
analogWrite(RedPin, 255);
analogWrite(GreenPin, 255);
analogWrite(BluePin, 0);
}
void magenta () {

//set the LED pins to values that make magenta
analogWrite(RedPin, 0);
analogWrite(GreenPin, 255);
analogWrite(BluePin, 0);
}
void turnOff () {

//set all three LED pins to 0 or OFF
analogWrite(RedPin, 255);
analogWrite(GreenPin, 255);
analogWrite(BluePin, 255);
}  

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 MOSFET Power Switch & Buck Regulator with the wall adapter. Cover the photoresistor with your finger (or just turn off the lights in the room) and turn the potentiometer. You should notice the colors cycling through as the potentiometer is within certain ranges. You will probably want to 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. That way you can view the serial data and adjust the threshold value based on the lighting in the room.

Now that we have ported the example from the RedBoard Qwiic with an ATmega328P to the RedBoard IoT Development Board - ESP32, try adjusting the condition statement with the potentiometer to add additional colors. Or even writing some code save the threshold value whenever a button is pressed down. You can also try to take advantage of the ESP32's wireless capabilities and adjust the color of the LED strip based on the weather.

Going Further and Other Resources

There are more examples in the Arduino Library that allow you to control a Squirrel Cage Blower to make a little "magic," as well. 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

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

FavoritedFavorite13

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

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)

20 available 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

FavoritedFavorite10

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

FavoritedFavorite18

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

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

SFE_MMC5983MA myMag;

// Here's where we set up the servos

#include <Servo.h>
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(&currentX, &currentY, &currentZ);

    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

FavoritedFavorite91

Wish List

added to your cart!

SparkFun RedBoard Plus

In stock 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

FavoritedFavorite26

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

FavoritedFavorite5

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.

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.

• 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 <SparkFun_Qwiic_Buzzer_Arduino_Library.h>  // 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 <SparkFun_Qwiic_Buzzer_Arduino_Library.h>
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

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

FavoritedFavorite7

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

#include <SparkFun_Alphanumeric_Display.h> //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 <Wire.h>

#include <SparkFun_Alphanumeric_Display.h>  //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 <Wire.h>

#include <SparkFun_Alphanumeric_Display.h>  //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 <Wire.h>

#include <SparkFun_Alphanumeric_Display.h>  //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 <Wire.h>

#include <SparkFun_Alphanumeric_Display.h>  //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

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

3

FavoritedFavorite53

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

3

FavoritedFavorite53

Wish List

added to your cart!

Experiential Robotics Platform (XRP) Kit - Beta

Out of stock KIT-22230

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

$114.95

FavoritedFavorite65

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

FavoritedFavorite63

Wish List

added to your cart!

Flexible Qwiic to STEMMA Cable - 500mm

Out of stock CAB-25596

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

$2.10

FavoritedFavorite3

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

FavoritedFavorite43

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

FavoritedFavorite23

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 USB, navigate to the XRPCode editor, and connect to your XRP. For usage information, see the XRPCode User Guide.

Upload the example files into the root directory (/), or directory of your choice, on the XRP. Begin by finding the Upload to XRP option:

Select the files to upload:

Select the root directory (/), or directory of your choice, on the XRP:

Click the OK button and wait for the files to upload and save:

You should then see the examples in the Filesystem panel on the left:

Example 1: Basic Readings

This first example just does some basic measurements to make sure everything is hooked up correctly. Assuming you uploaded this example in the procedure above, double-click qwiic_otos_ex1_basic_readings.py in the Filesystem panel on the left:

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

#!/usr/bin/env python
#-------------------------------------------------------------------------------
# qwiic_otos_ex1_basic_readings.py
#
# 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.
#-------------------------------------------------------------------------------
# Written by SparkFun Electronics, May 2024
#
# This python library supports the SparkFun Electroncis Qwiic ecosystem
#
# More information on Qwiic is at https://www.sparkfun.com/qwiic
#
# Do you like this library? Help support SparkFun. Buy a board!
#===============================================================================
# Copyright (c) 2023 SparkFun Electronics
#
# Permission is hereby granted, free of charge, to any person obtaining a copy 
# of this software and associated documentation files (the "Software"), to deal 
# in the Software without restriction, including without limitation the rights 
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
# copies of the Software, and to permit persons to whom the Software is 
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all 
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
# SOFTWARE.
#===============================================================================

import qwiic_otos
import sys
import time

def runExample():
    print("\nQwiic OTOS Example 1 - Basic Readings\n")

    # Create instance of device
    myOtos = qwiic_otos.QwiicOTOS()

    # Check if it's connected
    if myOtos.is_connected() == False:
        print("The device isn't connected to the system. Please check your connection", \
            file=sys.stderr)
        return

    # Initialize the device
    myOtos.begin()

    print("Ensure the OTOS is flat and stationary during calibration!")
    for i in range(5, 0, -1):
        print("Calibrating in %d seconds..." % i)
        time.sleep(1)

    print("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()

    # Main loop
    while True:
        # Get the latest position, which includes the x and y coordinates, plus
        # the heading angle
        myPosition = myOtos.getPosition()

        # Print measurement
        print()
        print("Position:")
        print("X (Inches): {}".format(myPosition.x))
        print("Y (Inches): {}".format(myPosition.y))
        print("Heading (Degrees): {}".format(myPosition.h))

        # Wait a bit so we don't spam the serial port
        time.sleep(0.5)

        # Alternatively, you can comment out the print and delay code above, and
        # instead use the following code to rapidly refresh the data
        # print("{}\t{}\t{}".format(myPosition.x, myPosition.y, myPosition.h))
        # time.sleep(0.01)

if __name__ == '__main__':
    try:
        runExample()
    except (KeyboardInterrupt, SystemExit) as exErr:
        print("\nEnding Example")
        sys.exit(0)

Then click the run button in the top right corner:

You should see the following output in the Shell:

Move the sensor around to see how the coordinates change!

Example 2: Set Units

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. Assuming you uploaded this example in the procedure above, double-click qwiic_otos_ex2_set_units.py in the Filesystem panel on the left:

Alternatively, you can expand the link below and copy and paste the code into a shiny new file and upload to the XRP as described above.

#!/usr/bin/env python
#-------------------------------------------------------------------------------
# qwiic_otos_ex2_set_units.py
#
# 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.
#-------------------------------------------------------------------------------
# Written by SparkFun Electronics, May 2024
#
# This python library supports the SparkFun Electroncis Qwiic ecosystem
#
# More information on Qwiic is at https://www.sparkfun.com/qwiic
#
# Do you like this library? Help support SparkFun. Buy a board!
#===============================================================================
# Copyright (c) 2023 SparkFun Electronics
#
# Permission is hereby granted, free of charge, to any person obtaining a copy 
# of this software and associated documentation files (the "Software"), to deal 
# in the Software without restriction, including without limitation the rights 
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
# copies of the Software, and to permit persons to whom the Software is 
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all 
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
# SOFTWARE.
#===============================================================================

import qwiic_otos
import sys
import time

def runExample():
    print("\nQwiic OTOS Example 2 - Set Units\n")

    # Create instance of device
    myOtos = qwiic_otos.QwiicOTOS()

    # Check if it's connected
    if myOtos.is_connected() == False:
        print("The device isn't connected to the system. Please check your connection", \
            file=sys.stderr)
        return

    # Initialize the device
    myOtos.begin()

    print("Ensure the OTOS is flat and stationary during calibration!")
    for i in range(5, 0, -1):
        print("Calibrating in %d seconds..." % i)
        time.sleep(1)

    print("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(myOtos.kLinearUnitMeters)
    # myOtos.setLinearUnit(myOtos.kLinearUnitInches)
    myOtos.setAngularUnit(myOtos.kAngularUnitRadians)
    # myOtos.setAngularUnit(myOtos.kAngularUnitDegrees)

    # 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()

    # Main loop
    while True:
        # Get the latest position, which includes the x and y coordinates, plus
        # the heading angle
        myPosition = myOtos.getPosition()

        # Print measurement
        print()
        print("Position:")
        print("X (Meters): {}".format(myPosition.x))
        print("Y (Meters): {}".format(myPosition.y))
        print("Heading (Radians): {}".format(myPosition.h))

        # Wait a bit so we don't spam the serial port
        time.sleep(0.5)

if __name__ == '__main__':
    try:
        runExample()
    except (KeyboardInterrupt, SystemExit) as exErr:
        print("\nEnding Example")
        sys.exit(0)

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

Then click the run button in the top right corner:

You should see the following output in the Shell:

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. Assuming you uploaded this example in the procedure above, double-click qwiic_otos_ex3_calibration.py in the Filesystem panel on the left:

Alternatively, you can expand the link below and copy and paste the code into a shiny new file and upload to the XRP as described above.

#!/usr/bin/env python
#-------------------------------------------------------------------------------
# qwiic_otos_ex3_calibration.py
#
# 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.
#-------------------------------------------------------------------------------
# Written by SparkFun Electronics, May 2024
#
# This python library supports the SparkFun Electroncis Qwiic ecosystem
#
# More information on Qwiic is at https:#www.sparkfun.com/qwiic
#
# Do you like this library? Help support SparkFun. Buy a board!
#===============================================================================
# Copyright (c) 2023 SparkFun Electronics
#
# Permission is hereby granted, free of charge, to any person obtaining a copy 
# of this software and associated documentation files (the "Software"), to deal 
# in the Software without restriction, including without limitation the rights 
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
# copies of the Software, and to permit persons to whom the Software is 
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all 
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
# SOFTWARE.
#===============================================================================

import qwiic_otos
import sys
import time

def runExample():
    print("\nQwiic OTOS Example 3 - Calibration\n")

    # Create instance of device
    myOtos = qwiic_otos.QwiicOTOS()

    # Check if it's connected
    if myOtos.is_connected() == False:
        print("The device isn't connected to the system. Please check your connection", \
            file=sys.stderr)
        return

    # Initialize the device
    myOtos.begin()

    print("Ensure the OTOS is flat and stationary during calibration!")
    for i in range(5, 0, -1):
        print("Calibrating in %d seconds..." % i)
        time.sleep(1)

    print("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)
    # done = False
    # while(done == False):
    #     # Check how many samples remain
    #     samplesRemaining = myOtos.getImuCalibrationProgress()

    #     # 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()

    # Main loop
    while True:
        # Get the latest position, which includes the x and y coordinates, plus
        # the heading angle
        myPosition = myOtos.getPosition()

        # Print measurement
        print()
        print("Position:")
        print("X (Inches): {}".format(myPosition.x))
        print("Y (Inches): {}".format(myPosition.y))
        print("Heading (Degrees): {}".format(myPosition.h))

        # Wait a bit so we don't spam the serial port
        time.sleep(0.5)

if __name__ == '__main__':
    try:
        runExample()
    except (KeyboardInterrupt, SystemExit) as exErr:
        print("\nEnding Example")
        sys.exit(0)

Then click the run button in the top right corner:

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.

Assuming you uploaded this example in the procedure above, double-click qwiic_otos_ex4_set_offsets_and_position.py in the Filesystem panel on the left:

Alternatively, you can expand the link below and copy and paste the code into a shiny new file and upload to the XRP as described above.

#!/usr/bin/env python
#-------------------------------------------------------------------------------
# qwiic_otos_ex4_set_offsets_and_position.py
#
# 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.
#-------------------------------------------------------------------------------
# Written by SparkFun Electronics, May 2024
#
# This python library supports the SparkFun Electroncis Qwiic ecosystem
#
# More information on Qwiic is at https:#www.sparkfun.com/qwiic
#
# Do you like this library? Help support SparkFun. Buy a board!
#===============================================================================
# Copyright (c) 2023 SparkFun Electronics
#
# Permission is hereby granted, free of charge, to any person obtaining a copy 
# of this software and associated documentation files (the "Software"), to deal 
# in the Software without restriction, including without limitation the rights 
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
# copies of the Software, and to permit persons to whom the Software is 
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all 
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
# SOFTWARE.
#===============================================================================

import qwiic_otos
import sys
import time

def runExample():
    print("\nQwiic OTOS Example 4 - Set Offsets and Position\n")

    # Create instance of device
    myOtos = qwiic_otos.QwiicOTOS()

    # Check if it's connected
    if myOtos.is_connected() == False:
        print("The device isn't connected to the system. Please check your connection", \
            file=sys.stderr)
        return

    # Initialize the device
    myOtos.begin()

    print("Ensure the OTOS is flat and stationary during calibration!")
    for i in range(5, 0, -1):
        print("Calibrating in %d seconds..." % i)
        time.sleep(1)

    print("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).
    offset = qwiic_otos.Pose2D(-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.
    currentPosition = qwiic_otos.Pose2D(0, 0, 0)
    myOtos.setPosition(currentPosition)

    # Main loop
    while True:
        # Get the latest position, which includes the x and y coordinates, plus
        # the heading angle
        myPosition = myOtos.getPosition()

        # Print measurement
        print()
        print("Position:")
        print("X (Inches): {}".format(myPosition.x))
        print("Y (Inches): {}".format(myPosition.y))
        print("Heading (Degrees): {}".format(myPosition.h))

        # Wait a bit so we don't spam the serial port
        time.sleep(0.5)

if __name__ == '__main__':
    try:
        runExample()
    except (KeyboardInterrupt, SystemExit) as exErr:
        print("\nEnding Example")
        sys.exit(0)

Then click the run button in the top right corner:

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 GitHub Repo!

Going Further and Other Resources

Below are a few tutorials that may help users familiarize themselves with various aspects of the board.

The SparkFun Optical Tracking Odometry Sensor - PAA5160E1 (Qwiic) takes advantage of the Qwiic connect system. We recommend familiarizing yourself with the Logic Levels and I2C tutorials. Click on the banner above to learn more about Qwiic products.

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