Now and again there’s a need to expand the I/O capabilities of your chosen microcontroller, and instead of upgrading you can often use external parts to help solve the problem.

One example of this is the 74HC4067 16-channel analog multiplexer demultiplexer. That’s a mouthful – however in simple form it’s an IC that can direct a flow of current in either direction from one pin to any one of sixteen pins. Another way to think abou it is that you can consider the 74HC4067 to be a digital replacement to those rotary switches that allow you to select one of sixteen positions.

Here’s an example of the SMD version:

Don’t let that put you off, it’s just what we had in stock at the time. The part itself is available in through-hole and surface mount versions.

Using the 74HC4067

At this point you should download the data sheet, as we refer to it through the course of the article. The first thing to note is that the 74HC4067 can operate on voltages between 2 and 6V DC, which allows use with 3.3V and 5V microcontrollers and boards such as Arduino and Raspberry Pi. If for some reason you have the 74HCT4067 it can only work on 4.5~5.5V DC. Next – consider the pinout diagram from the data sheet:

The power supply for the part is applied to pin 24, and GND to … pin 12. Pin 15 is used to turn the control the current flow through the inputs/outputs – if this is connected to Vcc the IC stops flow, and when connected to GND it allows flow. You can always control this with a digital output pin if required, or just tie it to GND if this doesn’t matter.

Next – pin one. This is where the current either flows in to be sent to one of the sixteen outputs – or where the current flows out from one of the sixteen inputs. The sixteen inputs/outputs are labelled I0~I15. Finally there are the four control pins – labelled S0~S3. By setting these HIGH or LOW (Vcc or GND) you can control which I/O pins the current flow is directed through. So how does that work? Once again – reach for the the data sheet and review the following table:

Not only does it show what happens when pin 15 is set to HIGH (i.e. nothing) it shows what combination of HIGH and LOW for the control pins are required to select which I/O pin the current will flow through. If you scroll down a bit hopefully you noticed that the combination of S0~S3 is in fact the binary equivalent of the pin number – with the least significant bit first. For example, to select pin 9 (9 in binary is 1001) you set the IC pins S0 and S3 to HIGH, and S1 and S2 to LOW. How you control those control pins is of course up to you – either with some digital logic circuit for your application or as mentioned earlier with a microcontroller.

Limitations

Apart from the power supply requirements, there are a few limitations to keep in mind. Open you data sheet and consider the “DC Electrical Specifications” table. The first two parameters show what the minimum voltage that can be considered as a HIGH and the maximum for a LOW depending on your supply voltage. The next item of interest is the “ON” resistance – that is the resistance in Ohms (Ω) between one of the sixteen inputs/outputs and the common pin. When a channel is active, and a 5V supply voltage, we measured a resistance of 56Ω without a load through that channel – and the data sheet shows other values depending on the current load and supply voltage. Finally, don’t try and run more than 25 mA of current through a pin.

Examples

Now to show an example of both multiplexing and demultiplexing. For demonstration purposes we’re using an Arduino Uno-compatible board with the 74HC4067 running from a 5V supply voltage. Pin 15 of the ‘4067 is set to GND, and control pins S0~S3 are connected to Arduino digital output pins D7~D4 respectively.

Multiplexing

This is where we select one input pin of sixteen and allow current to flow through to the common pin (1). In this example we connect the common pin to the board’s analog input pin – so this can be used as a method of reading sixteen analog signals (one at a time) using only one ADC. When doing so – take note of the limitations mentioned earlier – take some resistance measurements in your situation to determine what the maximum value will be from your ADC and calibrate code accordingly.

With both of the examples we’ll use port manipulation to control the digital pins which are connected to the 74HC4067’s control pins. We do this as it reduces the code required and conceptually I feel it’s easier. For example – to select I/O 15 you need to turn on all the control pins – so you just have to set Arduino PORTD to B11110000 (which is binary 15 LSB first) and much neater than using four digitalWrite() functions.

In the following example sketch, you can see how we’ve put the binary values for each control possibility in the array byte controlPins[] – which is then used to set the pins easily in void loop().

This simply sets each input pin in turn, then reads the ADC value into an array – whose values are then sent to the serial monitor:

// 74HC4067 multiplexer demonstration (16 to 1) // control pins output table in array form // see truth table on page 2 of TI 74HC4067 data sheet // connect 74HC4067 S0~S3 to Arduino D7~D4 respectively // connect 74HC4067 pin 1 to Arduino A0 byte controlPins[] = {B00000000, B10000000, B01000000, B11000000, B00100000, B10100000, B01100000, B11100000, B00010000, B10010000, B01010000, B11010000, B00110000, B10110000, B01110000, B11110000 }; // holds incoming values from 74HC4067 byte muxValues[] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,}; void setup() { Serial.begin(9600); DDRD = B11111111; // set PORTD (digital 7~0) to outputs } void setPin(int outputPin) // function to select pin on 74HC4067 { PORTD = controlPins[outputPin]; } void displayData() // dumps captured data from array to serial monitor { Serial.println(); Serial.println("Values from multiplexer:"); Serial.println("========================"); for (int i = 0; i < 16; i++) { Serial.print("input I"); Serial.print(i); Serial.print(" = "); Serial.println(muxValues[i]); } Serial.println("========================"); } void loop() { for (int i = 0; i < 16; i++) { setPin(i); // choose an input pin on the 74HC4067 muxValues[i]=analogRead(0); // read the vlaue on that pin and store in array } // display captured data displayData(); delay(2000); }

… and a quick video of the results:

Demultiplexing

Now for the opposite function – sending current from the common pin to one of sixteen outputs. A fast example of this is by controlling one of sixteen LEDs each connected to an output pin, and with 5V on the 74HC4067 common pin. We don’t need current-limiting resistors for the LEDs due to the internal resistance in the 74HC4067. Here’s the sketch:

// 74HC4067 demultiplexer demonstration (1 to 16) // control pins output table in array form // see truth table on page 2 of TI 74HC4067 data sheet // connect 74HC4067 S0~S3 to Arduino D7~D4 respectively // 5V to 74HC4067 pin 1 to power the LEDs 🙂 byte controlPins[] = {B00000000, B10000000, B01000000, B11000000, B00100000, B10100000, B01100000, B11100000, B00010000, B10010000, B01010000, B11010000, B00110000, B10110000, B01110000, B11110000 }; void setup() { DDRD = B11111111; // set PORTD (digital 7~0) to outputs } void setPin(int outputPin) // function to select pin on 74HC4067 { PORTD = controlPins[outputPin]; } void loop() { for (int i = 0; i < 16; i++) { setPin(i); delay(250); } }

… and the LEDs in action:

Conclusion

If you’re considering the 74HC4067 or hadn’t known about it previously, we hope you found this of interest. You can order them in breakout boards, through-hole or surface-mount package.

This post is brought to you by pmdway.com – everything for makers and electronics enthusiasts, with free delivery worldwide.

To keep up to date with new posts at tronixstuff.com, please subscribe to the mailing list in the box on the right, or follow us on twitter @tronixstuff.