UNIVERSIDAD NACIONAL DEL ALTPLANO PUNO
Facultad de Ingeniería Mecánica Eléctrica
Electrónica Y Sistemas
Escuela profesional de Ingeniería Electrónica
Procesamiento Digital de Señales
Proyecto: Procesamiento Digital de Señal de Audio usando
Arduino
DOCENTE: David Salinas Mendoza
ESTUDIANTES:
Fredy Jesus Calcina Quispe (171161)
Bartolome Roque Roque (170412)
Bebeto Romario Aquilar Yanapa (170226)
PUNO-PERU
2022-I
Índice
I. Introducción ................................................................................................................................ 3
II. Resumen ...................................................................................................................................... 3
III. Objetivos ................................................................................................................................. 3
1. Objetivo General ..................................................................................................................... 3
2. Objetivos Específicos ............................................................................................................... 3
IV. Metodología ............................................................................................................................ 4
1. Trabajando con la señal Periódica........................................................................................... 4
2. Trabajando con la señal de Audio ........................................................................................... 9
V. Conclusiones.............................................................................................................................. 15
VI. Anexos ................................................................................................................................... 15
1. Programación en Matlab ....................................................................................................... 15
1.1 Programación de Señal de prueba ................................................................................ 15
1.2 Programación de Transformada de Fourier .................................................................. 15
1.3 Programación de Filtro IIR pasa bajos ........................................................................... 16
1.4 Programación de comparación de graficas ................................................................... 16
1.5 Programación de Transformada de Fourier de señal filtrada ....................................... 16
1.6 Programación de señal de audio ................................................................................... 17
2. Programación en Arduino IDE ............................................................................................... 17
P á g i n a 2 | 18
I. Introducción
El procesamiento digital de señales o DSP (Digital Signal Processing) es la manipulación
matemática de una señal de información para modificarla o mejorarla en algún
sentido, esto se consigue llevando la señal en tiempo discreto en el dominio de
frecuencia discreta.
Arduino UNO es una placa de desarrollo basada en el microcontrolador Atmega328p,
equipada con conjuntos de pines de E/S digitales y analógicas que pueden conectarse
a varias placas de expansión y otros circuitos, la cuales son los encargados de realiza la
lectura de datos como señales de audio,
Al hacer procesamiento de audio, se debe de pensar en un sistema con dos etapas, la
etapa de adquisición de la señal y la etapa de procesamiento.
II. Resumen
En este informe se realizó el diseño, simulación e implementación de un sistema para
el procesamiento digital de señales, dicho sistema será diseñado y simulado en el
software Matlab e implementado en el procesador Atmega 328p que se encuentra en
Arduino UNO, la implementación del sistema será un filtro IIR encargado de eliminar el
ruido del audio que se obtendrá mediante un sensor de audio y se procesara en el
Arduino para obtener un audio limpio de ruido, para esto se harán 2 análisis.
Primero trabajaremos solo en Matlab generando una señal periódica de 4Hz y una
señal que fungirá como ruido de 60Hz, para esto diseñaremos un filtro IIR pasa bajo de
grado 5 con una frecuencia de corte de 40Hz que solo permita el paso de señales
menores a esta y elimine las señales mayores a 40Hz, este filtro será implementado
solo como simulación y conocer bien el funcionamiento de el filtro IIR.
Como Segundo paso, tendremos el diseño en Matlab e implementación de un filtro IIR
pasa bajo de grado 5 con una frecuencia de corte de 40Hz para el procesamiento de
audio, dicha señal será adquirida por un sensor de sonido conectado a Arduino, ya que
en el Arduino la señal será filtrada que finalmente deberá de salir libre de ruido
III. Objetivos
1. Objetivo General
Diseñar, Simular e implementar un filtro IIR pasa bajo para señales periódicas
y señales de audio.
2. Objetivos Específicos
Eliminar el ruido presente en las señales de audio adquiridas mediante el uso
de un micrófono.
Determinar el grado de funcionamiento óptimo de nuestro filtro
P á g i n a 3 | 18
IV. Metodología
1. Trabajando con la señal Periódica
Empezamos generando señales periódicas funcionen como señal principal y señal
de ruido de 4Hz y 60hz respectivamente:
P á g i n a 4 | 18
Procedemos a aplicar la transformada de Fourier para graficar el espectro de
frecuencias encontradas en la señal generada anteriormente:
P á g i n a 5 | 18
Diseñamos el filtro IIR estableciendo la frecuencia de corte en 40Hz y definiendo el
grado del filtro, en este caso de de grado 5.
Filtramos la señal ruidosa establecida al inicio y observamos que nuestro filtro
elimino el ruido de 60Hz.
P á g i n a 6 | 18
Para comprobar que el filtro funciono graficamos la señal filtrada y su
transformada de Fourier, y podemos observar que la señal de ruido de 60Hz
disminuyo significativamente.
P á g i n a 7 | 18
Des esta simulación, podemos sacar datos como la función de transferencia que
usaremos para llevarlo a transformada Z y así poder implementarlo con Arduino
Este primer procedimiento se hizo con el objetivo de probar el filtro diseñado y así
experimentar con señales periódicas
P á g i n a 8 | 18
2. Trabajando con la señal de Audio
Comenzamos con la obtención de la señal de audio en Matlab para su respectivo
procesamiento:
Después de la obtención de la señal se pasará a graficar la transformada de
Fourier de dicha señal de audio para poder observar el comportamiento que
presenta en el espectro de frecuencia:
P á g i n a 9 | 18
Se observa que el ruido se encuentra en las frecuencias altas, Para lo cual
crearemos un filtro IIR de grado 2 CON UNA FRECUENCIA DE CORTE DE 40hz.
P á g i n a 10 | 18
A continuación, se puede observar el audio original y el audio filtrado
respectivamente:
P á g i n a 11 | 18
Para finalizar graficamos el audio filtrado y su espectro de frecuencia, y podemos
observar que el filtro funciono correctamente
P á g i n a 12 | 18
Sabiendo que el filtro funcionó, procederemos a la obtención de la función de
transferencia para poder implementarlo en Arduino.
Teniendo la función de transferencia en el plano Z se procedera al reemplazo de
los coeficientes como se muestra:
𝑏0 𝑧 5 + 𝑏1 𝑧 4 + 𝑏2 𝑧 3 + 𝑏3 𝑧 2 + 𝑏4 𝑧1 +𝑏5
𝐻(𝑧) =
𝑧 5 + 𝑎1 𝑧 4 + 𝑎2 𝑧 3 + 𝑎3 𝑧 2 + 𝑎4 𝑧1 + 𝑎5
Reemplazar en la siguiente ecuación para implementar en Arduino IDE
𝑦[𝑛] = 𝑎1 𝑦(𝑛 − 1) + 𝑎2 𝑦(𝑛 − 2) + ⋯ + 𝑏0 𝑥(𝑛) + 𝑏1 𝑥(𝑛 − 1)
Teniendo la ecuación ya preparada se procedera a la programación en Arduino IDE
P á g i n a 13 | 18
Para la adquisición de la señal de audio usaremos un micrófono como se muestra
en la figura y se conectar en A0 de nuestro Arduino UNO:
En el Serial Plotter de Arduino graficamos señal de audio inicial y la señal de audio
filtrada, y podemos observar como el ruido disminuye considerablemente
Vemos que el filtro funciona correctamente la señal de color azul representa la
señal de entrada mientras que la señal de color rojo representa la señal filtrada.
P á g i n a 14 | 18
V. Conclusiones
Para el diseño e implementación se debe de considerar la frecuencia de corte
de los filtros pasa bajos.
Se logró eliminar el ruido de la señal de audio aplicando el filtro IIR pasa bajos
ya que el ruido está presente en frecuencias altas.
El grado del filtro es muy importante ya que este definirá que tan bien
funcionara nuestro filtro.
VI. Anexos
1. Programación en Matlab
La programación en Matlab se dividen en 6 programas distintos
1.1 Programación de Señal de prueba
clear all
close all
clc
f1=60;
f4=4;
fs=14400;
t=0:(1/fs):1-(1/fs);
x1= 0.2*sin(2*pi*f1*t);
x2= 0.2*sin(2*pi*f4*t);
x=x1+x2;
subplot(3,1,3)
plot(t,x)
title('Signal de 4Hz con ruido de 60Hz');
grid
hold on
subplot(3,1,1)
plot(t,x2,'r')
title('Signal original de 4Hz')
subplot(3,1,2)
plot(t,x1,'r')
title('Signal de ruido de 60Hz')
1.2 Programación de Transformada de Fourier
Xk=abs(fft(x));
L=length(Xk);
Xk2=Xk(1:L/2);
Xk2=Xk2/max(Xk2);
F=fs*(1:(L/2))/L;
n=length(x);
P á g i n a 15 | 18
t=n/fs;
Ts=1/fs
tiempo=(0:Ts:(t-Ts));
figure
g1=subplot(2,1,1)
plot(tiempo,x,'b');
title('Senal de Audio capturada, en el dominio del tiempo');
xlabel('Tiempo s');
ylabel('Amplitud');
g2=subplot(2,1,2)
plot(F,Xk2);
title('Espectro de Frecuencia ' );
xlabel('Frecuencia en Hz');
ylabel('Amplitud');
grid(g2,'on');
xlim([0 70])
1.3 Programación de Filtro IIR pasa bajos
Fc=40;
Wn=Fc/(fs/2);
N=5;
[num,den]=butter(N,Wn,'low');
1.4 Programación de comparación de graficas
y=filter(num,den,x);
figure
subplot(3,1,1)
plot(x)
title('Signal con ruido')
grid
subplot(3,1,2)
plot(y)
title('Signal filtrada con un firtro IIR de orden 5');
grid
1.5 Programación de Transformada de Fourier de señal filtrada
Xk=abs(fft(y));
L=length(Xk);
Xk2=Xk(1:L/2);
Xk2=Xk2/max(Xk2);
F=fs*(1:(L/2))/L;
n=length(x);
t=n/fs;
P á g i n a 16 | 18
Ts=1/fs
tiempo=(0:Ts:(t-Ts));
figure
g1=subplot(2,1,1)
plot(y,'b');
title('Signal capturada, en el dominio del tiempo');
xlabel('Tiempo s');
ylabel('Amplitud');
g2=subplot(2,1,2)
plot(F,Xk2);
title('Espectro ' );
xlabel('Frecuencia en Hz');
ylabel('Amplitud');
grid(g2,'on');
xlim([0 100])
1.6 Programación de señal de audio
a=audiorecorder;
recordblocking(a,2);
play(a);
x=getaudiodata(a);
2. Programación en Arduino IDE
float x[] = {0,0};
float y[] = {0,0};
int k = 0;
void setup() {
Serial.begin(115200);
}
void loop() {
x[0] = analogRead(A0);
x[0] = x[0];
float b[] = {4.921e-11, 2.46e-10, 4.921e-10, 4.921e-10, 2.46e-10, 4.921e-11};
float a[] = {-4.944, 9.776, -9.666, 4.779, -0.9451};
y[0] =
a[0]*y[1]+a[1]*y[2]+a[2]*y[3]+a[3]*y[4]+a[4]*y[5]+b[0]*x[0]+b[1]*x[1]+b[2]*x[2]+
b[3]*x[3]+b[4]*x[4]+b[5]*x[5];
P á g i n a 17 | 18
if(k % 3 ==0)
{
//Señal azul
Serial.print(x[0]);
Serial.print(" ");
//Señal roja
Serial.println(y[0]);
}
delay(1);
x[1] = x[0];
y[1] = y[0];
k = k+1;
}
P á g i n a 18 | 18
