Universidade Federal do Triângulo Mineiro
Instituto de Ciências Tecnológicas e Exatas
Engenharia Elétrica
Bruna Mayer
Marcelo Nascimento Eduardo
Victor Leoni Santos Soares
Trabalho de Processamento Digital de Sinais
Uberaba
2024
Bruna Mayer
Marcelo Nascimento Eduardo
Victor Leoni Santos Soares
Trabalho de Processamento Digital de Sinais
Relatório apresentado à disciplina
Processamento Digital de Sinais como
requisitos de avaliação do curso de
Engenharia Elétrica.
Docente: Cláriton Bernardelli.
Uberaba
2024
2
RESUMO
O desenvolvimento da FFT (Fast Fourier Transform) no esp32 usando o Arduino IDE
neste relatório é uma aplicação eficaz para análise de sinais em projetos eletrônicos,
especialmente aqueles relacionados com processamento de áudio ou outras formas
de análises de frequência. O esp32 é um microcontrolador de baixo custo com
capacidades robustas de Wi-Fi e Bluetooth, que também oferece um desempenho
significativo para operações matemáticas complexas, como a FFT, graças ao seu
processador de dual-core e a capacidade de operar até 240 MHz.
Para implementar a FFT no esp32 com Arduino IDE, primeiramente, é necessário
configurar o ambiente de desenvolvimento, instalando o Arduino IDE e adicionando o
suporte ao esp32 através do gerenciador de placas.
A utilização da FFT no esp32 em conjunto com o Arduino IDE permite explorar
plenamente os recursos deste microcontrolador em aplicações de análise de sinais de
forma eficiente e acessível, abrindo um leque de possibilidades para projetos
experimentais, educacionais ou mesmo para pequenas aplicações industriais.
Palavras chave: Esp32, FFT, Arduino IDE
3
ABSTRACT
The development of FFT (Fast Fourier Transform) on the esp32 using the Arduino
IDE in this report is an effective application for signal analysis in electronic projects,
especially those related to audio processing or other forms of frequency analysis.
The esp32 is a low-cost microcontroller with robust Wi-Fi and Bluetooth capabilities,
which also offers significant performance for complex mathematical operations such
as FFT, thanks to its dual-core processor and the ability to operate up to 240 MHz.
To implement FFT on the esp32 with the Arduino IDE, it is first necessary to set up
the development environment by installing the Arduino IDE and adding support for
the esp32 through the board manager.
The use of FFT on the esp32 in conjunction with the Arduino IDE allows for full
exploitation of this microcontroller's resources in signal analysis applications in an
efficient and accessible way, opening a range of possibilities for experimental,
educational, or even small industrial applications..
Keywords: Esp32, FFT, Arduino IDE
4
SUMÁRIO
1 INTRODUÇÃO ........................................................................................................ 6
2 OBJETIVOS ............................................................................................................. 7
3 RESULTADOS ........................................................................................................ 7
5 CONCLUSÃO ........................................................................................................ 23
6 REFERÊNCIAS ...................................................................................................... 25
5
1 INTRODUÇÃO
A transformada de Fourier é um artifício matemático de grande importância para
diversas áreas da engenharia. Ela nos permite analisar sistemas físicos sob uma
perspectiva diferente, revelando informações valiosas sobre suas componentes de
frequência. Pode-se comparar a transformada como uma separação de um sinal no
domínio do tempo em suas ondas senoidais constituintes. Essa é a essência da
transformada de Fourier.
Jean-Baptiste Joseph Fourier, um matemático e físico francês do século XIX,
desenvolveu a série de Fourier para representar funções periódicas complexas como
uma soma infinita de senos e cossenos. Essa decomposição é especialmente útil
para entender sinais no domínio do tempo, como ondas sonoras ou pulsos elétricos.
A transformada de Fourier generaliza as séries de Fourier para funções não
periódicas. Ela nos permite analisar sinais que não se repetem periodicamente. A
transformada de Fourier converte um sinal do domínio do tempo para o domínio da
frequência, revelando as diferentes componentes de frequência presentes no sinal.
No domínio discreto, a FFT (Fast Fourier Transform) é um algoritmo que
revolucionou a computação da transformada de Fourier. Em vez de realizar cálculos
demorados, a FFT divide o problema em partes menores e resolve-as de forma
eficiente. Isso é especialmente útil em processamento digital de sinais, resolução de
equações diferenciais e até mesmo na multiplicação de grandes inteiros.
Ao analisar a transformada no Arduino IDE e utilizando o esp32. Esse
microcontrolador é amplamente utilizado em projetos de IoT, automação residencial
e muito mais. Ao executar a FFT no esp32, pode-se analisar sinais em tempo real,
como processamento de áudio, detecção de frequências e até mesmo
monitoramento de vibrações.
6
2 OBJETIVOS
Os objetivos deste relatório são:
• Fazer a configuração do ESP 32 através da Arduino IDE.
• Executar o código do algoritmo da FFT
• Coletar os dados gerador
• Utilizando alguma ferramenta, fazer a plotagem do gráfico
• Discutir os resultados no contexto da disciplina de PDS
4 RESULTADOS E DISCUSSÕES
Utilizando o Arduino IDE e o esp32, o seguinte código foi gerado:
//Example data:
int data[64]={14, 30, 35, 34, 34, 40, 46, 45, 30, 4, -26, -48, -55, -49, -37,
-28, -24, -22, -13, 6, 32, 55, 65, 57, 38, 17, 1, -6, -11, -19, -34,
-51, -61, -56, -35, -7, 18, 32, 35, 34, 35, 41, 46, 43, 26, -2, -31, -50,
-55, -47, -35, -27, -24, -21, -10, 11, 37, 58, 64, 55, 34, 13, -1, -7};
byte sine_data [91]=
{
0,
4, 9, 13, 18, 22, 27, 31, 35, 40, 44,
49, 53, 57, 62, 66, 70, 75, 79, 83, 87,
91, 96, 100, 104, 108, 112, 116, 120, 124, 127,
131, 135, 139, 143, 146, 150, 153, 157, 160, 164,
167, 171, 174, 177, 180, 183, 186, 189, 192, 195, //Paste this at top of
program
198, 201, 204, 206, 209, 211, 214, 216, 219, 221,
223, 225, 227, 229, 231, 233, 235, 236, 238, 240,
241, 243, 244, 245, 246, 247, 248, 249, 250, 251,
252, 253, 253, 254, 254, 254, 255, 255, 255, 255
};
float f_peaks[5]; // top 5 frequencies peaks in descending order
void setup()
{
[Link](250000);
}
void loop() {
//example
FFT(data,64,100); //to get top five value of frequencies of X having 64 sample at
100Hz sampling
/*
7
after ruing above FFT(), frequencies available at
f_peaks[0],f_peaks[1],f_peaks[2],f_peaks[3],f_peaks[4],
*/
}
//-----------------------------FFT Function----------------------------------------------//
float FFT(int in[],int N,float Frequency)
{
/*
Code to perform FFT on arduino,
setup:
paste sine_data [91] at top of program [global variable], paste FFT function at end of
program
Term:
1. in[] : Data array,
2. N : Number of sample (recommended sample size 2,4,8,16,32,64,128...)
3. Frequency: sampling frequency required as input (Hz)
If sample size is not in power of 2 it will be clipped to lower side of number.
i.e, for 150 number of samples, code will consider first 128 sample, remaining
sample will be omitted.
For Arduino nano, FFT of more than 128 sample not possible due to mamory
limitation (64 recomended)
For higher Number of sample may arise Mamory related issue,
Code by ABHILASH
Contact: abhilashpatel121@[Link]
Documentation:[Link]
*/
unsigned int data[13]={1,2,4,8,16,32,64,128,256,512,1024,2048};
int a,c1,f,o,x;
a=N;
for(int i=0;i<12;i++) //calculating the levels
{ if(data[i]<=a){o=i;} }
int in_ps[data[o]]={}; //input for sequencing
float out_r[data[o]]={}; //real part of transform
float out_im[data[o]]={}; //imaginory part of transform
x=0;
for(int b=0;b<o;b++) // bit reversal
{
c1=data[b];
f=data[o]/(c1+c1);
for(int j=0;j<c1;j++)
{
x=x+1;
in_ps[x]=in_ps[j]+f;
}
}
8
for(int i=0;i<data[o];i++) // update input array as per bit reverse order
{
if(in_ps[i]<a)
{out_r[i]=in[in_ps[i]];}
if(in_ps[i]>a)
{out_r[i]=in[in_ps[i]-a];}
}
int i10,i11,n1;
float e,c,s,tr,ti;
for(int i=0;i<o;i++) //fft
{
i10=data[i]; // overall values of sine/cosine :
i11=data[o]/data[i+1]; // loop with similar sine cosine:
e=360/data[i+1];
e=0-e;
n1=0;
for(int j=0;j<i10;j++)
{
c=cosine(e*j);
s=sine(e*j);
n1=j;
for(int k=0;k<i11;k++)
{
tr=c*out_r[i10+n1]-s*out_im[i10+n1];
ti=s*out_r[i10+n1]+c*out_im[i10+n1];
out_r[n1+i10]=out_r[n1]-tr;
out_r[n1]=out_r[n1]+tr;
out_im[n1+i10]=out_im[n1]-ti;
out_im[n1]=out_im[n1]+ti;
n1=n1+i10+i10;
}
}
}
/*
for(int i=0;i<data[o];i++)
{
[Link](out_r[i]);
[Link](" "); // un comment to print RAW o/p
[Link](out_im[i]); [Link]("i");
}
9
*/
//---> here onward out_r contains amplitude and our_in conntains frequency (Hz)
for(int i=0;i<data[o-1];i++) // getting amplitude from compex number
{
out_r[i]=sqrt(out_r[i]*out_r[i]+out_im[i]*out_im[i]); // to increase the speed delete
sqrt
out_im[i]=i*Frequency/N;
[Link](out_im[i]); [Link]("Hz");
[Link]("\t"); // un comment to print freuency bin
[Link](out_r[i]);
x=0; // peak detection
for(int i=1;i<data[o-1]-1;i++)
{
if(out_r[i]>out_r[i-1] && out_r[i]>out_r[i+1])
{in_ps[x]=i; //in_ps array used for storage of peak number
x=x+1;}
}
s=0;
c=0;
for(int i=0;i<x;i++) // re arraange as per magnitude
{
for(int j=c;j<x;j++)
{
if(out_r[in_ps[i]]<out_r[in_ps[j]])
{s=in_ps[i];
in_ps[i]=in_ps[j];
in_ps[j]=s;}
}
c=c+1;
}
for(int i=0;i<5;i++) // updating f_peak array (global variable)with descending
order
{
f_peaks[i]=out_im[in_ps[i]];
}
}
float sine(int i)
{
int j=i;
float out;
while(j<0){j=j+360;}
while(j>360){j=j-360;}
if(j>-1 && j<91){out= sine_data[j];}
else if(j>90 && j<181){out= sine_data[180-j];}
10
else if(j>180 && j<271){out= -sine_data[j-180];}
else if(j>270 && j<361){out= -sine_data[360-j];}
return (out/255);
}
float cosine(int i)
{
int j=i;
float out;
while(j<0){j=j+360;}
while(j>360){j=j-360;}
if(j>-1 && j<91){out= sine_data[90-j];}
else if(j>90 && j<181){out= -sine_data[j-90];}
else if(j>180 && j<271){out= -sine_data[270-j];}
else if(j>270 && j<361){out= sine_data[j-270];}
return (out/255);
}
Com este código os seguintes gráficos foram gerados:
Figura 1: Freqência e Módulo
Fonte: Dos Autores, 2024
11
Figura 2: Módulo x Amostra
Fonte: Dos Autores, 2024
Figura 3: Fase x Amostra
Fonte: Dos Autores, 2024
12
5 CONCLUSÃO
Na conclusão deste projeto, fica evidente que o uso da FFT no esp32, programado
através do Arduino IDE, representa uma solução poderosa e versátil para análise de
sinais em tempo real. O esp32, com sua capacidade de processamento dual-core e
frequências de operação elevadas, demonstrou ser uma plataforma adequada para
tarefas computacionais intensivas como a transformada rápida de Fourier. Através
do uso de bibliotecas adequadas e práticas de otimização, conseguimos
implementar eficientemente a FFT, permitindo a execução de análises espectrais
detalhadas.
Essa implementação não apenas atende às necessidades básicas de análise de
frequência, mas também abre portas para aplicações mais sofisticadas, como
sistemas de monitoramento ambiental, diagnósticos médicos, processamento de
áudio e outras aplicações industriais que dependem de análise de dados em tempo
real. Além disso, a possibilidade de integração com interfaces de usuário e outros
módulos de hardware expande ainda mais seu potencial de aplicação.
Em suma, o desenvolvimento da FFT no esp32 via Arduino IDE demonstrou ser uma
estratégia eficaz que alia custo-benefício a alto desempenho, adequando-se
perfeitamente tanto a entusiastas da eletrônica quanto a aplicações profissionais
mais exigentes.
6 REFERÊNCIAS
LATHI, B. P. & DING, Z., Sistemas de Comunicações Analógicos e Digitais
Modernos. 4º Edição. LTC, 2012.
13