Universidade Estadual Paulista “Júlio de Mesquita Filho”

Faculdade de Engenharia de Ilha Solteira – FEIS

Departamento de Engenharia Elétrica

Aplicação Transformada Rápida de

Fourier em um Sinal

COMPUTAÇÃO CIÊNTÍFICA
COM PYTHON

Docente: Dr. Prof. Emanuel Rocha Woiski

Discente: Vitor José Luz Polaquini RA nº 132054159

Ilha Solteira
– 14/12/2017 –
 Resumo

Este trabalho tem como principal objetivo demonstrar a utilização da

Transformada Rápida de Fourier (FFT) na linguagem de programação Python.
A utilização deste tipo de aplicação se faz muito presente atualmente, pois está
diretamente relacionada com a análise de sinais e formas de onda. Esta análise se dá na
aquisição do sinal em questão que é feita através de uma sequência de amostras do sinal
contínuo, tornando-o um sinal discreto e a partir disto, o sinal é passado do domínio do
tempo para o domínio da frequência. Isto é o princípio básico da teoria de processamento
digital de sinais, por isso sua importância tão grande.
Para a programação destas aplicações é, neste caso, utilizado o Python científico
que contempla algumas extensões como Scipy, Numpy e Matplotlib, onde estas são
ferramentas com aplicações nos mais variados e complexos campos.

1
 Sumário
Resumo .................................................................................................................................................. 1
1. Introdução ...................................................................................................................................... 3
2. Metodologia ................................................................................................................................... 4
3. Conclusão ....................................................................................................................................... 6
4. Bibliografia..................................................................................................................................... 7

2
 1. Introdução

Quando tratamos do assunto de processamento digital de sinais, estamos

basicamente analisando um sinal contínuo no tempo que é produzido pelo sistema
estudado. Porém, para que este sinal seja analisado em simulações, aquisições ou
osciloscópios digitais por exemplo, é necessário que este sinal seja “lido” pelo
computador.
É desta forma que a Transformada de Fourier se torna importante, pois há uma
complexidade de operações que tornam isso possível. Basicamente, o que é feito, é coletar
diversas amostras do sinal, formando assim uma imagem de diversos pontos discretos
obtidos. Para que haja a leitura destes pontos, há a chamada convolução do sinal com a
janela de aquisição, que seria de forma simplificada, uma multiplicação no domínio da
frequência.
A velocidade com que isso é feito é o que torna esta “transformação” mais
eficiente, pois assim o sinal gerado pode ser analisado de forma instantânea conforme é
gerado. Ocorre que a DFT decompõe uma sequência de valores em componentes de
diferentes frequências e isto pode ser “lento” do ponto de vista computacional.
Então, temos a FFT, que torna o processo mais rápido, nos retornando um sinal
um pouco menos preciso, mas que na maioria dos casos é suficientemente exato.

Python Científico:

Com a combinação de três módulos: NumPy, SciPy e Matplotlib, temos uma

infinidade de aplicações nas quais podemos utilizar o Python científico e é nisto que
vamos nos basear.
Com a NumPy há uma grande facilidade de operação e criação matricial e vetorial.
Já o SciPy nos permite o uso de muitas ferramentas científicas, bem como tratamento de
sinais, integração, álgebra linear, dentre milhares de funções. O matplotlib nos permite
plotar gráficos de matrizes NumPy de forma rápida e fácil, melhorando a visualização.

3
 2. Metodologia

O que temos quando adquirimos o sinal, é sua resposta no domínio do tempo,

como pode-se observar na Figura 1.

Figura 1 – Sinal no domínio do tempo.

Após utilizar a DFT, obtemos o espectro no domínio da frequência:

Figura 2 – Espectro do sinal no domínio da frequência.

Abaixo segue a programação referente a execução da FFT em um sinal,

juntamente com os devidos comentários:

import numpy as np
from scipy.fftpack import fft
import matplotlib.pyplot as plt
N = 400
T = 1.0/1000.0
x = np.linspace(0.0, N*T,N)
g = np.sin(35.0*2.0*np.pi*x)
h = 0.5*np.sin(70.0*2.0*np.pi*x)
y = g+h
Ys = fft(y)
Y = 2.0/N * np.abs(Ys[0:N/2])

4
 X = np.linspace(0.0, 1.0/(2.0*T), N/2)
import matplotlib.pyplot as plt
plt.plot(x,y)
plt.grid()
plt.show()

Este método é bem semelhante ao que se faz analiticamente, isto o torna mais
reduzido. Porém, é necessário fornecer alguns parâmetros iniciais, como largura da janela
(número de amostras) e tempo de aquisição e isto requer do programador um
conhecimento prévio sobre o assunto para que não haja risco de sobreposição do sinal.
Primeiramente, são importadas as ferramentas necessárias para o programa, como
numpy, a função da fft da scipy e definir matplotlib para a plotagem da curva resultante.
Em seguida, é definido o número de amostras N, que deve ser suficientemente
grande para uma boa visualização. É definido o período T e a função linspace cria o nosso
eixo x de forma igualmente espaçada para que o sinal não fique distorcido, enquanto a
amplitude é a soma dos fatores g e h.
O Y(s) que diz respeito a transformada é obtido utilizando a função fft de g+h.
Feito isso, o resultado tem o espaçamento corrigido e é finalmente plotado.

Figura 3 – Forma de onda obtida.

5
 3. Conclusão

Utilizando a FFT, nota-se uma boa representação do sinal e também uma

velocidade grande, por conta da simplicidade do algoritmo. Por conta disto, este programa
também tem suas limitações, a onda envolvida deve ter alguns parâmetros conhecidos, N
e T também. Porém, este é o princípio básico de onde pode vir a surgir uma alta
complexidade afim de alcançar uma gama maior de problemas e se aproximar cada vez
mais da realidade na prática.

6
 4. Bibliografia

1. Joyce Van de Vegte, Fundamentals of Digital Signal Processing, Prentice Hall,

2002.
2. Discrete Fourier Transform (numpy.fft) 2014,
http://docs.scipy.org/doc/numpy/reference/routines.fft.html
Acesso em: 10/12/2017