Digital Filter Design With Arduino DUE and Matlab
Juana Fernández, Walter Gemin, Raúl Rivera, Miguel Revuelta, Melisa Kuzman, Roberto Hidalgo
Universidad Nacional de Mar del Plata
Mar del Plata, Buenos Aires, Argentina
gfernand@fi.mdp.edu.ar
Abstract— In the bibliography and the different teaching
courses on Digital Signal Processing (DSP) there are a substantial
space aimed to the digital filters design theory including the
approximation methods of Butterworth, Chebyshev, Elíptico,
Cauer, pointing to the development of useful methods for
calculating the filter coefficients
Until recently the only way to experiment with filters in real
time was with commercial DSP boards usually of high cost and
low availability considering its application in the DSP laboratory
practice.
Nowadays, the features of the hardware and the low
complexity of the software development environment (IDE) of
the Arduino platform, give to it important characteristics for
the practical implementation of DSP algorithms, especially the
ARDUINO DUE board has enhanced features such as processor
SAM3X8E Atmel ARM Cortex- M3, ideal for projects that
require high capabilities of processing.
In this article is proposed the flexible design and the
automatic modification in the digital filter response, IIR or FIR
by using Arduino DUE supported by Matlab libraries.
The scheme proposed allows a simple and fast comparative
analysis between the different filters.
Keywords— Matlab; Arduino DUE; DSP; Digital Filter .
I. INTRODUCCION
El Procesamiento Digital de Señales puede enseñarse desde
una perspectiva matemática sin emplear herramientas de
simulación o el hardware correspondiente. No obstante, en los
cursos orientados a la educación tecnológica, las actividades
en el laboratorio juegan un rol fundamental dado que sirven
para desarrollar habilidades en la implementación práctica de
los algoritmos y para reforzar los aspectos teóricos del curso.
Existen diversas plataformas que pueden considerarse
adecuadas para los laboratorios de enseñanza de DSP. En la
práctica suelen tener entornos de desarrollo poco amigables,
necesidad de contar con licencias para su uso,
incompatibilidades entre el ambiente de desarrollo del código
y del hardware, etc. Arduino [1] [2] presenta ventajas
comparativas en los aspectos antes mencionados a los que se
les debe agregar su bajo costo en relación con las placas
tradicionales.
Arduino es una plataforma cuyo diseño de hardware,
software e IDE son abiertos. El IDE es simple, emplea
lenguaje C y tiene suficiente funcionalidad para editar,
descargar y correr código en distintos sistemas operativos. La
placa Arduino DUE cuenta con un microcontrolador Atmel
SAM3X8E ARM Cortex-M3 de 32 bits. Este chip trabaja a
‹,(((
84Mhz (3,3v) y aporta una potencia de cálculo superior a la
de los microcontroladores de modelos anteriores de Arduino.
Esta característica lo hace adecuado para el desarrollo de
proyectos que requieran alta capacidad de procesamiento. El
núcleo de 32 bits permite realizar, además, operaciones con
datos de 4 bytes en un solo ciclo de reloj. La memoria SRAM
es de 96KB e incorpora un controlador DMA que mejora el
acceso a memoria que puede hacer la CPU. Dispone también
de una memoria flash de 512KB que le permite el
almacenamiento de códigos de programación extensos. El
sistema tiene, entre otros, 54 pines de E/S digitales, 12 de
entradas analógicas, y 2 de salidas digitales (DAC).
El entorno de desarrollo (IDE) Arduino está basado en
Processing, permite trabajar con distintos modelos de placas,
para lo cual se debe configurar para una correcta compilación
del firmware. La conexión USB disponible en el módulo
Arduino permite cargar el firmware, depurarlo y monitorear el
proceso.
El entorno consiste en el editor de texto, compilador y
comunicación USB para la descarga del programa y monitoreo
de puerto serie. La estructura del programa es la del Lenguaje
C y el IDE ofrece una librería que facilita el uso de funciones
preconstruidas (build-in functions) que permiten realizar
operaciones matemáticas avanzadas, entrada/salida de datos,
conexiones serie o la interacción con distintos periféricos
como las placas de expansión.
Es bien conocido que las características de estos filtros están
determinadas por el valor de los coeficientes de la Función
Transferencia H(z) [5] que además, para un mismo tipo de
filtro, varían de acuerdo a la realización seleccionada. Cada
vez que se deben modificar el tipo o las características, se
deben recalcular los coeficientes y replantear las ecuaciones
en diferencia que los representan. Estas modificaciones deben
efectuarse en el algoritmo que corre en la placa. Los
coeficientes, en general, son números reales con una
importante cantidad de dígitos decimales, lo que hace que el
procedimiento de reconfiguración del filtro sea una tarea
engorrosa y lenta cuando se realiza manualmente. Por otra
parte, en la librería de Matlab [6] [7] existen funciones para el
cálculo de estos coeficientes que permiten elegir el tipo de
filtro, el ancho de banda, las atenuaciones, etc. y devuelven el
número de coeficientes del filtro y sus valores. El objetivo de
este trabajo es poder diseñar cualquier tipo de filtro enviando,
a través del puerto serie de la PC, los comandos y los
coeficientes calculados con Matlab para reconfigurarlo en
forma automática.
 II. REALIZACIÓN FORMA DIRECTA I
void setup() {
A. Firmware del filtro en Arduino Due Serial.begin(9600);
analogReadResolution(10);
El siguiente listado describe en detalle el código del filtro analogWriteResolution(10);
correspondiente al firmware en la placa Arduino que consiste }
en 4 pasos principales, lectura sobre el puerto serie de la
cantidad y valor de cada coeficiente del filtro, cálculo de la // 3 - Ecuaciones en diferencia del filtro
respuesta del filtro para cada muestra de la señal de entrada void loop() {
entregada por el conversor A/D de 10 bits, a partir de los
coeficientes Ai y Bi, y generación mediante el DAC del valor dato[0]=analogRead(A0);
muestra de salida calculado. Las etapas en las cuales se divide sal1=0;
este proceso son: sal2=0;

1. Declaración del vector de entrada por puerto serie de for (i=0;i<d;i++)
30 elementos en formato flotante coef[30], {
coeficientes A[15] y B[15] del filtro y vectores dato[] sal1=sal1+dato[i]*B[i];
y sal[] de valores muestra de entrada y salida al filtro }
respectivamente .
2. Configuración del puerto serie y resoluciones de los for (j=1;j<d;j++)
conversores A/D y D/A. {
3. Cálculo de las ecuaciones diferencias del filtro y sal2=sal2+sal[j]*A[j];
generación de la salida analógica. }
4. Evento de lectura de los coeficientes y comandos
desde el puerto serie. El proceso de registro de los sal[0]=sal1-sal2;
coeficientes se realiza al final del comando enviado for (i=1;i<d;i++)
desde la PC, detectando el final del mismo con la {
aparición del carácter especial nueva línea (/n). dato[d-i]=dato[d-1-i];
Dentro de este evento se calcula la componente }
continua, utilizada para su restauración sobre el
espectro, cuando se trata de un filtro pasa-alto o for (j=1;j<d;j++)
pasa-banda, reinyectándola en la señal de salida del {
DAC. sal[d-j]=sal[d-1-j];
}
B. Listado del programa Arduino analogWrite(DAC1,sal[0]+conti);
}
// 1 - Declaración del vector de 30 posiciones en formato
flotante para registrar los coeficientes del filtro. // 4 - Lectura de los coeficientes y comandos desde el //puerto
serie
boolean stringComplete = false;
float coef[30]; // ajuste para la máxima cantidad de void serialEvent()
//coeficientes esperados {
int i,n,j=0; while (Serial.available())
float dato[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; {
//condiciones iniciales del filtro coef[n] = Serial.parseFloat();
float sal2; char inChar = (char)Serial.read();
float sal1; if (inChar == '\n')
float sal[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; {
//condiciones iniciales del filtro stringComplete = true;
float A[15]; //se ajusta para la máxima cantidad de n++;
//coeficientes esperados coef/2 }
float B[15]; //se ajusta para la máxima cantidad de }
//coeficientes esperados coef/2 for (i=0;i<d;i++)
int d,conti; {
B[i]=coef[i+1];
// 2 - Ajustes de la velocidad del puerto serie y de la }
//resolución de los conversores
 %[N w]=buttord(0.3,0.50,3,55); pasabajos %Butterworth
for (i=0;i<d;i++) %[B A]=butter(N,w)
{
A[i]=coef[i+d+1]; %Filtro 2
} %[N, Wp] = CHEB1ORD(0.1, 0.2, 0.5, 20); %pasabajos
d=int (coef[0]+1); // Ajuste de redondeo en conversión Butterworth
//flotante a entero. %[B,A] = CHEBY1(N,0.5,Wp)
conti=int (coef[2*d+1]+0.5)*511; // Cálculo de la
//componente contínua en filtros pasa alto. %Filtro 3
%[N w]=buttord([.2 .4],[.1 .5],3,20); %filtro %pasabanda
} %[B A]=butter(N,w);

%Filtro 4
C. Programa en Matlab para configurar el filtro
%[N w]=buttord(0.2,0.4,1,30); %filtro pasabajos
%[B A]=butter(N,w);
El programa que se describe, corresponde a Matlab, versión
6 en adelante, dado que necesita librería que soporte % Filtro 5
comunicación serie. Ha sido probado en una placa Arduino %[N, Wp] = cheb1ord(0.2, 0.15, 1, 35); %filtro %pasaaltos
Due, obteniendo una frecuencia de muestreo con el algoritmo %[B A]= cheby1(N,0.5,Wp,'high')
del filtro incluido, entre 15 y 25 Ks/s, dependiendo de la
cantidad de coeficientes. Básicamente, consiste en 3 pasos % Filtro 6
como se observa en el siguiente listado: %Wp = [.3 .6], Ws = [.1 .8]
%[N, Wn] = BUTTORD(Wp,Ws,1, 20); %filtro
1. Configuración e inicialización de la comunicación %pasabanda
con el puerto serie virtual de Arduino e identificación %[B,A] = BUTTER(N,Wn)
de filtro.
2. Cáculo de los coeficientes del filtro para distintas % Filtro 7
tipos, en este ejemplo está basado en un Chebyshev. [N, Wp] = CHEB1ORD([.2 .7], [.3 .6], 0.5, 30); %
Los otros métodos no se están utilizando pero están %eliminabanda
comentados, para poder observar la sintaxis de su [B,A] = cheby1(N,0.5,Wp,'stop');
uso.
3. Envío de los coeficientes del filtro, la variable d2 es d=length(B);
un vector que posee en su primer elemento el número d2=[d B A pb]
de coeficientes del filtro y en el resto la secuencia de
valores de sus coeficientes. % 3 – Envío de los coeficientes por puerto serie

D. Listado de programa Matlab fopen(PS);

% 1 - Configuración e inicialización del puerto serie
%Envia comandos y coeficientes al filtro %implementado
en Arduino-forma
%Directa I-
delete(instrfind({'port'},{'COM12'})); %habilita el %puerto
donde se instaló Arduino
PS=serial('COM12');
set(PS,'Baudrate',9600); %velocidad de comunicación
set(PS,'InputBufferSize',3000); %ajuste del buffer
set(PS,'OutputBufferSize',3000);
pb=input('Si el filtro es pasabanda o pasaalto ingrese 1 sino
ingrese 0 ') %ajusta el nivel de continua del DAC
% 2 – Cálculo de los coeficientes del filtro para distintas
tipos de implementación
% Filtro 1
V=[];
com=fscanf(PS)
fprintf(PS,'%7.5f\n',d2); %se envian los commandos y %los
coeficientes
fclose(PS);
delete(PS);
clear PS;
III. REALIZACIÓN EN CASCADA
A. Firmware del filtro en Arduino Due
Esta realización es útil cuando se requiere un mínimo
número de multiplicaciones y retardos, al igual que la
estructura directa, tiene la misma función de
transferencia y relación de entrada salida. Sin embargo,
gracias a su implementación y ajuste, su
 comportamiento es más estable cuando se utiliza con {
aritmética de precisión finita en filtros muy selectivos. stringComplete = true;
n++;
B. Listado del programa Arduino }
}
boolean stringComplete = false; for (i=0;i<d;i++)
float {
dato[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 B[i]=coef[i+1];
,0,0,0,0,0,0}; }
float y[2];
float coef1[50]; for (i=0;i<d;i++)
float coef[50]; {
int m,j; A[i]=coef[i+d+1];
int n,i; }
float sal1; d=int (coef[0]+1);
float sal2; conti=int (coef[2*d+1]+0.5)*511;
int conti; m=int(coef1[0]+1);
for (j=0;j<6*m;j++)
void setup() { {
Serial.begin(9600); coef[j]=coef1[j+2];
analogReadResolution(10); }
analogWriteResolution(10); }
} C. Programa Matlab para implementar el filtro en la forma
CASCADA
void loop() {

dato[0]=analogRead(A0); En este caso se agrega al código en Matlab descripto, las

sal1=0; instrucciones:
sal2=0;
[Z,P,K]=tf2zp(B,A)y [SOS,G]=zp2sos(Z,P,K,'UP')
for(i=0;i<m;i++){
que reconfiguran el espacio de los coeficientes para una
sal1=coef[i*6]*dato[i*6]+coef[i*6+1]*dato[i*6+1]+coef[i*6+ estructura en cascada.
2]*dato[i*6+2];
sal2=coef[i*6+4]*dato[i*6+4]+coef[i*6+5]*dato[i*6+5]; D. Listado en Matlab
y[0]=sal1-sal2;
dato[i*6+3]=y[0]; %calcula los coeficientes de la configuración cascada de
dato[i*6+2]=dato[i*6+1]; %distintos filtros
dato[i*6+1]=dato[i*6+0]; delete(instrfind({'port'},{'COM12'}));
dato[i*6+5]=dato[i*6+4]; PS=serial('COM12');
dato[i*6+4]=dato[i*6+3]; set(PS,'Baudrate',9600);
dato[i*6+6]=y[0]; set(PS,'InputBufferSize',3000);
} set(PS,'OutputBufferSize',3000);
analogWrite(DAC1,coef1[r]*y[0]+conti); //sumar 511
pb=input('Si el filtro es pasabanda o pasaalto ingrese 1 sino
pasabanda o pasaalto
ingrese 0 ')
}

//programa de lectura de los coeficientes y comandos desde el % Filtro 1

puerto serie [N w]=buttord(0.3,0.50,3,55);% pasabajos
void serialEvent() [B A]=butter(N,w)
{
while (Serial.available()) %Filtro 2
{ %[N, Wp] = CHEB1ORD(0.1, 0.2, 0.5, 20); % %pasabajos
coef[n] = Serial.parseFloat(); %[B,A] = CHEBY1(N,0.5,Wp)
char inChar = (char)Serial.read();
if (inChar == '\n') %Filtro 3
%[N w]=buttord([.2 .4],[.1 .5],3,20); %pasabanda resultante, evidencia los beneficios que las características de
%[B A]=butter(N,w); cálculo en 32 bits y frecuencia de clock de 84 MHz de la placa
Arduino Due, ofrece para la experimentación con filtros de
%Filtro 4 audio.
%[N w]=buttord(0.2,0.4,1,30); % pasabajos
%[B A]=butter(N,w);

%Filtro 5
%[N, Wp] = cheb1ord(0.2, 0.15, 1, 35); % pasaaltos
%[B A]= cheby1(N,0.5,Wp,'high')

% Filtro 6
%Wp = [.3 .6], Ws = [.1 .8]
%[N, Wn] = BUTTORD(Wp,Ws,1, 20); %pasabanda
%[B,A] = BUTTER(N,Wn)
Figura 1: Señales de entrada y salida del filtro
% Filtro 7
%[N, Wp] = CHEB1ORD([.2 .7], [.3 .6], 0.5, 30); %
Las Fig. 2 y la Fig. 3, muestran las señales de entrada y salida
%eliminabanda
y la respuesta espectral respectivamente , para una
%[B,A] = cheby1(N,0.5,Wp,'stop');
configuración Butterworth de un filtro pasabajos como el
indicado en el listado de Matlab como Filtro 1, mediante la
[Z,P,K]=tf2zp(B,A); %instrucciones para transformar %en expresión: [N w]=buttord(0.3,0.50,3,55), de 20 coeficientes
config. cascada implementado en forma directa I y cascada.
[SOS,G]=zp2sos(Z,P,K,'UP');
[m n]=size(SOS);
COEF=[];
for i=1:m
for j=1:n
COEF=[COEF SOS(i,j)]; %se arma el vector de
%coeficientes
end
end

d2=[m pb COEF G]
k=length(d2);
fopen(PS); Figura 2: Señales de entrada y salida del filtro
V=[];
com=fscanf(PS)
En este caso la frecuencia de muestreo, observada dentro
fprintf(PS,'%7.5f\n',d2);
del círculo de la Fig. 2 y señalada entre cursores resultó de
fclose(PS); 16.67 Ks/s y la frecuencia de corte en 3dB indicada en el
delete(PS); cursor de la Fig. 3, es de aproximadamente 2,6 KHz y se
clear PS; corresponde con la configurada en Matlab, dado que cumple la
IV. RESULTADOS relación Fc = 0,3 x 16,67 KHz / 2 = 2.5 KHz programada

De los resultados experimentales del funcionamiento de los

filtros implementados con Arduino Due, se muestran a
continuación varias figuras obtenidas para un ajuste tal que
permita observar la velocidad de muestreo en el DAC de
salida, para distintos tipos de filtro y cantidad de coeficientes.
La Fig. 1, corresponde a un filtro pasa-banda Chebyshev de 7
coeficientes Ai y Bi, implementado en forma directa y
cascada. Las señales observadas son las de entrada y salida del
filtro y los cursores de tiempo abarcan la duración de una
muestra con una indicación de tiempo entre ellos de 44 μs y
una frecuencia de muestreo de 22,73 Ks/s. Esta relación entre
la cantidad de coeficientes y la velocidad de muestreo Figura 3: Respuesta en frecuencia
 En la Fig. 4, se observa la respuesta en frecuencia de un
filtro pasabanda implementado mediante la configuración
Butterworth indicado en el listado de Matlab como Filtro 3,
mediante la expresión: [N w]=buttord([.2 .4],[.1 .5],3,20).
Las frecuencias indicadas por los cursores son
aproximadamente f1 = 1,85 KHz y f2 = 3,7 KHz, son las
frecuencias de corte de ancho de banda de 3dB
respectivamente, correspondientes a una frecuencia de
muestreo de 18,52 Ks/s.
Figura 4: Respuesta en frecuencia de filtro pasabanda
V. CONCLUSIONES
Las características del hardware y la baja complejidad del
ambiente de desarrollo de software (IDE) de la plataforma
Arduino, le confieren notables características para la
implementación práctica de los algoritmos del DSP.
Las ventajas comparativas de Arduino se basan en tres
aspectos, disponibilidad en el mercado, sencillez de
programación y bajo costo frente a las plataformas
tradicionales para los laboratorios de enseñanza de DSP.
Los filtros descriptos permiten su experimentación en tiempo
real, observar y medir las señales de entrada y salida para
diferentes configuraciones, en prácticas de laboratorio de
DSP.
Las expresiones de cálculo DSP de los filtros son legibles,
permitiendo observar e interpretar claramente los algoritmos
de filtrado.
Los programas descriptos tienen como aspecto relevante
que permiten diseñar y configurar, en forma automática,
cualquier tipo de filtro digital sobre una placa Arduino Due .
REFERENCIAS
[1] Jeremy Blum, “Exploring Arduino: Tools and Techniques for
Engineering”, Wiley, 2013.
[2] Matt Mets, “Using Arduino with MATLAB”, Wiley, 2010.
[3] ] Sanjit K. Mitra, “Digital Signal Processing”, McGraw-Hill, 2001K.
Elissa, “Title of paper if known,” unpublished.
[4] Alan V. Oppenheim, Ronald W. Schafer, “Tratamiento de Señales en
Tiempo Discreto”, Prentice Hall, 2000.
[5] Emmanuel C. Ifeachor, Barrie W. Jervi,”Digital Signal Processing”,
Addison Wesley, 2002.
[6] A. Biran, “Matlab for Engineer”, Addison Wesley, 2005.
[7] Argus Kurniawan,“Getting Started with Matlab Simulink and Arduino”,
PE Press, 2013.