usuarios de Akai mpc's y más cosas

Archivo para la Categoría "electrónica"

Retrazoo Delay effect

Front_web_png_10000x10000_q85.jpg

Back_web_png_10000x10000_q85.jpg

RE: Retrazoo (for Propellerhead Reason)

RetraZoo es una nueva unidad de efecto de retardo diseñada por MagmaSonic. RetraZoo se compone de 5 secciones principales:

  • Sección de retardo
  • Sección de filtro
  • Sección de modulación de LFO
  • Sección de modulación de seguidor de envolvente
  • Sección de mezcla principal

Los filtros se pueden configurar como filtros de paso bajo o paso alto, ya sea en una configuración de estilo en serie o en paralelo. RetraZoo puede producir modulación compleja combinando tanto los LFO como los parámetros de cantidad de modulación interna del Seguidor de Envolvente o externamente a través de CV para modular otros dispositivos en el Rack. Además, el parámetro “Spice” de la etapa de salida se puede utilizar para aumentar el volumen del audio procesado.

Detalles del producto:
RetraZoo es ideal para definir los sonidos ambientales, oscuros, dub y de efectos de sonido en tus pistas, usa el parámetro Time de la sección Delay, modula con los LFOs y obtendrás una loca cola de sonido. El parámetro Pan y el interruptor en la parte posterior le permiten abrir los sonidos en el campo estéreo. Inténtalo. La configuración de los filtros en serie o en paralelo te permitirá moldear los sonidos fácilmente. Los dos LFO permitirán modulaciones extremas y puedes tomar la salida de cada LFO a través de las salidas CV para modular los parámetros internos o externos en otros dispositivos en tu rack. El seguidor de envolvente te permitirá modular muchos parámetros y en la sección Mix puede imprimir caracteres a tus sonidos con un toque de Spice en las salidas.

 

Anuncios

Comportamiento de un filtro analógico en alta frecuencia y su homólogo digital

Comparativa entre el comportamiento de un filtro analógico en alta frecuencia y uno digital
Se realiza la conversión del filtro analógico desde el domino s al dominio digital z, mediante la transformada bilineal (BLT).

Así la función de transferencia de un filtro paso bajo de un polo se puede expresar así:


 

kill(all);
Hz2Rad(x):=float(x*2*%pi)$
dB(x):= float(20 * log(abs(x))/log(10))$
H(s):=1/(s/ωc+1)$ /*funcion de transferencia paso bajo 1 polo*/ 
fc:round(makelist(2^(10*x)*20,x,0.5,1,0.1))$/*6 frecuencias de corte*/
ωc:float(Hz2Rad(fc))$Hs:makelist(1/(s/x+1),x,ωc)$freq: []$
gaindB1:[]$
gaindB2:[]$
gaindB3:[]$
gaindB4:[]$
gaindB5:[]$
gaindB6:[]$n_muestras:150$
delta:ceiling(22050/n_muestras)$
for f:0.1 step delta thru 22050 do
(
ω:2*%pi*f/*frecuencia angular*/
s:%i*ω,
auxdB: dB(ev(cabs(Hs[1]))),
gaindB1: append(gaindB1,[auxdB]),
auxdB: dB(ev(cabs(Hs[2]))),
gaindB2: append(gaindB2,[auxdB]),
auxdB: dB(ev(cabs(Hs[3]))),
gaindB3: append(gaindB3,[auxdB]),
auxdB: dB(ev(cabs(Hs[4]))),
gaindB4: append(gaindB4,[auxdB]),
auxdB: dB(ev(cabs(Hs[5]))),
gaindB5: append(gaindB5,[auxdB]),
auxdB: dB(ev(cabs(Hs[6]))),
gaindB6: append(gaindB6,[auxdB]))$for f:0.1 step delta thru 22050 do
(
freq: append(freq,[f])
)$lista1:[discrete,float(freq),float(gaindB1)]$
lista2:[discrete,float(freq),float(gaindB2)]$
lista3:[discrete,float(freq),float(gaindB3)]$
lista4:[discrete,float(freq),float(gaindB4)]$
lista5:[discrete,float(freq),float(gaindB5)]$
lista6:[discrete,float(freq),float(gaindB6)]$lista:[lista1,lista2,lista3,lista4,lista5,lista6]$fc1:string(fc[1])$
fc1:sconcat(fc1,Hz)$
fc2:string(fc[2])$
fc2:sconcat(fc2,Hz)$
fc3:string(fc[3])$
fc3:sconcat(fc3,Hz)$
fc4:string(fc[4])$
fc4:sconcat(fc4,Hz)$
fc5:string(fc[5])$
fc5:sconcat(fc5,Hz)$
fc6:string(fc[6])$
fc6:sconcat(fc6,Hz)$
fcs:[fc1,fc2,fc3,fc4,fc5,fc6]$wxplot2d(lista,
[x,10,22050],
[y,20,3],
[logx],
[legend,fcs[1],fcs[2],fcs[3],fcs[4],fcs[5],fcs[6]],
[color,blue,blue,blue,blue,blue,blue],
[grid2d,true],
[xlabel,Frecuencia(Hz)],
[ylabel,Amplitud(dB)],
[label,[3dB,fc[1],3],[3dB,fc[5],3]]
);

 


 

Vemos que el comportamiento del filtro analógico en la gráfica de arriba para diversas frecuencias de corte,
ahora la tarea es mediante la la transformada bilineal BLT, convierte la función de transferencia en s-→z
y calcular la gráfica para las diversas frecuencias y comprobar la diferencias entre el comportamiento s<–>z

/**/
gaindBd1:[]$
gaindBd2:[]$
gaindBd3:[]$
gaindBd4:[]$
gaindBd5:[]$
gaindBd6:[]
/*H(s):=1/(s/ωc+1)$*/
s: 2/T*(z1)/(z+1)$ /*transformada bilineal BLT*/
samplerate:44100$ /*samples/s*/
T: float(1/samplerate)$
Hz:ev(H(s))$
Hz:ratsimp(Hz)for f:0.1 step delta thru 22050 do
(                                 
ω:2*%pi*f/*frecuencia angular*/
Ω:ω*T,  /*frecuencia en digital*/
z: exp(%i*Ω),
auxdB: dB(ev(cabs(Hz[1]))),
gaindBd1: append(gaindBd1,[auxdB]),
auxdB: dB(ev(cabs(Hz[2]))),
gaindBd2: append(gaindBd2,[auxdB]),
auxdB: dB(ev(cabs(Hz[3]))),
gaindBd3: append(gaindBd3,[auxdB]),
auxdB: dB(ev(cabs(Hz[4]))),
gaindBd4: append(gaindBd4,[auxdB]),
auxdB: dB(ev(cabs(Hz[5]))),
gaindBd5: append(gaindBd5,[auxdB]),
auxdB: dB(ev(cabs(Hz[6]))),
gaindBd6: append(gaindBd6,[auxdB]))listad1:[discrete,float(freq),float(gaindBd1)]$
listad2:[discrete,float(freq),float(gaindBd2)]$
listad3:[discrete,float(freq),float(gaindBd3)]$
listad4:[discrete,float(freq),float(gaindBd4)]$
listad5:[discrete,float(freq),float(gaindBd5)]$
listad6:[discrete,float(freq),float(gaindBd6)]listad:[listad1,listad2,listad3,listad4,listad5,listad6]$wxplot2d(listad,
[x,10,22050],
[y,20,3],
[logx],
[legend,fcs[1],fcs[2],fcs[3],fcs[4],fcs[5],fcs[6]],
[color,blue,blue,blue,blue,blue,blue],
[grid2d,true],
[xlabel,Frecuencia(Hz)],
[ylabel,Amplitud(dB)],
[label,[3dB,fc[1],3],[3dB,fc[5],3]]
);

 




listaf:append(lista,listad)
wxplot2d(listaf,
[x,10,22050],
[y,20,3],
[logx],
/*[legend,fcs[1],fcs[2],fcs[3],fcs[4],fcs[5],fcs[6]],*/
[legend,false],
[color,blue,blue,blue,blue,blue,blue,red,red,red,red,red,red],
[grid2d,true],
[xlabel,Frecuencia(Hz)],
[ylabel,Amplitud(dB)],
[label,[3dB,fc[1],3],[3dB,fc[5],3]]
);
 

 

 

Comprobamos que en el gráfico de arriba la gran diferencia de comportamiento de los filtros digitales y analógicos en alta frecuencia, al realizar la transformada bilineal (BLT), s-→z.


Created with wxMaxima.

PCB para puertos MIDI

Quizás tengas la necesidad de conectar tu microcontrolador (arduino, PIC, TI,…) a algún instrumento musical que lleva esos puertos midi din 5 pines (por otra parte cada vez más en deshuso).

He diseñado una PCB con componentes ThrueHole que fácilmente puedes realizar en tu casa.

He probado conectándolo al puerto serial (tx,rx) 5v. de mi arduino uno y de mi TI Tiva TM4C123G con 3.3v y han funcionado sin problemas.

 

Aquí les dejo el esquema del circuito,

midi_esquema

 

 

El diseño para la PBC,

midi_PCB

 

y la vista en 3D para que vean como puede quedar una vez realizada la PCB.

midi_3D

 

Adaptando el módulo SD de LC Studio para Arduino Uno

Recientemente he adquirido un módulo lector de tarjetas SD para conectar con Arduino, de la marca LC Studio en mi proveedor de componentes electrónicos local. Me dijeron que era compatible con Arduino y como su precio era muy económico me la lleve muy contento para casa.

tarjeta sd LC

Un módulo para almacenar y leer datos desde una tarjeta SD es muy útil. Puedes almacenar los datos leídos por los sensores para posteriormente procesarlo o bien leer desde la tarjeta SD las posiciones de un robot previamente almacenadas, por ejemplo.

Así cuando dispuse a conectar la LC Studio, según la documentación de Arduino nos dice que los pines para el protocolo SPI se conectan de esta manera:

Pines Arduino Uno Pines tarjeta SD LC Studio
11 MOSI
12 MISO
13 SCK
10 (configurable) CS

Una vez realizado el montaje, veo que con los programas de ejemplo que vienen con la librería de Arduino para la tarjeta SD me da todo tipo de errores. En un principio pensé que estaba algo mal en el cableado, pero cerciorándome que todas las conexiones estaban correctas, me di cuenta que los errores se debían a envío incorrecto de los comandos para leer o escribir en la tarjeta SD, con el resultado de que me corrompía los ficheros de la tarjeta SD. Una rápida búsqueda por internet me llevó a la siguiente página: http://www.extremadura-web.es/Blog/2012/11/16/cableando-sd-lc-studio-en-arduino-uno-y-mega/

Sacando como conclusión que el proveedor Chino LC Studio había implementado en esta tarjeta el manejo de pines con niveles +3.3v y como Arduino Uno tiene implementado por lo pines de salida la lógica de +5v, con lo que ya teníamos localizado el error que resulta bajo el protocolo SPI.

En el enlace que puse más arriba solucionan el problema de la lógica desde +5 a +3.3v mediante un sencillo divisor de tensión, pero en vista que tendría que poner un de par resistencias por cada pin. He pensado que podría usar un integrado que me solucione la papeleta. Buceando por internet he encontrado el CD4050.

image01

Es un desplazador de niveles de voltaje en función del voltaje de referencia, que le entra por la patilla 1. Como vemos tenemos hasta 6 entradas/salidas para adaptar los niveles de tensión.  De esta forma, si alimentamos la patilla 1 con 3.3v y metemos, por ejemplo, lógica de 5v por la patilla2, obtendríamos lógica de  3.3v por la patilla de salida 3. Perfecto. Manos a la obra.

Lo primero es realizar el esquema de las conexiones, para ello armado con fritzing realizo la ruta de conexiones que voy a seguir:

sd_LC_level_shifter

 

Para probar si todo va bien realizo el montaje sobre la protoboard:

20140719_204945

20140719_204954

Y aquí como conectamos al integrado 4050

20140719_205111

Y las conexiones sobre Arduino Uno

20140719_205038

Cargamos el  código de ejemplo que viene con la librería SD y hacemos las comprobaciones de que todo va correcto.

No olvidarnos de configurar el pin de selección CS como 10 según nuestro montaje

20140719_205217

Vemos que lee y escribe en la tarjeta SD de forma correcta

20140719_205244

Ahora queda integrar todo esto en una shield que podamos conectar fácilmente a nuestro Arduino, para ello he realizado esta sencilla implementación a una sola cara para que podamos realizarla en nuestra casa.

 

placa01

La representación 3D de la placa quedaría algo como así:

20140719_205352placa03


controlador midi con arduino

Roland EG-101 Extended

 

 

Después de unos añitos disfrutando de mi teclado Roland EG-101, recientemente me tropecé con algo de información complementaria respecto al teclado, donde había una serie de funciones muy interesantes, pero que están inaccesibles desde los controles del teclado.

Por lo que he estado desarrollando esta pequeña utilidad para poder acceder a las funciones directamente.

EG-101_extended

Las funciones que se pueden manejar desde este panel son las siguientes:

Pitch bend para la rueda de tono. hasta +24 tonos. Desde el teclado viene preconfigurado sólo 2 tonos.

ADR para la función del amplificador. No accesibles desde el teclado.

Vibrato Rate y Depth no accesibles desde el teclado.

Varios tipos de Rever y los parámetros asociados, no accesibles desde el teclado.

Varios tipos de Chorus y sus parámetros, no accesibles desde el teclado.

Podeís descarga la beta desde aquí:

Roland EG-101 Extended

De momento es sólo para PC Winxp/7 en forma de fichero exe. dll.

Para grabar los datos en tu secuenciador favorito debereís usar un puerto virtual como midi joke o similar.

Hay algunos parámetros que se envían mediante comandos sysex, que requieren unos segundos para que el EG-101 los reciba.

La versión ejecutable (.exe) la puedes descargar aquí

Comunicar Matlab con arduino

esta nueva entrada nace porque me he visto en deuda con el blog que mencioné en una entrada anterior. Gracias a estos simpáticos chicos pude redondear mi proyecto fin de carrera, y como al final, echando unas horitas en ello, pudimos (mi compi Gonzalo y yo) por fin lograr una comunicación bidireccional entre Matlab y la tarjeta Arduino uno rev3.

Si estamos en Matlab empezaremos por crear el objeto serial:

%crear objeto serie

s = serial(‘COM8′,’BaudRate’,9600,’Terminator’,’CR/LF’);

Para abrir el puerto serial mediante este comando:

%abrir puerto

fopen(s);

Y para enviar datos a arduino en formato byte:

 fwrite(s,comando,’uint8′);

ahora ya en arduino debemos escribir un skecth con la siguiente estructura para poder recibir los datos.

#include <EEPROM.h>

byte comando; //va a ser el byte a recibir

void setup() {

//configuramos el puert serial

Serial.begin(9600);

}

void loop() {

if (Serial.available()>0){  //si hay datos disponibles en el serial

delay(50);  //esperemos a que se terminen de recibir

comando=Serial.read();  //leemos el primer datos –byte-

 EEPROM.write(0,comando);//lo escribimos en la EPROM para cualquier uso que se nos ocurra.

     Serial.flush();//limpiamos el serial.

}

}

Para recibir datos en matlab desde arduino, como este puedes escribir cadenas alfanuméricas con retorno de carro en el puerto serial, recibiremos los datos de esta manera:

en arduino escribimos:

Serial.println(dato);

y en Matlab no tedríamos más que recoger los datos enviados por el puerto serial con el comando:

a=fscanf(s,’%d’);

no olvidaros de cerrar el puerto serial mediante

fclose(s);

porque si no nos dará todo tipo de errores y habrá que reiniciar Matlab.

Qué aproveche!

Nube de etiquetas