usuarios de Akai mpc's y más cosas

Archivo para la Categoría "electrónica"

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.

Anuncios

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

Roland EG-101

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.

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!

we choose the moon

En estos días que me encuentro realmente ocupado, debido a que estoy inmerso en la elaboración del proyecto fin de carrera, y buscando algo de información sobre mi arduino, me he tropezado con esta maravillosa web, por eso nace está entrada, para compartir este enlace:

http://wechoosethemoon.es/

 

Al hilo de este blog hay unas frases que me ha hecho reflexionar a cerca de los políticos que nos han tocado:

We choose to go to the moon. We choose to go to the moon in this decade and do the other things, not because they are easy, but because they are hard, because that goal will serve to organize and measure the best of our energies and skills, because that challenge is one that we are willing to accept, one we are unwilling to postpone, and one which we intend to win, and the others, too.

La traducción que figura en el blog http://wechoosethemoon.es/:

“El título proviene de un famoso discurso de John Fitzgerald Kennedy; en él, anuncia el propósito de los EEUU de viajar a la Luna antes de que acabe la década de los 70, no porque sea fácil, sino precisamente porque es difícil, y esa dificultad demostrará lo mejor de lo que son capaces:

El discurso entero es magnífico (ojalá quedara algún político así) y vale la pena leerlo detenidamente. Se menciona, por ejemplo, que lo que va a costar el programa Apollo es un poco menos del gasto anual en tabaco en EEUU, y que será aproximadamente de $0.50/semana por cada hombre, mujer y niño del país.

Y el conmentario más arriba con el que no puedo estar más de acuerdo.

Al margen de todo esto, este blog tiene articulos muy interesantes, tanto en el campo de arduino, mathlab y otros. Espero que sea de provecho.

 

Nube de etiquetas