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

#include <Adafruit_NeoPixel.h>

#define S0 18
#define S1 19
#define S2 22
#define S3 23
#define COM 34
#define NP_PIN 4
#define NUMPIXELS 16

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, NP_PIN, NEO_GRB + NEO_KHZ800);

const uint8_t controlPins[] = { S0, S1, S2, S3 };

const uint8_t muxChannels [16][4] = {
  {0,0,0,0},
  {1,0,0,0},
  {0,1,0,0},
  {1,1,0,0},
  {0,0,1,0},
  {1,0,1,0},
  {0,1,1,0},
  {1,1,1,0},
  {0,0,0,1},
  {1,0,0,1},
  {0,1,0,1},
  {1,1,0,1},
  {0,0,1,1},
  {1,0,1,1},
  {0,1,1,1},
  {1,1,1,1}
};

int readMux(int channel)
{
  for(int i = 0; i < 4; i ++)
  {
    digitalWrite(controlPins[i], muxChannels[channel][i]);
  }
  delay(10);
  return digitalRead(COM);
}

void setup()
{
  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pixels.begin();
}

void loop()
{
  pixels.clear();
  for(int i = 0; i < 16; ++i)
  {
    if (readMux(i))
    {
      pixels.setPixelColor(i, pixels.Color(0, 150, 0));
    }
  }
  pixels.show();
}

CD74HC4067.ino

diagram.json

// CD74HC4067
// 16-Channel Analog Multiplexer
// https://www.ti.com/lit/ds/symlink/cd74hc4067.pdf

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

//! Channel pin names.
const char* pin_names_I [16] = { 
  "I0", "I1", "I2", "I3",
  "I4", "I5", "I6", "I7", 
  "I8", "I9", "I10", "I11",
  "I12", "I13", "I14","I15"
};

//! Chip data.
typedef struct {
  pin_t  I[16];
  pin_t  S[4];
  pin_t  VCC;
  pin_t  GND;
  pin_t  COM;
  pin_t  EN;
  uint32_t floatingSig;
  uint32_t analogDemux;
  uint32_t digitalMode;
} chip_data_t;

//! Returns true if VCC and GND are properly connected.
bool power_connected(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  return pin_read(chip->VCC) && !pin_read(chip->GND);
}

//! Called when E pin is high or the chip is not powered correctly.
void off_state(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;

  if (attr_read(chip->floatingSig))
  {
    pin_mode(chip->COM, INPUT);
  }
  else
  {
    pin_mode(chip->COM, ANALOG);
    pin_dac_write(chip->COM, 0);
  }
    
  for (int i = 0; i < 16; ++i)
  {
    pin_mode(chip->I[i], INPUT);
  }
}

//! Returns the currently selected channel.
uint8_t selected_channel(void *data)
{
    chip_data_t *chip = (chip_data_t*)data;
    bool S0 = pin_read(chip->S[0]);
    bool S1 = pin_read(chip->S[1]);
    bool S2 = pin_read(chip->S[2]);
    bool S3 = pin_read(chip->S[3]);
    return S3 << 3 | S2 << 2 | S1 << 1 | S0;
}

//! Sets COM and all of the channel pins to analog mode.
void analog_mode(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  pin_mode(chip->COM, ANALOG);
      
  for (int i = 0; i < 16; ++i)
  {
    pin_mode(chip->I[i], ANALOG);
  }
}

//! Sets COM and all of the channel pins to digital mode.
void digital_mode(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  pin_mode(chip->COM, OUTPUT);
      
  for (int i = 0; i < 16; ++i)
  {
    pin_mode(chip->I[i], INPUT);
  }
}

//! Sets the selected channel to the same voltage read on the COM pin.
void analog_demux(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;

  for (int i = 0; i < 16; ++i)
  {
    pin_dac_write(chip->I[i], 0);
  }
  
  uint8_t channel = selected_channel(chip);
  pin_dac_write(chip->I[channel], pin_adc_read(chip->COM));
}

//! Drives the selected channel HIGH. Called when COM is also HIGH.
void digital_demux(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;

  for (int i = 0; i < 16; ++i)
  {
    pin_mode(chip->I[i], OUTPUT);
    pin_write(chip->I[i], LOW);
  }
  
  uint8_t channel = selected_channel(chip);
  pin_write(chip->I[channel], HIGH);
}

//! Sets the COM pin to the same voltage read on the selected channel.
void mux(void *data)
{
  chip_data_t *chip = (chip_data_t*)data;
  uint8_t channel = selected_channel(chip);
  if (attr_read(chip->digitalMode))
  {
    pin_write(chip->COM, pin_read(chip->I[channel]));
  }
  else
  {
    pin_dac_write(chip->COM, pin_adc_read(chip->I[channel]));
  }
}

//! Main loop.
void chip_timer_callback(void *data) 
{
  chip_data_t *chip = (chip_data_t*)data;

  if (power_connected(chip) && !pin_read(chip->EN))
  {
    pin_mode(chip->COM, INPUT_PULLDOWN);

    if (pin_read(chip->COM))
    {
      digital_demux(chip);
    }
    else
    {
      if (attr_read(chip->digitalMode))
      {
        digital_mode(chip);
      }
      else
      {
        analog_mode(chip);  
      }
      
      if (attr_read(chip->analogDemux))
      {
        analog_demux(chip);
      }
      else
      {
        mux(chip);
      }
    }
  }
  else
  {
    off_state(chip);
  }
}

//! Chip initialization.
void chip_init() 
{
  chip_data_t *chip = (chip_data_t*)malloc(sizeof(chip_data_t));

  for (int i = 0; i < 16; ++i)
  {
    chip->I[i] = pin_init(pin_names_I[i], ANALOG);
  }

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

  chip->COM = pin_init("COM", INPUT);
  chip->VCC = pin_init("VCC", INPUT);
  chip->GND = pin_init("GND", INPUT);
  chip->EN = pin_init("EN", INPUT);

  chip->floatingSig = attr_init("floatingSig", 0);
  chip->analogDemux = attr_init("analogDemux", 0);
  chip->digitalMode = attr_init("digitalMode", 0);

  const timer_config_t config = 
  {
    .callback = chip_timer_callback,
    .user_data = chip,
  };

  timer_t timer_id = timer_init(&config);
  timer_start(timer_id, 10000, true);
}


CD74HC4067.chip.c

CD74HC4067

CD74HC4067.chip.json

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

# Automatically added based on includes:
Adafruit NeoPixel

Adafruit NeoPixel