import machine
import utime

# Multiplexer pin mappings
s0 = machine.Pin(18, machine.Pin.OUT)
s1 = machine.Pin(17, machine.Pin.OUT)
s2 = machine.Pin(16, machine.Pin.OUT)
e = machine.Pin(15, machine.Pin.OUT)

# Enable multiplexer
e.value(1)

# Set the appropriate s0, s1, and s2 pins to select channel 15
s0.value(1)
s1.value(1)
s2.value(1)

# Connect NTC temperature sensor to the appropriate pin on the multiplexer
ntc = machine.ADC(machine.Pin(26))

# Read temperature and convert to Celsius
temp = ntc.read_u16()
temp = int(round(-273.15 + (3.3 / temp - 1) / 0.0043))
print("Temperature: ", temp, "C")

# Disable multiplexer
e.value(0)


main.py

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>

typedef struct {
  pin_t  COM;
  pin_t  VCC;
  pin_t  E;
  pin_t  I[16];
  pin_t  S[4];
  pin_t  GND;
  timer_t timer_id;
} chip_data_t;

void OnPinChangedE(void *user_data, pin_t pin, uint32_t value)
{
  printf("OnPinChangedE value = %d\n", value);  // Never called. Bug?
  chip_data_t *chip_data = (chip_data_t*)user_data;
  //bool E = pin_read(chip_data->E);

  if (value == 0)
  {
    // Start the timer when the chip is enabled, i.e. E = LOW.
    timer_start(chip_data->timer_id, 1000, true);
  }
  else
  {
    // Stop the timer when the chip is not enabled, i.e. E = HIGH.
    timer_stop(chip_data->timer_id);
  }
}

void chip_timer_callback(void *data) 
{
  chip_data_t *chip_data = (chip_data_t*)data;
  bool E = pin_read(chip_data->E);

  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;
    float input = pin_adc_read(chip_data->I[inputIndex]);
    //printf("Reading input %d = %f.\n", inputIndex, input);
    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->I[ 0] = pin_init("I0", ANALOG);
  chip_data->I[ 1] = pin_init("I1", ANALOG);
  chip_data->I[ 2] = pin_init("I2", ANALOG);
  chip_data->I[ 3] = pin_init("I3", ANALOG);
  chip_data->I[ 4] = pin_init("I4", ANALOG);
  chip_data->I[ 5] = pin_init("I5", ANALOG);
  chip_data->I[ 6] = pin_init("I6", ANALOG);
  chip_data->I[ 7] = pin_init("I7", ANALOG);
  chip_data->I[ 8] = pin_init("I8", ANALOG);
  chip_data->I[ 9] = pin_init("I9", ANALOG);
  chip_data->I[10] = pin_init("I10", ANALOG);
  chip_data->I[11] = pin_init("I11", ANALOG);
  chip_data->I[12] = pin_init("I12", ANALOG);
  chip_data->I[13] = pin_init("I13", ANALOG);
  chip_data->I[14] = pin_init("I14", ANALOG);
  chip_data->I[15] = pin_init("I15", 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 timer_config_t timerConfig = 
  {
    .callback = chip_timer_callback,
    .user_data = chip_data,
  };

  chip_data->timer_id = timer_init(&timerConfig);

  const pin_watch_config_t pinWatchConfig = 
  {
    .edge = BOTH,
    .pin_change = OnPinChangedE,
    .user_data = chip_data
  };

  bool b = pin_watch(chip_data->E, &pinWatchConfig);
  printf("pin_watch = %s\n", b ? "true" : "false");

  timer_start(chip_data->timer_id, 1000, true);
}