/////////////////////////////////////////////
// Choosing your board
// Define your board, choose:
// "ATMEGA32U4" if using with ATmega32U4 - Micro, Pro Micro, Leonardo...
// "ATMEGA328" if using ATmega328 - Uno, Mega, Nano...
// "DEBUG" if you just want to debug the code in the serial monitor

#define DEBUG 1 // output debug to serial
// #define ATMEGA328 1  // put here the uC you are using, like in the lines above followed by "1", like "ATMEGA328 1", "DEBUG 1", etc.


_MIDI_Controller.ino

diagram.json

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

ResponsiveAnalogRead-master@wokwi:c500129e6f8e4007becda9b7d443242b4e2ef71d


libraries.txt

#include <ResponsiveAnalogRead.h>  // https://github.com/dxinteractive/ResponsiveAnalogRead
// #include <Thread.h>            // Threads library >> https://github.com/ivanseidel/ArduinoThread
// #include <ThreadController.h>  // Same as above

// ThreadController cpu;         //thread master, where the other threads will be added
// Thread threadPotentiometers;  // thread to control the pots
// Thread threadChannelMenu;     // thread to control the pots

const byte N_POTS = 8;  // total numbers of pots (slide & rotary). Number of pots in the Arduino + number of pots on multiplexer 1 + number of pots on multiplexer 2...

// Responsive Analog Read
float snapMultiplier = 0.01;                      // (0.0 - 1.0) - Increase for faster, but less smooth reading
ResponsiveAnalogRead responsivePot[N_POTS] = {};  // creates an array for the responsive pots. It gets filled in the Setup.

const int TIMEOUT = 300;      // Amount of time the potentiometer will be read after it exceeds the varThreshold
const byte varThreshold = 8;  // Threshold for the potentiometer signal variation - Increase if using ESP32
// For varThreshold I usually use "8" for normal Arduino and "30" for ESP32

// put here the min and max reading in the potCState
// in the potMin put a little bit more and in the potMax put a little bit less
// IMPORTANT:
// Regular Arduinos have 10 bit resolution: 0 - 1023
// ESP32 boards have 12 bit resolution: 0 - 4095
const int potMin = 20;
const unsigned int potMax = 940;

// variables you don't need to change
int reading = 0;

int potCState[N_POTS] = { 0 };  // Current state of the pot
int potPState[N_POTS] = { 0 };  // Previous state of the pot
int potVar = 0;                 // Difference between the current and previous state of the pot

int PBVal[N_POTS] = { 0 };

boolean potMoving = true;             // If the potentiometer is moving
unsigned long PTime[N_POTS] = { 0 };  // Previously stored time
unsigned long timer[N_POTS] = { 0 };  // Stores the time that has elapsed since the timer was reset

///////////////////////////////////////////////////////////

const byte N_POTS_PER_MUX[N_MUX] = { 8 };  // number of pots in each multiplexer (in order)
const byte POT_MUX_PIN[N_MUX][8] = { { 0, 1, 2, 3, 4, 5, 6, 7 } };

int nPotsPerMuxSum = 0;  //offsets the buttonCState at every mux reading

/////////////////////////////////////////////
// Function
void potentiometers() {

  // reads the pins from every mux
  for (int j = 0; j < N_MUX; j++) {

    Serial.print("Mux ");
    Serial.print(j);

    Serial.print("; Pots: ");
    for (int i = 0; i < N_POTS_PER_MUX[j]; i++) {
      potCState[i + nPotsPerMuxSum] = readMux(MUX_1_INPUT, POT_MUX_PIN[j][i]);
      // mux[j].readChannel(POT_MUX_PIN[j][i]);

      #ifdef DEBUG
        Serial.print("[");
        Serial.print(potCState[i + nPotsPerMuxSum]);
        Serial.print("] ");
      #endif

      responsivePot[i + nPotsPerMuxSum].update(reading);
      potCState[i + nPotsPerMuxSum] = responsivePot[i + nPotsPerMuxSum].getValue();
    }
    Serial.println(" ");

    nPotsPerMuxSum += N_POTS_PER_MUX[j];
  }
}


B_Potentiometers.ino

// button vars
int buttonMuxThreshold = 850;
unsigned long debounceDelay = 50;  // the debounce time; increase if the output flickers

const byte N_BUTTONS_PER_MUX[N_MUX] = { 8 };  // number of buttons in each mux (in order)
const byte BUTTON_MUX_PIN[N_MUX][16] = {
  { 8, 9, 10, 11, 12, 13, 14, 15 } // pins of the first mux
};

const byte N_BUTTONS = 8; // total numbers of buttons.

int buttonCState[N_BUTTONS] = { 0 };  // stores the button current value
int buttonPState[N_BUTTONS] = { 0 };  // stores the button previous value

// debounce
unsigned long lastDebounceTime[N_BUTTONS] = { 0 };  // the last time the output pin was toggled

/////////////////////////////////////////////
// Function
void buttons() {

  int nButtonsPerMuxSum = 0;  // offsets the buttonCState at every mux reading

  // read the pins from every mux
  for (int j = 0; j < N_MUX; j++) {

    Serial.print("Mux ");
    Serial.print(j);

    Serial.print("; Buttons: ");
    for (int i = 0; i < N_BUTTONS_PER_MUX[j]; i++) {

      buttonCState[i + nButtonsPerMuxSum] = readMux(MUX_1_INPUT, BUTTON_MUX_PIN[j][i]);
      // mux[j].readChannel(BUTTON_MUX_PIN[j][i]);
      #ifdef DEBUG
        Serial.print("[");
        Serial.print(buttonCState[i + nButtonsPerMuxSum]);
        Serial.print("] ");
      #endif

    }
    Serial.println(" ");

  }

}


B_Buttons.ino

void setup() {
  // Setup Serial logger
  Serial.begin(9600);
  Serial.println("Running setup");

  // Initialize multiplexer inputs
  pinMode(A0, INPUT);

  // Initialize multiplexer control outputs
  for (int i = 0; i < 4; i++) {
    pinMode(muxControlPins[i], OUTPUT);
  }
}


D_Setup.ino

void loop() {
  buttons();
  potentiometers();
  delay(1500);
}

D_Loop.ino

#define N_MUX 1  // number of multiplexers

// #define s0 3
// #define s1 4
// #define s2 5
// #define s3 6

#define MUX_1_INPUT A0  // analog pin of the first mux
const uint8_t muxControlPins[] = { 2, 3, 4, 5 };

float readMux(int muxInputPin, int channel)
{
  int controlPinMessage[4] = { 0, 0, 0, 0 };

  for(int i = 0; i < 4; i ++)
  {
    controlPinMessage[i] = channel >> i & 1;
    digitalWrite(muxControlPins[i], controlPinMessage[i]);
  }
  delay(10);
  int pinValue = analogRead(muxInputPin);

  #ifdef DEBUG
    // Serial.print("Control: ");
    // Serial.print(controlPinMessage[0]);
    // Serial.print(controlPinMessage[1]);
    // Serial.print(controlPinMessage[2]);
    // Serial.print(controlPinMessage[3]);
    // Serial.print(" - ");
  #endif

  return pinValue;
}
