Relatório sobre o Hardware para Fast Fourier

Transform
Matheus Leor Lopes de Lima Marrocos

Summary

1 Introdução 1

Implementação no MATLAB 2

2 Fast Fourier Transform em System Verilog 4

3 Controlador de Entrada/Saı́da 7

4 Hardware Completo 10

5 Testes 12

6 Comentários adicionais e Cronologia 15

7 Fontes 15

8 Anexos 16

1 Introdução
Este documento explica o processo de desenvolvimento, da concepção à imple-
mentação, de um hardware que possui um mecanismo de controle de entrada
(input valid), recebe 16 entradas externas (4 a cada clock), executa uma FFT
com raiz 2, fica com saı́da (output) válida por um clock. Além disso, o proced-
imento aqui adotado pode ser generalizado para ”n” entradas, o que também
será explicado.
O esquema do hardware desenvolvido é mostrado abaixo, na Figura 1.

1
 Figure 1: Hardware Desenvolvido

Implementação no MATLAB
Para melhor pensar como realizar o hardware, visualizando como este deve-
ria funcionar efetivamente, foi desenvolvido um estudo sobre FFT (conforme o
anexo evidencia) e, a partir do aprendizado ao se fazer os cálculos manualmente,
elaborou-se um algoritmo (em estágio primário) e testou sua funcionalidade no
software MATLAB, comparando os resultados obtidos aos resultados corretos
(adquiridos por meio da função embutida, ”fft”, do MATLAB).
O código, que evidencia o algoritmo desenvolvido e praticado manualmente
é mostrado abaixo, nas figuras 2 e 3, para a FFT de 4 e 8 saı́das. O algoritmo
para 16 saı́das é o mesmo, só muda a quantidade de termos e será evidenciado
na explicação do hardware. Nota-se que, nesse primeiro momento, não havia
domı́nio da ferramenta e por isso os coeficientes foram colocados manualmente
para cada caso, o que será corrigido no código do hardware (em system verilog).

2
Figure 2: Algoritmo para FFT de 4 Saı́das

Figure 3: Algoritmo para FFT de 8 Saı́das

3
2 Fast Fourier Transform em System Verilog
Com o proósito de se construir a FFT de 16 saı́das, foi testado o algoritmo feito
no MATLAB para 2 saı́das, 4, 8, 16. Os dois primeiros e o último hardware
serão mostrados nesta seção.

F.F.T. de 2 componentes
Primeiro foi observado que na FFT de 2 componentes há um entrelaçamento
(ilustrado no anexo) e isso foi representado no código que é demonstrado abaixo.
Também se pensou na entrada complexa, que foi representada como um array,
onde o primeiro componente era a parte real e o segundo a parte imaginária.

Figure 4: Hardware Desenvolvido para FFT de 2 Saı́das

F.F.T. de 4 componentes
Neste segundo momento, foi percebido que a lógica da FFT em hardware é:

1o Divide xn em componentes pares e ı́mpares, passa para o hardware que

é metade do que se está trabalhando, gerando os termos que se quer
trabalhar (neste exemplo: X20, X21, X22, X23)
2o Calcula-se a constante conforme a divisão do cı́rculo limitado em j/-j e
1/-1.
3o Percebe-se que o primeiro termo (por exemplo, X40) é igual ao termo
que é metade do seu ı́ndice (nesse caso, X20) somado ao termo que é
metade do seu ı́ndice + metade do seu ı́ndice/10 (nesse caso, X20+2
= X22).
4o Percebe que metade do ı́ndice (2, se aqui o ı́ndice for representado por 4)
de termos será dado pelo termo inicial (explicado em 3) + 1 nos ı́ndices

4
 de cada componente. A outra metade começará do primeiro ı́ndice (0)
+ o número de termos passados (neste caso, 0+2 = 2, começa em X42)
e possuirá o valor dado pelas mesmas equações da outra metade, com
exceção de que o ”+” do meio vira -

Esse algoritmo é melhor visualizado na descrição de hardware abaixo.

Figure 5: Hardware Desenvolvido para FFT de 4 Saı́das

F.F.T. de 16 componentes
Usando a lógica explicada para a FFT de 4 componentes, foi feita a FFT de 8
componentes e posteriormente a FFT de 16 componentes.
A primeira imagem abaixo ilustra a chamada da FFT anterior (FFT de 8)
com os componentes divididos em pares e ı́mpares.

5
 Figure 6: Chamada da FFT de 8 Saı́das pela FFT de 16 Saı́das

A próxima imagem mostra as constantes, obtidas a partir do cı́rculo trigonométrico

com 16 divisões.

Figure 7: Constantes da FFT de 16 Saı́das

6
 A próxima imagem mostra o terceiro passo descrito para a FFT de 4 saı́das
aplicado à FFT de 16 saı́das.

Figure 8: Passo 3 da resolução da FFT de 16 Saı́das

A próxima imagem mostra o quarto passo descrito para a FFT de 4 saı́das

aplicado à FFT de 16 saı́das.

Figure 9: Passo 4 da resolução da FFT de 16 Saı́das

3 Controlador de Entrada/Saı́da
Por último, foi desenvolvido o hardware abaixo, que seria integrado ao hardware
final. Basicamente é um hardware que recebe 16 entradas, de 4 em 4, envia essas

7
entradas junto ao sinal de output válido e tem controle de input válido.

Figure 10: Hardware de Controle de Entrada e Saı́da Válidas

Para se testar esse hardware passo a passo, foi usada a função ”monitor”,
que tem sintaxe como se mostra a seguir.

Figure 11: Mecanismo Usado para Testar o Hardware

O código da implementação completa deste hardware em system verilog está

demonstrado abaixo.

8
Figure 12: Hardware de Controle de Entrada e Saı́da Válidas

9
4 Hardware Completo
O hardware completo, mostrado na primeira seção, é simplesmente a união do
hardware que faz FFT com 16 saı́das com o hardware que controla as entradas
e saı́das válidas.
Suas entradas e saı́das estão ilustradas abaixo.

Figure 13: Entradas e Saı́das do Hardware Completo

Na imagem seguinte são mostrados os componentes adicionais para se fazer

conexões (entre o módulo de controle e o módulo de cálculo).

10
 Figure 14: Componentes de Ligação do Hardware Completo

Então, mostra-se a chamada dos módulos.

Figure 15: Chamada de Módulos no Módulo Completo

11
 Finalmente, é mostrado o que o módulo completo faz, ou seja, espera o
output ser válido para calcular a nova FFT, ficando com input não válido nesse
momento, e, caso isso não ocorra, mantém o valor que foi calculado enquanto
esse cálculo novo não for requisitado novamente.

Figure 16: Funcionamento do Módulo Completo

5 Testes
Os testes para o funcionamento geral (incluindo o controle de output e input)
estão em anexo. Aqui será mostrado apenas a comparação dos resultos no
hardware com os resultados no MATLAB para dois conjuntos de valores.

Teste 1
Valores de x = [0, 1*j, 2*j, 3*j, 4*j, 5*j, 6*j, 7*j, 8*j, 9*j, 10*j, 11*j, 12*j, 13*j,
14*j, 15*j];
Resultados obtidos no hardware:

12
 Figure 17: Resultados Obtidos em Hardware para o Teste 1

Resultados obtidos no Matlab:

Figure 18: Resultados Obtidos no MATLAB para o Teste 1

Comparando, percebe-se que os resultados foram praticamente iguais, a

menos de algumas aproximações.

13
Teste 2
Valores de x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
Resultados obtidos no hardware:

Figure 19: Resultados Obtidos em Hardware para o Teste 2

Resultados obtidos no Matlab:

Figure 20: Resultados Obtidos no MATLAB para o Teste 2

14
 Comparando, percebe-se que os resultados foram praticamente iguais, a
menos de algumas aproximações.

6 Comentários adicionais e Cronologia

Pode-se expandir facilmente a FFT de 16 para 128 usando o algoritmo explicado
para a FFT de 4 saı́das. Pode-se converter esse algoritmo em uma estrutura
parametrizada em hardware ou usar C++ (ou outra linguagem) e criar um
gerador de código.
O trabalho (descrito neste relatório) foi feito conforme o flowchart abaixo
demonstra.

Figure 21: Método de Ação para Resolver o Problema

7 Fontes
A teoria sobre FFT foi aprendida no dia 11 de Fevereiro de 2018 no endereço:
https://www.youtube.com/watch?v=BXghmsH-mKYlist=PL4K9r9dYCOoqmykdiyCq2jyAb0zwO0p-
b

15
 A utilização de ”monitor” foi aprendida no dia 12 de Fevereiro no endereço:
http://www.asic-world.com/verilog/verilogo ned ay4.html
O restante utilizado neste relatório foi aprendido nas aulas do professor Mar-
cos Ricardo Alcântara Morais, professor da Universidade Federal de Campina
Grande, e na aula de Felipe Gonçalves Assis.

8 Anexos
Nas próximas páginas estão o texto com a descrição do hardware (os módulos)
e a descrição do módulo top que foi usado para testar o sistema.
Também são mostrados os resultados obtidos para esse teste, assim como os
desenhos feitos enquanto se estudava o problema e os códigos do MATLAB.

16