21 Potenciometros en proyecto midi (SOLUCIONADO)

gracias por la respuesta tauro0221, si para otros proyectos tengo pensado usar mega, por ahora no necesito mas puertos, solo configurar pero bueno, gracias de todos modos

Bueno estoy recalculando porque pense que el CD4067 era un multiplexor digital y es analógico asi que tengo que volver a mirar todo con otros ojos.

Reconsiderando tu petición de aumentar la cantidad de potenciometros encontré esto:

Sin embargo si miras la línea 24

// potentiometers
const byte NPots = 17; // coloque aquí el numero de entradas analógicas.

const byte muxPotPin[NPots] = {8, 9, 10, 11, 12, 1, 0, 3, 2, 5, 4, 6, 7, 13, 14, 15}; // en esta vector coloque en el orden deseado los pines de los puertos analógicos, o mux channel, utilizados
int potCState[NPots] = {0}; // estado actual del puerto analógico
int potPState[NPots] = {0}; // estado previo del puerto analógico
int potVar = 0; // variación entre el valor del estado previo y el actual del puerto analógico
int lastCcValue[NPots] = {0};

Ahi lees const byte Npots = 17 quiere decir que usa 16 potenciometros.
Si quieres mas potenciometros, bien aumenta el nro ahi y luego tendremos que asignar pines para su conexionado físico.

El problema que tengo es que mi mente se frena cuando ve esquemas hechos en Fritzing de este tipo, claro que Fritzing tmb permite visualizar las cosas como esquema electronico, pero todos gustan de ver el protoboard y eso no dice nada de hecho luce confuso para mi y no puedo interpretar el conexionado.

Tampoco comprendo como hay 10 potenciometros y se definen 16.
Lo único que veo son 16 botones (menos mal, algo veo!!).

Amplio la idea:

esta linea

Multiplexer4067 mplex = Multiplexer4067(2, 3, 4, 5, A3);

Define que pines se usan para elegir la entrada analógica y por donde se lee finalmente A3
Tendrias que usar por ejemplo otro 4067 y el pin A4, algo asi

Multiplexer4067 mplex1 = Multiplexer4067(2, 3, 4, 5, A4);

Con lo cual tendrias 16 potenciometros mas!!

gracias por la respuesta, lo que pasa es que el diseño original fliper DJ, lleva 10 potes y creo 16 botones, y en la configuracion de potes dice -1, pues uno esta destinado a un control midi, yo como dije antes, quiero modificar eso, entonces, aumente el numero de potes a 17, de primera instancia, y cambie a todos los puertos del multiplexor, asi me quedo en 16 canales de potes, y los botones q originalmente estaban asignados al multiplexor los deje en 0, asi al menos pude tener 16 potes, la cosa ahora es, q no puedo hacer q 3 pines del mismo arduino funcionen como 3 potes mas, asi pudiendo completar los 19 que necesito, me imagino q hay q programar todo para q el programa reconozca esos 3 pines como potes, luego q los cambie a mensajes midi y los mande a 3 canales mas, ahi yo me pierdo completamente

Entonces ese esquema que tauro y yo vimos no corresponde a tu circuito?

To loop debería entonces leer solo esto

void loop() {
  cpu.run();
  readPots();
}

Ahora dice

void loop() {
  cpu.run();
  readButtons();
}

Estas cosas se prestan a confunsión

Bueno habria que establecer un criterio similar a como hace con los botones.
Veo que el código usa botones multiplexados y botones del arduino. Bueno en tu caso buscas lo mismo entonces

hay que definir pot multiplexados que son los que estan conectados al 4067 y pot a los pines AD que queden del Arduino.

Esto es lo que resultó

Definí 3 potenciometros a A0 A1 y A2
A3 es la entrada del CD4067

Mira a ver porque no puedo compilarlo.

#include "MIDIUSB.h"

#include <Multiplexer4067.h> // Multiplexer CD4067 library >> https://github.com/sumotoy/Multiplexer4067
#include <Thread.h> // Threads library >> https://github.com/ivanseidel/ArduinoThread
#include <ThreadController.h> // Mesma lib de cima
//#include "digitalIOPerformance.h" 

/////////////////////////////////////////////
// buttons
const byte muxNButtons  = 0; // *coloque aqui o numero de entradas digitais utilizadas no multiplexer
const byte NButtons     = 8; // *coloque aqui o numero de entradas digitais utilizadas
const byte totalButtons = muxNButtons + NButtons;
const byte muxButtonPin[muxNButtons] = {}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
const byte buttonPin[NButtons] = { 10, 16, 14, 15, 6, 7, 8, 9}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
int buttonCState[totalButtons] = {0}; // estado atual da porta digital
int buttonPState[totalButtons] = {0}; // estado previo da porta digital

/////////////////////////////////////////////
// debounce
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 5; // the debounce time; increase if the output flickers

/////////////////////////////////////////////
// potentiometers
const byte muxPots   = 17;
const byte NPots     = 3; // coloque aqui las entradas digitales no multiplexadas utilizadas
const byte totalPots = Npots + muxPots;
const byte muxPotPin[muxPots] = {8, 9, 10, 11, 12, 1, 0, 3, 2, 5, 4, 6, 7, 13, 14, 15}; // este vector coloque los canales analogicos multiplexados
const byte potsPin[NPots]     = {A0, A1, A2}; // tres potenciometros
int potCState[totalPots] = {0}; // estado atual de la puerta analogica
int potPState[totalPots] = {0}; // estado previo de la puerta analogica
int potVar = 0; // variación entre un valor del estado previo y el actual
int lastCcValue[totalPots] = {0};

/////////////////////////////////////////////
// pot reading
int TIMEOUT = 50; //quantidade de tempo em que o potenciometro sera lido apos ultrapassar o varThreshold
byte varThreshold = 4; //threshold para a variacao no sinal do potenciometro
boolean potMoving = true; // se o potenciometro esta se movendo
unsigned long pTime[totalPots] = {0}; // tempo armazenado anteriormente
unsigned long timer[totalPots] = {0}; // armazena o tempo que passou desde que o timer foi zerado

/////////////////////////////////////////////
// midi
byte midiCh   = 0; // *Canal midi a ser utilizado
byte note     = 36; // *Nota mais grave que sera utilizada
byte cc       = 1; // *CC mais baixo que sera utilizado

/////////////////////////////////////////////
// Multiplexer
Multiplexer4067 mplex = Multiplexer4067(2, 3, 4, 5, A3);

/////////////////////////////////////////////
// threads - programa cada atividade do Arduino para acontecer em um determinado tempo
ThreadController cpu; //thread master, onde as outras vao ser adicionadas
Thread threadReadPots; // thread para controlar os pots

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

void setup() {

mplex.begin(); // inicializa o multiplexer

for (int i = 0; i < NButtons; i++) { // inicializa os botoes como input utilizando o pull up resistor
    pinMode(buttonPin[i], INPUT_PULLUP);
}

pinMode(A3, INPUT_PULLUP);

/////////////////////////////////////////////
// threads
threadReadPots.setInterval(10);
threadReadPots.onRun(readPots);
cpu.add(&threadReadPots);
/////////////////////////////////////////////

}

void loop() {
  cpu.run();
  readPots();
}


/////////////////////////////////////////////
// read buttons

void readButtons() {

  for (int i = 0; i < muxNButtons; i++) { //reads buttons on mux
      int buttonReading = mplex.readChannel(muxButtonPin[i]);
      //buttonCState[i] = map(mplex.readChannel(muxButtonPin[i]), 22, 1023, 0, 2); // stores on buttonCState
      if (buttonReading > 1000) {
          buttonCState[i] = HIGH;
      }
      else {
          buttonCState[i] = LOW;
      }
  //Serial.print(buttonCState[i]); Serial.print(" ");
  }
  //Serial.println();

  for (int i = 0; i < NButtons; i++) { //read buttons on Arduino
      buttonCState[i + muxNButtons] = digitalRead(buttonPin[i]); // stores in the rest of buttonCState
  }

  for (int i = 0; i < totalButtons; i++) {

      if ((millis() - lastDebounceTime) > debounceDelay) {
          if (buttonCState[i] != buttonPState[i]) {
              lastDebounceTime = millis();

              if (buttonCState[i] == LOW) {
                  noteOn(potMidiCh(), note + i, 127); // Channel 0, middle C, normal velocity
                  MidiUSB.flush();
                  //MIDI.sendNoteOn(note + i, 127, potMidiCh()); // envia NoteOn(nota, velocity, canal midi)
                  //Serial.print("Note: "); Serial.print(note + i); Serial.println(" On");
                  buttonPState[i] = buttonCState[i];
              }
              else {
                  noteOn(potMidiCh(), note + i, 0); // Channel 0, middle C, normal velocity
                  MidiUSB.flush();
                  //MIDI.sendNoteOn(note + i, 0, potMidiCh());
                  //Serial.print("Note: "); Serial.print(note + i); Serial.println(" Off");
                  buttonPState[i] = buttonCState[i];
              }
          }
      }
  }
}

/////////////////////////////////////////////
//read potentiometers

void readPots() {

for (int i = 0; i < muxPots - 1; i++) { // le todas entradas analogicas utilizadas, menos a dedicada a troca do canal midi
    potCState[i] = mplex.readChannel(muxPotPin[i]);
}

for (int i = 0; i < NPots; i++) { //read buttons on Arduino
      buttonCState[i + muxPots] = analogRead(potsPin[i]); // stores in the rest of buttonCState
}

for (int i = 0; i < NPots; i++) {

    potVar = abs(potCState[i] - potPState[i]); // calcula a variacao da porta analogica

    if (potVar >= varThreshold) { //sets a threshold for the variance in the pot state, if it varies more than x it sends the cc message
        pTime[i] = millis(); // armazena o tempo previo
    }
    timer[i] = millis() - pTime[i]; // reseta o timer
    if (timer[i] < TIMEOUT) { // se o timer for menor que o tempo maximo permitido significa que o potenciometro ainda esta se movendo
        potMoving = true;
    }
    else {
        potMoving = false;
    }

    if (potMoving == true) { // se o potenciometro ainda esta se movendo, mande o control change
        int ccValue = map(potCState[i], 22, 1022, 0, 127);
        if (lastCcValue[i] != ccValue) {
            controlChange(11, cc + i, ccValue); // manda control change (channel, CC, value)
            MidiUSB.flush();
            //MIDI.sendControlChange(cc + i, map(potCState[i], 0, 1023, 0, 127), 11); // envia Control Change (numero do CC, valor do CC, canal midi)
            //Serial.print("CC: "); Serial.print(cc + i); Serial.print(" value:"); Serial.println(map(potCState[i], 22, 1023, 0, 127));
            potPState[i] = potCState[i]; // armazena a leitura atual do potenciometro para comparar com a proxima
            lastCcValue[i] = ccValue;
        }
    }
}

}

/////////////////////////////////////////////
// calculates midi channel based on pot position
int potMidiCh () {
  int potCh = map(mplex.readChannel(muxPotPin[9]), 22, 1023, 0, 4);

  if (potCh == 4) {
      potCh = 3;
  }

  return potCh + midiCh;
}

/////////////////////////////////////////////
// Arduino (pro)micro midi functions Arcore Library
//void noteOn(byte channel, byte pitch, byte velocity) {
// MIDIEvent noteOn = {0x09, 0x90 | channel, pitch, velocity};
// MIDIUSB.write(noteOn);
//}
//
//void noteOff(byte channel, byte pitch, byte velocity) {
// MIDIEvent noteOff = {0x08, 0x80 | channel, pitch, velocity};
// MIDIUSB.write(noteOff);
//}

/////////////////////////////////////////////
// Arduino (pro)micro midi functions MIDIUSB Library
void noteOn(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOn);
}

void noteOff(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOff);
}

void controlChange(byte channel, byte control, byte value) {
  midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};
  MidiUSB.sendMIDI(event);
}

gracias por la ayuda, a mi también me da error al compilar, sin embargo me gusta la idea de usar otro multiplexor, tengo varios

el codigo q propones me da este error
"exit status 1 'Npots' was not declared in this scope"

No hace falta con el código y las instrucciones que te pasé
Pero como gustes.

ahora estoy entrampado en como hacer funcionar los 2 multiplexores, probe varias formas y no doy con la que funcione

Hi,
Aqui puedes hacerlo con solo anadirle un transistor y puedes usar los dos multiplexer sin necesidad de anadirle mas puertos. Lo que tienes que hacer es mover una de las senales analogas al segundo cd4067 y usas ese port para seleccionar cual de los cd4067 quieres leer. Un zero selecciona uno y uno positivo secciona el segundo por medio del transistor.

Adjunto esta el esquematico para que lo consideres. Creo que estas haciendo mas deficil la programacion por querer seguir usando el NANO. Al usar un mega se te va hacer mas facil pero es tu projecto.

gracias por la respuesta, pero me estas dando una solucion que esta lejisimos de mis posibilides, en este momento probe con 2 multiplexores y no me funciono, tampoco funciono el codigo que se posteo para incluir entradas analogas del arduino, en lo de poner 2 multiplexores, llego a un punto en que o funciona uno, o el otro, pero no logro que funcionen ambos a la vez

tampoco funciono el codigo que se posteo para incluir entradas analogas del arduino,

Cómo que no funciona?

lo he subido tal cual lo escribiste y me sale este mensaje de error

Arduino:1.8.7 (Windows 7), Tarjeta:"SparkFun Pro Micro, ATmega32U4 (5V, 16 MHz)"

12potes_14_botones:27:24: error: 'Npots' was not declared in this scope

 const byte totalPots = Npots + muxPots;

                        ^

12potes_14_botones:30:24: error: size of array 'potCState' is not an integral constant-expression

 int potCState[totalPots] = {0}; // estado atual de la puerta analogica

                        ^

12potes_14_botones:31:24: error: size of array 'potPState' is not an integral constant-expression

 int potPState[totalPots] = {0}; // estado previo de la puerta analogica

                        ^

12potes_14_botones:33:26: error: size of array 'lastCcValue' is not an integral constant-expression

 int lastCcValue[totalPots] = {0};

                          ^

12potes_14_botones:40:30: error: size of array 'pTime' is not an integral constant-expression

 unsigned long pTime[totalPots] = {0}; // tempo armazenado anteriormente

                              ^

12potes_14_botones:41:30: error: size of array 'timer' is not an integral constant-expression

 unsigned long timer[totalPots] = {0}; // armazena o tempo que passou desde que o timer foi zerado

                              ^

exit status 1
'Npots' was not declared in this scope

Este reporte podría tener más información con
"Mostrar salida detallada durante la compilación"
opción habilitada en Archivo -> Preferencias.

Indicame en donde puedo descargar la librerías

#include "MIDIUSB.h"

#include <Multiplexer4067.h> // Multiplexer CD4067 library >> https://github.com/sumotoy/Multiplexer4067
#include <Thread.h> // Threads library >> https://github.com/ivanseidel/ArduinoThread
#include <ThreadController.h> // Mesma lib de cima
//#include "digitalIOPerformance.h"

El Error estaba en la linea 27 decia Npots, y debia ser NPots, corregido esto se puede compilar y subir al arduino, pero no manda MIDI, edito, si manda midi, pero solo por los botones, todos los potenciometros no funcionan

Hi,
Si las salidas de los cd4067 estan conectadas juntas no pueden trabajarlas dos a la vez. Tienes que leer una y despues lee la otra. Si quires leer las dos a las vez entonces tienes que leer las salidas individuales. Pero tienes que seleccionar una a las vez y lee las salidas. Acuerdate que las salidas estan en paralelo.

Te felicito por encontrar el error de Npots vs NPots, es lo menos que se puede esperar de alguien que pide ayuda pero que debe poner algo de su parte para llegar a la solución que se pretende.

Bueno el error fue que copie lo hecho con buttons y se me deslizaron algunas variables que no cambie
Mira esto a ver si estamos algo mejor.

#include "MIDIUSB.h"

#include <Multiplexer4067.h> // Multiplexer CD4067 library >> https://github.com/sumotoy/Multiplexer4067
#include <Thread.h> // Threads library >> https://github.com/ivanseidel/ArduinoThread
#include <ThreadController.h> // Mesma lib de cima
//#include "digitalIOPerformance.h" 

/////////////////////////////////////////////
// buttons
const byte muxNButtons  = 0; // *coloque aqui o numero de entradas digitais utilizadas no multiplexer
const byte NButtons     = 8; // *coloque aqui o numero de entradas digitais utilizadas
const byte totalButtons = muxNButtons + NButtons;
const byte muxButtonPin[muxNButtons] = {}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
const byte buttonPin[NButtons] = { 10, 16, 14, 15, 6, 7, 8, 9}; // *neste array coloque na ordem desejada os pinos das portas digitais utilizadas
int buttonCState[totalButtons] = {0}; // estado atual da porta digital
int buttonPState[totalButtons] = {0}; // estado previo da porta digital

/////////////////////////////////////////////
// debounce
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 5; // the debounce time; increase if the output flickers

// potentiometers
const byte muxPots   = 17;
const byte NPots     = 3; // coloque aqui las entradas digitales no multiplexadas utilizadas
const byte totalPots = NPots + muxPots;
const byte muxPotPin[muxPots] = {8, 9, 10, 11, 12, 1, 0, 3, 2, 5, 4, 6, 7, 13, 14, 15}; // este vector coloque los canales analogicos multiplexados
const byte potsPin[NPots]     = {A0, A1, A2}; // tres potenciometros
int potCState[totalPots] = {0}; // estado atual de la puerta analogica
int potPState[totalPots] = {0}; // estado previo de la puerta analogica
int potVar = 0; // variación entre un valor del estado previo y el actual
int lastCcValue[totalPots] = {0};

/////////////////////////////////////////////
// pot reading
int TIMEOUT = 50; //quantidade de tempo em que o potenciometro sera lido apos ultrapassar o varThreshold
byte varThreshold = 4; //threshold para a variacao no sinal do potenciometro
boolean potMoving = true; // se o potenciometro esta se movendo
unsigned long pTime[totalPots] = {0}; // tempo armazenado anteriormente
unsigned long timer[totalPots] = {0}; // armazena o tempo que passou desde que o timer foi zerado

/////////////////////////////////////////////
// midi
byte midiCh   = 0; // *Canal midi a ser utilizado
byte note     = 36; // *Nota mais grave que sera utilizada
byte cc       = 1; // *CC mais baixo que sera utilizado

// Multiplexer
Multiplexer4067 mplex = Multiplexer4067(2, 3, 4, 5, A3);


// threads - programa cada atividade do Arduino para acontecer em um determinado tempo
ThreadController cpu; //thread master, onde as outras vao ser adicionadas
Thread threadReadPots; // thread para controlar os pots

void setup() {

mplex.begin(); // inicializa o multiplexer

for (int i = 0; i < NButtons; i++) { // inicializa os botoes como input utilizando o pull up resistor
    pinMode(buttonPin[i], INPUT_PULLUP);
}

pinMode(A3, INPUT_PULLUP);

/////////////////////////////////////////////
// threads
threadReadPots.setInterval(10);
threadReadPots.onRun(readPots);
cpu.add(&threadReadPots);
/////////////////////////////////////////////

}

void loop() {
  cpu.run();
  readPots();
}


/////////////////////////////////////////////
// read buttons

void readButtons() {

  for (int i = 0; i < muxNButtons; i++) { //reads buttons on mux
      int buttonReading = mplex.readChannel(muxButtonPin[i]);
      //buttonCState[i] = map(mplex.readChannel(muxButtonPin[i]), 22, 1023, 0, 2); // stores on buttonCState
      if (buttonReading > 1000) {
          buttonCState[i] = HIGH;
      }
      else {
          buttonCState[i] = LOW;
      }
  //Serial.print(buttonCState[i]); Serial.print(" ");
  }
  //Serial.println();

  for (int i = 0; i < NButtons; i++) { //read buttons on Arduino
      buttonCState[i + muxNButtons] = digitalRead(buttonPin[i]); // stores in the rest of buttonCState

  }

  for (int i = 0; i < totalButtons; i++) {

      if ((millis() - lastDebounceTime) > debounceDelay) {
          if (buttonCState[i] != buttonPState[i]) {
              lastDebounceTime = millis();

              if (buttonCState[i] == LOW) {
                  noteOn(potMidiCh(), note + i, 127); // Channel 0, middle C, normal velocity
                  MidiUSB.flush();
                  //MIDI.sendNoteOn(note + i, 127, potMidiCh()); // envia NoteOn(nota, velocity, canal midi)
                  //Serial.print("Note: "); Serial.print(note + i); Serial.println(" On");
                  buttonPState[i] = buttonCState[i];
              }
              else {
                  noteOn(potMidiCh(), note + i, 0); // Channel 0, middle C, normal velocity
                  MidiUSB.flush();
                  //MIDI.sendNoteOn(note + i, 0, potMidiCh());
                  //Serial.print("Note: "); Serial.print(note + i); Serial.println(" Off");
                  buttonPState[i] = buttonCState[i];
              }
          }
      }
  }
}

/////////////////////////////////////////////
//read potentiometers

void readPots() {

for (int i = 0; i < muxPots - 1; i++) { // le todas entradas analogicas utilizadas, menos a dedicada a troca do canal midi
    potCState[i] = mplex.readChannel(muxPotPin[i]);
    Serial.println("Canal["+String(i)+"]="+String(potCState[i]));
}

for (int i = 0; i < NPots; i++) { //read buttons on Arduino
     potCState[i + muxPots] = analogRead(potsPin[i]); // stores in the rest of buttonCState
    Serial.println("Canal["+String(i+muxPots)+"]="+String(potCState[i+muxPots]));
}

for (int i = 0; i < NPots; i++) {

    potVar = abs(potCState[i] - potPState[i]); // calcula a variacao da porta analogica

    if (potVar >= varThreshold) { //sets a threshold for the variance in the pot state, if it varies more than x it sends the cc message
        pTime[i] = millis(); // armazena o tempo previo
    }
    timer[i] = millis() - pTime[i]; // reseta o timer
    if (timer[i] < TIMEOUT) { // se o timer for menor que o tempo maximo permitido significa que o potenciometro ainda esta se movendo
        potMoving = true;
    }
    else {
        potMoving = false;
    }

    if (potMoving == true) { // se o potenciometro ainda esta se movendo, mande o control change
        int ccValue = map(potCState[i], 22, 1022, 0, 127);
        if (lastCcValue[i] != ccValue) {
            controlChange(11, cc + i, ccValue); // manda control change (channel, CC, value)
            MidiUSB.flush();
            //MIDI.sendControlChange(cc + i, map(potCState[i], 0, 1023, 0, 127), 11); // envia Control Change (numero do CC, valor do CC, canal midi)
            //Serial.print("CC: "); Serial.print(cc + i); Serial.print(" value:"); Serial.println(map(potCState[i], 22, 1023, 0, 127));
            potPState[i] = potCState[i]; // armazena a leitura atual do potenciometro para comparar com a proxima
            lastCcValue[i] = ccValue;
        }
    }
}

}

/////////////////////////////////////////////
// calculates midi channel based on pot position
int potMidiCh () {
  int potCh = map(mplex.readChannel(muxPotPin[9]), 22, 1023, 0, 4);

  if (potCh == 4) {
      potCh = 3;
  }

  return potCh + midiCh;
}

/////////////////////////////////////////////
// Arduino (pro)micro midi functions Arcore Library
//void noteOn(byte channel, byte pitch, byte velocity) {
// MIDIEvent noteOn = {0x09, 0x90 | channel, pitch, velocity};
// MIDIUSB.write(noteOn);
//}
//
//void noteOff(byte channel, byte pitch, byte velocity) {
// MIDIEvent noteOff = {0x08, 0x80 | channel, pitch, velocity};
// MIDIUSB.write(noteOff);
//}

// Arduino (pro)micro midi functions MIDIUSB Library
void noteOn(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOn = {0x09, 0x90 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOn);
}

void noteOff(byte channel, byte pitch, byte velocity) {
  midiEventPacket_t noteOff = {0x08, 0x80 | channel, pitch, velocity};
  MidiUSB.sendMIDI(noteOff);
}

void controlChange(byte channel, byte control, byte value) {
  midiEventPacket_t event = {0x0B, 0xB0 | channel, control, value};
  MidiUSB.sendMIDI(event);
}

bueno bueno muchísimas pero muchísimas gracias por tanta ayuda, yo suelo ser muy entregado a este tipo de cosas, pero como dije es mi primer proyecto y creo que fue demasiado complejo.
Luego de revisar y comparar, creo que ya esta bien, me faltan hacer las pruebas finales con el DAW, entonces

en la fila 78 hay q ingresar esto

readButtons();

y en la fila 145 hay q poner

for (int i = 0; i < totalPots; i++) {

esto lo deduje observando el primer codigo,

Bueno repito mis mas sinceras y mas sentidas gracias y felicitaciones por el apoyo y ayuda q brindan, sin duda que no habria logrado nada sin su ayuda, por mi parte, me di cuenta de que necesito empezar desde 0 con arduino, para en un futuro poder saber exactamente donde buscar, un abrazo enorme y estaré comentando como progresa el proyecto

Si claro que fue muy complejo, pero uno no se da cuenta hasta ponerse con la tarea.

Lo bueno es que te propondrás estudiar y eso te dará mas herramientas y al menos tienes el sentido común que no todos encuentran.

Recuerda que cuando algo no funcione, puedes usar Serial.print(variables) para que te diga que esta sucediendo.
Los que te brindamos ayuda no tenemos tu hardware y a veces se dificulta guiarlos. A veces no, casi siempre.

bueno, he ido probando y funciona todo muy bien, muy estable, completamente configurable desde el DAW, ahora estaba empezando a leer mas cosas sobre arduino y pues otra cosa se me vino encima como una ola de 25 metros, quizá mas complejo q lo anterior, la cosa es esto, hay 16 pontenciometros mandando 16 mensajes midi, para 8 canales de audio (un volume y un paneo L-R) veo q a través de una matriz se puede hacer que esos 16 botones cambien a 16 mensajes midi diferentes, entonces de esta forma se podrían configurar mas canales de audio según el porte de la matriz, también decir q en reaper se pueden configurar hasta 99 canales de audio, pero bueno yo nunca trabaje en proyectos tan grandes así es que hasta 64 canales estaría de lujo, entonces tendría q hacer una matriz de 8x8 (o 16x8) y un par de botones que cambien la fila (o la columna, aun no se como se hace), peeeero se me queda muy grande también esta tarea, quiza mas adelante la lleve a cabo cuando tenga mas experiencia programando el arduino, por ahora sigo con los tutoriales básicos jejejej