I/O Expander Modules
2
1
3
Sometimes, when working with microcontrollers, you just don’t have
enough pins to do what needs to be done. You might have started with the
idea of a simple design but later found out that you had forgotten some
crucial features. Uh oh! It can be a lot of work to change to a bigger, more
expensive microcontroller, possibly involving learning some new soldering
or programming skills. But there’s another way out of this pickle.
by Tim Blythman
I
f you’ve been working with
microcontrollers, you’ve almost certainly run into the situation where
you don’t have enough I/O pins to do
what you need to. Or you’ve known in
advance that you don’t have enough
pins, but for whatever reason, you don’t
want to switch to a bigger part. It can
be a conundrum.
The ideal solution is to use an I/O
expander module. In this article, we
describe three different expander modules. They are all controlled over an
I2C serial bus, so at worst, they take
up two pins on your micro. If you’re
already using the I2C bus for other
purposes, they won’t use up any more
pins at all.
That’s the great thing about I2C; the
addressing scheme means that over 100
devices can be controlled by just two
lines. Many microcontroller platforms
(including Arduino and Micromite BASIC) include native support for I2C.
And all three of the modules we
present have the option to change the
device address, so multiple expand34
ers can be connected using the same
bus. I/O pin counts in the hundreds
are easily achievable by using enough
of these modules.
The three modules we describe here
have a variety of different features, so
they have different strengths. We’ll
describe them according to the IC that
they are based around; in each case,
the IC data sheet is a great resource to
help you fully understand each module’s capabilities and quirks.
While it’s possible to use the bare
ICs in your designs, they are all quite
small, so by using a module, you not
only save the effort of having to solder
them, you also get all the other necessary support components along with
handy headers to make connecting to
other devices a cinch.
The PCA9685 module measures 63 ×
25mm and features two six-way headers
for control, plus 12 three-way I/O headers arranged in groups of four. There’s
also a two-way screw terminal for power and six pairs of pads which can be
bridged to change the IC’s I2C address.
The original version of this board was
designed by the Adafruit company, but
has been cloned and is also available
from several different online stores. The
circuit diagram of the original Adafruit
version is shown in Fig.1.
We sourced a few variants of this
board, and found that there were a few
variations, including one that omitted
the reverse-polarity protection and one
that used different resistor values. Another lacked the bypass capacitor. But
they all did pretty much the same job.
Expander 1: PCA9685 module
This module provides up to 16 pulsewidth modulated (PWM) or standard
digital outputs, which can be used for
various purposes including controlling LED brightness or stepper motors.
The PCA9685 IC
This useful IC is manufactured by
NXP; its data sheet can be found at:
https://bit.ly/pe-nov21-nxp
It runs from 2.3-5.5V, so can work
with both 5V Arduinos and 3.3V
Practical Electronics | November | 2021
PCA9685-based 16 x 12-bit PWM Expansion Module
Fig.1: the PCA9685 module circuit (designed by Adafruit). Some variants/clones use different resistor values (eg, 120Ω instead
of 470Ω, so the power LED is very bright) or omit the reverse polarity protection MOSFET or the electrolytic bypass capacitor.
Micromites, as well as the increasing
number of 3.3V Arduinos.
It comes in a 28-pin SSOP or QFN
package (both SMD). While it’s possible to hand-solder chips this small, we
find it easier to use the module if we
have enough space to mount it.
While originally intended to be
an LED PWM driver, Adafruit sells
their PCA9685 board as a servo motor driver. Its 16 PWM channels can
operate at up to 1500Hz with 12 bits
of resolution (4096 steps), which is
more than enough to generate servo
control pulses.
The three-wide rows of pin headers
allow many standard servo motors to
plug directly into the board. At 50Hz
(20ms between the pulses, as in a typical servo signal), pulses can be generated with a resolution of around 5µs,
giving just over 200 steps between the
standard servo pulse-width limits of
1ms and 2ms.
With these normally corresponding
to positions of 0° and 180°, this gives
a mechanical resolution of slightly better than 1°.
One interesting feature which may
come in useful is that the PWM outputs
can be started at different times, giving
Practical Electronics | November | 2021
them different phases throughout the
PWM cycle, although all outputs must
run at the same frequency.
So for example, if you are driving
multiple LEDs at less than full duty,
they can be timed to stagger their
switch-on times, such that (for example) only one is switched on at a time.
This will limit the current steps drawn
from the supply and probably reduce
EMI too.
With the addition of a high-current
buffer (eg, a Darlington array), this board
could even be used to drive a stepper
motor or brushless DC motor. By staggering the phases and changing the frequency, the output of the PCA9685 can
be set to produce a pulse train sufficient
to allow the motor to keep turning without further intervention.
We tested out some possible approaches to generate motor drive signals with this module, and some examples of the waveforms we came up with
are shown in oscilloscope grab Scope 1.
Module description
Apart from the 16 sets of output pins
(each output is paired with a dedicated GND and power pin), there are
also headers for power and I2C bus
connections as well as six solder jumpers to allow the address to be set.
An output enable (OE) pin is also
broken out on the board, allowing all
outputs to be enabled or disabled with a
single signal, but an external clock connection is not provided. The module
relies on the chip’s internal 25MHz oscillator instead. The external clock pin
is grounded as per the data sheet’s recommendation for when it is not used.
Referring to the circuit diagram in
Fig.1, we see that there are two different supply rails on the board. A nominal 5V rail powers the chip and can
be found on the six-way headers at the
pin marked VCC. In a 3.3V system, this
would be connected to the 3.3V rail.
A second rail marked V+ is also available at the six-way header, as well as
the two-way screw terminal. A diodewired MOSFET provides reverse polarity protection if power is fed into
V+ from the screw terminal but not
from the header. A 1000µF capacitor
bypasses the V+ rail.
There is no connection between V+
and VCC. The intention is that servo motors (if connected) run from the V+ rail,
while the logic runs from VCC, minimising interaction between the logic and
35
The PCA9685-based
module is one of the
better designed I/O
expander modules.
Practically all the
available pins are
broken out, with the
control pins replicated
at each end, to allow
multiple modules to be
daisy-chained.
power parts of the circuit. All they have
in common is a ground connection.
A separate bypass capacitor for the IC
and the power indicator LED is also fed
from VCC. Apart from the external clock
pin, all the IC’s pins are broken out.
The six address pins (A0-A5) are
normally pulled to ground by 10kΩ
resistors, but they can be individually pulled high if the associated solder
jumper is bridged.
While this might appear to give up
to 64 available addresses, due to I2C
reserved addresses and auxiliary addresses for the PCA9685, the actual
usable number is 55, using the (7-bit)
range 64-119, excepting 112.
By default, with no jumpers set, the
board has a 7-bit address of 64 or hexadecimal 0x40. The six jumpers effectively set the value of the six low-order
address bits.
Address 112 is designated as ‘All
Call’ and can be used to address any
PCA9685 device regardless of its set
address. This allows initialisation of a
large number of ICs to occur quickly,
by setting all attached devices to the
same initial conditions.
During initialisation (or at any
other time), the outputs can be set to
open-drain (either pull low or highimpedance), push-pull or to inverted
push-pull configurations.
The 16 PWM outputs are brought out
to the top (yellow) row of pins on the
board, where they are combined with a
row of V+ (red) and GND (black) headers to form a row of servo motor compatible connection points.
The OE (output enable) pin is
brought out to the six-way headers but
is also pulled to GND by a 10kΩ resistor, so the outputs are enabled by default. This line can be pulled up by a
Fig.2: the basic wiring needed to connect the
PCA9685-based module to an Arduino or Micromite.
In each case, only four wires are needed, with I2C
pull-up resistors being provided by the module.
36
host micro to shut down the outputs
if necessary.
The I2C SDA and SCL pins are also
brought out to the six-way headers
and these have 10kΩ pull-up resistors.
While this is higher than the recommended 4.7kΩ value for I2C bus lines,
we had no trouble without adding external pull-ups. Later, we will look at
how these resistors behave when multiple boards are connected.
Cleverly, the two six-way headers
have matching pin-outs, so boards can
be stacked end to end, for example,
by fitting a female header to one end
and a male jumper to the other. The
V+ track is quite thick, and the GND
trace consists of a solid copper pour
on the back of the PCB, so passing a
fair amount of current between boards
is possible.
It appears the board is quite well designed and breaks out practically all
the useful features of the PCA9685 IC.
What needs to be connected?
For basic testing, only four wires are
needed: VCC, GND, SDA and SCL. If
you wish to connect a servo motor to
the headers, you will need a supply
for the V+ rail too. The basic connections for a Micromite and Arduino are
shown in Fig.2.
Software
We have written sample programs for Arduino and Micromite. Both of these allow
the PWM frequency to be set,
as well as the start and duration times of the pulses.
Internally, the PCA9685
uses start and end variables
to define the pulse parameters of each output, as well as
specific bits to enable full-on
and full-off states, so some
minor translation is done by
the code.
In the Micromite example, these variables are set
by sliders on an attached
ILI9341 LCD (as you would
have on a Micromite LCD
BackPack), while the Arduino code uses the serial
monitor as a menu to enter
the parameters, these being
a letter for the parameter followed by its value. Both examples contain some functions to simplify writing
your own code to control
the module. Adafruit has
also written an Arduino library which can be found at
https://bit.ly/pe-nov21-ada
Our sample program code
is available for download in
Practical Electronics | November | 2021
Scope 1: here we’re using the PCA9685 module to generate
pulse trains each phase shifted by approximately 120°
compared to the last. Waveform like this could be used to
drive a brushless motor or spread out the current demand
of multiple PWM loads.
this month’s free bundle from the November 2021 page of the PE website.
Expander 2:
PCF8574 module
You may have heard of the PCF8574
before, especially if you have ever
used any of the I2C-controlled character LCD panels, as described in our
June 2018 article. It is the PCF8574
that provides the I2C-to-parallel conversion that makes it so easy to use
these LCD screens.
The module we are looking at, designated ‘HW-171’, measures 48 × 11mm,
although other similar modules are
also available. Its circuit diagram is
shown in Fig.3. It has a wide operating
voltage range, 2.5-6V, making it suitable for all 3.3V and 5V applications.
The I2C modules designed to attach
to the back of an LCD panel can also be
used as I/O expanders, although they
usually omit one of the pins as only
seven control lines are needed for driving a character LCD.
This module has a simple interface, with a four-pin male header at
one end and a four-pin female header
at the other end for control and daisy
chaining. The pins are designated VCC,
GND, SDA and SCL, with the last two
being the I2C bus. A nine-way header
breaks out the I/O ports on one side
(the ninth pin provides an interrupt
Scope 2: this demonstrates using the PCA9685 module to
produce three different PWM waveforms with different
rise and fall positions, with each duty cycle being fully
adjustable. The main restriction is that the repetition
frequency of all outputs must be the same.
function), while a row of three threepin headers with jumper shunts are
used for address selection.
The male/female pin header combination allows multiple modules to be
easily connected to the same I2C bus,
and the addressing scheme allows up
to eight unique addresses.
Apart from the main IC, the only
other electronic components on the
module are a pair of 1kΩ pull-up resistors on the I2C lines. These are much
lower values than are typically used as
I2C pull-ups, but it still seems to work
fine. We’ll have a look at the effects of
these resistors a bit later.
The PCF8574 IC
Just Like the PCA9685, the PCF8574
is made by NXP. Its datasheet is well
worth a look, and you can examine
it here: https://bit.ly/pe-nov21-nxp2
While it can only have eight different addresses, there is a variant called
the PCF8574A, which is identical but
has a different set of addresses, giving
16 total possibilities.
The PCF8574 can have a 7-bit address from the range 32 to 39, while
the PCF8574A can have an address
from 56 to 63. Our units had a default
address of 32. Since the chips are interchangeable, if you can’t get your
module to work, check which of these
two chips it has.
The PCF8574 modules are designed to be stacked end-on-end, meaning that
it’s trivial to connect multiple such modules to a single microcontroller. Note
that the address jumpers are set here to give each module a different I2C bus
address, to avoid conflicts.
Practical Electronics | November | 2021
While NXP does not make a DIP version of this IC, Texas Instruments does,
so it is possible to replicate the functions of this module on a breadboard
with the addition of two pull-up resistors for the I2C bus.
The datasheet mentions the
PCF8574’s suitability for driving
LEDs, but unlike the PCA9685, this
device is quite minimalist and so can
only switch them on or off. But it does
provide the ability to read the state of
each pin, allowing them to be used as
digital inputs, which the more complex
PCA9685 does not.
Each of the eight I/O pins can be set
to one of two states. The default powerup state is for the pins to be pulled up
by a 100µA current source. In this state,
the pin can be used as an input, detecting when a connected device pulls the
pin low. The 100µA current source is
also sufficient to drive a logic pin high,
such as when the PCF8574 is used to
drive alphanumeric LCD screens.
The other state is to pull the pin low.
Each pin can sink up to 10mA. A brief
1mA pull-up current is applied on a
transition from low to high, supplementing the weak 100µA pull-up and
speeding up transitions.
While this scheme appears very basic, it allows all the pins to be written
and/or read with a single byte command. Since repeated reads or writes
can occur during the same I2C transaction, complex wave trains can be
generated as easily as port writes on
a microcontroller.
This is perfect for controlling devices such as the character LCDs we
mentioned earlier, as a stream of digital
data is often needed to update a series
of characters on the display.
The interrupt pin is an open-drain
active-low output, and goes low on
37
needed; the data that is written or read
corresponds precisely to the pin states.
PCF8574-based I/O Expansion Module
Fig.3: the circuit of the PCF8574-based module. Apart from the main IC, there
are just two extra resistors. It’s a great module in that all the useful pins are
broken out in a well laid out arrangement.
Fig.4: the wiring for the PCF8574
module is similar to the others, as they
all use an I2C serial control interface.
The boards have both female and male
sockets; either end can be connected to
a microcontroller, with the other end
connecting to nothing, or more boards.
any change of input pin level. It is reset when a read occurs. It is intended
to signal to the microcontroller that the
input state(s) have changed and require
reading. The interrupt pins of multiple
38
modules can be paralleled, as any device can assert a low without conflicting with other modules.
With such a simple control scheme,
no initialisation or command codes are
Module description
The module itself is quite simple, as
noted above, with only two resistors
in addition to the main IC.
While the stackable feature of the
modules is handy, it’s a pity that the
interrupt function is not brought out
to a fifth pin at each end, which would
make it easy to feed this signal back
to the controller.
VCC and GND pins near the I/O
pins would have been nice too; as
it is, there is nowhere convenient to
connect the controlled device to the
power supply.
As for the other module, only four
connections are needed: VCC, GND,
SDA and SCL. See Fig.4 for the recommended connections to either a Micromite or an Arduino.
Software
As for the PCA9685 module, we have
created both an Arduino and Micromite example program. The Micromite
program uses a touch panel interface,
while the Arduino program uses a serial interface.
Entering any of the numbers 0-7 will
toggle the state of that output pin. The
pin states are also read and the current
state displayed. A read can also be performed by pressing the ‘READ’ button
or entering ‘R’ on the Arduino software.
To help with troubleshooting, we’ve
found some small I2C scanner programs
(for Arduino and Micromite) and included them in our software download
for this article.
These scan all addresses on the I2C
bus and determine which addresses are
actually in use. That might help you
figure out which address your module
is set for, if you can’t figure it out from
the jumpers and IC code.
Expander 3: MCP23017/S17 module
The MCP23017 IC is produced by Microchip, the same company responsible for PIC microcontrollers. It has 16
bi-directional digital I/O ports and is
controlled over an I2C bus. There is
an SPI version, which is called the
MCP23S17. The module suits either
version of the IC, as some of the pins
are marked with designators for both
I2C and SPI signals.
The MCP23017 IC has a working
range of 1.8-5.5V, so this module is suitable for use with both Micromites and
Arduinos. It is quite compact, measuring just 25 × 20mm, although this
means that it only has space to label the
functions on the back of the module. It
has 30 pins in total, although they do
not come fitted with headers.
Practical Electronics | November | 2021
It supports full bi-directional I/O operation on all pins. The register set is
reminiscent of a PIC microcontroller,
with control bytes for direction, pullups, output latches, port reading and
interrupt enable. There’s also another
byte which can be used to invert the
polarity of the port.
Given this many registers, there’s
a greater level of control than for the
PCF8574-based module, including full
push-pull output drivers, although it
lacks the PWM feature of the PCA9685.
Just like a PIC microcontroller, all
the I/O pins start as inputs but can be
set to be outputs. The commands are
simple, and consist of the IC address
(as for all I2C transactions) followed
by a command (register) byte and data
byte. Port writes up to eight-bits wide
are possible. Its data sheet can be found
at: https://bit.ly/pe-nov21-mc
Module description
There are two rows of ten pins at one
end of the module with the connections
to the controlled I/O ports (16 pins)
plus connections for interrupt signals
and power. There is another single row
of 10 pins with the connection to the
host for control and power; other nonI/O pins such as the address pins are
broken out here too.
But the small size of the module
means that some of the nicer features
found on the other boards are omitted.
For example, although the MCP23017
has three address pins to allow addressing up to eight modules, these pins
aren’t broken out to jumpers. To use
them, you have to solder a wire from
one or more of the address pins to the
ground pin.
Similarly, there isn’t a header to
allow multiple modules to be easily
stacked. So it’s most easily used when
it’s the only expander module connected to the micro.
The fact that the two rows of output
pins are adjacent means that the module does not lend itself well to being
used on a breadboard, unless you’re
happy using just one row of the output pins.
The circuit
The circuit diagram for this module is
shown in Fig.5. Apart from the main IC,
there are two 10kΩ resistors, one fourway 10kΩ resistor array and a 100nF
ceramic capacitor, used to bypass the
IC’s supply.
The two individual resistors are the
I2C pull-ups, while the resistor array is
connected to pull the RESET (MR) pin
high (so the chip will operate as soon as
power is supplied) and the address pins
low (setting the default address). Otherwise, all the IC’s pins are connected
Practical Electronics | November | 2021
directly to pads on the module, with
power (VCC) and ground being the only
pins connected via both sets.
For basic operation, only four wires
need to be connected; power, ground
and the two I2C lines. These connections are sufficient to work with our
sample code, and are shown in Fig.6.
Software
Because the MCP23017 works similarly to microcontroller I/Os, we have
written our code to emulate the most
common microcontroller pin control
functions. For Arduino, the functions
are named:
MCP23017digitalWrite()
MCP23017digitalRead()
MCP23017pinMode()
These work the same as their native
counterparts. Our sample code is nothing more than the classic ‘blink’ routine
(which toggles an output between high
and low at 1Hz), with code added to
read back the set state.
The Micromite code is similar, although the syntax of the commands is
slightly different from the inbuilt statements. The functions are named:
MCP23017SETPIN
MCP23017READPIN
MCP23017WRITEPIN
The pin modes are:
OUT
IN
IN_PULLUP
the absolute maximum pin current of
the PIC32, and even under these conditions, I2C communications at 400kHz
(the Micromite’s upper speed limit)
worked flawlessly.
So a maximum of four PCF8574based modules or 45 PCA9685-based
modules can be connected to a Micromite, based on current draw on the I2C
pins. This does not take into account
extra capacitance which may be added
to the bus lines when extra modules
are added, so these numbers may not
be achievable in practice.
Removing the resistors from some of
the modules will decrease this load, as
will adding a second I2C bus.
Similarly, the ATmega328 processor
on an Arduino Uno supports a maximum of 40mA on each pin, which corresponds to 125Ω pull-ups to the 5V
supply. So we tested using 150Ω pullup resistors.
This too proved to work fine for both
modules, suggesting up to six PCF8574based modules or 66 PCA9685-based
modules can be connected to an Arduino board. This includes the same
assumptions as earlier, and these results may not be achievable in practice.
It appears that the I2C bus is quite
robust, and can work well if it’s operating slightly outside its recommended conditions.
Although we didn’t run any tests on
the MCP23017-based module, based on
these results, it should work fine with
up to eight modules (the maximum that
would be addressable).
The Micromite code draws buttons
on an attached ILI9341 LCD screen in
landscape mode. Four rows of sixteen
buttons correspond to the 16 I/O channels and four states; the states are: input, input with pull-up, output high
and output low. A further row shows
the last states read from the I/O pins.
Pressing any of the buttons, including
the ‘read’ button, will cause the read
states to be updated.
Level shifting
Another interesting possibility that
arises in using I/O expander modules
is that it allows for parts of the circuit
to operate at different voltages.
I2C is an open-collector bus, so devices either pull the SCL and SDA lines to
ground or let them rise to a higher voltage due to the pull-up resistors. Thus, it
isn’t necessary for all devices on the bus
to have an identical logic high voltage.
If the bus pull-ups are connected
to the lowest voltage supply used, no
I2C pull-ups
All three of these modules communicate via I2C, and all have onboard
pull-up resistors. The total pull-up resistance decreases as more boards are
added and the resistors are effectively
paralleled. We investigated what range
of resistances allowed for correct operation, to get an idea of how many boards
could realistically be used without
modification.
For the Micromite, 220Ω pull-up resistances for SDA and SCL result in
15mA being sunk from the 3.3V supply
when the pins are driven low. This is
The MCP23017 module does not
feature stackable headers or address
jumpers, but it is very compact and
provides full digital I/O control
of 16 pins, similar to that of a
microcontroller. Due to its small size,
the pins are labelled on the back of
the module.
39
CJMCU-2317 (MCP23017) I/O Expander Module
Fig.5: the MCP23017-based module is quite compact, although this does leave it
at a minor disadvantage for usability compared to the other two modules. The
I2C and power pins are on one side, with the I/O pins on the other side.
Fig.6: as for the other two modules, only
four wires are needed. These connections
are conveniently arranged as a group at
one end of the module.
40
damage can occur through over-voltage. As long as this level is detected
as high by the device with the highest
logic voltage, then it will still work, although with reduced margin in clearly
defined logic levels.
It’s important in this sort of situation to ensure that the pull-up resistors
that are connected to the bus go only
to the lower voltage supplies (although
most chips have internal clamp diodes
which will clamp the high voltage to a
safe level anyway).
So for example, you could connect
an I/O expander module running off
5V to a 3.3V Micromite and it should
work just fine.
You would then have 3.3V I/Os available direct from the Micromite, and 5V
I/Os from the expander. Ideally, the I2C
pull-ups should go to the 3.3V supply.
Similarly, you could connect a 3.3V
I/O expander to a 5V Arduino micro.
In this case, you would want to use the
pull-ups on the expander module. The
Arduino will read 3.3V as a high level,
and while it will have its own 5V I/Os,
you can also use the 3.3V I/Os of the
expander module to communicate with
other devices running at 3.3V.
One of these expander modules may
even be the easiest and cheapest way
to communicate with a chip that has a
digital interface operating at a different
level to your micro.
Note though that the resulting I/O
speeds will not be very high; this is another factor to be considered.
Summary
Each module described here provides
quite a different set of features, so
which one is best for you will depend
on your needs. You may even find it
handy to connect multiple different
expander modules to a single micro to
perform different jobs.
For PWM or servo control, or LED
brightness control, the PCA9685 module is the most useful. Its large number
of possible addresses is also a strength.
But it doesn’t provide you with any extra digital inputs.
The PCF8574 module is the simplest
and easiest to use.
If you need more full-fledged microcontroller type I/O pins, then the
MCP23017 module has the advantage.
There is extra overhead in controlling it
compared to the PCF8574, but this is offset by extra features and more I/O pins.
As mentioned above, you can mix
and match the modules, although it
is an unlucky coincidence that the
MCP23017 and the PCF8574 both share
the same address space.
Reproduced by arrangement with
SILICON CHIP magazine 2021.
www.siliconchip.com.au
Practical Electronics | November | 2021
