Published October 19, 2020 © GPL3+

Botonera 2000

8 button, 3 potentiometers, input for expression pedal multichannel midi controller (pedalboard)

IntermediateShowcase (no instructions)622

Things used in this project

Hardware components

Arduino UNO

Switch Actuator, Head for spring return push-button

LED (generic)

Rotary potentiometer (generic)

DIN Audio / Video Connector, 5 Contacts

Audio TRS Plug

Slide Switch

9V Battery Clip

Software apps and online services

Arduino IDE

Hand tools and fabrication machines

Soldering iron (generic)

Solder Wire, Lead Free

Story

botonera 2000 is a midi controller originally thought for controlling a lexicon mpx1. it was supposed to be a prototype but it is working really good so it became very definitive. i only bought the arduino uno and the buttons, everything else is recycled from another devices either broken or unused. even the case is made with two betamax video boxes. it has 6 buttons for activate and deactivate effects, 2 more buttons and 3 potentiometers to modify parameters, it has a plug input for an expression pedal. this year with the covid-19 pandemic and the quarantine establish here in my country i started to use the controller with software in the pc so i needed to have more control and expand the capabilities of the controller. it originally worked only through midi channel 1. the original code i used was from the NOTES AND VOLTS site. this is a very useful code, easy to start working but i wanted to write the new code from scratch. so nowadays the pedalboard has 2 modes, one with the original setting, each button activate different fx, through midi cc, the three potentiometers and extra buttons for other global parameters and the expression pedal all through midi channel 1 and another mode which is activated with a switch, in this mode the 6 buttons become channel selectors, from channel 11 to 16 and the extra buttons and the potentiometers are automatically set to that channel to modify especific parameters for each fx, so now the 3 pots become 18 and so with the extra buttons (2 become 12). (sorry for my engish)

------------------------------------------------------------------------------------

Botonera 2000 se trata de un controlador MIDI originalmente pensado para controlar un rack de efectos, se suponía que fuera un prototipo pero hoy en día funciona muy bien así que se volvió bastante definitivo.. lo único que compre fue el Arduino Uno y los botones, todo lo demás es reciclado de otros aparatos que no servían. Incluso la carcasa esta hecha con dos cajas de video betamax unidas.. Posee 6 botones para activar y desactivar efectos, 2 botones y 3 potenciometros para modificar parámetros, tiene también una entrada plug para pedal de expresión. Con el advenimiento de la pandemia y la consiguiente cuarentena empece a usar el controlador para controlar programas y efectos para guitarra, así surgió la necesidad de ampliar las posibilidades de la misma (originalmente funcionaba enviando informacion solo por el canal midi 1). El código original era del sitio de NOTES & VOLTS, es muy fácil de usar y durante un tiempo estuvo bien pero durante la cuarentena me propuse escribir de cero un código para poder cambiar mas parámetros, de esta manera la pedalera hoy en día tiene 2 modos, un modo para tocar donde los botones actúan como bypass para 6 efectos, otros 2 botones y 3 potenciometros actúan sobre el canal 1 y se puede asignar a distintas funciones (volumen, tap tempo, cambio de patch, etc.) en el modo setup los 6 botones actúan como selectores de canal MIDI, y los 2 botones y 2 potenciometros se asignan a dicho canal, de esta manera puedo seleccionar el canal de un efecto y asignarle los botones y potenciometros para modificar dicho efecto, osea que los 3 potenciometros pasan a ser 18 al igual que los 2 botones pasan a ser 12. ademas la botonera tiene una entrada plug para pedal de expresión asignado al canal MIDI 1

Code

Botonera 2000

Botonera 2000

Arduino

the code uses the arduino midi library, it sends midi cc through midi serial port, two modes, 8 buttons in total, 3 potentiometers and expression pedal input, in one mode everything goes through midi channel 1 and in the other mode 6 buttons become channel selectors and the extra buttons and the pots are set to that channel, the code is quite repetitive, i am sure it could be much simpler and shorter, the next step would be to make it more simple, more "automatized" maybe? i am very happy with it, it does what is supposed to do so for the moment is great. UPDATED: now the code is much simpler, more automatized, it includes a reset function.
------------------------------------------------------------------------------------------------------
Utiliza la libreria MIDI de Arduino, envia control change por un puerto midi, 8 botones en total, 3 potenciometros y entrada para pedal de expresion, el codigo es muy repetitivo, no hay nada automatizado.. seguramente podria ser mas simple, quizas sea el proximo paso, hacerlo mas simple. asi como esta funciona muy bien, hace lo que debe. basicamente son dos programas, uno para tocar y otro para setear parametros. ACTUALIZACION: el codigo es ahora mas simple, varias variables automatizadas, incluye un modo de reseteo.

#include <MIDI.h>

/*************************************************************
  BOTONERA 2000
  x NATANIEL GARCIA
  2021 (HECHO EN PANDEMIA 2.0)
   
  Version 7.0
 *************************************************************/

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

void(* resetFunc) (void) = 0; // ESTO RESETEA LA BOTONERA

MIDI_CREATE_DEFAULT_INSTANCE();

// DECLARAR LAS VARIABLES DE DONDE ESTAN CONECTADOS LOS BOTONES
const int boton[8] = {5, 6, 0, 13, 3, 2, A4, A5};

const int botonMaster = 4; // BOTON PARA CAMBIAR DEL MODO PLAY AL MODO SETUP

// DECLARAR LAS VARIABLES PARA EL LOOP DE CADA BOTON
int estadoboton[8] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};
int anteriorboton[8] = {HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH, HIGH};

int ButtonState10 = 0;
int LastButtonState10 = 0;

// VARIABLES PARA EL LOOP DE LOS POTENCIOMETROS
int pot[4]; // 3 POTENCIOMETROS Y LA ENTRADA DE PEDAL DE EXPRESION
int potant[4];
int potes[4] = {1, 3, 0, 2}; // DONDE ESTAN ENCHUFADOS
int ccpot[4] = {80, 81, 82, 11}; // CC DE CADA POTE EN EL MODO PLAY

// DECLARAR LAS VARIABLES DE LOS LEDS, DONDE ESTAN CONECTADOS
const int ledpin[6] = {11, 12, 7, 10, 8, 9};

// VARIABLES PARA DETERMINAR SI CADA BOTON DEBE ENVIAR O NO SEAL POR MEDIO DE SWITCH Y CASE (UNICAMENTE MASTER, EL RESTO LO HACE POR EL ESTADO DEL LED - VARIABLE MEMLED, INCLUSO 7 Y 8)
int ACTIVARMASTER = 127; // PARA EL BOTON PLAY/SETUP

// VARIABLE PARA DETERMINAR EL CANAL MIDI POR EL QUE ENVIAN SEAL LOS POTENCIOMETROS Y LOS 2 BOTONES DE ARRIBA
int CANAL = 1;

// VARIABLE NUMERO DE CC DE LOS 8 BOTONES
int CC[8] = {14, 15, 16, 17, 18, 19, 3, 9};

// VARIABLE PARA DETERMINAR EL CC MIDI QUE ENVIAN LOS POTENCIOMETROS Y LOS 2 BOTONES DE ARRIBA POR LOS CANALES 11 AL 16
int BOTVARIABLE[8];
int POTVARIABLE[8];

// DECLARAR LAS VARIABLES PARA GUARDAR EN MEMORIA QUE LEDS ESTAN PRENDIDOS EN EL MODO PLAY
int MEMLED[8];

// DECLARAR LAS VARIABLES PARA GUARDAR EN MEMORIA QUE CANAL ESTA SELECCIONADO EN EL MODO SETUP
int MEMCANAL[6];

// DECLARAR LAS VARIABLES PARA APAGAR LOS LEDS DEL MODO ANTERIOR
int APAGARLEDS = 0; // PARA LOS LEDS DEL MODO SETUP
int APAGARLEDS2 = 0; // PARA LOS LEDS DEL MODO PLAY

// VARIABLE PARA CAMBIAR DEL MODO SETUP AL MODO PLAY
int MODOPLAY = 1;

// VARIABLE PARA VER SI SE VA A USAR CON LA LEXICON MPX1 O CON SOFTWARE
int LEXICON[8] = {1, 2, 3, 4, 5, 6, 7, 8};
int APAGAR[8] = {1, 2, 3, 4, 5, 6, 7, 8};
int UNAVEZ = 0; // ESTA VARIABLE ES PARA EJECUTAR LA CONFIGURACION DE ELECCION ENTRE SOFTWARE Y LEXICON UNA SOLA VEZ

// VARIABLES PARA MANTENER APRETADO UN BOTON
unsigned long botonapretado[8];
unsigned long tiempoapretado = 1500; // TIEMPO QUE DEBE ESTAR PRESIONADO PARA ACCEDER AL SETUP DE LEX PC INDIVIDUAL
unsigned long tiemporeset = 3000; // TIEMPO PARA RESETEAR LA BOTONERA
unsigned long tiempoLUCECITAS = 5000;
unsigned long resetpresionado;
unsigned long LUCECITAS;

// VARIABLE PARA PODER USAR BOTONES 3 Y 4 COMO OPCION Y QUE NO QUEDE EN UN LOOP INFINITO
int VECES[6];

// VARIABLE PARA EL JUEGO DE LUCES DEL COMIENZO
int INTRO = 0; 

// VARIABLE PARA EJECUTAR SOLO UNA VEZ EL USO DEL CANAL 1 EN EL MODO SETUP
int modoconfig = 0;
  
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {
  // put your setup code here, to run once:

MIDI.begin(MIDI_CHANNEL_OMNI);

//Serial.begin(115200); // ESTO SERIA PARA USAR EL ARDUINO POR USB

// ESTABLECER LOS PINS QUE USAN LOS BOTONES COMO ENTRADA Y ACTIVA LA RESISTENCIA INCORPORADA
for (int i = 0; i < 8; i++){ // PARA LOS 8 BOTONES
pinMode(boton[i], INPUT_PULLUP);
}

pinMode(botonMaster, INPUT_PULLUP); // PARA EL SWITCH DE MODOPLAY

// ESTABLECER LOS PINS DONDE ESTAN LOS LEDS COMO SALIDA
for (int i = 0; i < 6; i++){
pinMode(ledpin[i], OUTPUT);
}

}

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

void loop() {
  // put your main code here, to run repeatedly:

unsigned long tiempo = millis(); // ACA SE DEFINE LA VARIABLE TIEMPO PARA UTILIZAR LA OPCION DE BOTON PRESIONADO

while (INTRO == 0){
  intro();
  INTRO = 1;
}

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

while (UNAVEZ == 0){ // CUANDO SE PRENDE LA BOTONERA SE ELIGE ENTRE MODO LEXICON (BOTON 3) Y PC (BOTON 4)
  digitalWrite(ledpin[3] , HIGH); // LA DIFERENCIA ESTA EN EL MODO EN QUE EL PRENDIDO Y APAGADO DE LOS BOTONES SE COMPORTA
  digitalWrite(ledpin[2] , HIGH); // SE PRENDEN LAS DOS LUCES DE LOS BOTONES 3 Y 4
  estadoboton[2] = digitalRead(boton[2]);
  estadoboton[3] = digitalRead(boton[3]);
  if (estadoboton[2]!= anteriorboton[2] || estadoboton[3] != anteriorboton[3] ) { // SI SE PRESIONA EL BOTON 3 SE ACTIVA EL MODO LEXICON    
    if (estadoboton[2] == LOW){
      for (int i = 0; i < 8; i++){
        LEXICON[i] = 1; // MODO LEXICON ACTIVADO
      }
      for (int i = 0; i < 6; i++){
        APAGAR[i] = 0; // EL MODO DE APAGAR BOTON ES MEDIANTE EL VALOR 0
      }
      APAGAR[6] = 127; // EN EL MODO LEXICON LOS BOTONES 7 Y 8 PRENDEN CADA VEZ QUE SE PRESIONAN
    APAGAR[7] = 127;      
    digitalWrite(ledpin[2] , LOW);
    digitalWrite(ledpin[3] , LOW);      
    UNAVEZ = 1;
    eligio3();
    }     
    
    if (estadoboton[3] == LOW){ // SI SE PRESIONA EL BOTON 4 SE ACTIVA EL MODO PC
    for (int i = 0; i < 8; i++){
    LEXICON[i] = 0; // MODO LEXICON APAGADO MODO PC ACTIVADO
    }
    for (int i = 0; i < 6; i++){
    APAGAR[i] = 127; // EL MODO DE APAGAR BOTON ES REPITIENDO EL MENSAJE 127 (BOTON ACTIVADO)
    }
    APAGAR[6] = 0; // EN EL MODO PC 7 Y 8 FUNCIONAN COMO TOGGLE CC
    APAGAR[7] = 0;
    digitalWrite(ledpin[3] , LOW);
    digitalWrite(ledpin[2] , LOW);      
    UNAVEZ = 1; // PARA QUE SE EJECUTE SOLO UNA VEZ
    eligio4();
    } 
  }
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 // CHEQUEAR EL ESTADO DEL BOTON PLAY/SETUP (BOTON10)
ButtonState10 = digitalRead(botonMaster);
  // comparar el estado ACTUAL del boton10 con el anterior PARA DETERMINAR SI FUE ACCIONADO
  if (ButtonState10 != LastButtonState10) { // si el estado cambio ES PORQUE FUE ACCIONADO      
    if (ButtonState10 == LOW) {
    // si el estado PASO DE HIGH A LOW FUE ACTIVADO EL MODO PLAY
      switch (ACTIVARMASTER) { // SE USA EL SWITCH PARA INCORPORAR LAS DOS OPCIONES, 0 Y 127 PARA QUE SE TOMEN COMO ACTIVADO
      case 127:
      ACTIVARMASTER = 0;
      MODOPLAY = 1;
      break;
      case 0:
      ACTIVARMASTER = 127;
      MODOPLAY = 1;
      }      
    }
    if (ButtonState10 == HIGH) {
    // si el estado PASO DE LOW A HIGH FUE ACTIVADO EL MODO SETUP  
      switch (ACTIVARMASTER) {
      case 127:
      ACTIVARMASTER = 0;
      MODOPLAY = 0;
      break;
      case 0:
      ACTIVARMASTER = 127;
      MODOPLAY = 0;
      }
    }      
    // un poco de delay para evitar el bouncing
    delay(50);     
  }  
// guardar el estado actual como el estado anterior - DE ESTA MANERA VOLVERA EL LOOP SOLO SI CAMBIA NUEVAMENTE EL ESTADO DEL BOTON PARA EL OTRO LADO
LastButtonState10 = ButtonState10;

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

switch (MODOPLAY){
case 1: // MODOPLAY ACTIVADO, LOS SEIS BOTONES SE USAN PARA ACTIVAR O DESACTIVAR LOS FX, LOS BOTONES QUE QUEDAN Y LOS POTES VAN POR CANAL 1
APAGARLEDS = 0; // PARA QUE SE EJECUTE EL APAGADO DE LEDS CUANDO SE CAMBIE AL MODOSETUP
  if (APAGARLEDS2 == 0){ // LOOP PARA APAGAR LOS LEDS QUE ESTABAN PRENDIDOS EN EL MODOSETUP (EL MODOSETUP ES EL MODOPLAY = 0) 
  apagartodo();
  APAGARLEDS2 = 1; // ESTO ASEGURA QUE EL LOOP SE EJECUTE UNA SOLA VEZ, CUANDO ENTRA EN EL MODOPLAY 
  }
for (int i = 0; i < 6; i++){
  if (MEMLED[i] == 1) { // ESTA SERIE DE LOOPS RESTITUYEN LOS LEDS QUE HABIAN QUEDADO PRENDIDOS ANTES
  digitalWrite(ledpin[i] , HIGH);
  }
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

// LA VARIABLE POT LEE LA ENTRADA ANALOGICA Y LO ALMACENA, SI ESE VALOR CAMBIA SE ENVIA A TRAVES DE MIDI CC
for (int i = 0; i < 3; i++){
pot[i] = (analogRead(potes[i])/8); // LEE LOS POTES, ES DECIR EL PIN DE ENTRADA Y LO ALMACENA EN POT
  if (pot[i] != potant[i]){ // COMPARA POT CON EL ESTADO ANTERIOR POTANT, SI CAMBIO CONTINUA
  MIDI.sendControlChange ( ccpot[i], pot[i], 1 );  // ENVIA EL CCPOT CON EL VALOR POT POR EL CANAL 1
  }
potant[i] = pot[i]; // ACTUALIZA EL ESTADO DE POT PARA EL PROXIMO LOOP
delay(10); 
}
///////////////////////////////////////////////////////////////////////////////////////////////

for (int i = 0; i < 6; i++){ // LOOP PARA LOS 6 BOTONES
estadoboton[i] = digitalRead(boton[i]);
  if (estadoboton[i] != anteriorboton[i]) {  
    if (estadoboton[i] == LOW) {        
      switch (MEMLED[i]) {
      case 0:
      MIDI.sendControlChange ( CC[i], 127 ,1 );
      digitalWrite(ledpin[i] , HIGH);
      MEMLED[i] = 1;
        if (LEXICON[i] == 0) {
        delay(50);
        MIDI.sendControlChange ( CC[i], 0 ,1 );
        }
      break;
      case 1:
      MIDI.sendControlChange ( CC[i], APAGAR[i] ,1 ); 
      digitalWrite(ledpin[i] , LOW); 
      MEMLED[i] = 0; 
        if (LEXICON[i] == 0) {
        delay(50);  
        MIDI.sendControlChange ( CC[i], 0 ,1 ); 
        }
      break;
      }   
    }
    delay(50); 
  }  
  anteriorboton[i] = estadoboton[i];
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

for (int i = 06; i < 8; i++){ // LOOP PARA BOTONES 7 Y 8
estadoboton[i] = digitalRead(boton[i]);
  if (estadoboton[i] != anteriorboton[i]) {  
    if (estadoboton[i] == LOW) {        
      switch (MEMLED[i]) {
      case 0:
      MIDI.sendControlChange ( CC[i], 127 ,1 );
      digitalWrite(ledpin[i] , HIGH);
      MEMLED[i] = 1;
        if (LEXICON[i] == 1) {
        delay(50);
        MIDI.sendControlChange ( CC[i], 0 ,1 );
        }
      break;
      case 1:
      MIDI.sendControlChange ( CC[i], APAGAR[i] ,1 ); 
      digitalWrite(ledpin[i] , LOW); 
      MEMLED[i] = 0; 
        if (LEXICON[i] == 1) {
        delay(50);  
        MIDI.sendControlChange ( CC[i], 0 ,1 ); 
        }
      break;
      }   
    }
  delay(50); 
  }  
  anteriorboton[i] = estadoboton[i];
}
break;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

case 0: // MODOSETUP ACTIVADO, CADA UNO DE LOS SEIS BOTONES ACTUA COMO SELECTOR DE CANAL MIDI DEL 11 AL 16, LOS DOS BOTONES Y LOS POTES SE CAMBIAN AL CANAL SELECCIONADO CON CC NUEVOS
APAGARLEDS2 = 0; // PARA QUE SE EJECUTE EL APAGADO DE LEDS CUANDO SE CAMBIA AL MODOPLAY
  if (APAGARLEDS == 0){ // LOOP PARA APAGAR LOS LEDS QUE ESTABAN PRENDIDOS EN EL MODOPLAY  
  apagartodo();
  APAGARLEDS = 1; // SE ASEGURA QUE EL LOOP SE EJECUTE UNA SOLA VEZ
if (modoconfig == 0){
      CANAL = 1;
      BOTVARIABLE[6] = 3;
      BOTVARIABLE[7] = 9;
      POTVARIABLE[0] = 80;
      POTVARIABLE[1] = 81;   
      POTVARIABLE[2] = 82;
      POTVARIABLE[3] = 11;
      modoconfig = 1;
    }
  }
for (int i = 0; i < 6; i++){
  if (MEMCANAL[i] == 1) { // ESTA SERIE DE LOOPS ES PARA RESTITUIR LA SELECCION DE CANAL DE LA INSTANCIA DE MODOSETUP ANTERIOR
  digitalWrite(ledpin[i] , HIGH);
  }
}
////////////////////////////////////////////////////////////////////////////

for (int i = 0; i < 3; i++){ // MISMO COMPORTAMIENTO QUE EN EL MODOPLAY PERO CON EL CC VARIABLE Y EL CANAL TAMBIEN
pot[i] = (analogRead(potes[i])/8);
  if (pot[i] != potant[i]){
  MIDI.sendControlChange ( POTVARIABLE[i], pot[i], CANAL ); 
  }
potant[i] = pot[i]; 
delay(10); 
}
//////////////////////////////////////////////////////////////////////////////////////////////    
for (int i = 0; i < 6; i++){ // LOOP PARA LOS 6 BOTONES EN MODOSETUP
estadoboton[i] = digitalRead(boton[i]); 
  if (estadoboton[i] != anteriorboton[i]) { 
  anteriorboton[i] = estadoboton[i];   
    if (estadoboton[i] == LOW) {
    VECES[2] = 1;
    VECES[3] = 1;   
    botonapretado[i] = tiempo;  
    apagartodo(); 
    for (int i = 0; i < 6; i++) 
    MEMCANAL[i] = 0;      
      switch (i){
      case 0:
      digitalWrite(ledpin[0] , HIGH);
      CANAL = 11;
      MEMCANAL[0] = 1;
      BOTVARIABLE[6] = 20;
      BOTVARIABLE[7] = 21;
      POTVARIABLE[0] = 102;
      POTVARIABLE[1] = 103;
      POTVARIABLE[2] = 104;
      POTVARIABLE[3] = 83;


      
      break;
      case 1:
      digitalWrite(ledpin[1] , HIGH);
      CANAL = 12;
      MEMCANAL[1] = 1;
      
      BOTVARIABLE[6] = 22;
      BOTVARIABLE[7] = 23;
      POTVARIABLE[0] = 105;
      POTVARIABLE[1] = 106;
      POTVARIABLE[2] = 107;
      POTVARIABLE[3] = 85;

      break;
      case 2:
      digitalWrite(ledpin[2] , HIGH);
      CANAL = 13;
      MEMCANAL[2] = 1;
      BOTVARIABLE[6] = 24;
      BOTVARIABLE[7] = 25;
      POTVARIABLE[0] = 108;
      POTVARIABLE[1] = 109;
      POTVARIABLE[2] = 110;
      POTVARIABLE[3] = 86;

      break;
      case 3:
      digitalWrite(ledpin[3] , HIGH);
      CANAL = 14;
      MEMCANAL[3] = 1;
      BOTVARIABLE[6] = 26;
      BOTVARIABLE[7] = 27;
      POTVARIABLE[0] = 111;
      POTVARIABLE[1] = 112;
      POTVARIABLE[2] = 113;
      POTVARIABLE[3] = 87;

      break;
      case 4:
      digitalWrite(ledpin[4] , HIGH);
      CANAL = 15;
      MEMCANAL[4] = 1;
      BOTVARIABLE[6] = 28;
      BOTVARIABLE[7] = 29;
      POTVARIABLE[0] = 114;
      POTVARIABLE[1] = 115;
      POTVARIABLE[2] = 116;
      POTVARIABLE[3] = 89;

      break;
      case 5:
      digitalWrite(ledpin[5] , HIGH);
      CANAL = 16;
      MEMCANAL[5] = 1;
      BOTVARIABLE[6] = 30;
      BOTVARIABLE[7] = 31;
      POTVARIABLE[0] = 117;
      POTVARIABLE[1] = 118;
      POTVARIABLE[2] = 119;
      POTVARIABLE[3] = 90;

      break;
      }      
    }
    
    if (i == 0){
      LUCECITAS = tiempo - botonapretado[0]; 
  if (LUCECITAS >= tiempoLUCECITAS) { // SI EL TIEMPO APRETADO SUPERA LUCECITAS ENTRA EN MODO NAVIDEO
    apagartodo();
    NAVIDA();
  }
    }
    
    if (i == 5){ // MANTENIENDO EL BOTON 6 PRESIONADO RESETEA LA BOTONERA
      
      resetpresionado = tiempo - botonapretado[5];
      
      if (resetpresionado >= tiemporeset) {
      digitalWrite(ledpin[5] , LOW);  
      resetFunc();
      }
    }
    if (tiempo - botonapretado[i] >= tiempoapretado) { // MISMO COMPORTAMIENTO QUE EL BOTON 1
      if (VECES[i] < 2){
      UNAVEZ = 0;
        while (UNAVEZ == 0){
        apagartodo();
        MEMCANAL[i] = 0;
        digitalWrite(ledpin[3] , HIGH); 
        digitalWrite(ledpin[2] , HIGH); 
        estadoboton[2] = digitalRead(boton[2]);
        estadoboton[3] = digitalRead(boton[3]);
          if (estadoboton[2] != anteriorboton[2] || estadoboton[3] != anteriorboton[3]) {
            if (estadoboton[2] == LOW){    
            LEXICON[i] = 1; // MODO LEXICON ACTIVADO (PARA ESTE BOTON ES MODO TOGGLE)
            APAGAR[i] = 0; // EL MODO DE APAGAR BOTON ES MEDIANTE EL VALOR 0
            digitalWrite(ledpin[3] , LOW);
            digitalWrite(ledpin[2] , LOW);      
            UNAVEZ = 1;
            eligio3();
            VECES[i] = VECES[i] + 1;
            }
            if (estadoboton[3] == LOW){ 
            LEXICON[i] = 0; // MODO LEXICON APAGADO MODO PC ACTIVADO (PARA ESTE BOTON ES MODO NO TOGGLE)
            APAGAR[i] = 127; // EL MODO DE APAGAR BOTON ES REPITIENDO EL MENSAJE 127 (BOTON ACTIVADO)
            digitalWrite(ledpin[3] , LOW);
            digitalWrite(ledpin[2] , LOW);      
            UNAVEZ = 1; // PARA QUE SE EJECUTE SOLO UNA VEZ
            eligio4();
            VECES[i] = VECES[i] + 1;
            } 
          }
        }
      }
    }
    // un poco de delay para evitar el bouncing
    delay(50); 
  }
  // guardar el estado actual como el estado anterior para la proxima vez
  //anteriorboton[2] = estadoboton[2];
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
for (int i = 6; i < 8; i++){ // LOOP PARA LOS BOTONES 7 Y 8 EN EL MODOSETUP
estadoboton[i] = digitalRead(boton[i]);
  if (estadoboton[i] != anteriorboton[i]) {
    if (estadoboton[i] == LOW) {
    VECES[2] = 1;
    VECES[3] = 1;
    botonapretado[i] = tiempo;  
      switch (MEMLED[i]) {
      case 1: 
      MIDI.sendControlChange ( BOTVARIABLE[i], 127 ,CANAL ); 
      MEMLED[i] = 0; 
        if (LEXICON[i] == 1) {
        delay(50);
        MIDI.sendControlChange ( BOTVARIABLE[i], 0 ,CANAL ); 
        }
      break;
      case 0: // SE APAGA EL BOTON
      MIDI.sendControlChange ( BOTVARIABLE[i], APAGAR[i] ,CANAL ); 
      MEMLED[i] = 1; 
        if (LEXICON[i] == 1) {
        delay(50);
        MIDI.sendControlChange ( BOTVARIABLE[i], 0 ,CANAL ); 
        }
      break;
      }
    }
    if (tiempo - botonapretado[i] >= tiempoapretado) { // MISMO COMPORTAMIENTO QUE EL BOTON 1 PERO CON LAS OPCIONES AL REVES
    UNAVEZ = 0;
      while (UNAVEZ == 0){ 
      apagartodo();
      digitalWrite(ledpin[3] , HIGH);
      digitalWrite(ledpin[2] , HIGH);
      estadoboton[2] = digitalRead(boton[2]);
      estadoboton[3] = digitalRead(boton[3]);
        if (estadoboton[2] != anteriorboton[2] || estadoboton[3] != anteriorboton[3]) { 
          if (estadoboton[2] == LOW){
          LEXICON[i] = 1; // MODO LEXICON ACTIVADO (PARA ESTE BOTON ES MODO NO TOGGLE)
          APAGAR[i] = 127; // EL MODO DE APAGAR BOTON ES MEDIANTE EL VALOR 0
          digitalWrite(ledpin[3] , LOW);
          digitalWrite(ledpin[2] , LOW);      
          UNAVEZ = 1;
          eligio3();
          }
          if (estadoboton[3] == LOW){ 
          LEXICON[i] = 0; // MODO LEXICON APAGADO MODO PC ACTIVADO (PARA ESTE BOTON ES MODO TOGGLE)
          APAGAR[i] = 0; // EL MODO DE APAGAR BOTON ES REPITIENDO EL MENSAJE 127 (BOTON ACTIVADO)
          digitalWrite(ledpin[3] , LOW);
          digitalWrite(ledpin[2] , LOW);      
          UNAVEZ = 1; // PARA QUE SE EJECUTE SOLO UNA VEZ
          eligio4();
          } 
        }
      }
    }
  // un poco de delay para evitar el bouncing
  delay(50); 
  }
// guardar el estado actual como el estado anterior para la proxima vez
anteriorboton[i] = estadoboton[i];
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
break;
}
}

void eligio3(){
digitalWrite(ledpin[2] , HIGH);
delay(500);
digitalWrite(ledpin[2] , LOW);
delay(500);
digitalWrite(ledpin[2] , HIGH);      
delay(500);
digitalWrite(ledpin[2] , LOW);
delay(500);
digitalWrite(ledpin[2] , HIGH);
delay(500);
digitalWrite(ledpin[2] , LOW);
delay(500);
digitalWrite(ledpin[2] , HIGH);      
delay(500);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[3] , LOW);
UNAVEZ = 1;
}

void eligio4(){
digitalWrite(ledpin[3] , HIGH);
delay(500);
digitalWrite(ledpin[3] , LOW);
delay(500);
digitalWrite(ledpin[3] , HIGH);      
delay(500);
digitalWrite(ledpin[3] , LOW);
delay(500);
digitalWrite(ledpin[3] , HIGH);
delay(500);
digitalWrite(ledpin[3] , LOW);
delay(500);
digitalWrite(ledpin[3] , HIGH);      
delay(500);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[3] , LOW);
UNAVEZ = 1;
}

void apagartodo(){
digitalWrite(ledpin[5] , LOW);
digitalWrite(ledpin[4] , LOW);
digitalWrite(ledpin[3] , LOW);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[1] , LOW);
digitalWrite(ledpin[0] , LOW);
}

void intro(){
digitalWrite(ledpin[0] , HIGH); //SUBE
delay(75);
digitalWrite(ledpin[0] , LOW);
digitalWrite(ledpin[1] , HIGH);
delay(75);
digitalWrite(ledpin[1] , LOW);
digitalWrite(ledpin[2] , HIGH);
delay(75);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[3] , HIGH);
delay(75);
digitalWrite(ledpin[3] , LOW);
digitalWrite(ledpin[4] , HIGH);
delay(75);
digitalWrite(ledpin[4] , LOW);
digitalWrite(ledpin[5] , HIGH);
delay(75);
digitalWrite(ledpin[5] , LOW);
digitalWrite(ledpin[4] , HIGH); // BAJA
delay(75);
digitalWrite(ledpin[4] , LOW);
digitalWrite(ledpin[3] , HIGH);
delay(75);
digitalWrite(ledpin[3] , LOW);
digitalWrite(ledpin[2] , HIGH);
delay(75);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[1] , HIGH);
delay(75);
digitalWrite(ledpin[1] , LOW);
digitalWrite(ledpin[0] , HIGH); // SUBE
delay(75);
digitalWrite(ledpin[0] , LOW);
digitalWrite(ledpin[1] , HIGH);
delay(75);
digitalWrite(ledpin[1] , LOW);
digitalWrite(ledpin[2] , HIGH);
delay(75);
digitalWrite(ledpin[2] , LOW);
digitalWrite(ledpin[3] , HIGH);
delay(75);
digitalWrite(ledpin[3] , LOW);
digitalWrite(ledpin[4] , HIGH);
delay(75);
digitalWrite(ledpin[4] , LOW);
digitalWrite(ledpin[5] , HIGH);
delay(75);
digitalWrite(ledpin[5] , LOW);
delay(1000);
}

void NAVIDA() {
int  luces = 1;
  
  delay(1000);
  digitalWrite(ledpin[0] , HIGH); //SUBE
  delay(100);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  delay(100);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[2] , HIGH);
  delay(100);
  digitalWrite(ledpin[2] , LOW);
  digitalWrite(ledpin[3] , HIGH);
  delay(100);
  digitalWrite(ledpin[3] , LOW);
  digitalWrite(ledpin[4] , HIGH);
  delay(100);
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[5] , HIGH);
  delay(100);
  digitalWrite(ledpin[5] , LOW);
  delay(250);

while (luces = 1){
  
  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  digitalWrite(ledpin[0] , HIGH);
  digitalWrite(ledpin[2] , HIGH);  
  digitalWrite(ledpin[4] , HIGH);
  delay (750);
  digitalWrite(ledpin[0] , LOW);
  digitalWrite(ledpin[2] , LOW);  
  digitalWrite(ledpin[4] , LOW);
  digitalWrite(ledpin[1] , HIGH);
  digitalWrite(ledpin[3] , HIGH);  
  digitalWrite(ledpin[5] , HIGH);
  delay (750);
  digitalWrite(ledpin[1] , LOW);
  digitalWrite(ledpin[3] , LOW);  
  digitalWrite(ledpin[5] , LOW);

  delay (750);

  digitalWrite(ledpin[0] , HIGH); //SUBE
  delay(150);
  digitalWrite(ledpin[1] , HIGH);
  delay(150);
  digitalWrite(ledpin[2] , HIGH);
  delay(150);
  digitalWrite(ledpin[3] , HIGH);
  delay(150);
  digitalWrite(ledpin[4] , HIGH);
  delay(150);
  digitalWrite(ledpin[5] , HIGH);
  delay(150);
  digitalWrite(ledpin[0] , LOW);
  delay(150);
  digitalWrite(ledpin[1] , LOW);
  delay(150);
  digitalWrite(ledpin[2] , LOW);
  delay(150);
  digitalWrite(ledpin[3] , LOW);
  delay(150);
  digitalWrite(ledpin[4] , LOW);
  delay(150);
  digitalWrite(ledpin[5] , LOW);
  delay(150);
  
  digitalWrite(ledpin[5] , HIGH); //BAJA
  delay(150);
  digitalWrite(ledpin[4] , HIGH);
  delay(150);
  digitalWrite(ledpin[3] , HIGH);
  delay(150);
  digitalWrite(ledpin[2] , HIGH);
  delay(150);
  digitalWrite(ledpin[1] , HIGH);
  delay(150);
  digitalWrite(ledpin[0] , HIGH);
  delay(150);
  digitalWrite(ledpin[5] , LOW);
  delay(150);
  digitalWrite(ledpin[4] , LOW);
  delay(150);
  digitalWrite(ledpin[3] , LOW);
  delay(150);
  digitalWrite(ledpin[2] , LOW);
  delay(150);
  digitalWrite(ledpin[1] , LOW);
  delay(150);
  digitalWrite(ledpin[0] , LOW);
  delay(250);
  }
}

Botonera 2000

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

Botonera 2000

Code

Botonera 2000

Credits

nataniel_81

Comments

Embed the widget on your own site

Botonera 2000

Botonera 2000

Things used in this project

Hardware components

Software apps and online services

Hand tools and fabrication machines

Story

Schematics

Botonera 2000

Code

Botonera 2000

Credits

nataniel_81

Comments

Related channels and tags