RedBoard Qwiic Hookup Guide

Pages
Favorited Favorite 0

Introduction

The SparkFun RedBoad Qwiic is the newest edition of the Arduino-compatible development platforms in the SparkFun catalog. This updated version of the classic SparkFun RedBoard incorporates a few key improvements over its predecessor (see Hardware Overview). However, like the original SparkFun RedBoard, it is designed to be an easy-to-use learning platform for coding, physical computing, and project prototyping. These skills are becoming increasingly significant in today's education and the technological community.

SparkFun RedBoard Qwiic

SparkFun RedBoard Qwiic

DEV-15123
$19.95

This tutorial aims to familiarize you with the new SparkFun RedBoad Qwiic and help you get started using it. To begin, we will go over the hardware and features of the board. Next, this we'll guide you through the installation of the Arduino IDE (Integrated Development Environment) software, the main user interface for programming the board. Finally, we will walk you through a few examples using the Arduino IDE.

The SparkFun RedBoad Qwiic can interact with real-world sensors, control motors, display information, and perform near-instantaneous calculations. It enables anyone to create unique, nifty projects from something as simple as displaying characters on an LCD display or detecting changes in light to vastly more complicated projects like an IoT cellular device (Not recommend for beginners... start with something simpler and work your way up.). If you're familiar with how the original SparkFun RedBoard worked, you may want to skim over parts of this tutorial.

Required Materials/ Tools

To get started, all you need is a few things:

  • SparkFun RedBoad Qwiic - You definitely need this; otherwise, you are on the wrong tutorial page.
  • USB micro-B Cable - 6 Foot - The USB interface serves two purposes: it powers the board and allows you to upload programs to it.
  • Computer with the Arduino IDE installed on it - That is how we will program the board and interface with it.
    Troubleshooting Tip: If you are not a technical or computer savy individual and you have your choice of computers, a Windows 7 or 10 computer is highly recommended. You will usually run into the the least issues, if any, with these operating systems.

That is ALL... pretty simple right? Now you won't be able to do much since there are no additional sensors to interact with the physical world. However, you can at least blink an LED and do some math calculations.

Click the buttons above to toggle the additional materials based on the tasks you
wish to perform. Feel free to modify the items in your cart to fit your needs.


Jumper Modification

If you would like to modify the 3.3V/5V I/O jumper or A4/A5 Qwiic connector jumpers, you will need soldering equipment and/or a knife.

Solder Lead Free - 100-gram Spool

Solder Lead Free - 100-gram Spool

TOL-09325
$7.95
7
Weller WLC100 Soldering Station

Weller WLC100 Soldering Station

TOL-14228
$44.95
Chip Quik No-Clean Flux Pen  - 10mL

Chip Quik No-Clean Flux Pen - 10mL

TOL-14579
$7.95
1
Hobby Knife

Hobby Knife

TOL-09200
$2.95
2

Qwiic Example

If you would like to follow along with the examples below to interact with the physical world, you will also need the following items:

SparkFun Distance Sensor Breakout - 4 Meter, VL53L1X (Qwiic)

SparkFun Distance Sensor Breakout - 4 Meter, VL53L1X (Qwiic)

SEN-14722
$21.95
5
Qwiic Cable - 100mm

Qwiic Cable - 100mm

PRT-14427
$1.50

Suggested Reading

The SparkFun RedBoad Qwiic aims to be a beginner-friendly microcontroller platform. You can get started without an innate knowledge of Ohm's Law or How Electricity Works (but a little understanding wouldn't hurt!). The following are some subjects you should be familiar with; however, to use the more advanced features of the board, it is recommended that you read up on the Logic Levels and I2C tutorials.

What is a Circuit?

Every electrical project starts with a circuit. Don't know what a circuit is? We're here to help.

What is an Arduino?

What is this 'Arduino' thing anyway?

Logic Levels

Learn the difference between 3.3V and 5V devices and logic levels.

I2C

An introduction to I2C, one of the main embedded communications protocols in use today.

One of the new, advanced features of the board is that it takes advantage of the Qwiic connect system. We recommend familiarizing yourself with the Logic Levels and I2C tutorials (above) before using it, as all Qwiic sensors utilize an I2C communication protocol.

Qwiic Connect System
Qwiic Connect System
Fun Fact: Qwiic is a play on words between "quick" and I2C or "iic".

Installing Drivers

The SparkFun RedBoard Qwiic uses a USB-to-Serial adapter based on the CH340C IC from WCH. The driver for the CH340C chip should automatically install on most operating systems. The driver allows your computer to recognize the SparkFun RedBoard Qwiic as a device and lets it communicate with the board over the USB connection.

The SparkFun RedBoard Qwiic has been tested on Windows 7, Windows 10, Mac OSX High Sierra, and Raspbian Stretch (11-13-2018 release) for the Raspberry Pi. However, there is a wide range of operating systems out there; you may need to manually install your driver or delete/uninstall your old driver before updating to the new driver. We’ve also written a separate SparkFun Serial Basic CH340C Hookup Guide in case you run into issues.

Click the buttons above for further instructions on verifying
that your computer recognizes your board or updating your old drivers.

Driver Verification

To verify that your driver is working, you should see the difference in the following pictures after plugging in your SparkFun RedBoard Qwiic. Alternatively, once you have the Arduino IDE installed, you should also see a change in the number of available Serial/COM Ports (you may need to restart the Arduino IDE for the board to populate).

Windows

Check that the board shows up in your device manager. You can click the Start or (Windows) button and type "device" to quickly search for the application. (*On Windows 10, the quick search function is picky on the spelling of the application you are searching for. For example, you may get results using "devi" and none for "device".)

Windows 10 Device Manager Window
Screenshot of Window 10 Device Manager with RedBoard (Qwiic) on COM42. Click to enlarge.

Mac OSX

Open the Terminal and run the following command "ls /dev/cu*" in the Terminal and check for the following changes (your board may show up under a different device name). To open the Terminal, open your Applications folder, Utilities folder, then double-click on Terminal. Otherwise, press (Command) + space bar (Space Bar) to launch Spotlight and type "Terminal," then double-click the search result.

Mac OSX CLI Command Entry
Screenshot of Mac OSX terminal with RedBoard (Qwiic) on cu.wchusbserialfd1410. Click to enlarge.

ls /dev/cu*
Note: If you are still unsure of how to access the Terminal, watch this video or read this Apple support article.

Raspbian

Run the following command "ls /dev/ttyUSB*" in the CLI/Terminal and check for the following changes (your board may show up under a different device name).

Raspbian CLI Command Entry
Screenshot of Raspberry Pi CLI with RedBoard (Qwiic) on ttyUSB0. Click to enlarge

ls /dev/ttyUSB*

Updating Drivers

The CH340C is made by WCH. You can find the latest version of their drivers here, but most of their pages are in Mandarin. If you use a Chrome web browser, you should have the option to have the web page translated.

If you have the older CH340 drivers installed, you may need to update them. Below are the instructions for doing so on each of the tested operating systems:

Windows 7/10

Download and run the executable. Click the "Uninstall" button first, followed by the "Install" button.

Win 10 Installation Screenshot
Windows CH340 Driver Installation

Mac OSX

Run the following commands in the CLI/Terminal before installing the new drivers:

rm -rf /System/Library/Extensions/usb.kext
rm -rf /System/Library/Extensions/usbserial.kext
Note:
To open the Terminal, open your Applications folder, Utilities folder, then double-click on Terminal. Otherwise, press (Command) + space bar (Space Bar) to launch Spotlight and type "Terminal," then double-click the search result.

If you are still unsure of how to access the Terminal, watch this video or read this Apple support article.
Download and extract the folder. Then, open the ".pkg" file from the unzipped folder.

Mac OSX Installation Screenshot
Mac OSX CH340 Driver Installation File

Raspbian

Run the following commands in the CLI/Terminal:

sudo apt-get upgrade
sudo apt-get update

Other Linux Distributions

Unfortunately, I do not have a Linux computer to test with, but here is the downloadable .zip folder for the CH340 driver.

Installing the Arduino IDE

Download/Install Arduino

You can download the Arduino IDE from their website. They have installation instructions, but we will also go over the installation process as well. Make sure you download the version that matches your operating system.

Click for Arduino IDE Download Page

The installation procedure is fairly straightforward, but it does vary by OS. Here are some tips to help you along. We've also written a separate Installing Arduino tutorial in case you get stuck.

Troubleshooting Tips:
  • We recommend using a computer with a full desktop operating system like Windows 7/10 (avoid Windows 8 if you can), Mac OSX, and certain flavors Linux (check the Arduino FAQ page for compatibility).

    • If you are not a technical or computer savy individual and you have your choice of computers, I highly recommend using a Windows 7 or 10 computer. You will usually run into the the least issues, if any, with these operating systems.

  • We do NOT recommend using a Chromebook, Netbook, tablet, phone, or the Arduino Web IDE in general. You will be responsible for troubleshooting any driver or Arduino Web IDE issues.

  • As of writing this tutorial (12-14-2018), the most recent and stable release of the Arduino IDE is version 1.8.5. We recommend using that version of the Arduino IDE; you can download the previous releases here.

  • On Windows 10, we do NOT recommend installing the Arduino IDE from the app store. You may run into issues because the OS will automatically update to the most recent release of the Arduino IDE, which may have unknown bugs (like the compiler errors in versions 1.8.6 and 1.8.7).

  • Raspberry Pi users with Raspbian installed should use the Linux ARM download. We do not recommend using the command line installation. It will install the oldest release of Arduino, which is useless when it comes to installing new boards definitions or libraries.

  • For additional troubleshooting tips, here is a troubleshooting guide from Arduino.

Click the buttons above for OS specific instructions.

Windows Install Tips

The Windows version of Arduino is offered in two options: an installer or a zip file. The installer is the easier of the two options, just download that, and run the executable file to begin the installation.

Windows 10- Arduino Installation Diagram
Windows install steps. Click the image to get a bigger view.

When you're prompted to install a driver during installation, select "Install". This will install drivers for Arduino specific boards (like the Uno, Nano, etc.) that you may use in the future.

  • If you choose to download the zip file version of Arduino, you'll need to extract the files yourself. Don't forget which folder you extract the files into! You will need to run the executable Arduino file in the folder to start the Arduino IDE.

  • On Windows 10, there is an option to install Arduino through their app store. we do not recommend installing the Arduino IDE from the app store. You may run into issues because the OS will automatically update to the most recent release of the Arduino IDE, which may have unknown bugs.

Mac Install Tips

The Mac download of Arduino is only offered in a zip file version. After the download is finished, simply double-click the .zip file to unzip it.

Mac Install Screenshot
Mac OSX Arduino.app

Following that, you'll need to copy the Arduino application into your applications folder to complete the installation.

Linux Install Tips

As Linux users are no doubt aware, there are many flavors of Linux out there, each with unique installation routines. Check out the FAQ section of the Arduino webpage for more details. Otherwise, you can also use the Linux section of our Installing Arduino tutorial for some helpful links for an assortment of Linux distributions.
Raspbian Stretch
Raspberry Pi users with Raspbian installed should use the Linux ARM download. Do not use the command line installation process. For more information, please refer to this blog post from Arduino.
Ubuntu and Debian
For Ubuntu and Debian users, installing Arduino should only need a simple "apt-get" command like:

sudo apt-get update && sudo apt-get install arduino arduino-core
Other Distributions
Other Linux distros aren't too dissimilar from the Ubuntu and Debian instructions.


With Arduino downloaded and installed, the next step is to plug the board in and test it out! Pretty soon you'll be blinking LEDs, reading buttons, and doing some physical computing!


Hardware Overview

Below is an annotated image, and an overview of all of the important features for the SparkFun RedBoard Qwiic:

Annotated image of RedBoard

Click the buttons below for more details.

New Features

The new features of the SparkFun RedBoard Qwiic include:
  • An updated Serial-USB Converter Chip
  • An improved AP2112 Voltage Regulator
  • A Qwiic Connector
  • Available A4/A5 Jumpers
  • Available Voltage Level Jumpers
  • An improved Reset Button
  • RX/TX LED color change
Annotated image of new features
New features of RedBoard Qwiic.

Serial-USB Converter Chip

The new CH340C IC allows the SparkFun RedBoard Qwiic to utilize the USB micro-B connection and should reduce the need for users to manually install drivers. Newer operating systems should automatically recognize and install the drivers for the board.

AP2112 Voltage Regulator

The AP2112 is a more robust 3.3V regulator to provide more power to daisy chain multiple Qwiic devices. Unlike the MIC5205, which could only source about 150mA of current; the AP2112 can source up to 600mA of current and should be able to handle most of your Qwiic device needs.

Qwiic Connector

This connector allows the SparkFun RedBoard Qwiic to seamlessly interface with SparkFun's Qwiic Ecosystem.

A4/A5 Jumpers

Pins A4 and A5 are tied directly to the I2C bus. These jumpers can be used to disconnect the logic level converters from pins A4 and A5 so that they might be used independently from the Qwiic system for analog readings.

Voltage Level Jumpers

These jumpers allow users to easily switch from a 3.3V to 5V board. This allows the user to convert the board (and I/O pins) to either 3.3V or 5V based on their needs. Unlike the the original SparkFun RedBoard, you no longer need a logic level converter to interface directly to a 3.3V device or sensor.

Reset Button

The board also includes a new, more pronounced reset button that is easier to push. Anyone with "fat fingers" can relate to this struggle.
Reset Button Comparison
The more ergonomic reset button that is easier to press.

RX/TX LEDs

The TX LED is now green, instead of yellow and the RX LED is now yellow, instead of red.

Dimensions

The dimensions for the board are approximately 2.7" x 2.1". The board uses female headers laid out in a standard configuration for Arduino shields. The barrel jack for power uses a standard 5.5mm outer diameter and 2.1mm inner diameter mating connection. The Qwiic connector uses a 4-pin JST SH type connector. There are also 4 mounting points on the board.

RedBoard Qwiic Dimensions
Screen shot of RedBoard Qwiic board layout in Eagle. (Click image to enlarge.)

For the more details on the board sizing and component placement please refer to the Eagle files provided.

Download Eagle Files (ZIP)

Eagle is a free for educators, makers, and hobbyists (i.e. basically, anything not for commercial purposes). All measurements are accurate, excluding any manufacturing tolerances. (Unfortunately, we do not have this information available; you may need to just measure the board you purchase.)

Microcontroller

The microcontroller (ATmega328 IC) is the work horse of the SparkFun RedBoard Qwiic. The ATmega328 is an 8-bit AVR microcontroller manufactured by Atmel, now Microchip. Once an Arduino sketch is uploaded to the board, the program is stored in the memory of the ATmega328. The microcontroller will then run/execute the program while the SparkFun RedBoard Qwiic is powered.

ATmega328
Image of the ATmega328 IC.

Clock

An external 16 MHz crystal is used as the clock for the ATmega328.

Memory

The ATmega328 has Flash, SRAM (Static Random Access Memory), and EEPROM (Electrically Erasable Programmable Read-Only Memory) memory.

  • 32KB Flash Memory - where the Arduino sketch/program is stored (including the 512 byte Optiboot bootloader).
  • 2KB SRAM - where the sketch/program creates and manipulates variables when it runs.
  • 1KB EEPROM - is available for stable long-term storage (read/written with the EEPROM library).
The Flash and EEPROM memory are non-volatile; the data is still stored even when the board is no longer powered. The SRAM, on the other hand, is volatile and the data is only available while the board is powered.

Troubleshooting Tips:
  • The EEPROM can be corrupted with low power/brown out issues.
  • When you run out of SRAM, the sketch may fail or act strangely after it is uploaded. If you suspect this is the issue, try to comment out any long strings or large data structures. If the sketch starts to run normally, then you may need to modify your data requirements.

Bootloader

The Optiboot bootloader is a unique piece of firmware (512 bytes) at the end of the address space of the flash memory. The Optiboot bootloader is specifically configured for the ATmega328 to interface with the Arduino IDE, through a serial interface, to upload code. Without a bootloader, you would need to external programmer and program the microcontroller through the SPI interface (specifically, the ISP/ICSP headers).

For more details on the ATmega328, memory, and the bootloader check out these tutorials: You can also find the datasheet for the ATmega328 from the Microchip product page.

Power/Reset

The SparkFun RedBoard Qwiic can be powered via the USB and/or barrel jack connectors. If you choose to power it via USB, the other end of the USB cable can be connected to either a computer or a 5V (regulated) USB wall charger. Otherwise, should you choose to use the barrel jack, any wall adapter connected to this jack should supply a DC voltage between 7 and 15V.

Annotated image of power features
Annotated image of RedBoard Qwiic with power and reset features highlighted.

Power LED Indicator

Just to the right of the word RedBoard on your circuit board, there’s a tiny LED next to the word ON. This green LED should light up whenever you plug your Arduino into a power source. If this light doesn’t turn on, there’s a good chance something is wrong.

Reset Button

Just like the original Nintendo, the Arduino has a reset button. Pushing it will temporarily connect the reset pin to ground and restart any code that is loaded on the Arduino. This can be very useful if your code doesn’t repeat, but you want to test it multiple times. Unlike the original Nintendo however, blowing on the Arduino doesn’t usually fix any problems.
Reset Button Comparison
This updated version of the RedBoard has a more ergonomic reset button that is easier to press.

Barrel Jack for VIN

The barrel jack accepts a male, center-positive connector with a 5.5mm outer diameter and 2.1mm inner diameter. Check out this tutorial for more information on power connectors.

Our 9V and 12V power adapters are good choices if you're looking to power the board through the barrel jack. Any wall adapter connected to this jack should supply a DC voltage between 7 and 15V as specified by the electrical characteristics of the LM1117 voltage regulator used on the board. The input voltage pin VIN on the power headers is directly connected to the input voltage of the barrel jack.

Troubleshooting Tips:
The board could operate on an external supply of 6 to 20 volts, but the recommended range is 7 to 12 volts. (*If supplied with less than 7V, the 5V pin may supply less than five volts and the board may be unstable. Using more than 12V, the voltage regulator may overheat and damage itself and/or the board.)

For more technical details about voltage regulators and thermal dissipation, I suggest taking a look at these blog posts and tutorial:

USB

A USB micro-B cable is usually the easiest way to power the board, especially when you're programming it because the USB interface is required for uploading code too. A traditional USB port supplies a regulated 5V, but is limited to about 500mA (USB 2.0). Additionally, there is a fuse that protects your computer from shorts and overcurrent. If more than ~750mA is drawn through the USB port, it automatically throttles the current draw or disconnects power until the short/overload is removed. If you need more than that a barrel jack wall adapter is the best choice.
USB connection example
An example of how to pull USB cable straight out.
Troubleshooting Tip:
Users should take care NOT to pry or leverage on the connector when inserting/removing the USB cable. Doing so, WILL damage the board and cause the pads and/or traces to tear off as well. The cable should be removed by pulling straight outwards from the board.

The fuse can also be tripped with a high current draw and high ambient temperatures.

AP2112 Voltage Regulator

The AP2112 is a more robust 3.3V regulator to provide more power to daisy chain multiple Qwiic (I2C) devices. Unlike the MIC5205, which could only source about 150mA of current; the AP2112 can source up to 600mA of current and should be able to handle the needs of your Qwiic devices.

Troubleshooting Tip:
If you need more power for your Qwiic devices, you can attach a separate power supply. However, it is recommended that you cut the 3.3V line of the Qwiic cable to the SparkFun RedBoard Qwiic. Leave the GND line alone, as that ground loops your system, providing a consistent reference voltage for your I2C signals. By cutting the 3.3V line, this allows you to power all your devices without straining the 3.3V regulator. For more details on voltage regulators, check out this According to Pete blog post.

The Power Header

The power headers provides all your reference, input, and output, voltages.

Annotated image of power header
RedBoard Qwiic Power Header

  • VIN- The input voltage to the Arduino board when it's using an external power source. You can provide an external supply voltage through this pin or access the external supply voltage from the power jack through this pin. If only powered through a USB connection, voltage will be around 5V.
  • 5V- This pin outputs a regulated 5V from the regulator on the board. The board can be supplied with power either from the DC power jack (7 - 12V), the USB connector (5V), or the VIN pin of the board (7-12V). Supplying voltage via the 5V or 3.3V pins bypasses the regulator, and can damage your board. We don't advise it.
  • 3V3- A 3.3 volt supply generated by the on-board regulator. Maximum current draw is 600 mA.
  • GND- Ground pins.
  • RESET- This pin is tied to the Reset pin of the microcontroller and Reset Button. If this pin is toggled low or shorted to the GND pin, it will trigger a reset of the microcontroller.

Dual Power

It is fine to connect both a barrel jack and a USB connector at the same time. The SparkFun RedBoard Qwiic has power-control circuitry to automatically select the best power source.

USB and barrel jack wires connected

USB and barrel jack wires connected.

Status Indicator LEDs

There are 4 status LEDs on the SparkFun RedBoard Qwiic that indicate power, serial communication, and a test/status LED.

Annotated image of status LEDs
Status LEDs on the RedBoard Qwiic.
Note:
There is a small change to the color of ther status LEDs from the original RedBoard. The power LED is green, the LED for Pin 13 is blue, the RX LED is yellow, and the TX LED is green. However, the color of the LED's don't really matter, the indication is based on whether the LED is on/off. The color differences only help to indicate which LED is on when the LED is blinks quickly or from a quick glance.

Power

The first LED is the power LED. This LED indicates that there is a potential between the VCC and GND pins. A good secondary test for this status indicator is to use a multimeter to test the VIN, 5V, and 3.3V pins against the GND pin.

RX/TX

The next two status LEDs are the serial communication LEDs. These LEDs indicate that there is data moving between the serial UART RX/TX pins and the USB-to-Serial Converter. A good secondary test for this status indicator is to make sure that these LEDs are flashing during upload or any other serial communication.

Pin 13

The last indicator is the Pin 13 LED. This is typically only used as a test LED to make sure that a board is working or for basic debugging. However, for the SparkFun RedBoard Qwiic, this LED also indicates if the presence of the bootloader. If the board was properly flashed, the LED should flash a few times on power up.
Troubleshooting Tips:
  • New boards will come programmed with a test sketch that cycles between the RX and TX LEDs.
  • Pin 13 is difficult to use as a digital input because of the voltage drop from status LED and resistor soldered in series to it. If the pin is enabled as an input with the internal 20k pullup resistor, it will always read a LOW state; an expected 5V (HIGH) signal will instead read around 1.7V (LOW).

    If you must use pin 13 as a digital input, it is recommended that you set the pinMode() as an INPUT

    pinMode(13, INPUT);
    and use an external pulldown resistor.

Programming

There are two ways to program the SparkFun RedBoard Qwiic. The most common way for users is through the USB connection. The other slightly less common method is through the ISP headers or pins.

Annotated image of programming connections
RedBoard Qwiic programming connections.

USB Connection

The USB micro-B connector is the most convenient way to power and program the board. To program the board through the USB connection, you will need a USB micro-B cable and there must be a bootloader flashed to the microcontroller (factory "installed"). For the SparkFun SparkFun RedBoard Qwiic, this is the same Optiboot bootloader from the Arduino UNO. For most users, the board will be programmed through a USB connection using the Arduino IDE.

USB connection example
An example of how to pull USB cable straight out.
Troubleshooting Tip:
Users should take care NOT to pry or leverage on the connector when inserting/removing the USB cable. Doing so, WILL damage the board and cause the pads and/or traces to tear off as well. The cable should be removed by pulling straight outwards from the board.
CH340C USB-to-Serial Converter
Unlike the classic SparkFun RedBoard, that uses an FTDI IC; this board uses the CH340C IC for USB-to-serial conversion. One advantage is that it does not need a driver since most operating systems will have the drivers already installed. The chip is used to convert USB data coming to and from your computer into a serial protocol for the microcontroller.

Troubleshooting Tip:
  • Whenever you upload to your board or send serial data, you should seen the RX and/or TX LEDs flashing. The best way to test the functionality of this part is to send serial data between your computer and the board.
  • For more details on what happens in the Arduino IDE when code is uploaded through the bootloader, check out this great forum post.

For more tips and details on serial communication, read our Serial Communication and Terminal Basics tutorials.

ISP or ICSP Connector

A less common way for most users to program the microcontroller on their board, is to use the ISP header. This method programs a microcontroller directly through the SPI pins. A more experienced user, with a firm grasp on digital electronics and the microcontroller (datasheet), will probably use a software package like Atmel studio, which is easier to debug. The most common reasons for programming an AVR via an in-system programmer (ISP) are:
  • ISP is faster and more reliable- We use this method in our QC process for most boards.
  • There is no bootloader on the microcontroller or your board wasn't flashed properly:
    • This is probably the only way to program the microcontroller without a bootloader.
  • You want to use your own, custom bootloader.
  • Configure fuse bits for various settings.
  • Program without bootloader, when you need just a little bit more space for your program to load.
Most AVRs are programmed through a Serial Peripheral Interface (SPI). There are six unique signals required for communication between ISP and AVR.

top avr isp pinouts

AVR ISP Pinouts – Top View.

On the SparkFun RedBoard Qwiic the MOSI and D11 pins, MISO and D12 pins, and SCK and D13 pins are tied together. To program the SparkFun RedBoard Qwiic through the ISP pins, you will want to set the I/O jumper to 5V. This will tie the VCC of the microcontroller to the 5V rail//pin of the ISP header. Otherwise, you will probably run into issues and likely damage the I/O pins and/or the microcontoller chipset.

Troubleshooting Tip: Re-flashing the Bootloader
Often, this method is used as a last ditch effort, when after all else has failed to revive a board (do not attempt, unless you know what you are doing). Most likely your board isn’t bricked unless you have done something drastic like modified the fuses. In which case, reflashing the board probably won’t help you. However, if you have no options left and want to try to reflash the bootloader with an Uno or RedBoard. Here are links to some tutorials to get you started:

Time Capsule: If you would like to take a look back, here is a tutorial from back in June 2008 on How to Get Code Onto a Microcontroller. We have come so far since then!

Back then, it wasn't as easy to get into programming or processing. Without a USB-to Serial Converter or Bootloader, you needed an external ISP programmer to flash a microcontroller. You needed to use a lower level language and complex development platform to create and compile code for your microcontroller. Before flash memory, you could only program chips once.
(*Make sure to upload the ISP sketch to the programming board. Lastly, be sure to double check the board options you are selecting so that the Arduino IDE uses the correct bootloader hex file.)

Pin Functions

All of the SparkFun RedBoard Qwiic's pins are broken out to 0.1" spaced female headers (i.e. connectors) on the outer edges of the board. The pins are arranged into logical collections; there are headers dedicated to power inputs/outputs, analog inputs, and digital inputs.

Annotated image of pin functionality
RedBoard Qwiic pin functionality.

Note: To learn more about analog vs. digital signals, check out this great tutorial.

Power Pins

The power pins aren't really I/O (Input/Output) pins for the microcontroller; however, they are pertinent to the board. For more details on these pins, see the .

Annotated image of power header
RedBoard Qwiic Power Header

The power header is mostly full of voltage supply pins. These pins are traditionally used as power sources for other pieces of hardware (like LEDs, potentiometers, and other circuits).
  • 3.3V- A regulated 3.3V voltage source.
  • 5V- A regulated 5V voltage source.
  • GND- The common ground or the 0V reference for the voltage supplies.
  • VIN- The input voltage, it'll be equal to the voltage of your input supply if you have a wall adapter connected. If nothing is connected to the barrel jack, and you're powering the board via USB, VIN should be around 5V.
  • RESET- The RESET pin can be shorted to the GND pin to reset the microcontroller, similar to using the reset button.

Microcontroller I/O Pins

All of the I/O pins on this board are digital inputs or outputs for the microcontroller (ATmega328). There are select pins, like the Analog pins, which have additional capabilities.

Digital I/O

There are 20 I/O pins on this board that can be used as digital inputs or outputs for the microcontroller (ATmega328). This includes the pins labeled as Analog, which may be configured and used in the same manner as the Digital pins. These are what you connect to buttons, LEDs, sensors, etc. to interface the Arduino with other pieces of hardware.
    Input
    By default, all digital I/O pins are configured as inputs. It is best practice to define the pinMode() in the setup of each sketch (programs written in the Arduino IDE) for the pins used. When configured properly, an input pin will be looking for a HIGH or LOW state. Input pins are High Impedance and takes very little current to move the input pin from one state to another.

    Troubleshooting Tips:
    • If an input pin is read and that is floating (with nothing connected to it), you will see random data/states. In practice, it may be useful to tie an input pin to a known state with a pullup resistor (to VCC), or a pulldown resistor (to GND).
    • There are 20K pullup resistors built into the ATmega328 chip that can be configured by setting the pinMode() as INPUT_PULLUP.
    • Pin 13 is difficult to use as a digital input because of the voltage drop from status LED and resistor soldered in series to it. If the pin is enabled as an input with the internal 20k pullup resistor, it will always read a LOW state; an expected 5V (HIGH) signal will instead read around 1.7V (LOW). If you must use pin 13 as a digital input, it is recommended that you set the pinMode() as an INPUT and use an external pulldown resistor.
    Output
    When configured as an output the pin will be at a HIGH or LOW voltage. Output pins are Low Impedance: This means that they can provide a substantial amount of current to other circuits.

    Troubleshooting Tip:
    The maximum current an I/O pin can source (provide positive current) or sink (provide negative current) is 40 mA (milliamps). For more details, you can refer to the ATmega328 datasheet or this reference page. Attempting to run high current devices may damage the output the pin or entire ATmega328 chip.
Note: For more details about digital pins, check out this reference page.

Additional Functions

There are several pins that have special functionality in addition to general digital I/O. These pins and their additional functions are listed in the tabs below. For more technical specifications on the I/O pins, you can refer to the ATmega328 datasheet.

Analog Input Pins
There are 6 analog inputs on the analog header. These pins all have 10-bit (10-bit = 1024 different values) analog to digital converter (ADC), which can be used to read in an analog voltage between 0 and VCC. These are useful if you need to read the output of a potentiometer or other analog sensors.

Troubleshooting Tip:
To take analog readings on pins A4/A5, the jumpers for the Qwiic connector need to be cut. Otherwise, the pullup resistors for the logic level converters will act as voltage dividers and the pins will read improper values at lower voltages.
Annotated image of analog inputs
RedBoard Qwiic analog input pins.

Note:
The AREF pin provides a reference voltage for the analog inputs. This pin can be used to get a higher resolution at lower voltage levels. Be sure to read the Notes and Warnings on the analogReference() page.

Analog pins 4 and 5 also support I2C (TWI) communication using the Wire library.
For more details on the analog inputs, check out these tutorials:
Pulse Width Modulation (PWM) Output Pins
Digital pins (3, 5, 6, 9, 10, and 11) marked with a tilde (~) are 8-bit PWM capable outputs, which you can use to dim LEDs or run servo motors.
Annotated image of PWM pins
RedBoard Qwiic PWM pins.

Troubleshooting Tip:
Novice users often mistake PWM pins as an analog output. Although, it can somewhat mimic that functionality, it is not a true analog output.
For more details on pulse width modulation, check out these tutorials:
Serial Communication Pins
Digital pins 0 (RX) and 1 (TX) are also dedicated serial communication pins ties to the USB-to-serial converter (CH340C). These pins are used to receive (RX) and transmit (TX) TTL serial data as well as program the microcontroller. Other digital pins can be use to emulate serial communication with SoftwareSerial().
Annotated image of serial communication pins
RedBoard Qwiic dedicated serial communication pins.

Troubleshooting Tip:
If a device is communicating to the microcontroller over digital pins 0 and 1, while you are trying to upload code, you will run into an upload error. Disconnect the device before uploading code again. It may be easier to emulate serial communication with another set of pins to make debugging easier.
For more details on serial communication, check out these tutorials:
SPI Communication Pins
Digital pins 10 (SS), 11 (MOSI), 12 (MISO), and 13 (SCK) support Serial Peripheral Interface (SPI) communication.
Annotated image of SPI pins
RedBoard Qwiic SPI pins.

Note:
Using the Serial Peripheral Interface, configures the SCK and MOSI pins to be directly managed by the SPI hardware. Therefore, while in use, pins 11 and 13 can't be used (i.e. the LED on pin 13 can no longer be used as a debug/status indicator.) Executing "SPI.end();" allows those pins 11 and 13 to be used as general I/O again.
For more details on the serial peripheral interface, check out these tutorials:
I2C Communication Pins
Analog pins 4 (SDA) and 5 (SCL) support I2C (TWI) communication.
Annotated image of I2C pins
RedBoard Qwiic I2C pins.
Qwiic System
The Qwiic system is intended a quick, hassle-free cabling/connector system for I2C devices. The Qwiic connector is tied to the I2C pins via the A4 /A5 jumpers. Also, there are a set of logic level converters for the Qwiic system, which uses a 3.3V logic level.
Troubleshooting Tip:
Be sure to double check that you are not trying to use and I2C device while you are trying use analog pin 4 or 5 to read analog data, you will run into issues. You can only do one or the other.
For more details on the serial peripheral interface, check out these tutorials:
Interrupt Pins
Interrupts allow you to interrupt the code running in your main loop and execute another set of instructions (also known as interrupt handler or interrupt service routine) before returning back to the main loop. Digital pins 2 and 3 can be configured to trigger an interrupt on a low value, a rising or falling edge, or a change in value.
Annotated image of interrupt pins
RedBoard Qwiic interrupt pins.

For more details on the interrupts, check out these tutorials:

Connecting to the Board

Jumper Wire

All of the SparkFun RedBoard Qwiic's pins are broken out to 0.1"-spaced female headers (i.e. connectors) on the outer edges of the board. There are a variety of wires, connectors, and other items that can be inserted into these headers to interface with the Arduino. Jumper wires are a good option if you want to connect the RedBoard up to other pieces of circuitry that may live on a breadboard.
RedBoard connected to breadboard via jumper wires
A tangled assortment of jumper wires run between the RedBoard headers and components on a breadboard. An Arduino baseplate holds them all in one place.

When connecting to the headers, be sure you are aware of the functionality of the pins you are using.
Troubleshooting tip:
If you don't have jumper wires, you can strip and cut some solid core wire (20-24 AWG wire works best).

Arduino Shields

Shields are another popular way to interface with the headers. These Arduino-shaped boards are stackable and connect to all four headers of the SparkFun RedBoard Qwiic at once. Shields exist in hundreds of forms, they can add GPS, WiFi, MP3 decoding, and all sorts of other functionality to your Arduino. For more details on Arduino shields and shield assembly, please refer to this Arduino Shields tutorial.

Ethernet Shield on RedBoard
An Ethernet Shield stacks onto a RedBoard to help get it connected to the Internet.

Troubleshooting tip:
Most shields are expecting a 5V board. Double check the documentation or datasheet for the shield you are using to verify what voltage it is expecting. You will need to adjust the I/O jumper accordingly.

Qwiic Connector

The most convenient feature of the board is the Qwiic connector that allows the SparkFun RedBoard Qwiic to seamlessly interface with SparkFun's Qwiic Ecosystem.
Qwiic Connect System
Qwiic Connect System

What is Qwiic?

The Qwiic system is intended a quick, hassle-free cabling/connector system for I2C devices. Qwiic is actually a play on words between "quick" and I2C or "iic".

Hardware assembly for VL53L1X
A demonstration for the simplicity of the Qwiic system using the VL53L1X distance sensor.

Features of the Qwiic System

Keep your soldering iron at bay.

Cables plug easily between boards making quick work of setting up a new prototype. We currently offer three different lengths of Qwiic cables as well as a breadboard friendly cable to connect any Qwiic enabled board to anything else. Initially you may need to solder headers onto the shield to connect your platform to the Qwiic system but once that’s done it’s plug and go!

Qwiic Cable and Board

Qwiic cables connected to Spectral Sensor Breakout

Minimize your mistakes.

How many times have you swapped the SDA and SCL wires on your breadboard hoping the sensor will start working? The Qwiic connector is polarized so you know you’ll have it wired correctly, every time, from the start.

The PCB connector is part number SM04B-SRSS (Datasheet) or equivalent. The mating connector used on cables is part number SHR04V-S-B or equivalent. This is a common and low cost connector.

JST Connector

1mm pitch, 4-pin JST connector

Expand with ease.

It’s time to leverage the power of the I2C bus! Most Qwiic boards will have two or more connectors on them allowing multiple devices to be connected.

Logic Level Conversion

There are logic level converters used on the Qwiic connector to maintain a 3.3V logic level on the I2C bus. They are tied directly to the VCC of the microcontroller and the 3.3V rail. Therefore, the board automatically does the logic level conversion for the I/O voltage selected.

Qwiic Logic Level Voltage
RedBoard (Qwiic) schematic of voltage for logic level converters (click image for closer view).

A4/A5 Jumpers

These jumpers directly disconnect the logic level converters and the Qwiic connector from the A4/SDA and A5/SCL pins.

Qwiic jumper
A4/A5 or Qwiic jumpers.

Troubleshooting Tip:
To take analog readings on pins A4/A5, the jumpers for the Qwiic connector need to be cut. Otherwise, the pullup resistors for the logic level converters will act as voltage dividers and the pins will read improper values at lower voltages.
How to Modify the A4/A5 Jumper
You will need a knife to modify the A4/A5 jumpers. To modify the jumper, located on the back of the board next to the Qwiic connector, you need to cut the trace between the two pads. Once you have cut the trace, the Qwiic connector and logic level conveters will be disconnected. To repair the connection, you just need to solder a jumper between the pads of both jumpers. Be sure to test the jumper with a multimeter to make sure you have a good soldered connection.

Adding External Power

If you need more power for your Qwiic devices, you can attach a separate power supply. However, it is recommended that you cut the 3.3V line of the Qwiic cable to the SparkFun RedBoard Qwiic. Leave the GND line alone, as that ground loops your system, providing a consistent reference voltage for your I2C signals.

cutting the 3.3V line
Cutting the 3.3V line of the Qwiic cable to the Qwiic connector.

By cutting the 3.3V line, this allows you to power all your devices without straining the 3.3V regulator on the board. Since, all voltage regulators are slightly different and don't maintain a perfect 3.3 voltage, the 3.3V AP2112 regulator would be constantly battling the voltage regulator of your separate power supply to regulate its version of 3.3V. For more details on voltage regulators, check out this According to Pete blog post.

Jumpers

There are 3 jumpers on the SparkFun RedBoard Qwiic. The two jumpers on the back of the board can be used to disconnect the Qwiic connector from the A4/SDA and A5/SCL pins. The last jumper, on the top of the board, allows users to change the voltage level of the microcontroller.

Using the I/O jumper

One of the great features of the SparkFun RedBoard Qwiic is this I/O jumper that allows users to easily switch from a 3.3V to 5V board.

I/O jumper
I/O jumper.
Why is this an important feature and what does it even do?
This jumper allows users to easily convert the I/O pins to either 3.3V or 5V logic levels based on their needs. With the original SparkFun RedBoard, a 5V board, you would need logic level converter to interface directly to a 3.3V device or sensor.
What are Logic Levels?
The logic levels are a specific range of voltages, in which a device can recognize as HIGH or LOW signals.

ATmega328 Logic Levels

ATmega328 Logic Levels

In most electrical devices, the logic level used is the same as the VCC (Voltage Common Collector). For example, in the original SparkFun RedBoard, the VCC of the microcontroller is set by the LM117 5V linear voltage regulator. Therefore, the original SparkFun RedBoard was a 5V board that used 5V logic levels.

RedBoard schematic with 5V regulator highlighted
RedBoard schematic with 5V regulator highlighted (click image for closer view).

However, the updated SparkFun RedBoard Qwiic has an IO voltage jumper that lets you connect the VCC of the microcontroller to the LM117 5V or AP2112 3.3V linear voltage regulator. Therefore, the logic level of the ATmega328 can be set to 3.3V or 5V. For more details see our Logic Level tutorial.

RedBoard (Qwiic) schematic with IO jumper highlighted
RedBoard (Qwiic) schematic with IO jumper highlighted (click image for closer view).
How to Modify the I/O
If you would like to modify the 3.3V/5V I/O jumper, you will need soldering equipment and a knife. To modify the jumper, located next to the "I/O" silkscreen (pictured), you need to cut the trace between the center and the 5V pads. Once you have cut the trace, to select a specific I/O voltage, you just need to solder a jumper between the center pad and the correlating voltage pad of your choice. Be sure to test the jumper with a multimeter to make sure you have a good jumper soldered.

Troubleshooting Tips:
  • When cutting the jumper, cut downwards (away from the "I/O" silk screened on the board), it will give you a little more wiggle room in case your knife slips while cutting the jumper, the trace for the 5V line is a little further away from the jumper than the I/O trace.
  • To test if you have fully cut the jumper, you can plug your board back in. If the jumper has been completely severed, the VCC line will not be powered and none of the status LEDs will turn on.
Programming via ISP:
If you choose to program the SparkFun RedBoard Qwiic through the ISP pins, you will want to set the I/O jumper to 5V. This will tie the VCC of the microcontroller to the 5V rail//pin of the ISP header. Otherwise, you will probably run into issues and likely damage the I/O pins and/or the microcontoller chipset.

A4/A5 jumpers

Since the SparkFun's Qwiic System, utilizes the I2C bus of the SparkFun RedBoard Qwiic, these jumpers are used to separate the board from the Qwiic connector are provided. These jumpers directly disconnect the logic level converters and the Qwiic connector from the A4/SDA and A5/SCL pins.

Qwiic jumper
A4/A5 or Qwiic jumpers.

Note: There are logic level converters used on the Qwiic connector to maintain a 3.3V logic level on the I2C bus. They are tied directly to the VCC of the microcontroller and the 3.3V rail. Therefore, the board automatically does the logic level conversion for the I/O voltage selected.
How to Modify the I/O
You will need a knife to modify the A4/A5 jumpers. To modify the jumper, located on the back of the board next to the Qwiic connector, you need to cut the trace between the two pads. Once you have cut the trace, the Qwiic connector and logic level converters will be disconnected. To repair the connection, you just need to solder a jumper between the pads of both jumpers. Be sure to test the jumper with a multimeter to make sure you have a good soldered connection.

Examples

Example 1: Uploading Blink

In this example we will go over the basics of the Arduino IDE and upload a sample code. This is a great way to test the basic functionality of any board to make sure it is working.

The Arduino IDE

Now it's finally time to open up the Arduino software. You'll be presented with a window that looks a little something like this:

Arduino IDE annotated
Layout of the Arduino IDE.

Before we can send the code over to the RedBoard, there are a couple of adjustments we need to make.

Select a Board

This step is required to tell the Arduino IDE which of the available Arduino boards, we are using. Go up to the Tools menu. Then hover over Board and make sure Arduino/Genuino Uno is selected.
Board Selection
Screen shot of Board selection.

Select a Serial Port

Next up we need to tell the Arduino IDE which of our computer's serial ports the RedBoard is connected to. For this, again go up to Tools, then hover over Serial Port and select your RedBoard's COM port.
Port Selection
Screen shot of COM Port selection.

If you've got more than one port, and you're not sure which of the serial ports is your RedBoard, unplug it for a moment and check the menu to see which one disappears.

Blink Sketch

Code written for the Arduino IDE are referred to as sketches. All code in Arduino is C based. Let us upload a Blink sketch to make sure our new RedBoard setup is totally functional. Go up to the File menu in Arduino, then go to Examples > 01.Basics > Blink to open it up.
Board Selection
Screen shot of Blink sketch selection.

Upload!

With all of those settings adjusted, you're finally ready to upload some code! Click the Upload button (the right-pointing arrow) and allow the IDE some time to compile and upload your code. It should take around 10-20 seconds for the process to complete. When the code has uploaded, you should see something like this in your console window:
Done uploading
Screen shot of upload complete.

And if you look over to the RedBoard, you should see the blue LED turn on for a second, off for a second, on for a second, off for a second...ad infinitum (at least until it loses power).

Blink Example
Expected response from board

If you want to adjust the blink speed, try messing with the "1000" value in the delay(1000); lines. You're well on your way to becoming an Arduino programmer!

Something Wrong?

Uh oh! If you didn't get a "Done Uploading" message, and instead got an error, there are a few things we can double-check.

If you got an avrdude: stk500_getsync(): not in sync: resp=0x00 error in your console window.

Upload error
Screen shot of Error Message in the Console.

Either your serial port or board may be incorrectly set. Again, make sure Arduino/Genuino Uno is the board selection (under the "Tools > Board" menu). The serial port is usually the more common culprit here. Is the Serial Port correctly set (under the "Tools > Serial Port" menu)? Did the drivers successfully install? To double check your RedBoard's serial port, look at the menu when the board is plugged in, then unplug it and look for the missing port. If none of the ports are missing, you may need to go back to driver installation.

Example 2: Qwiic Connector

One of the great features of the RedBoard (Qwiic) is its ability to interface with I2C devices using our Qwiic system. The Qwiic system is a solderless connection system that allows users to seamlessly daisy chain multiple I2C devices with ease.

The Qwiic Distance Sensor

For this example, we will be running a basic sketch using the SparkFun 4m Distance Sensor (VL53L1X). For more examples with this sensor, please refer to the complete hookup guide.

Hardware Assembly

The wiring for this is simple. Use the Qwiic cable and connect the distance sensor to the board. That is it! The connections are polarized, so you don't have to worry about which side or connector you are using.

Hardware assembly for VL53L1X example

Hardware assembly for VL53L1X distance sensor example.

Let's run an example for our distance sensor to see how it behaves.

Install the Arduino Library

Note: If you have not previously installed an Arduino library, please check out our Arduino library installation guide.

First, you'll need the Sparkfun VL53L1X Arduino library. You can obtain these libraries through the Arduino Library Manager. Search for Sparkfun VL53L1X Arduino Library to install the latest version. If you prefer downloading the libraries from the GitHub repository and manually installing it, you can grab them here:

DOWNLOAD THE SPARKFUN VL53L1X ARDUINO LIBRARY (ZIP)

Example 1 - Read Distance

To get started with this example, open up File > Examples > SparkFun VL53L1x 4M Laser Distance Sensor > Example1_ReadDistance. In this example, we begin by creating a SFEVL53L1X object called distanceSensor with our wire port, Wire, and then our shutdown and interrupt pins. Then we initialize our sensor object in the setup() loop. The code to do this is shown below.

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

//Optional interrupt and shutdown pins.
#define SHUTDOWN_PIN 2
#define INTERRUPT_PIN 3

SFEVL53L1X distanceSensor(Wire, SHUTDOWN_PIN, INTERRUPT_PIN);

void setup(void)
{
  Wire.begin();

  Serial.begin(9600);
  Serial.println("VL53L1X Qwiic Test");

  if (distanceSensor.init() == false)
    Serial.println("Sensor online!");

}

Once we've initialized our sensor, we can start grabbing measurements from it. To do this, we send some configuration bytes to our sensor using distanceSensor.startRanging() to initiate the measurement. We then wait for data to become available and when it does, we read it in, convert it from millimeters to feet, and print it out over serial. The void loop() function that does this is shown below.

language:c
void loop(void)
{
  distanceSensor.startRanging(); //Write configuration bytes to initiate measurement
  int distance = distanceSensor.getDistance(); //Get the result of the measurement from the sensor
  distanceSensor.stopRanging();

  Serial.print("Distance(mm): ");
  Serial.print(distance);

  float distanceInches = distance * 0.0393701;
  float distanceFeet = distanceInches / 12.0;

  Serial.print("\tDistance(ft): ");
  Serial.print(distanceFeet, 2);

  Serial.println();
}

Opening your serial monitor to a baud rate of 9600 should show the distance between the sensor and the object it's pointed at in both millimeters and feet. The output should look something like the below image.

Read Distance
Distance readings in mm and ft

Troubleshooting

Below, we have also included some additional troubleshooting tips for issues that you may come across with the new RedBoard (Qwiic).

  1. One of our employees compiled a great list of troubleshooting tips based on the most common customer issues. This is the perfect place to start.
  2. For any Arduino IDE specific issues, I recommend starting with their troubleshooting guide.

If neither of the troubleshooting guides above were able to help, here are some tips you might have missed. (Most of this material is summarized from the tutorial.):

Are You Using a Recommended Computer OS?

This board is not tested using the Arduino Web IDE. We do NOT recommend using a Chromebook, Netbook, tablet, phone, or the Arduino Web IDE in general. If you are here, try a RECOMMENDED operating system (see Installing the Arduino IDE).

My Board Isn't Working:

Every board that we manufacture gets tested. If you didn't buy the board from us or one of our authorized distributors, it could be a knock-off. That being said, let's try a basic test to see if just the board is working. Disconnect everything that you have attached to the board; we just want to test the board.

  1. Inspect the board:
    Check the board to make sure everything looks about right. Use the pictures on the product page to verify component placement or alignment, and bad solder joints, or damage.
  2. Power and check the status LEDs:
    Using a known good USB micro-B cable, plug your board in to the computer. Do any of the status LEDs turn on (see Hardware Overview)?
    • New boards will come programmed with a test sketch that cycles between the RX and TX LEDs.
  3. Upload the Blink sketch:
    Try to upload a blink sketch. Why blink? It is simple, known to work (from the example files), and you have an indicator LED.
    • Double check that you have the proper Board and Serial Port selected.
    • For boards that are already running the blink example, I recommend changing the timing parameters to check for a change in the board's response.
    Verify that you see the status LED blinking properly and that the Arduino IDE shows a status of "Done uploading."

I Don't See My Board on a Serial/COM Port:

If you don't see your board as an available COM port on the Arduino IDE:

  • Try to re-open the Arduino IDE.
  • Check the Device Manager to verify that your computer recognizes the board. Click the Driver Verification button in the Installing Drivers section of the tutorial.
  • If you have previously installed the older CH340G drivers, you may need to update your drivers. Particularly on Macs, you will need to delete the previous drivers and install the updated drivers.
  • If that is not the case, you issue might be related to your USB cable. Check that you are using a USB cable capable of data transfers. Some cables only have the power pins connected for charging. A good way to test this is to plug in a device to your USB cable (like a phone). If it doesn't show up as a device or drive, then try a new USB micro-B cable.
  • This rarely happens, but it is easy to check. If you are using a USB 3.0 port (you will see a blue "tongue" in the USB jack or bad USB port, try a different USB port. You can also try to test the board on a different computer to double check for a hardware incompatibility (usually with expansion boards).

Errors Uploading to the Board:

There are two types of issues that you will usually see in the console of the Arduino IDE, compile errors or upload errors. The easiest way to see where to start is by clicking the Verify button (check mark); the Arduino IDE will try to compile your code. A failure here is a compile error.

It takes a some experience, but if you enable the verbose output from the Arduino IDE preferences, it may give you more clues to where the issue is.

Screen shots of enabling verbose output

Screen shots of how to enable verbose output. Click to enlarge.

  • Compile Errors:
    With compile errors, there are several things that could be causing issues. However, 99% of the time, it is user error. Usually something wrong with your code or the library you are using. Once in a while you will have a file structure issue if you manually added a file/folder in any of the Arduino folders (still user error).
  • Upload Errors:
    Upload errors get a little more tricky. You will usually just see the Arduino IDE trying to upload to the board multiple times. There are usually several different causes for this, often without specific errors in the console. Here are a few common examples:
    • Wrong Board Selection:
      Double check you board selection options. If you uploaded with the wrong board selection, there is a small chance that you may have overwritten the bootloader on the board or damaged the microcontroller.
    • Missing Bootloader:
      If your board has the bootloader flashed, pin 13 will flash several times on power up.
    • Serial Port Interference:
      If a device is communicating to the microcontroller over digital pins 0 and 1, while you are trying to upload code.
    • Bad USB cable or port (see Serial Port section above).

Additional Tips:

If an input pin is read and that is floating (with nothing connected to it), you will see random data/states. In practice, it may be useful to tie an input pin to a known state with a pullup resistor (to VCC), or a pulldown resistor (to GND).

Pin 13 is difficult to use as a digital input because of the voltage drop from status LED and resistor soldered in series to it. If you must use pin 13 as a digital input, it is recommended that you set the pinMode() as an INPUT and use an external pulldown resistor.

The maximum current an I/O pin can source (provide positive current) or sink (provide negative current) is 40 mA (milliamps). You can power small sections of LED strips or small motors, but will run into issue with high power devices.

Be sure to double check that you are not trying to use and I2C device while you are trying use analog pin 4 or 5 to read analog data, you will run into issues. You can only do one or the other.

Using the Serial Peripheral Interface, configures the SCK and MOSI pins to be directly managed by the SPI hardware. Therefore, while in use, pins 11 and 13 can't be used (i.e. the LED on pin 13 can no longer be used as a debug/status indicator.) Executing "SPI.end();" allows those pins 11 and 13 to be used as general I/O again.

Resources and Going Further

Now that you've successfully got started with your SparkFun RedBoard Qwiic, it's time to incorporate it into your own project! For more information, check out the resources below:


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

SparkFun Tutorials

Installing an Arduino Library

How do I install a custom Arduino library? It's easy! This tutorial will go over how to install an Arduino library using the Arduino Library Manager. For libraries not linked with the Arduino IDE, we will also go over manually installing an Arduino library.

What is an Arduino?

What is this 'Arduino' thing anyway?

Installing Arduino IDE

A step-by-step guide to installing and testing the Arduino software on Windows, Mac, and Linux.

Arduino Tutorials

Arduino Board Comparison Guides

Choosing an Arduino for Your Project

Examining the diverse world of Arduino boards and understanding the differences between them before choosing one for a project.

Standard Arduino Comparison Guide

Arduino Comparison Guide Uno or Pro Mini? Bluetooth or wireless? When it comes to Arduinos, there are a lot of choices. We've compiled every Arduino development…

RedBoard vs. Uno

In this tutorial we discuss the differences and similarities between the RedBoard and the Arduino Uno (SMD and PTH). The development platforms

Arduino Shields

Arduino Shields

All things Arduino Shields. What they are and how to assemble them.
Beginner

Click the buttons above for tutorials relating to the board functionality based on topic difficulty.

Beginner

Serial Communication

Asynchronous serial communication concepts: packets, signal levels, baud rates, UARTs and more!

Analog to Digital Conversion

The world is analog. Use analog to digital conversion to help digital devices interpret the world.

Logic Levels

Learn the difference between 3.3V and 5V devices and logic levels.

Analog vs. Digital

This tutorial covers the concept of analog and digital signals, as they relate to electronics.

Data Types in Arduino

Learn about the common data types and what they signify in the Arduino programming environment.

How to Work with Jumper Pads and PCB Traces

Handling PCB jumper pads and traces is an essential skill. Learn how to cut a PCB trace, add a solder jumper between pads to reroute connections, and repair a trace with the green wire method if a trace is damaged.

Intermediate

Serial Peripheral Interface (SPI)

SPI is commonly used to connect microcontrollers to peripherals such as sensors, shift registers, and SD cards.

I2C

An introduction to I2C, one of the main embedded communications protocols in use today.

Processor Interrupts with Arduino

What is an interrupt? In a nutshell, there is a method by which a processor can execute its normal program while continuously monitoring for some kind of event, or interrupt. There are two types of interrupts: hardware and software interrupts. For the purposes of this tutorial, we will focus on hardware interrupts.

Advanced

Installing an Arduino Bootloader

This tutorial will teach you what a bootloader is and why you would need to install or reinstall it. We will also go over the process of burning a bootloader by flashing a hex file to an Arduino microcontroller.

Integrated Circuits

An introduction to integrated circuits (ICs). Electronics' ubiquitous black chips. Includes a focus on the variety of IC packages.

Reading and Writing Serial EEPROMs

EEPROM is a great way to add extra memory to your microcontroller project. Wait 'til you see how easy it is to use!

Example Projects

Assembly Guide for RedBot with Shadow Chassis

Assembly Guide for the RedBot Kit. This tutorial includes extra parts to follow to go along with the RedBot Inventor's Kit tutorial.

SparkFun Inventor's Kit Experiment Guide - v4.0

The SparkFun Inventor's Kit (SIK) Experiment Guide contains all of the information needed to build all five projects, encompassing 16 circuits, in the latest version of the kit, v4.0a.

RedBoard Edge Hookup Guide

The RedBoard Edge is a RedBoard that's been rebuilt around the idea that projects are eventually put into an enclosure to help clean up their look.

Qwiic Quad Relay Hookup Guide

SparkFun’s Qwiic Quad Relay is a product designed for switching not one but four high powered devices from your Arduino or other low powered microcontroller using I2C.