Adafruit has hundreds of designs that use I2C - a two-wire protocol that can let you quickly connect sensors, OLEDs, GPIO expanders, and more. Folks love I2C because you can simply connect 4 wires for power and data, and even better, share those wires with multiple devices!

One things folks don't like about I2C is that each device requires it's own unique 'address'. You can only have one device with a 0x20 address, for example, so while in theory you could have up to 127 device, each for the 7-bits of address space available, in reality you will quickly bump into two sensors with the same address.

Many I2C components have jumpers or switches that allow changing the address, but not all. And some only let you pick between two values. One solution is to use an I2C multiplexer, and these work pretty well, but they require some noodling in your code to set up the multiplexer and then switch between the devices being 'plexed.

The Adafruit LTC4316 I2C Address Translator is another solution, with some magic sprinkled inside. This chip does on the fly address translation. There's an 'input I2C' half, and an 'output I2C' half. And any devices on the 'output' half will automatically have their addresses translated from the input half.

Specifically, each device will have bit A6 flipped (most-significant-bit of the address) and then bits A4 and A5 can also be flipped or kept the same, with the two DIP switches on board. To determine the translated address, we use XOR bitwise math.

Ok, that's a little confusing, so let's work through an example. Say we have an AHT20 connected on the output side of this breakout. The AHT20 does not have an adjustable I2C address: it's fixed at 0x38. If both DIP switches are ON, then only A6 is flipped. That means the I2C controller on the input side will see 0x38 XOR 0x40 = 0x78 address. If we flip the A5 switch off, now it will be 0x38 XOR 0x60 = 0x58 and if both switches are off, now bits A4, A5 and A6 will be flipped, so 0x38 XOR 0x70 = 0x48.

As far as the AHT20 is concerned, it will happily still see I2C writes and reads on 0x38, but from the I2C controller's perspective, the device is responding on the new address.

If you need more than 4 address translation options (two switches give you 4 options) we also have a spot where you can solder an XOR_LOW resistor for setting the 'bottom' 3 bits by soldering in a resistor value according to the datasheet.

It can get confusing quickly, so we definitely recommend using an I2C scanner to debug. Note also that you have to reset the LTC if you change the translation address with resistors or the DIP switches: the translation value is picked up on chip boot and isn't on-the-fly adjustable without a toggle of the Enable pin.

While this chip is magical, there's a few things to watch for: it doesn't seem to support clock-stretching so not for funky chips like BNO055. Just because you can change the address on the fly, doesn't mean the software driver supports it!

Some firmware is expecting a specific address and it may not be trivial to change the address. Check the driver to make sure you know how to change the address to the new value.

To get you going fast, we spun up a custom-made PCB in the STEMMA QT form factor, making it easy to interface. The STEMMA QT connectors on either side are compatible with the SparkFun Qwiic I2C connectors. This allows you to make solderless connections between your development board and the LTC4316 or to chain it with a wide range of other sensors and accessories using a compatible cable. QT Cable is not included, but we have a variety in the shop.

Power Pins

• VIN - this is the power pin. To power the board, give it the same power as the logic level of your microcontroller - e.g. for a 5V microcontroller like Arduino, use 5V.
• GND - common ground for power and logic.

I2C Logic Pins

• SCI - I2C clock pin for the input side, connect to your I2C controller I2C clock line. There is a 10K pullup on this pin.
• SDI - I2C data pin for the input side, connect to your I2C controller I2C data line. There is a 10K pullup on this pin.
• SCO - I2C clock pin for the output side, connect to the clock line on the sensor whose I2C address you want to change. There is a 10K pullup on this pin.
• SDO - I2C data pin for the output side, connect to the data line on the sensor whose I2C address you want to change. There is a 10K pullup on this pin.
• STEMMA QT - These connectors allow you to connectors to dev boards with STEMMA QT connectors or to other things with various associated accessories.
  • The connector on the left of the board, above VIN, is for the input side.
  • The connector on the right of the board, above ENA, is for the output side.

DIP Switches

The two DIP switches are located at the top center of the board. The top switch (1) controls bit A5 and the bottom switch (2) controls bit A4 for the I2C address connected to the output side. This allows for four address translation options:

• If both switches are on, then only A6 will be flipped.
• If the A5 switch is off, bits A5 and A6 will be flipped.
• If the A4 switch is off, bits A4 and A6 will be flipped.
• If both switches are off, bits A4, A5 and A6 will be flipped.

XOR bitwise math is used to calculate the translated I2C address. This can get very complicated very quickly, so it's recommended to use an I2C scanner program to debug. Note also that you have to reset the LTC4316 if you change the translation address.

XORL Resistor Spot

Directly below the DIP switch is a spot to solder a XOR_LOW resistor for setting the 'bottom' 3 bits by soldering in a resistor value according to the datasheet (Table 2. Setting the Resistive Divider at XORL).

Just like with the DIP switches, this can get very complicated very quickly, so it's recommended to use an I2C scanner program to debug. 

Additional Pins

• RDY - This is the Ready pin. It is an output that indicates if the I2C device on the output side is ready for address translation. The pin releases high when the LTC4316 has completed configuration of the address translation byte.
• ENA - This is the Enable pin. It is an input to the LTC4316. You can toggle the pin low to restart the LTC4316. This restarts the configuration of the address translation byte.

Power LED and LED Jumper

• Power LED - In the upper left corner, above the STEMMA connector, on the front of the board, is the power LED, labeled on. It is a green LED.
• LED jumper - This jumper is located on the back of the board, to the right of the board label on the silk. Cut the trace on this jumper to cut power to the "on" LED.

This page shows how to perform an I2C scan to demonstrate how to use the LTC4316 for both a CircuitPython microcontroller and a Raspberry Pi single board computer running Linux. You'll connect two AHT20 sensors, which have the same I2C address (0x38), to experiment with translating the address for one of them. Remember that you need to restart the LTC4316 every time you adjust the DIP switch.

Then, you'll use the Adafruit_CircuitPython_AHTx0 driver to use two AHT20 sensors, with the help of the LTC4316, to read temperature and humidity data.

You can use the AHT20 driver with any CircuitPython microcontroller board or with a computer that has GPIO and Python thanks to Adafruit_Blinka, our CircuitPython-for-Python compatibility library.

CircuitPython Microcontroller Wiring

First wire up the sensors and LTC4316 to your board exactly as follows. The following are the breakouts wired to a Feather RP2040 using the STEMMA connector:

The following are the sensors wired to a Feather RP2040 using a solderless breadboard:

CircuitPython I2C Scan

Before running the AHT20 temperature and humidity example, you'll run an I2C scan to check the translated I2C address for the second AHT20 sensor. Update code.py with this script. Once everything is saved to the CIRCUITPY drive, connect to the serial console to see the data printed out!

# SPDX-FileCopyrightText: 2017 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: MIT

# pylint: disable=broad-except, eval-used, unused-import

"""CircuitPython I2C Device Address Scan"""
import time
import board
import busio

# List of potential I2C busses
ALL_I2C = ("board.I2C()", "board.STEMMA_I2C()", "busio.I2C(board.GP1, board.GP0)")

# Determine which busses are valid
found_i2c = []
for name in ALL_I2C:
    try:
        print("Checking {}...".format(name), end="")
        bus = eval(name)
        bus.unlock()
        found_i2c.append((name, bus))
        print("ADDED.")
    except Exception as e:
        print("SKIPPED:", e)

# Scan valid busses
if len(found_i2c):
    print("-" * 40)
    print("I2C SCAN")
    print("-" * 40)
    while True:
        for bus_info in found_i2c:
            name = bus_info[0]
            bus = bus_info[1]

            while not bus.try_lock():
                pass

            print(
                name,
                "addresses found:",
                [hex(device_address) for device_address in bus.scan()],
            )

            bus.unlock()

        time.sleep(2)
else:
    print("No valid I2C bus found.")

# SPDX-FileCopyrightText: 2017 Limor Fried for Adafruit Industries
#
# SPDX-License-Identifier: MIT

# pylint: disable=broad-except, eval-used, unused-import

"""CircuitPython I2C Device Address Scan"""
import time
import board
import busio

# List of potential I2C busses
ALL_I2C = ("board.I2C()", "board.STEMMA_I2C()", "busio.I2C(board.GP1, board.GP0)")

# Determine which busses are valid
found_i2c = []
for name in ALL_I2C:
    try:
        print("Checking {}...".format(name), end="")
        bus = eval(name)
        bus.unlock()
        found_i2c.append((name, bus))
        print("ADDED.")
    except Exception as e:
        print("SKIPPED:", e)

# Scan valid busses
if len(found_i2c):
    print("-" * 40)
    print("I2C SCAN")
    print("-" * 40)
    while True:
        for bus_info in found_i2c:
            name = bus_info[0]
            bus = bus_info[1]

            while not bus.try_lock():
                pass

            print(
                name,
                "addresses found:",
                [hex(device_address) for device_address in bus.scan()],
            )

            bus.unlock()

        time.sleep(2)
else:
    print("No valid I2C bus found.")

The I2C scanner code runs an I2C scan on each valid bus found and returns the device addresses found.

Both AHT20 sensors are on address 0x38. The sensor on the input side of the LTC4316 will remain on 0x38, but the sensor on the output side of the LTC4316 will be translated depending on the position of the DIP switches. To start, run the scanner code with the LTC4316 with both the A4 and A5 switches off, you'll see this result in the serial monitor:

Set switch A5 to on and power cycle the board. Now you'll see these addresses in the serial monitor:

Set switch A5 to off and A4 to on. Power cycle the board and you'll see these addresses in the serial monitor:

Finally, set both A5 and A4 to on and power cycle the board. The translated address for sensor 2 is 0x78, which is a reserved I2C address so it won't show up in CircuitPython. You'll only see 0x38 for sensor 1:

Raspberry Pi Wiring

Since there are dozens of Linux computers/boards you can use, we will show wiring for Raspberry Pi. For other platforms, please visit the guide for CircuitPython on Linux to see whether your platform is supported.

Here's the Raspberry Pi wired with I2C using the STEMMA connector. When you're working with I2C devices on a Raspberry Pi, it's important to plug everything in before powering up the Pi and do not unplug/replug devices while the Pi is running. This can cause errors on the filesystem.

Here's the Raspberry Pi wired with I2C using a solderless breadboard:

Raspberry Pi I2C Scan

You can run an I2C scan easily on a Raspberry Pi using i2cdetect in a terminal window. If not already done, be sure to enable I2C on the Raspberry Pi via raspi-config. If the i2cdetect command is not found, install it with:

sudo apt-get install i2c-tools

sudo apt-get install i2c-tools

And then to run a scan, use i2cdetect with the following command line parameters:

i2cdetect -y 1

i2cdetect -y 1

Here is the output in the terminal with switch A5 on and switch A4 off:

Now that you've completed the I2C scan on either a CircuitPython microcontroller or a Raspberry Pi, you can run an example for both of the AHT20 sensors.

Python Installation of AHTx0 Library

You'll need to install the Adafruit_Blinka library that provides the CircuitPython support in Python. This may also require enabling I2C on your platform and verifying you are running Python 3. Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready!

Once that's done, from your command line run the following command:

• pip3 install adafruit-circuitpython-ahtx0

If your default Python is version 3 you may need to run 'pip' instead. Just make sure you aren't trying to use CircuitPython on Python 2.x, it isn't supported!

CircuitPython Usage

To use with CircuitPython, you need to first install the Adafruit_CircuitPython_AHTx0 library, and its dependencies, into the lib folder on your CIRCUITPY drive. Then you need to update code.py with the example script.

Thankfully, we can do this in one go. In the example below, click the Download Project Bundle button below to download the necessary libraries and the code.py file in a zip file. Extract the contents of the zip file, and copy the entire lib folder and the code.py file to your CIRCUITPY drive.

Your CIRCUITPY/lib folder should contain the following folders and file:

• /adafruit_bus_device
• /adafruit_register
• adafruit_ahtx0.mpy

Python Usage

Once you have the library pip3 installed on your computer, copy or download the following example to your computer, and run the following, replacing code.py with whatever you named the file:

python3 code.py

Example Code

For this example, you'll have the LTC4315 switch A5 on and switch A4 off. This will give the translated AHT20 sensor an I2C address of 0x68.

If running CircuitPython: Once everything is saved to the CIRCUITPY drive, connect to the serial console to see the data printed out!

If running Python: The console output will appear wherever you are running Python.

# SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
# SPDX-License-Identifier: MIT

"""
LTC4315 with two AHT20 sensors example
Set the LTC4315 switch A5 on and switch A4 off
The translated sensor will be on address 0x68
"""

import time
import board
import adafruit_ahtx0

# Create sensor object, communicating over the board's default I2C bus
i2c = board.I2C()  # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller
default_sensor = adafruit_ahtx0.AHTx0(i2c, 0x38)
translated_sensor = adafruit_ahtx0.AHTx0(i2c, 0x68)

while True:
    print("\nAHT20 at 0x38:")
    print(f"Temperature: {default_sensor.temperature:0.1f} C")
    print(f"Humidity: {default_sensor.relative_humidity:0.1f} %")
    print("\nAHT20 at 0x68:")
    print(f"Temperature: {translated_sensor.temperature:0.1f} C")
    print(f"Humidity: {translated_sensor.relative_humidity:0.1f} %")
    time.sleep(2)

# SPDX-FileCopyrightText: 2024 Liz Clark for Adafruit Industries
# SPDX-License-Identifier: MIT

"""
LTC4315 with two AHT20 sensors example
Set the LTC4315 switch A5 on and switch A4 off
The translated sensor will be on address 0x68
"""

import time
import board
import adafruit_ahtx0

# Create sensor object, communicating over the board's default I2C bus
i2c = board.I2C()  # uses board.SCL and board.SDA
# i2c = board.STEMMA_I2C()  # For using the built-in STEMMA QT connector on a microcontroller
default_sensor = adafruit_ahtx0.AHTx0(i2c, 0x38)
translated_sensor = adafruit_ahtx0.AHTx0(i2c, 0x68)

while True:
    print("\nAHT20 at 0x38:")
    print(f"Temperature: {default_sensor.temperature:0.1f} C")
    print(f"Humidity: {default_sensor.relative_humidity:0.1f} %")
    print("\nAHT20 at 0x68:")
    print(f"Temperature: {translated_sensor.temperature:0.1f} C")
    print(f"Humidity: {translated_sensor.relative_humidity:0.1f} %")
    time.sleep(2)

First, both sensors are instantiated over I2C. The first AHT20 is instantiated with its default address 0x38. The second AHT20 is instantiated with its translated address at 0x68. In the loop, readings from both sensors are printed to the serial monitor.

This page shows how to perform an I2C scan to demonstrate how to use the LTC4316 for with Arduino. You'll connect two AHT20 sensors, which have the same I2C address (0x38), to experiment with translating the address for one of them. Remember that you need to restart the LTC4316 every time you adjust the DIP switch.

Then, you'll use the Adafruit_AHTx0 library to use two AHT20 sensors, with the help of the LTC4316, to read temperature and humidity data.

Wiring

Wire as shown for a 5V board like an Uno. If you are using a 3V board, like an Adafruit Feather, wire the board's 3V pin to the breakout VIN.

Here is an Adafruit Metro wired up to the two AHT20 sensors and the LTC4316 using the STEMMA QT connector:

Here is an Adafruit Metro wired up using a solderless breadboard:

I2C Scan Example Code

// SPDX-FileCopyrightText: 2023 Carter Nelson for Adafruit Industries
//
// SPDX-License-Identifier: MIT
// --------------------------------------
// i2c_scanner
//
// Modified from https://playground.arduino.cc/Main/I2cScanner/
// --------------------------------------

#include <Wire.h>

// Set I2C bus to use: Wire, Wire1, etc.
#define WIRE Wire

void setup() {
  WIRE.begin();

  Serial.begin(9600);
  while (!Serial)
     delay(10);
  Serial.println("\nI2C Scanner");
}


void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    WIRE.beginTransmission(address);
    error = WIRE.endTransmission();

    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);           // wait 5 seconds for next scan
}

// SPDX-FileCopyrightText: 2023 Carter Nelson for Adafruit Industries
//
// SPDX-License-Identifier: MIT
// --------------------------------------
// i2c_scanner
//
// Modified from https://playground.arduino.cc/Main/I2cScanner/
// --------------------------------------

#include <Wire.h>

// Set I2C bus to use: Wire, Wire1, etc.
#define WIRE Wire

void setup() {
  WIRE.begin();

  Serial.begin(9600);
  while (!Serial)
     delay(10);
  Serial.println("\nI2C Scanner");
}


void loop() {
  byte error, address;
  int nDevices;

  Serial.println("Scanning...");

  nDevices = 0;
  for(address = 1; address < 127; address++ )
  {
    // The i2c_scanner uses the return value of
    // the Write.endTransmisstion to see if
    // a device did acknowledge to the address.
    WIRE.beginTransmission(address);
    error = WIRE.endTransmission();

    if (error == 0)
    {
      Serial.print("I2C device found at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.print(address,HEX);
      Serial.println("  !");

      nDevices++;
    }
    else if (error==4)
    {
      Serial.print("Unknown error at address 0x");
      if (address<16)
        Serial.print("0");
      Serial.println(address,HEX);
    }
  }
  if (nDevices == 0)
    Serial.println("No I2C devices found\n");
  else
    Serial.println("done\n");

  delay(5000);           // wait 5 seconds for next scan
}

Both AHT20 sensors are on address 0x38. The sensor on the input side of the LTC4316 will remain on 0x38, but the sensor on the output side of the LTC4316 will be translated depending on the position of the DIP switches.

To start, setup the LTC4316 with both the A4 and A5 switches off. Upload the sketch to your board and open up the Serial Monitor (Tools -> Serial Monitor) at 9600 baud. You'll see this result in the Serial Monitor:

Set switch A5 to on and power cycle the board. Now you'll see these addresses in the Serial Monitor:

Set switch A5 to off and A4 to on. Power cycle the board and you'll see these addresses in the Serial Monitor:

Finally, set both A5 and A4 to on and power cycle the board. In this iteration, sensor 2's translated address is 0x78, which is a reserved I2C address and is usually not used. However, it does show up in with this scan:

Now that you've run the I2C scan test, you can run an example for both of the AHT20 sensors.

Library Installation

You can install the Adafruit AHTX0 library for Arduino using the Library Manager in the Arduino IDE.

Click the Manage Libraries... menu item, search for Adafruit AHTX0, and select the Adafruit AHTX0 library:

If asked about dependencies, click "Install all".

If the "Dependencies" window does not come up, then you already have the dependencies installed.

AHT20 Example

For this example, you'll have the LTC4315 switch A5 on and switch A4 off. This will give the translated AHT20 sensor an I2C address of 0x68.

// SPDX-FileCopyrightText: 2023 Carter Nelson for Adafruit Industries
//
// SPDX-License-Identifier: MIT

// LTC4315 with two AHT20 sensors example
// Set the LTC4315 switch A5 on and switch A4 off
// The translated sensor will be on address 0x68

#include <Adafruit_AHTX0.h>

Adafruit_AHTX0 default_aht;
Adafruit_AHTX0 ltc4316_aht;

void setup() {
  Serial.begin(115200);
  while ( !Serial ) delay(10);
  Serial.println("Adafruit AHT20 with LTC4316 demo!");
  if (! default_aht.begin(&Wire, 0, 0x38)) {
    Serial.println("Could not find AHT20 on 0x38? Check wiring.");
    while (1) delay(10);
  }
  if (! ltc4316_aht.begin(&Wire, 0, 0x68)) {
    Serial.println("Could not find AHT20 attached to LTC4316 on 0x68? Check wiring and switches");
    while (1) delay(10);
  }
  Serial.println("AHT20 sensors found on 0x38 and 0x68");
}

void loop() {
  sensors_event_t humidity0, temp0;
  sensors_event_t humidity1, temp1;
  default_aht.getEvent(&humidity0, &temp0);// populate temp and humidity objects with fresh data
  ltc4316_aht.getEvent(&humidity1, &temp1);// populate temp and humidity objects with fresh data
  Serial.println("AHT20 on 0x38:");
  Serial.print("Temperature: "); Serial.print(temp0.temperature); Serial.println(" degrees C");
  Serial.print("Humidity: "); Serial.print(humidity0.relative_humidity); Serial.println("% rH");
  Serial.println();
  Serial.println("AHT20 on 0x68:");
  Serial.print("Temperature: "); Serial.print(temp1.temperature); Serial.println(" degrees C");
  Serial.print("Humidity: "); Serial.print(humidity1.relative_humidity); Serial.println("% rH");
  Serial.println();

  delay(500);
}

// SPDX-FileCopyrightText: 2023 Carter Nelson for Adafruit Industries
//
// SPDX-License-Identifier: MIT

// LTC4315 with two AHT20 sensors example
// Set the LTC4315 switch A5 on and switch A4 off
// The translated sensor will be on address 0x68

#include <Adafruit_AHTX0.h>

Adafruit_AHTX0 default_aht;
Adafruit_AHTX0 ltc4316_aht;

void setup() {
  Serial.begin(115200);
  while ( !Serial ) delay(10);
  Serial.println("Adafruit AHT20 with LTC4316 demo!");
  if (! default_aht.begin(&Wire, 0, 0x38)) {
    Serial.println("Could not find AHT20 on 0x38? Check wiring.");
    while (1) delay(10);
  }
  if (! ltc4316_aht.begin(&Wire, 0, 0x68)) {
    Serial.println("Could not find AHT20 attached to LTC4316 on 0x68? Check wiring and switches");
    while (1) delay(10);
  }
  Serial.println("AHT20 sensors found on 0x38 and 0x68");
}

void loop() {
  sensors_event_t humidity0, temp0;
  sensors_event_t humidity1, temp1;
  default_aht.getEvent(&humidity0, &temp0);// populate temp and humidity objects with fresh data
  ltc4316_aht.getEvent(&humidity1, &temp1);// populate temp and humidity objects with fresh data
  Serial.println("AHT20 on 0x38:");
  Serial.print("Temperature: "); Serial.print(temp0.temperature); Serial.println(" degrees C");
  Serial.print("Humidity: "); Serial.print(humidity0.relative_humidity); Serial.println("% rH");
  Serial.println();
  Serial.println("AHT20 on 0x68:");
  Serial.print("Temperature: "); Serial.print(temp1.temperature); Serial.println(" degrees C");
  Serial.print("Humidity: "); Serial.print(humidity1.relative_humidity); Serial.println("% rH");
  Serial.println();

  delay(500);
}

Upload the sketch to your board and open up the Serial Monitor (Tools -> Serial Monitor) at 115200 baud. You'll see the two AHT20 sensors recognized over I2C. The first is on its default address of 0x38. The second is on the translated address of 0x68. Then, temperature and humidity readings from both sensors will be printed to the Serial Monitor.

Files

• LTC4316 Datasheet
• EagleCAD PCB Files on GitHub
• Fritzing object in the Adafruit Fritzing Library

Schematic and Fab Print