// CD74HC4067
// 16-Channel Analog Multiplexer
// Demultiplexing not implemented for this simulation.
// https://www.ti.com/lit/ds/symlink/cd74hc4067.pdf

#include "Mux.h"


#define S0 18
#define S1 19
#define S2 22
#define S3 23

#define CLK 32
#define DT 35
#define SW 34
#define EN 33


uint8_t pins[4] {S0, S1, S2, S3};
uint8_t ens[2]{25, 26};

auto m = COMBINED_MUX(pins, ens);

int counter[16] {};
int btnCounter[16] {};
bool currentStateCLK[16] {};
bool lastStateCLK[16] {};
bool btnStates[16] {};


void setup() {
 Serial.begin(115200);
 pinMode(32, OUTPUT);
 m.setup();
}


void loop() {
 
 for (size_t i = 0; i < m.length(); i++) {
 m.select(0);
 digitalWrite(32, 1);
 delay(1000);
 m.select(16);
 delay(1000);
 digitalWrite(32, 0);
 delay(1000);
 }
}

CD74HC4067.ino

diagram.json

// CD74HC4067
// 16-Channel Analog Multiplexer
// Demultiplexing not implemented for this simulation.
// https://www.ti.com/lit/ds/symlink/cd74hc4067.pdf

#include "wokwi-api.h"
#include <stdio.h>
#include <stdlib.h>

#define MUX_MODE OUTPUT

typedef struct {
 pin_t COM;
 pin_t VCC;
 pin_t E;
 pin_t Y[16];
 pin_t S[4];
 pin_t GND;
} chip_data_t;

void OnPinChanged(void *data, pin_t pin, uint32_t value)
{
 chip_data_t *chip_data = (chip_data_t*)data;
 bool E = pin_read(chip_data->E);
 printf("%d", value);
 
 if (!E)
 {
 bool S0 = pin_read(chip_data->S[0]);
 bool S1 = pin_read(chip_data->S[1]);
 bool S2 = pin_read(chip_data->S[2]);
 bool S3 = pin_read(chip_data->S[3]);

 int inputIndex = S3 << 3 | S2 << 2 | S1 << 1 | S0;

 if (MUX_MODE == OUTPUT){
 float input = pin_adc_read(chip_data->Y[inputIndex]);
 pin_dac_write(chip_data->COM, input);
 return;
 }

 float input = pin_adc_read(chip_data->Y[inputIndex]);
 pin_dac_write(chip_data->COM, input);
 }
}


void chip_init() 
{
 chip_data_t *chip_data = (chip_data_t*)calloc(1, sizeof(chip_data_t));

 chip_data->COM = pin_init("COM", ANALOG);

 chip_data->E = pin_init("E", INPUT);

 chip_data->Y[ 0] = pin_init("Y0", ANALOG);
 chip_data->Y[ 1] = pin_init("Y1", ANALOG);
 chip_data->Y[ 2] = pin_init("Y2", ANALOG);
 chip_data->Y[ 3] = pin_init("Y3", ANALOG);
 chip_data->Y[ 4] = pin_init("Y4", ANALOG);
 chip_data->Y[ 5] = pin_init("Y5", ANALOG);
 chip_data->Y[ 6] = pin_init("Y6", ANALOG);
 chip_data->Y[ 7] = pin_init("Y7", ANALOG);
 chip_data->Y[ 8] = pin_init("Y8", ANALOG);
 chip_data->Y[ 9] = pin_init("Y9", ANALOG);
 chip_data->Y[10] = pin_init("Y10", ANALOG);
 chip_data->Y[11] = pin_init("Y11", ANALOG);
 chip_data->Y[12] = pin_init("Y12", ANALOG);
 chip_data->Y[13] = pin_init("Y13", ANALOG);
 chip_data->Y[14] = pin_init("Y14", ANALOG);
 chip_data->Y[15] = pin_init("Y15", ANALOG);

 chip_data->S[0] = pin_init("S0", INPUT);
 chip_data->S[1] = pin_init("S1", INPUT);
 chip_data->S[2] = pin_init("S2", INPUT);
 chip_data->S[3] = pin_init("S3", INPUT);

 const pin_watch_config_t pinWatchConfig = 
 {
 .edge = BOTH,
 .pin_change = OnPinChanged,
 .user_data = chip_data
 };

 bool b = pin_watch(chip_data->E, &pinWatchConfig);
 printf("pin_watch = %s\n", b ? "true" : "false");
}

CD74HC4067.chip.c

CD74HC4067

CD74HC4067.chip.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:


libraries.txt

#ifndef Mux_h
#define Mux_h

#include "MuxBase.h"
#include "MuxIO.h"
#include "CombinedMux.h"

#endif

Mux.h

#ifndef MuxBase_h
#define MuxBase_h

template <size_t N>
using MuxSelectorPins = const uint8_t (&)[N];

template <size_t N>
class Mux
{
private:
 MuxSelectorPins<N> pins;
 bool flip;
public:

 // define mux selector pins : S0, S1, ...Sn
 // however since there is no standard for mux implementation
 // it is possible to get unexpected result by selecting the wrong channel
 // read the datasheet of your chip for more info about the truth table
 // to mitigate the lack of standarized implementation
 // use the flip argument or just reverse the order of selector pins
 // 
 // non-flipped 
 // |__S0__|__S1__|__Ch__|
 // |___1__|___0__|__1___| 
 // |___0__|___1__|__2___|
 // 
 // flipped
 // |__S0__|__S1__|__Ch__|
 // |___0__|___1__|__1___|
 // |___1__|___0__|__2___|
 Mux(MuxSelectorPins<N> selectorPins, bool flip = false)
 :pins(selectorPins), flip(flip){}

 ~Mux(){};

 void select(size_t channel){
 size_t n = channel;
 for (size_t i = 0; i < N; i++)
 {
 digitalWrite(pins[i], n & 1);
 n = n >> 1;
 }
 }

 void setup(){
 for (size_t i = 0; i < N; i++)
 {
 pinMode(pins[i], OUTPUT);
 } 
 }

 size_t length(){
 return 1 << N;
 }
};


template <size_t N>
Mux<N> MUX(MuxSelectorPins<N> selectorPins, bool flip = false){
 Mux<N> m(selectorPins, flip);
 return m;
}


#endif

MuxBase.h

#ifndef MuxIO_h
#define MuxIO_h

#include "MuxBase.h"

template <size_t N>
class MuxIO
{
private:
 Mux<N> mux;
 uint8_t io;
 uint8_t en = NULL;

 void ch(uint8_t channel){
 disable();
 mux.select(channel);
 enable();
 }

public:

 // selectoPins : S0, S1, ...Sn
 // io : signal pin
 // en : allow the multiplexer to be enabled or disabled from the software
 MuxIO(MuxSelectorPins<N> selectorPins, uint8_t io, uint8_t en = NULL)
 :mux(selectorPins), io(io), en(en){}

 // selectoPins : S0, S1, ...Sn
 // flip : in case the multiplexer has non-standard truth table
 // io : signal pin
 // en : allow the multiplexer to be enabled or disabled from the software
 MuxIO(MuxSelectorPins<N> selectorPins, bool flip, uint8_t io, uint8_t en = NULL)
 :mux(selectorPins, flip), io(io), en(en){}



 ~MuxIO(){}

 void enable(){
 if(en == NULL) return;
 digitalWrite(en, 0);
 }

 void disable(){
 if(en == NULL) return;
 digitalWrite(en, 1);
 }

 size_t length(){
 return mux.length();
 }

 void pinMode(uint8_t mode){
 ::pinMode(io, mode);
 }

 void setup(){
 mux.setup();
 }

 void digitalWrite(uint8_t channel, bool val){
 ch(channel);
 ::digitalWrite(io, val);
 }

 void analogWrite(uint8_t channel, int val){
 ch(channel);
 ::analogWrite(io, val);
 }

 bool digitalRead(uint8_t channel){
 ch(channel);
 return ::digitalRead(io);
 }

 int analogRead(uint8_t channel){
 ch(channel);
 return ::analogRead(io);
 }
};

template <size_t N>
MuxIO<N> MUXIO(MuxSelectorPins<N> selectorPins, bool flip, uint8_t io, uint8_t en = NULL){
 MuxIO<N> m(selectorPins, flip, io, en);
 return m;
}

template <size_t N>
MuxIO<N> MUXIO(MuxSelectorPins<N> selectorPins, uint8_t io, uint8_t en = NULL){
 MuxIO<N> m(selectorPins, io, en);
 return m;
}

#endif

MuxIO.h

#ifndef COMBINED_MUX_H
#define COMBINED_MUX_H

#include "MuxBase.h"

template <size_t N>
using MuxEnablePins = const uint8_t (&)[N];


template <size_t N, size_t P>
class CombinedMux
{
private:
 Mux<N> mux;
 MuxEnablePins en;

 void enable(uint8_t p){
 digitalWrite(p, 0);
 }

 void disable(uint8_t p){
 digitalWrite(p, 1);
 }

 size_t get_en_idx(size_t ch){
 return ch >> N;
 }

public:

 // selectoPins : S0, S1, ...Sn
 // en : required to autamagically select the correct mux
 CombinedMux(MuxSelectorPins<N> selectorPins, MuxEnablePins en)
 :mux(selectorPins), en(en){}

 // selectoPins : S0, S1, ...Sn
 // flip : in case the multiplexer has non-standard truth table
 // en : required to autamagically select the correct mux
 CombinedMux(MuxSelectorPins<N> selectorPins, bool flip, MuxEnablePins en)
 :mux(selectorPins, flip), en(en){}

 ~CombinedMux(){}

 size_t length(){
 return mux.length() * P;
 }

 void setup(){
 mux.setup();
 for (size_t i = 0; i < P; i++)
 {
 pinMode(en[i], OUTPUT);
 } 
 }

 void select(size_t channel){
 #ifdef MUX_VALIDATE_CHANNEL_SELECTION
 size_t active = get_en_idx(channel % length());
 #else
 size_t active = get_en_idx(channel);
 #endif
 for (size_t i = 0; i < P; i++) {
 if(i == active) enable(en[i]); 
 else disable(en[i]);
 }
 mux.select(channel);
 }

};

template <size_t N, size_t P>
CombinedMux<N, P> COMBINED_MUX(MuxSelectorPins<N> selectorPins, bool flip, MuxEnablePins en){
 CombinedMux<N, P> m(selectorPins, flip, en);
 return m;
}

template <size_t N, size_t P>
CombinedMux<N, P> COMBINED_MUX(MuxSelectorPins<N> selectorPins, MuxEnablePins en){
 CombinedMux<N, P> m(selectorPins, en);
 return m;
}

#endif