Qwiic MUX Hookup Guide

Introduction

The Qwiic Mux - TCA9548A (v1) and (v1.1) enable communication with multiple I²C devices that have the same address. The IC is simple to interface with and also has 8 configurable addresses of its own, this allows you to put 64 I²C buses on a single bus!

SparkFun Qwiic Mux Breakout - 8 Channel (TCA9548A)

BOB-14685

The SparkFun Qwiic Mux Breakout enables communication with multiple I2C devices that have the same address that makes it simp…

Retired

SparkFun Qwiic Mux Breakout - 8 Channel (TCA9548A)

BOB-16784

The SparkFun Qwiic Mux Breakout enables communication with multiple I2C devices that have the same address that makes it simp…

$15.01

Revision Update: In the latest revision of the Qwiic MUX, we have made a few changes to improve the board, listed below. If users are unsure about which version they purchased, please refer to the pictures of the most prominent changes, shown below.

• We have added a pass-through Qwiic connector.
• The power LED was moved to accommodate the additional Qwiic connector.
• We have updated the I²C pull-up resistor jumper to a cuttable trace.
• We have widened the trace for the 3.3V power.
• There is a v11 label on the back of the board.
• The silk screen labels have been updated.

Added Qwiic connector to make board daisy-chainable.

The v11 label on the back.

In this tutorial we'll go over how to talk to sensors on different channels of your MUX breakout board. The application of this is pretty straightforward so things won't get too fancy.

Required Materials

You'll need a few additional items to get started with the Qwiic Mux. The RedBoard Qwiic is for the Arduino examples and the Qwiic pHAT is for the Raspberry Pi example (see note below). You may already have a few of these items, so feel free to modify your cart based on your needs. Additionally, there are also alternative parts options that are available as well (click button below to toggle options).

SparkFun Qwiic Cable Kit

KIT-15081

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

$12.95

SparkFun RedBoard Qwiic

DEV-15123

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

$21.95

SparkFun Qwiic pHAT for Raspberry Pi

DEV-15351

The SparkFun Qwiic pHAT for Raspberry Pi is the quickest and easiest way to make your way into the Qwiic ecosystem and still …

Retired

Qwiic compatible microcontrollers:

SparkFun Thing Plus - ESP32 WROOM

WRL-14689

The SparkFun ESP32 Thing Plus is the next step to get started with Espressif IoT ideations while still enjoying all the ameni…

Retired

SparkFun Thing Plus - SAMD51

DEV-14713

With a 32-bit ARM Cortex-M4F MCU, the SparkFun SAMD51 Thing Plus is one of our most powerful microcontroller boards yet!

$25.50

SparkFun RedBoard Turbo - SAMD21 Development Board

DEV-14812

If you’re ready to step up your Arduino game from older 8-bit/16MHz microcontrollers, the SparkFun RedBoard Turbo is a form…

$22.50

SparkFun RedBoard Qwiic

DEV-15123

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

$21.95

In addition we also offer, Qwiic compatible stackable shields for microcontrollers and pHATs for single board computers (like the Raspberry Pi boards) that don't include a Qwiic connector.

SparkFun Qwiic Shield for Arduino

DEV-14352

The SparkFun Qwiic Shield is an easy-to-assemble board that provides a simple way to incorporate the Qwiic Connect System wit…

$7.75

SparkFun Qwiic Shield for Photon

DEV-14477

The SparkFun Qwiic Shield for Photon is an easy-to-assemble board that provides a simple way to incorporate the Qwiic System …

Retired

SparkFun Qwiic Adapter

DEV-14495

The SparkFun Qwiic Adapter provides the perfect means to make any old I²C board into a Qwiic enabled board.

$1.60

SparkFun Qwiic HAT for Raspberry Pi

DEV-14459

The SparkFun Qwiic HAT for Raspberry Pi is the quickest and easiest way to make your way into the Qwiic ecosystem and still u…

$6.60

SparkFun Servo pHAT for Raspberry Pi

DEV-15316

The SparkFun Servo pHAT for Raspberry Pi allows your Raspberry Pi to control up to 16 servo motors in a straightforward manne…

$13.95

SparkFun Qwiic pHAT for Raspberry Pi

DEV-15351

The SparkFun Qwiic pHAT for Raspberry Pi is the quickest and easiest way to make your way into the Qwiic ecosystem and still …

Retired

SparkFun Qwiic SHIM for Raspberry Pi

DEV-15794

The SparkFun Qwiic SHIM for Raspberry Pi is a small, easily removable breakout that easily adds a Qwiic connector to your Ras…

$1.75

You will also need a Qwiic cable to connect to your Qwiic Mux, choose a length that suits your needs.

Qwiic Cable - 50mm

PRT-14426

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

Retired

Qwiic Cable - 100mm

PRT-14427

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

$1.50

Qwiic Cable - 200mm

PRT-14428

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

Retired

Qwiic Cable - 500mm

PRT-14429

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

Retired

Alternative Parts (Toggle)

Tools

Depending on your setup, you may need a hobby knife, soldering iron, solder, and/or general soldering accessories.

Hobby Knife

TOL-09200

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

$3.75

Solder Lead Free - 100-gram Spool

TOL-09325

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

$15.50

Weller WLC100 Soldering Station

TOL-14228

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

Retired

Slice Craft Knife

TOL-14508

The Slice Craft Knife is a high end hobby knife perfect for precision cutting, scraping, and handling.

Retired

Suggested Reading

If you're unfamiliar with jumper pads, I²C, Qwiic, or Python be sure to checkout some of these foundational tutorials.

The Qwiic Mux is intended for the Qwiic connect system. We recommend familiarizing yourself with the Logic Levels and I²C tutorials before using it. Click on the banner above to learn more about our Qwiic products.

Hardware Overview

Let's look over a few characteristics of the TCA9548A so we know a bit more about how it behaves.

Original Release:The Qwiic input for the Mux is located at the top-center of the board, labeled Main, highlighted in the image below. The outputs are then located on the left and right sides of the board and are numbered accordingly.

Revision Update: There are two Main connectors on the revision to provide a pass through for the I²C bus connection. This allow the board to be daisy chained in between other Qwiic boards.

The onboard reset pin, highlighted below, is an active low input. Pulling reset low for at least 6 ns will restart the multiplexer.

The Qwiic Mux also allows you to change the last 3 bits of the address byte, allowing for 8 jumper selectable addresses if you happen to need to put more than one Mux on the same I²C port. The address can be changed by adding solder to any of the three ADR jumpers, shown in the image below.

The below table shows which jumpers must be soldered together to change to the corresponding address.

Original Release:If you want to remove the pullup resistors from the I²C bus, simply remove the solder from the jumper highlighted in the below image.

Revision Update: If you want to remove the pullup resistors from the I²C bus, simply cut the jumper pad with a hobby knife. Be careful of the 3.3V trace above the jumper pad. Cutting the trace probably won't destroy the board, as the trace also circles around through the Qwiic connector on the bottom. However, it will leave the trace exposed at the cut.

Hardware Assembly

Arduino Example

Just plug one end of the Qwiic cable into the Main connector on the Qwiic multiplexer breakout and the other end into Qwiic connector on your Qwiic enabled microcontroller. If it seems like it's too easy to use, but that's why we made it that way! Otherwise, if you chose to use a Qwiic shield/adapter, now would be the time to head on over to that tutorial to assemble the shield.

With the shield assembled, SparkFun's new Qwiic environment means that connecting the mux could not be easier. Just plug one end of the Qwiic cable into the Qwiic multiplexer breakout (Main connector) and the other into the Qwiic Shield; then, you'll be ready to upload a sketch and figure out just how all those address sharing sensors are behaving.

Revision Update: Users can now daisy chain the Qwiic Mux in between other Qwiic boards.

Raspberry Pi Examples

With the Qwiic connector system, assembling the hardware is simple. In addition to the Qwiic Mux, you will need: a Qwiic cables, a SparkFun Qwiic pHAT for Raspberry Pi, and a Raspberry Pi setup with the Raspbian OS, monitor, and standard peripherals. (*If you are unfamiliar with the Qwiic pHAT, you can find the Hookup Guide here.)

Revision Update: Users can now daisy chain the Qwiic Mux in between other Qwiic boards.

Alternatively, you can also use another Qwiic adapter like the Pi Servo pHat instead.

Arduino Example

SparkFun has written some example code to enable and disable ports on the Qwiic Mux. Go ahead and download this example code here.

Additionally, you will need to install the MMA8452Q Arduino library if you are using two MMA8452Q accelerometers. First, you’ll need the Sparkfun MMA8452Q Arduino library. You can obtain these libraries through the Arduino Library Manager. Search for Sparkfun MMA8452Q Accelerometer by SparkFun Electronics to install the latest version. If you prefer downloading the libraries from the GitHub repository and manually installing it, you can grab them here:

Arduino Example Example1-BasicReadings.ino

Opening Example1-BasicReadings will open two tabs in the Arduino IDE, the first example, and also Mux_Control. Let's take a look under the hood of Mux_Control to get an idea of what's going on. There are two functions here, boolean enableMuxPort(byte portNumber) and boolean disableMuxPort(byte portNumber) which is pretty much all we need to specify which channels we'd like to talk to on the Mux. If we have a sensor on channel 0, we simply call enableMuxPort(0) to open that channel on the multiplexer. Then we'll take whatever reads and perform whatever actions we'd like to the sensor on that channel. Once finished, we have to call disableMuxPort(0) to close communication on that channel so we don't accidentally perform actions on the sensor on that channel. The below example code shows how to read from two MMA8452Q accelerometers.

language:c
#include <Wire.h>
#include <SparkFun_MMA8452Q.h> //From: https://github.com/sparkfun/SparkFun_MMA8452Q_Arduino_Library

#define NUMBER_OF_SENSORS 2

MMA8452Q accel[NUMBER_OF_SENSORS]; //Create an array of MMA8452Q sensors

void setup()
{
  Serial.begin(115200);
  Serial.println("Qwiic Mux Shield Read Example");
  Wire.begin();

  //Disable all eight mux ports initially, then we can enable them one at a time
  for (byte x = 0 ; x <= 7 ; x++)
  {
    disableMuxPort(x);
  }

  //Initialize all the sensors
  for (byte x = 0 ; x < NUMBER_OF_SENSORS ; x++)
  {
    enableMuxPort(x); //Tell mux to connect to port X
    accel[x].init(); //Init the sensor connected to this port
    disableMuxPort(x);
  }

  Serial.println("Mux Shield online");
}

void loop()
{
  for (byte x = 0 ; x < NUMBER_OF_SENSORS ; x++)
  {
    enableMuxPort(x); //Tell mux to connect to this port, and this port only

    if (accel[x].available())
    {
      accel[x].read();

      Serial.print("Accel ");
      Serial.print(x);
      Serial.print(": ");
      Serial.print(accel[x].cx, 2);
      Serial.print(" ");
      Serial.print(accel[x].cy, 2);
      Serial.print(" ");
      Serial.print(accel[x].cz, 2);
      Serial.print(" ");

      Serial.println(); // Print new line every time.
    }

    disableMuxPort(x); //Tell mux to disconnect from this port
  }

  delay(1); //Wait for next reading
}

With the example provided, you should be able to read two I²C sensors with the same address on the same bus! Try opening up the Arduino Serial Monitor set to 115200 baud in order to read the sensor values.

Arduino Library

We have also written a dedicated Arduino Library for the Qwiic Mux. It includes extra functions which you can use to (e.g.) enable or disable multiple ports in one call.

You can install the library via the Arduino Library Manager:

language:c
#include <SparkFun_I2C_Mux_Arduino_Library.h> //Click here to get the library: http://librarymanager/All#SparkFun_I2C_Mux

Or, if you want to, you can download and install it manually:

Please see Example2 for a fancier way of creating your array of sensors, using a pointer to an array of pointers!

Python Package Overview

We've written a Python package to easily get setup and utilize the Qwiic Mux. However, before we jump into operating the multiplexer, let's take a closer look at the available functions in the Python package. You can install the sparkfun-qwiic-tca9548a Python package hosted by PyPi.

Installation

To install the Python package for this product, it is recommended that users install the SparkFun Qwiic Python package, which installs all the available Python packages for our Qwiic products and includes the required I²C driver package. On systems that support PyPi installation via pip3 (use pip for Python 2) is simple, using the following commands:

For all users (note: the user must have sudo privileges):

language:bash
sudo pip3 install sparkfun-qwiic

For the current user:

language:bash
pip3 install sparkfun-qwiic

PyPi Installation

This repository is hosted on PyPi as the sparkfun-qwiic-tca9548a package. On systems that support PyPi installation via pip3 (use pip for Python 2) is simple, using the following commands:

For all users (note: the user must have sudo privileges):

sudo pip3 install sparkfun-qwiic-tca9548a

For the current user:

pip3 install sparkfun-qwiic-tca9548a

Local Installation

To install, make sure the setuptools package is installed on the system.

Direct installation at the command line (use python for Python 2):

python3 setup.py install

To build a package for use with pip3:

python3 setup.py sdist

A package file is built and placed in a subdirectory called dist. This package file can be installed using pip3.

cd dist
pip3 install sparkfun_qwiic_tca9548a-<version>.tar.gz

Python Package Operation

Below is a description of the basic functionality of the Python package. This includes the package organization, built-in methods, and their inputs and/or outputs. For more details on how the Python package works, check out the source code and the datasheet.

Dependencies

This Python package has a very few dependencies in the code, listed below:

language:python
import time                         # Time access and conversion package
import qwiic_i2c                    # I2C bus driver package

Default Variables

The default variables, in the code, for this Python package are listed below:

language:python
#The name of this device
_DEFAULT_NAME = "Qwiic Mux"

_AVAILABLE_I2C_ADDRESS = [*range(0x70,0x77 + 1)]

Class

QwiicTCA9548A() or QwiicTCA9548A(i2caddr)
This Python package operates as a class object, allowing new instances of that type to be made. An __init__() constructor is used that creates a connection to an I²C device over the I²C bus using the default or specified I²C address.

The Constructor

A constructor is a special kind of method used to initialize (assign values to) the data members needed by the object when it is created.

__init__(self, address = None, debug = None, i2c_driver = None)

Functions

A function that is an attribute of the class, which defines a method for instances of that class. In simple terms, they are objects for the operations (or methods) of the class.

.is_connected()
Determine if the device is conntected to the system.

.disable_all()
This method disables the connection of all channels on the Qwiic Mux.

.disable_channels(disable)
This method disables the connection of specific channels on the Qwiic Mux.

.enable_all()
This method enables the connection of specific channels on the Qwiic Mux.

.enable_channels(enable)
This method enables the connection of specific channels on the Qwiic Mux.

.list_channels()
This method lists all the available channels and their current configuration (enabled or disabled) on the Qwiic Mux.

Upgrading the Package

In the future, changes to the Python package might be made. Updating the installed packages has to be done individually for each package (i.e. sub-modules and dependencies won't update automatically and must be updated manually). For the sparkfun-qwiic-tca9548a Python package, use the following command (use pip for Python 2):

For all users (note: the user must have sudo privileges):

language:bash
sudo pip3 install --upgrade sparkfun-qwiic-tca9548a

For the current user:

language:bash
pip3 install --upgrade sparkfun-qwiic-tca9548a

Python Examples

The following examples are available in the GitHub repository. To run the examples, simple download or copy the code into a file. Then, open/save the example file (if needed) and execute the code in your favorite Python IDE.

For example, with the default Python IDLE click Run > Run Module or use the F5 key. To terminate the example use the Ctrl + C key combination.

Example 1

Users should run the first example after power up or reset of the board. In this example, channels 0 and 4 are enabled, there is a pause, and then channel 7 is enabled.

Import Dependencies

The first part of the code, imports the required dependencies to operate.

language:python
import qwiic
import time

Initialize Constructor

This line instantiates an object for the device.

language:python
test = qwiic.QwiicTCA9548A()

Test Run

This section of the code, illustrates how to enable the I²C channels on the Qwiic Mux. First, it list all the channels on the Qwiic Mux and their configuration (enabled or disabled). (*On power up or reset all the channels will be disabled.) The second part of the code, enables channels 0 and 4 using the list method. Then then the code pauses for a second before enabling channel 7. Once that task its complete, the code returns the final configuration of the channels. Users should expect to see channels 0, 4, and 7 enabled.

language:python
# List Channel Configuration
test.list_channels()

# Enable Channels 0 and 4
test.enable_channels([0,4])

# Pause 1 sec
time.sleep (1)

# Enable Channel 7
test.enable_channels(7)

# List Channel Configuration
test.list_channels()

Example 2

Users should run the first example before running this example. This example disables channels 0 and 4.

Import Dependencies

The first part of the code, imports the required dependencies to operate.

language:python
import qwiic
import time

Initialize Constructor

This line instantiates an object for the device.

language:python
test = qwiic.QwiicTCA9548A()

Test Run

This section of the code, illustrates how to disable the I²C channels on the Qwiic Mux. First, it list all the channels on the Qwiic Mux and their configuration (enabled or disabled). (*From the previous example, channels 0, 4, and 7 should be enabled.) The second part of the code, disables channels 0 and 4 using the list method. Then then the code returns the final configuration of the channels. Users should expect to see only channel 7 enabled.

language:python
# List Channel Configuration
test.list_channels()

# Enable Channels 0 and 4
test.disable_channels([0,4])

# List Channel Configuration
test.list_channels()

Troubleshooting Tips

Here are a few tips for troubleshooting this device.

No Available Devices

Double check your connections. On a Raspberry Pi, you may get this is indicated with an OSError: [Errno 121] Remote I/O error readout.

On a Raspberry Pi, also make sure that the I²C hardware is enabled. This is usually indicated with an Error: Failed to connect to I2C bus 1. readout.

Checking Your I²C Connection

A simple method to check if your Raspberry Pi can communicate over I²C with the Qwiic Mux, is to ping the I²C bus. On the latest releases of Raspbian Stretch, the i2ctools package should come pre-installed. If it isn't run the following command in the terminal:

sudo apt-get install i2ctools

Once the i2ctools package is installed, you can ping the I²C bus with the following command in the terminal:

i2cdetect -y 1

You should see a table printed out in the terminal. If the Qwiic Mux is connected/working properly you should see the address space for 0x70 marked with 70.

Resources and Going Further

Now that you've successfully got your Qwiic Mux listening to all of those concurrent addresses, it's time to incorporate it into your own project!

For more information, check out the resources below:

• SparkX (R&D)
  • Schematic (PDF)
  • Eagle Files (ZIP)
  • Product GitHub Repo
• Version 1.0
  • Schematic (PDF)
  • Eagle Files (ZIP)
  • Product GitHub Repo
• Version 1.1
  • Schematic (PDF) (v1.1)
  • Eagle Files (ZIP) (v1.1)
  • Board Dimensions - (v1.1) Dimensions are in inches and the mounting holes are for M3 screws (x4).
  • Product GitHub Repo (v1.1)
  • Product Video
• Datasheet:
  • TCA9548A
  • PCA9548A
• Arduino Example Code:
  • Arduino Example (ZIP)
  • I2C Mux Arduino Library
  • MMA8452Q Arduino Library
• TCA9548A Python Package
  • ReadtheDocs Documentation
• Product GitHub Repo
• SparkFun Product Showcase: Qwiic Mux
  • Gist: Light Spectrogram
• Qwiic Landing Page

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

Or check out this blog post for ideas.