Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://learn.sparkfun.com/tutorials/redboard-qwiic-hookup-guide below:

RedBoard Qwiic Hookup Guide - SparkFun Learn

The SparkFun RedBoard 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.

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

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

The SparkFun RedBoard 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.

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

• SparkFun RedBoard Qwiic - You'll definitely need this; otherwise, you might be on the wrong tutorial (wink-wink).
• 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.

Jumper Modification Qwiic Example

If you would like to modify the 3.3V/5V I/O jumper or A4/A5 Qwiic connector jumpers, you will need

and/or a

.

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

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

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

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

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

The SparkFun RedBoard 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 I²C tutorials.

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

What is this 'Arduino' thing anyway? This tutorials dives into what an Arduino is and along with Arduino projects and widgets.

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

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 I²C tutorials (above) before using it, as all Qwiic sensors utilize an I²C communication protocol. Click on the banner above to learn more about Qwiic products.

Fun Fact: Qwiic is a play on words between "quick" and I²C or "iic".

The USB-to-Serial adapter IC, used on the RedBoard Qwiic, is different from what was used on the original RedBoard.

because they are different chips made by separate manufacturers.

The SparkFun RedBoard Qwiic uses a CH340C USB-to-Serial adapter made by WCH. The driver for the CH340C chip will need to be installed on your computer. We have tested and confirmed that the driver works on Windows 7, Windows 10, Mac OSX High Sierra, and Raspbian Stretch (11-13-2018 release) for the Raspberry Pi. On all operating systems, if you have previously installed the CH340G drivers, you will need to uninstall those drivers first before updating to the new CH340C driver. For more information, check out our How to Install CH340 Drivers Tutorial.

Installing the CH340C driver allows your computer to recognize the SparkFun RedBoard Qwiic as a device and lets it communicate with the board over the USB connection. You can also find the latest version of the CH340 drivers from WCH here. (Most of their pages are in Mandarin, but if you use a Chrome web browser, you should have the option to have the web page translated.)

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.

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.

• 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.

Windows 7/10 Mac OSX Linux

The Windows version of Arduino is offered in two options: an installer or a zip file. The

is the easier of the two options, just download that, and run the executable file to begin the installation.

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.

The Mac download of Arduino is only offered in a zip file version. After the download is finished, simply

to unzip it.

Following that, you'll need to

to complete the installation.

As Linux users are no doubt aware, there are many flavors of Linux out there, each with unique installation routines. Check out the

of the Arduino webpage for more details. Otherwise, you can also use the

for some helpful links for an assortment of Linux distributions.

Raspberry Pi users with Raspbian installed should use the

download. Do not use the command line installation process. For more information, please refer to this

.

For Ubuntu and Debian users, installing Arduino should only need a simple "

" command like:

sudo apt-get update && sudo apt-get install arduino arduino-core

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!

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

New Features Dimensions Microcontroller Power/Reset Status LEDs Programming Pin Functions Pin Connections Qwiic Connection Jumpers

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

The new CH340C IC allows the

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.

The AP2112 is a more robust

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

of current and should be able to handle most of your

needs.

This connector allows the

to seamlessly interface with

.

Pins

and

are tied directly to the I

C bus. These jumpers can be used to disconnect the logic level converters from pins

and

so that they might be used independently from the

for analog readings.

These jumpers allow users to easily switch from a

to

board. This allows the user to convert the board (and I/O pins) to either

or

based on their needs. Unlike the the

, you no longer need a logic level converter to interface directly to a

device or sensor.

The board also includes a new, more pronounced reset button that is easier to push. Anyone with "

" can relate to this struggle.

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

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

connector. There are also 4 mounting points on the board.

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

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 any tolerance information available; you may need to just measure the board you purchase.)

The microcontroller (ATmega328 IC) is the work horse of the

. 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

is powered.

• 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 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.

For more details on the ATmega328, memory, and the bootloader check out these tutorials:

• Arduino Memory Tutorial
• SparkFun EEPROM Tutorial
• Arduino Bootloader Page
• Arduino as ISP and Arduino Bootloaders
• StackExchange Forum Post on Bootloaders

The

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

. Otherwise, should you choose to use the barrel jack, any wall adapter connected to this jack should supply a

.

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.

Users should take care

to pry or leverage on the connector when inserting/removing the USB cable. Doing so,

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.

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

. Leave the GND line alone, as that ground loops your system, providing a consistent reference voltage for your I

C 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

blog post.

• 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.

It is fine to connect both a barrel jack and a USB connector at the same time. The

has power-control circuitry to automatically select the best power source.

USB and barrel jack wires connected.

There are 4 status LEDs on the

that indicate power, serial communication, and a test/status LED.

There is a small change to the color of ther status LEDs from the

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

• 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.

There are two ways to program the

. The most common way for users is through the USB connection. The other slightly less common method is through the ISP headers or pins.

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.

• 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.

• 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.

AVR ISP Pinouts – Top View.

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:

• SparkFun's Installing an Arduino Bootloader Tutorial
• Arduino as ISP and Arduino Bootloaders
• Arduino Programming a Microcontroller Tutorial
• Pi AVR Programmer Hookup Guide

If you would like to take a look back, here is a tutorial from back in

on

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

(

)

All of the

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.

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

.

The power pins aren't really

(Input/Output) pins for the microcontroller; however, they are pertinent to the board. For more details on these pins, see the

.

The

is mostly full of voltage supply pins. These pins are traditionally

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.

All of the

pins on this board are

or

for the microcontroller (ATmega328). There are select pins, like the

, which have additional capabilities.

There are 20

pins on this board that can be used as

or

for the microcontroller (ATmega328). This includes the pins labeled as

, which may be configured and used in the same manner as the

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

For more details about

pins, check out this

.

There are several pins that have special functionality in addition to general

. These pins and their additional functions are listed in the tabs below. For more technical specifications on the

pins, you can refer to the

.

• Analog Input
• PWM Output
• Serial Comm.
• SPI
• I²C
• Interrupt

There are 6

on the analog header. These pins all have 10-bit (10-bit = 1024 different values)

(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.

The

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

on the

page.

Analog pins 4 and 5 also support I²C (TWI) communication using the Wire library.

For more details on the analog inputs, check out these tutorials:

• SparkFun Analog Pin Tutorial
• Arduino Analog Pin Tutorial

Digital pins (3, 5, 6, 9, 10, and 11) marked with a tilde (~) are 8-bit

, which you can use to dim LEDs or run servo motors.

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:

• SparkFun PWM Tutorial
• Arduino PWM Tutorial
• Arduino: Secrets of Arduino PWM

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

.

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:

• SparkFun Serial Communication Tutorial
• Arduino Serial Reference Page
• Arduino SoftwareSerial Reference Page
• Arduino SoftwareSerial Tutorial

Digital pins 10 (SS), 11 (MOSI), 12 (MISO), and 13 (SCK) support Serial Peripheral Interface (SPI) communication.

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:

• SparkFun SPI Tutorial
• Arduino SPI Tutorial
• Arduino SPI Reference Page
• Arduino SPI Settings Reference Page

Analog pins 4 (SDA) and 5 (SCL) support I

C (TWI) communication.

The Qwiic system is intended to be a quick, hassle-free cabling/connector system for I

C devices. The Qwiic connector is tied to the I

C 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 I²C 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:

• SparkFun I²C Tutorial
• Arduino I²C Reference Page

Interrupts allow you to

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.

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

• SparkFun Interrupt Tutorial
• Arduino Interrupt Tutorial
• Arduino attachinterrupt() Reference Page

All of the

'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.

are a good option if you want to connect the RedBoard up to other pieces of circuitry that may live on a breadboard.

When connecting to the headers, be sure you are aware of the functionality of the pins you are using.

Shields are another popular way to interface with the headers. These Arduino-shaped boards are stackable and connect to all four headers of the

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

tutorial.

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.

The most convenient feature of the board is the Qwiic connector that allows the

to seamlessly interface with

.

The Qwiic system is intended a quick, hassle-free cabling/connector system for I

C devices. Qwiic is actually a play on words between "quick" and I

C or "iic".

• No Soldering
• Polarized Connector
• Daisy Chain

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!

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.

1mm pitch, 4-pin JST connector

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

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.

You will need a

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

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.

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

. Leave the GND line alone, as that ground loops your system, providing a consistent reference voltage for your I

C signals.

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

version of 3.3V. For more details on voltage regulators, check out this

blog post.

There are 3 jumpers on the

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

One of the great features of the

is this

that allows users to easily switch from a

to

board.

ATmega328 Logic Levels

In most electrical devices, the logic level used is the same as the

(

). For example, in the

, the

of the microcontroller is set by the LM117

linear voltage regulator. Therefore, the

was a

that used

.

However, the

has an IO voltage jumper that lets you connect the

of the microcontroller to the LM117

or AP2112

linear voltage regulator. Therefore, the logic level of the ATmega328 can be set to

or

. For more details see our

tutorial.

• 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.

If you choose to program the

through the ISP pins, you will want to

. This will tie the

of the microcontroller to the

of the ISP header. Otherwise, you will probably run into issues and likely damage the I/O pins and/or the microcontoller chipset.

Note: There are logic level converters used on the Qwiic connector to maintain a 3.3V logic level on the I²C 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.

You will need a

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

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.

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.

Now it's finally time to

. You'll be presented with a window that looks a little something like this:

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

This step is required to tell the Arduino IDE

of the

, we are using. Go up to the

menu. Then hover over

and make sure

is selected.

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

, then hover over

and select your RedBoard's COM port.

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.

Code written for the Arduino IDE are referred to as sketches. All code in Arduino is C based. Let us upload a

to make sure our new RedBoard setup is totally functional. Go up to the

menu in Arduino, then go to

to open it up.

With all of those settings adjusted, you're finally ready to upload some code! Click the

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:

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).

If you want to adjust the blink speed, try messing with the "1000" value in the

lines. You're well on your way to becoming an Arduino programmer!

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.

Either your serial port or board may be incorrectly set. Again, make sure

is the board selection (under the "

>

" menu). The serial port is usually the more common culprit here. Is the Serial Port correctly set (under the "

>

" 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

.

One of the great features of the RedBoard (Qwiic) is its ability to interface with I

C devices using our

. The Qwiic system is a solderless connection system that allows users to seamlessly daisy chain multiple I

C devices with ease.

For this example, we will be running a basic sketch using the

. For more examples with this sensor, please refer to the

.

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.

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

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:

To get started with this example, open up

>

>

>

. In this example, we begin by creating a

object called

with our wire port,

, and then our shutdown and interrupt pins. Then we initialize our sensor object in the

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.

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.):

This board is not tested using the Arduino Web IDE. We do

recommend using a Chromebook, Netbook, tablet, phone, or the Arduino Web IDE in general. If you are here, try a

operating system (see

).

Every board that

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."

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).

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

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 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).

• 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 an I²C device while you are trying use analog pins A4 or A5 to read analog data. You will run into issues where the analog read will appear to be at a constant value. As a result, the analog readings will not reflect the changes seen from the sensor output. 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.

• This issue doesn't happen too often, but it can be arbitrarily, common: If your mouse pointer begins to move erratically, your mouse becomes unresponsive to your inputs, and your board is sending a lot of serial data, there is a chance that your computer thinks your board as a serial mouse. The fix is to unplug your board and the plug it back in while holding the reset button down, giving your computer a chance enumerate the COM port.

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:

• Schematic (PDF)
• Eagle Files (ZIP)
• CH340C Hookup Guide (for Drivers)
• Qwiic Landing Page
• GitHub Product Repository
• SFE Product Showcase

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

• Arduino IDE
• Boards & Shields
• Board Functionality
• Project Guides

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…

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

An update to our classic Arduino Shields Tutorial! All things Arduino shields. What they are and how to assemble them.

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

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

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

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

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

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.

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

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.

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.

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

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.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4