Go Down

Topic: 21 Potenciometros en proyecto midi (SOLUCIONADO) (Read 841 times) previous topic - next topic

roxo

hola a todos, debo decir que este es mi primer proyecto arduino, por necesidad, armé un controlador midi siguiendo las instrucciones de MusicoNerd, bueno, yo de programar se casi nada, estoy recién viendo cosas muy básicas, y bueno, este codigo, a prueba y error, lo fui modificando para mis necesidades, la cosa es que necesito 19 potenciometros, pero en este código solo pude configurar un max de 16, que son los canales del multiplexor 4067, y no esta programado para usar los puertos del arduino pro-micro como potenciometros, solo como botones, entonces, por favor, yo se que que este proyecto es demasiado para mis conocimientos super limitados de arduino, pero me gustaría terminarlo con éxito, y empezar con arduino de 0 despues de esto, quisiera q me ayudaran a incluir 3 potenciometros por los puertos del arduino, (18,19,20) porfa, muchisimas gracias de antemano




roxo

Code: [Select]
#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 NPots = 17; // *coloque aqui o numero de entradas analogicas utilizadas
const byte muxPotPin[NPots] = {8, 9, 10, 11, 12, 1, 0, 3, 2, 5, 4, 6, 7, 13, 14, 15}; // *neste array coloque na ordem desejada os pinos das portas analogicas, ou mux channel, utilizadas
int potCState[NPots] = {0}; // estado atual da porta analogica
int potPState[NPots] = {0}; // estado previo da porta analogica
int potVar = 0; // variacao entre o valor do estado previo e o atual da porta analogica
int lastCcValue[NPots] = {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[NPots] = {0}; // tempo armazenado anteriormente
unsigned long timer[NPots] = {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();
readButtons();

}

/////////////////////////////////////////////
// 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 < NPots - 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++) {

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);
}

surbyte

#2
Dec 06, 2018, 01:00 am Last Edit: Dec 06, 2018, 08:46 pm by surbyte
Y cual es el ejemplo para poder entender la idea?
Puedes poner el link al ejemplo que has copiado y pegado?


Supongo que es este Build this MIDI controller using an Arduino: Fliper Dj

Estas equivocado en tu enfoque.

Quote
y no esta programado para usar los puertos del arduino pro-micro como potenciometros
El 4067 es un multiplexor digital x ende no puedes configurarlo para usarlo con algo analógico.
No puede convertirse para leer 16 potenciometros

Tienes que usar un CD4051 y es un multiplexor de 8 canales no 16, claro que puedes poner 2 o 3 y llegar a 24 potenciometros.


EDITADO: Me he equivocado. Consultando la hoja de datos del CD4067 compruebo que no es multiplexor digital sino analógico.



roxo

#3
Dec 06, 2018, 01:11 am Last Edit: Dec 06, 2018, 01:16 am by roxo
este el video de MusicoNerd en youtube Fliper DJ, yo tome esto como punto de partida para crear una superficie de control para DAW (REAPER), con 8 potes deslizables (para 8 canales de audio) 1 pote deslizable para control de master, 8 controles rotarorios para control de paneo de cada pista y 2 potes para zoom de pista vertical y horizontal, todo esto es asignable en el DAW, la maquina solo manda mensajes midi, y para tal caso me faltan 3 potenciometros, debo aclarar que ya estoy usando 16 potes asignados a REAPER, funcionando a la perfección.

surbyte

#4
Dec 06, 2018, 04:02 am Last Edit: Dec 06, 2018, 04:03 am by surbyte
El habla de 16 botones no de 16 potenciometros. Dice que ajusta el knob (potenciometro) y cambia los botones. Para mi esta claro.
El código lo afirma, no hay un solo analogRead que es el comando que se usa para leer una entrada analógica que es precisamente lo que un potenciómetro te dará, valores entre 0 y 5V.
Min 1:49" it´s to show you the function of this knob. Actually this knob here it´s a bank selector
for the buttons so I have 16 buttons...."

roxo

me enredo, si bien te entiendo, los potes están programados como botones? me es difícil de entender, pues en mi caso los 16 potes que tengo conectados a las 16 entradas del multiplexor actúan como potes en el programa y en el monitor midi, los deslizables mueven los faders del programa, los rotatorios mueven los controles de panorama, emulando perfectamente el funcionamiento de una consola análoga, como explique en el encabezado es mi primer acercamiento a arduino y no estoy familiarizado con casi nada, me falta muchísimo si no es que todo por aprender, entonces como podría modificar este código para incluir 3 potenciometros mas en los puertos del arduino para que actúen tal cual como los que están conectados al multiplexor?

tauro0221

#6
Dec 06, 2018, 04:46 am Last Edit: Dec 06, 2018, 04:53 am by tauro0221
Hi,
Adjunto una foto del esquematico de como esta alambrado el  MIDI controller seguiendo el link dado en la pagina de U-tube. Creo que en el programa el lee los switches y lee las resistencias variables para cambiar el rimbo de la musica. El esta usando el 4067 para seleccionar las salidas del los potenciometros como senales analogas. Tambien adjunto el link donde puede bajar el  programa y el esquematico del midi.

https://musiconerd.us10.list-manage.com/subscribe?u=9942d2218aede48d044e43a2c&id=f809dcd271






roxo

#7
Dec 06, 2018, 12:20 pm Last Edit: Dec 06, 2018, 03:53 pm by roxo
eso mismo, salvo que yo necesito solo potenciometros en el multiplexor (que ya los tengo, si revisan el codigo se daran cuenta), aparte necesito 3 potenciometros mas en el arduino, para hacer un total de 19 potenciometros, el resto en botones, (5 botones que tambien ya estan listos), el codigo esta programado para transformar las señales del multiplexor en mensajes midi del tipo CC (pots), y los botones del arduino como mensajes on-off midi (buttons), yo no pude cambiar el codigo para que 3 puertos del arduino, que funcionan como botones, funcionen como CC, (tal cual los del multiplexor), y para esto necesito ayuda, ojala se entienda

tauro0221

Hi,
Aqui la solucion es que en vez de usar un micro uses un mega. Te va a dar mas puertos y mas senales analogas. Ya el micro esta a su  max capacidad y no te vaz a  poder anadir mas componentes mas tarde.

roxo

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

surbyte

#10
Dec 06, 2018, 08:54 pm Last Edit: Dec 06, 2018, 09:00 pm by surbyte
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
Code: [Select]
// 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
Code: [Select]
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!!

roxo

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

surbyte

#12
Dec 06, 2018, 09:03 pm Last Edit: Dec 06, 2018, 09:10 pm by surbyte
Entonces ese esquema que tauro y yo vimos no corresponde a tu circuito?

To loop debería entonces leer solo esto

Code: [Select]
void loop() {
  cpu.run();
  readPots();
}


Ahora dice

Code: [Select]
void loop() {
  cpu.run();
  readButtons();
}


Estas cosas se prestan a confunsión

surbyte

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.

Code: [Select]
#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);
}

roxo

#14
Dec 07, 2018, 04:40 pm Last Edit: Dec 07, 2018, 11:16 pm by roxo
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"

Go Up