Pedalera MIDI DIY

Serg10
#49 por Serg10 el 07/10/2019
#47
ignotus escribió:
Si, es cierto, se me había olvidado esa opción. Yo la descarté porque no quería tener que abrir otra aplicación de software cada vez que quiero usar el controlador, pero servir, sirve.


Lo suyo es como lo hiciste tú y no tener que depender de software...yo en principio usare el soft pero cuando la tenga ya todo andando seguramente le haga la misma placa que tu ;)
Subir
ignotus
#50 por ignotus el 07/10/2019
#48 Hace muuuchos años empecé la carrera de ingeniería electrónica, pero por razones personales lo tuve que dejar a mitad del 1er curso. Por vueltas de la vida años después estudié otra cosa completamente diferente, pero siempre tuve esa espinita clavada. Aún tengo los cuadernos con ejercicios de ecuaciones booleanas, con las puertas OR, NAND, NOR, etc... No llegué a aprender más que cosas muy elementales que en seguida se me olvidaron, pero aprendí a estañar, montar circuitos simples e identificar componentes, y con esa pequeña base he podido atreverme a montar algunos proyectos, con los que he aprendido mucho, relativamente hablando.

Lo de escribir código siempre me había parecido como magia (bueno, el 99% me lo sigue pareciendo...) pero con 4 conceptos básicos resulta que se pueden hacer cosas muy interesantes. El código que escribí para la pedalera en realidad no es más que un montonazo de declaraciones 'if' ('si X entonces Y'). Todas las funciones de la pedalera se basan en ese simple recurso, combinándolo de diferentes maneras. Lo que quiero decir es que en realidad, con tener curiosidad (y un poco de cabezonería), cualquiera puede aprender a escribir código para hacer cosas básicas. Luego hay todo un mundo que a mí se me escapa totalmente, pero el Arduino es una maravilla como introducción, con un montón de recursos para principiantes.

#49 Pues ánimo, ya nos enseñarás lo que hagas!
Subir
1
Serg10
#51 por Serg10 el 08/10/2019
#50

Las ganas lo es todo, si algo te llama la atención de verdad y quieres hacerlo te lo curras y vas probando, probando y vas aprendiendo hasta sacarlo. ;)

Ya compartiré resultados aunque mi idea es hacer algo bastante más sencillo!
Simplemente quiero tener unos botones y unos potes para manejar cosas del bias fx, guitar rig, reaper, o lo que quiera...un led que indique que esta encendido, otro que se encienda cuando se pulse algún botón y una entrada para conectarle un pedal de expresión que me quiero pillar...

Y ya después si le cojo el gusto al arduino tengo pensando hacer una batería electrónica, con piezo electricos, ldrs, etc.. jeje
Subir
1
Serg10
#52 por Serg10 el 08/10/2019
Aunque viendo tu "invento" estoy planteandome añadir la pantallita LCD para indicar que se ha pulsado o el % que esta un pote, y el lugar de conectarle un pedal de expresion comprado probar lo del sensor hall...
Subir
ignotus
#53 por ignotus el 08/10/2019
#52 En un principio mi idea también era hacer algo muy sencillo - 6 botones con sus LEDs y ya está... pero según iba aprendiendo y usando la pedalera, viendo sus limitaciones, surgían ideas para hacerla más versátil. Al fin y al cabo estamos hablando de componentes muy baratos y accesibles, y las funciones las vas añadiendo a tu gusto. Por otro lado, en cuanto empiezas a añadir pantalla y más cosas, el Arduino Uno se te puede quedar corto de entradas y de memoria. Para las entradas digitales se pueden hacer apaños para estirarlas, pero por lo que cuesta un Arduino Mega de los miniaturizados merece la pena empezar con eso y dejar margen para mejoras futuras.

Si vas a hacer una pedalera, en mi experiencia lo de añadirle potes no resultó muy práctico - por no agacharme acababa por no usarlos, y por eso hice un controlador aparte para poner en el escritorio.

Tengo bastante experiencia en el tema de baterías electrónicas DIY, puedes echar un vistazo a la mía aquí. Si te animas y quieres información o consejos, pásate por el foro de batacas.
Subir
1
Serg10
#54 por Serg10 el 08/10/2019
Wooow!genial lo de la batería, se ve curradisima!!la idea también es hacer algo simple, lo mio es la guitarra pero me gustaría aprender en casa cosillas básicas de batería, me guardo la info para cuando me ponga a ello!! ;)

La pedalera con poder subir o bajar de preset, activar desactivar delay u otra cosa, usar el wah y regular volumen de salida con un pote en principio es lo que hecho de menos...pero es cierto que igual luego eso me sabe a poco y quiero más :D :D
Lo que dices de los potes de agacharse no había caído...puede no ser practico y mejor usar el ratón...también había pensado dejarle entradas con jacks stereo para en un futuro ponerle algún botón más o meter un pote en una lata de atún conectado a una entrada de esas y poder manejar potes mejor, ya veré...de momento voy recogiendo ideas y haciendo pruebas de novato con arduino...y mientras voy pidiendome cosillas de aliexpress para cuando lleguen ver finalmente que hago con ellas :D

Unas dudas que me surge viendo lo del hall effect...¿que integrado usaste? y a que distancia debe quedar el iman del sensor?¿es importante o delicado de ajustar o luego con el código se puede ajustar por si queda muy cerca o lejos? (la parte mecánica del hacer el pedal es lo que más me asusta :( )
Subir
ignotus
#55 por ignotus el 08/10/2019
El sensor hall que uso es un A1302. La distancia depende un poco del imán que uses, pero tiene que ser de neodimio. Yo uso la mitad de uno circular de unos 2 cm de diámetro x 5 mm de grosor y funciona desde una distancia de unos 3 cm del sensor. Lo calibras usando un sketch simple para leer el puerto analógico, para ver qué rango de valores te salen de abierto a cerrado, y luego usas esos valores en tu sketch usando la función map().

Sí, una limitación de mi pedal de expresión es que al soltarlo siempre vuelve a su sitio; no puedes dejarlo en una posición fija.

Para poder ajustar el volumen de salida sin tener que usar potes y hacerlo rápidamente con el pie, hice que dos de los botones se pudieran usar para eso cuando la pedelera está en 'stomp mode'. Para todo lo demás tengo el controlador de escitorio, pero eso es útil para hacerlo al vuelo.

Yo también pensé en poner jacks para conectar los potes u otras cosas, pero el problema de eso es que acabas con cables por todas partes. El añadirle bluetooth fue un puntazo y funciona mejor de lo que pensaba - y tampoco es muy difícil añadirlo. Ya ves que no hago más que barrer para casa, jeje, pero te digo estas cosas porque pasé por todo el proceso y muchas cosas las tuve que rehacer para que fuera todo más práctico.
Subir
Serg10
#56 por Serg10 el 08/10/2019
ignotus escribió:
Para poder ajustar el volumen de salida sin tener que usar potes y hacerlo rápidamente con el pie, hice que dos de los botones se pudieran usar para eso cuando la pedelera está en 'stomp mode'. Para todo lo demás tengo el controlador de escitorio, pero eso es útil para hacerlo al vuelo.


oohh que buena idea!me la apunto! ;)

ignotus escribió:
Ya ves que no hago más que barrer para casa, jeje, pero te digo estas cosas porque pasé por todo el proceso y muchas cosas las tuve que rehacer para que fuera todo más práctico.


Si, si y se agradece precisamente por eso, prefiero tenerlo bien pensado antes de empezar a luego encontrarme que podría haberlo hecho de otra forma!
Subir
ignotus
#57 por ignotus el 16/06/2020
Link del post #24 actualizado.

El código se ha reducido drásticamente en extensión y he añadido alguna función como calibrado automático del pedal de expresión y la posibilidad de mandar mensajes MIDI para "Prev/Next Preset" y "Prev/Next Bank" en el software que se use. El repositorio contiene las librerías modificadas que son necesarias, instrucciones para programar y construir el receptor bluetooth-MIDI y alguna cosa más.
La cuarentena me ha servido para usarlo en más profundidad y pulir algunas cosas.
Subir
1
Serg10
#58 por Serg10 el 16/06/2020
#57

wow!le echare un ojo a ver, yo justamente hace poco acabe la mía!!me puse con ella en la cuarentena jeje a ver si algún rato subo fotos y info!
Es bastante mas simple, hice el pedal con sensor hall y unas arandelas de platillo para que no pierda la posición al quitar el pie, también puse un código para calibrarlo y convertir los datos logaritmicos del sensor en lineal y invertirlo y alguna cosa mas...de momento pego el código aquí, creo que con los comentarios a mi manera mas o menos se entiende :D

Alguien escribió:
//-------------------------------------------------
//------------BABUINO MIDI PEDALBOARD--------------
//-------------------------------------------------
//----Conexiones-----------------------------------
//LEDS (pins 12 y 13)-> conectar pin digital a r220ohm + led y a masa -> https://www.arduino.cc/en/uploads/Tutorial/ExampleCircuit_sch.png
//BOTONES (pins digitales 2-7)-> -> https://www.arduino.cc/en/uploads/Tutorial/button_schem.png (R=10k)
//POTENCIOMENTROS (pins analogicos 0,1,2) -> B10k lineal -> pin1 = masa / pin2 = entrada analogica / pin3 = +5v -> https://www.arduino.cc/en/uploads/Tutorial/AnalogReadSerial_sch.png
//SENSOR HALL A1302 (pin 3 analogico) -> Visto del lado NO plano = pin1 = +5v / pin2 = masa / pin3 = entrada analogica - Lado no plano = lado activo (el que apunta al iman)
//PEDAL EXPRESION STANDARD -> jack stereo -> 1(L)= + ,2(R)= pin 2 del pote ,3(GND)= -
//-------------------------------------------------

//Librerias
#include <MIDI.h> //Añade libreria MIDI (https://github.com/FortySevenEffects/arduino_midi_library)
MIDI_CREATE_INSTANCE(HardwareSerial, Serial, MIDI); //Create an instance of the library attached to a serial port


//----Variables------------------------------------
//LEDS
const int led_on_pin=13; //pin de el LED ON
const int led_send_pin=12; //pin de el LED SEND
int led_send_time = 50; //ms de parpadeo de el led send = tiempo que estara encendido antes de apagarse (que no sea mayor que el threshold de los buttons o pots)

//BOTONES
int buttons_number = 7; //(6 fijos + 1 externo = 7) indica el numero de botones usados (max=10), se asignaran consecutivamente del pin digital 2 al 12
int buttons_pins[11] = {2,3,4,5,6,7,8,9,10,11,12}; //los pines que seran usados consecuetivamente para asignarse a los botones, dejado libre el 0,1(rt, tx)y 13 (led)
int buttons_status[11] = {0,0,0,0,0,0,0,0,0,0,0}; //variable for reading the pushbutton status, no modificiar
int buttons_pressed[11] = {0,0,0,0,0,0,0,0,0,0,0}; //estado inicial no pulsado aun, no modificar
int buttons_CC_numbers[11] = {102,103,104,105,106,107,108,109,110,111,112}; //numero de CC de cada boton (102 to 119 are free)
int buttons_CC_values[11] = {1,1,1,1,1,1,1,1,1,1,1}; // valor de cada CC number, en este caso de botones no importa mucho creo.
int buttons_CC_channels[11] = {1,1,1,1,1,1,1,1,1,1,1}; //canal de cada CC number, no muy importante pero mejor dejar todos en el mismo.
int buttons_threshold[11] = {500,500,500,500,500,500,500,500,500,500,500}; //ms de delay entre pulsacion y pulsacion para debouncing de cada boton

//POTENCIOMETROS+PEDAL EXPRESION STANDARD
int pots_number = 4; // select number of desired analog inputs (max 6, o 5 pues el 6 se usa para en sensor hall),1,2,3 son potes + el 4 es el pedal standard / para añadir añadir y automaticamente se añade a la siguiente salida analogica(de 0 a 6)
int pedal_expresion_standard_pin = 3; //pin analogico donde esta el pedal de expresion standard
int pedal_expresion_standard_reverse = 0; //0 = lo deja como esta, 1 = lo invierte
int pots_analog_value[6] = {0,0,0,0,0,0}; // define variables for the controller data
int pots_last_analog_value[6] = {0,0,0,0,0,0}; // define the "lastValue" variables
int pots_cc_numbers[6] = {20,21,22,23,24,25}; // select the midi Controller Number for each input (20 to 31 are free)
int pots_cc_channels[6] = {1,1,1,1,1,1}; //canal de cada pote
int pots_threshold_noise[6] = {4,4,4,4,4,4}; //threshold de ruido (lectura inestable) de cada pote, a menos mas precision pero mas inestable, a mas menos precision pero mas estable.
int pots_threshold_delay[6] = {50,50,50,50,50,50}; //threshold de retraso tras mover cada pote

//SENSOR HALL/PEDAL EXPRESION
int sensor_hall_pin = 5; // pin del sensor hall
int sensor_hall_last_value = 0; // define the "lastValue"
int sensor_hall_cc_number = 85; //Numero de CC MIDI (85-90 son libres)
int sensor_hall_cc_channel = 1; //Canal del CC MIDI
int sensor_hall_threshold_noise = 3; //threshold de ruido (lectura inestable, el led send se queda parpadeando sin tocar el pedal) del sensor hall, a menos mas precision pero mas inestable, a mas menos precision pero mas estable.
int sensor_hall_threshold_delay = 50;//threshold de retraso tras mover el sensor hall/pedal
int sensor_hall_selected_mode = 4;//modo del sensor seleccionado por default, va de 1 a 4 (1 = logaritmico + natural, 2 = logaritmico + invertido, 3 = lineal + natural, 4 = lineal + invertido)

//Calibracion del sensor:
//rellenar estas variables con los valores obtenidos en cada posicion
//usar regla/pie de rey y la funcion de "utiles calibracion" para ver por el monitor serie los datos
int sensor_hall_min_value = 184;//ajuste sensor hall valor minimo = pedal cerrado/bajado
int sensor_hall_25_value = 334;//ajuste sensor hall valor al 25%
int sensor_hall_50_value = 431;//ajuste sensor hall valor al 50%
int sensor_hall_75_value = 459;//ajuste sensor hall valor al 75%
int sensor_hall_max_value = 468;//ajuste sensor hall valor maximo = pedal abierto/subido
//fin variables calibración

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

MIDI.begin(); //Inicializa libreria MIDI
Serial.begin(115200); //Inicializa el puerto serie indicando con baudrate (DEBE SER EL MISMO QUE ESTE PUESTO EN HAIRLEES)

//LEDS
pinMode(led_on_pin,OUTPUT); //define el modo salida para el pin donde esta el LED ON
pinMode(led_send_pin,OUTPUT); //define el modo salida para el pin donde esta el LED SEND

//BOTONES
for (int i = 0; i < buttons_number; i++) { //Inicializa pins de los botones como inputs
pinMode(buttons_pins, INPUT);
}//end for

}//end setup

//----Loop-----------------------------------------
void loop() { // put your main code here, to run repeatedly:
//LEDS
digitalWrite(led_on_pin,HIGH); //enciende el LED ON

//BOTONES
for (int i = 0; i < buttons_number; i++) { //recorre todos los botones
int button_state = digitalRead(buttons_pins);//mira estado del pin actual (pulsado o no pulsado)
int button_pressed = buttons_pressed;//mira si ha sido pulsado hace poco
if (button_state == HIGH & button_pressed == 0) { //comprueba si el boton ha sido pulsado Y si no ha sido pulsado aun(debounce)
MIDI.sendControlChange(buttons_CC_numbers,buttons_CC_values,buttons_CC_channels); //envia midi CC
led_send_on_off (); //ejecuta funcion que enciende y apaga led send
buttons_pressed = 1;delay(buttons_threshold); buttons_pressed = 0; //marca como enviado (debounce) -> espera un tiempo para volver a dejarlo en 1 (debounce) -> vuelve a marcar como no pulsado para poder pulsar de nuevo (debounce)
}//end if
}//end for

//POTENCIOMETROS
for (int i =0; i < pots_number; i++) { //recorre todos los potenciomentros
pots_analog_value = analogRead(i); //lectura del potenciometro en rango de 0 to 1023
if( abs(pots_analog_value-pots_last_analog_value) > pots_threshold_noise){//Mira si ha cambiado el valor del pote = si ha sido movido / con filtrado (se pierde precision pero solo se cumple si hay mas de x de diferencia en el cambio, asi se evita que cambie si hay "baile" de datos mientras el pot esta quieto realmente)
int pot_cc_value = pots_analog_value/8;//convierte a rango MIDI 0 - 127 de forma "casera"
//int pot_cc_value = map(pots_last_analog_value, 0, 1023, 0, 127); //convierte a rango MIDI 0 - 127 usando la funcion map (da fallos, a veces se dispara valor a 127 o se queda entre 125 y 2))
if (i == pedal_expresion_standard_pin && pedal_expresion_standard_reverse == 1){ //si es el pedal de expresion y esta en reverse
MIDI.sendControlChange(pots_cc_numbers,abs(pot_cc_value-127),pots_cc_channels); //envia el comando midi actual INVERTIDO
}
else{ //sino envio normal
MIDI.sendControlChange(pots_cc_numbers,pot_cc_value,pots_cc_channels); //envia el comando midi actual
}
led_send_on_off (); //ejecuta funcion que hace parpadear led send
pots_last_analog_value = pots_analog_value; //actualiza la ultima lectura
delay(pots_threshold_delay); //Retraso para evitar pequeñas flutuaciones al tocar o golpear potes
}//end if
}//end for

//SENSOR HALL/PEDAL EXPRESION
//Valor en bruto
int sensor_hall_value = analogRead(sensor_hall_pin);//measure magnetic field, poner "= 0;//" para desactivar pedal temporalmente

//Valores en MIDI logaritmico/natural
int sensor_hall_MIDI_value = map(sensor_hall_value, sensor_hall_min_value, sensor_hall_max_value, 0, 127);//Valor MIDI
sensor_hall_MIDI_value = constrain(sensor_hall_MIDI_value, 0, 127);//Limita el valor a MIDI 0-127, por si acaso se mueve iman y/o sensor
int sensor_hall_MIDI_value_inverted = abs(sensor_hall_MIDI_value-127);//Valor MIDI invertido

//Valores en MIDI Lineal
int rango = sensor_hall_max_value-sensor_hall_min_value; //rango total de valores en que se mueve el sensor
int out[] = {sensor_hall_min_value,(sensor_hall_min_value+(rango*0.25)),(sensor_hall_min_value+(rango*0.50)),(sensor_hall_min_value+(rango*0.75)),sensor_hall_max_value};//valores lineales deseados, calculado en 5 puntos (0%,25%,50%,75%,100%) / + puntos = + preciso.
int in[] = {sensor_hall_min_value,sensor_hall_25_value,sensor_hall_50_value,sensor_hall_75_value,sensor_hall_max_value}; //valores logaritmicos reales correspondientes a los deseados anteriores

int sensor_hall_lineal_value = multiMap(sensor_hall_value, in, out, 5); // Valor lineal
int sensor_hall_lineal_MIDI_value = map(sensor_hall_lineal_value, sensor_hall_min_value, sensor_hall_max_value, 0, 127); //Valor Lineal MIDI
sensor_hall_lineal_MIDI_value = constrain(sensor_hall_lineal_MIDI_value, 0, 127);//Limita el valor a MIDI 0-127, por si acaso se mueve iman y/o sensor
int sensor_hall_lineal_MIDI_value_inverted = abs(sensor_hall_lineal_MIDI_value-127);//Valor MIDI invertido

int sensor_hall_final_MIDI_value;//variable que tendra el valor midi final dependiendo del modo seleccionado
if (sensor_hall_selected_mode == 1){sensor_hall_final_MIDI_value = sensor_hall_MIDI_value;} //modo 1 = logaritmico + natural
if (sensor_hall_selected_mode == 2){sensor_hall_final_MIDI_value = sensor_hall_MIDI_value_inverted;} // modo 2 = logaritmico + invertido
if (sensor_hall_selected_mode == 3){sensor_hall_final_MIDI_value = sensor_hall_lineal_MIDI_value;} // modo 3 = lineal + natural
if (sensor_hall_selected_mode == 4){sensor_hall_final_MIDI_value = sensor_hall_lineal_MIDI_value_inverted;} //modo 4 = lineal + invertido

if( abs(sensor_hall_value-sensor_hall_last_value) > sensor_hall_threshold_noise) { //Mira si ha cambiado el valor del sensor hall = si ha sido movido / con filtrado (se pierde precision pero solo se cumple si hay mas de x de diferencia en el cambio, asi se evita que cambie si hay "baile" de datos mientras el sensor esta quieto realmente)
MIDI.sendControlChange(sensor_hall_cc_number,sensor_hall_final_MIDI_value,sensor_hall_cc_channel); //envia midi CC
//MIDI.sendControlChange(sensor_hall_selected_mode,sensor_hall_selected_mode,sensor_hall_selected_mode);//test para saber el modo, descomenttar para ver en hairless el modo seleccionado
led_send_on_off (); //ejecuta funcion que hace parpadear led send
sensor_hall_last_value = sensor_hall_value; //actualiza ultimo valor
delay(sensor_hall_threshold_delay); //Retraso para evitar pequeñas flutuaciones al tocar ,soltar o golpear pedal.
}//end if

//Utiles calibracion, descomentar para ver en el monitor serie los datos para calibrar
/*Serial.print("Value reading: ");Serial.println(sensor_hall_value);
Serial.print("MIDI reading: ");Serial.println(sensor_hall_MIDI_value);
Serial.print("MIDI reading -: ");Serial.println(sensor_hall_MIDI_value_inverted);
Serial.print("Value reading lineal: ");Serial.println(sensor_hall_lineal_value);
Serial.print("MIDI reading lineal MIDI: ");Serial.println(sensor_hall_lineal_MIDI_value);
Serial.print("MIDI reading lineal MIDI -: ");Serial.println(sensor_hall_lineal_MIDI_value_inverted);
Serial.println();delay(1000);*/

}//end loop



//----Funciones globales----------------------------

void led_send_on_off (){ //funcion para encender el led send por breve tiempo y apagar
digitalWrite(led_send_pin,HIGH); //enciende LED
delay (led_send_time); // tiempo de parpadeo
digitalWrite(led_send_pin,LOW); //apaga LED
}

//Funcion multimap, para convertir valores de logaritmico a lineal -> https://playground.arduino.cc/Main/MultiMap/
int multiMap(int val, int* _in, int* _out, uint8_t size)
{
// take care the value is within range
// val = constrain(val, _in[0], _in[size-1]);
if (val <= _in[0]) return _out[0];
if (val >= _in[size-1]) return _out[size-1];

// search right interval
uint8_t pos = 1; // _in[0] allready tested
while(val > _in[pos]) pos++;

// this will handle all exact "points" in the _in array
if (val == _in[pos]) return _out[pos];

// interpolate in the right segment for the rest
return (val - _in[pos-1]) * (_out[pos] - _out[pos-1]) / (_in[pos] - _in[pos-1]) + _out[pos-1];
}
Subir
1
ignotus
#59 por ignotus el 16/06/2020
¡Qué bueno!
Pues lo de cambiar la curva de respuesta del pedal ya lo voy a mirar porque sí que es algo que veía como mejorable.

Para estabilizar las lecturas analógicas utilizo la librería de ResponsiveAnalogRead (https://github.com/dxinteractive/ResponsiveAnalogRead) y va genial. Si quieres también puedes echar un vistazo al código que tengo para la calibración, es bastante simple y te ahorra tener que meter los valores manualmente.

Quedo a la espera de unas fotillos.
Subir
Serg10
#60 por Serg10 el 16/06/2020
#59

Genial!!!Me lo mirare todo pues ademas me he puesto ahora con la batería midi jeje, aunque de momento ando peleandome con los pads...
Subir
Hilos similares
Responder

Regístrate o para poder postear en este hilo