CENTRO UNIVERSITÁRIO POSITIVO

NÚCLEO DE CIÊNCIAS EXATAS E TECNOLÓGICAS

ENGENHARIA DA COMPUTAÇÃO

ALGORITMO GENÉTICO IMPLEMENTADO EM FPGA PARA

EVOLUÇÃO DE HARDWARE

Tiago Carvalho Oliveira

Monografia apresentada à disciplina de Projeto Final como requisito parcial à conclusão

do Curso de Engenharia da Computação, orientada pelo Prof. Valfredo Pilla Júnior

UNICENP/NCET
Curitiba
2007
 TERMO DE APROVAÇÃO

Tiago Carvalho Oliveira

Algoritmo genético implementado em FPGA para evolução de hardware

Monografia aprovada como requisito parcial à conclusão do curso de Engenharia da Computação

do Centro Universitário Positivo, pela seguinte banca examinadora:

Prof. Valfredo Pilla Júnior (Orientador)

Prof. Maurício Perretto

Prof. Edson Pedro Ferlin

Curitiba, 15 de Dezembro de 2007.

 AGRADECIMENTOS

Há muitas pessoas que contribuíram diretamente ou indiretamente para a finalização e sucesso

deste projeto de conclusão de curso. Entretanto, para registrar o devido reconhecimento a quem
mais contribuiu, deixo meus agradecimentos para aqueles que se esforçaram durante anos para
me proporcionar o que eles mesmos não tiveram a oportunidade de ter, meus pais.
 RESUMO

O projeto consiste no em um sistema capaz de evoluir um circuito eletrônico através de um

algoritmo genético. Este sistema é composto por três módulos principais: algoritmo genético
(embarcado em FPGA), módulo evolutivo (simulado no software SMASH) e módulo de
avaliação (software desenvolvido em C++). Os módulos de avaliação e simulação operam em
um computador comum e se comunicam com o algoritmo genético (AG) embarcado em uma
FPGA.

O objetivo principal do projeto é embarcar uma variante de um algoritmo genético específico

(Algoritmo Genético Compacto) em FPGA. A evolução do hardware é utilizada como validação
da capacidade de busca de solução do AG embarcado com um problema complexo.

O circuito simulado (circuito evoluído) é um amplificador de baixo ruído (LNA – Low Noise
Amplifier) que usa tecnologia de circuitos integrados CMOS e modelagem de transistores
MOSFET do tipo enriquecimento com base em corrente. Valores e dimensões de componentes
são utilizadas como variáveis no projeto do circuito a fim de obter um desempenho adequado do
amplificador para a freqüência central de operação. Foram determinados quatro parâmetros para
avaliação de desempenho: impedância do circuito, potência dissipada, diferença de fase e
linearidade de operação.

Palavras-chave: Hardware evolutivo, Computação Evolutiva, Algoritmo Genético, Algoritmo

Genético Compacto (CGA), Algoritmo Evolutivo, Field Programmable Array (FPGA),
Computação Reconfigurável, Hardware Reconfigurável, Amplificador de baixo ruído (LNA).
 Genetic Algorithm implemented on FPGA for Evolvable Hardware applications

ABSTRACT

The project consists on a system capable of evolving (through the use of Genetic Algorithms) a
circuit. This system is formed by three main modules: genetic algorithm (embedded on FPGA),
evolvable module (simulated on SMASH software) and assessment module (C++ developed
software). The assessment module runs on a personal computer and has an interface with the
genetic algorithm (GA) embedded on a FPGA.

The project main objective is to embed a variation of a specific GA (the compact genetic
algorithm) on a FPGA. The hardware evolution is used to validate the search power of the
embedded GA to solve a complex problem.

The simulated circuit (evolvable circuit) is a Low Noise Amplifier (LNA) based on CMOS
integrated circuit technology and MOSFET transistor modeling. Values and dimensions of
components are used as variables on circuit design project to obtain an amplifier adequate
performance on a central operation frequency. Four parameters are used to assess performance:
circuit impedance, dissipated power, phase difference and operating linearity.

Key words: Evolvable Hardware, Evolutionary Computation, Genetic Algorithm, Compact

Genetic Algorithm (CGA), Evolutionary Algorithm, Field Programmable Array (FPGA),
Reconfigurable Computing, Low Noise Amplifier (LNA).
 SUMÁRIO

Capítulo 1 - Introdução ....................................................................................................... 10

1.1 Motivação................................................................................................................................ 10
1.2 Definição do Trabalho.................................................................................................................. 11
Capítulo 2 – Fundamentação Teórica .................................................................................. 12
2.1 Dispositivos Lógicos Programáveis............................................................................................. 12
2.1.1 Field Programmable Gate Arrays (FPGA)................................................................................ 12
2.2 Computação Evolutiva ................................................................................................................. 13
2.2.1 Algoritmos Genéticos................................................................................................................ 14
2.2.2 Algoritmo Genético Compacto ................................................................................................. 16
2.3 Hardware Evolutivo ..................................................................................................................... 18
Capítulo 3 – Especificação do Projeto ................................................................................. 20
3.1 Especificação do Hardware.......................................................................................................... 20
3.1.1 Separação Física........................................................................................................................ 20
3.1.2 Separação Lógica ...................................................................................................................... 20
3.2 Especificação do Software ........................................................................................................... 21
Capítulo 4 – Desenvolvimento e Implementação .................................................................. 23
4.1 Hardware...................................................................................................................................... 23
4.1.1 Diagrama em blocos.................................................................................................................. 23
4.1.2 Materiais.................................................................................................................................... 26
4.2 Software ....................................................................................................................................... 28
4.2.1 Diagrama de fluxo de dados do Controlador do AGC .............................................................. 28
4.2.2 Diagrama de fluxo de dados do software avaliador .................................................................. 32
4.2.3 Diagrama de Estados do Controlador do AGC ......................................................................... 34
4.2.4 Diagrama de Estados do componente de comunicação ............................................................ 35
Capítulo 5 – Validação e Resultados.................................................................................... 37
5.1 – Simulação do AGC ................................................................................................................... 37
5.2 – Validação do AGC e comunicação com o computador ............................................................ 38
5.3 – Validação do AGC para evolução de hardware ........................................................................ 39
Capítulo 6 - Conclusão ........................................................................................................ 43
Capítulo 7 - Referências Bibliográficas ............................................................................... 44
 LISTA DE FIGURAS

Fig. 1 - Módulos do projeto.............................................................................................. 11

Fig. 2 - Estrutura de Algoritmo Evolutivo ........................................................................ 14
Fig. 3 - Pseudocódigo do Algoritmo Genético Compacto ................................................. 18
Fig. 4 - Separação dos módulos de hardware................................................................... 20
Fig. 5 - Blocos funcionais do projeto e fluxo de dados...................................................... 21
Fig. 6 - Diagrama em blocos do AGC .............................................................................. 23
Fig. 7 - Placa DE2 da Altera............................................................................................ 26
Fig. 8 - Cabo de conexão entre a porta paralela e a placa DE2 ....................................... 27
Fig. 9 - Conexão entre a placa DE2 e o cabo que liga à porta paralela ........................... 28
Fig. 10 - Diagrama de fluxo de dados do AGC................................................................ 31
Fig. 11 - Código-fonte de configuração de arquivos e chamada de execução do SMASH 32
Fig. 12 - Diagrama de fluxo de dados do software de cálculo do fitness.......................... 33
Fig. 13 - Código da função de comunicação do computador com a FPGA...................... 36
Fig. 14 - Esquemático do circuito do LNA ...................................................................... 40
 LISTA DE SIGLAS

AG – Algoritmo Genético
AGC – Algoritmo Genético Compacto
CE – Computação Evolutiva
EA – Algoritmo Evolutivo
FPGA – Field Programmable Gate Array
HE – Hardware Evolutivo
LNA – Low noise amplifier
NCET- Núcleo de Ciências Exatas e Tecnológicas
PC – Computador Pessoal
PLD – Programmable logic device
UNICENP – Centro Universitário Positivo
 LISTA DE TABELAS

TABELA 1 Características da família Cyclone II de FPGAs ........................................... 26

TABELA 2 Estados da máquina do controlador do AGC................................................. 34
TABELA 3 Estados da máquina do componente de comunicação.................................... 35
TABELA 4 Estados do AGC e ciclos de clock.................................................................. 38
TABELA 5 Restrições dos parâmetros do LNA................................................................ 41
TABELA 6 Resultados das simulações ............................................................................ 41
 CAPÍTULO 1 - INTRODUÇÃO

O crescimento acelerado nas últimas décadas da utilização de circuitos e componentes

eletrônicos nos mais diversos tipos de equipamentos e instalações fez com que surgissem novas
necessidades além do desenvolvimento e implementação dos circuitos. Entre elas podemos citar
a preocupação com o consumo de energia, disponibilidade de espaço físico e acesso à
manutenção. Algumas aplicações eletrônicas requerem um pequeno consumo de energia e
pequeno espaço físico, como por exemplo, dispositivos portáteis alimentados por bateria. Alguns
desses dispositivos podem ainda ter finalidades cuja localização ou funcionamento impeçam
manutenções regulares, seja por custo ou ininterruptibilidade das operações.

Para estes circuitos eletrônicos são pesquisadas diversas formas de manutenção remota visando
minimizar o problema de acesso. Entretanto, há aplicações em que não é possível prever ou
calcular as alterações necessárias em um circuito eletrônico, como o desgaste de componentes
em satélites artificiais devido às oscilações térmicas e tempo de utilização.

Motivado pela necessidade específica destas aplicações eletrônicas este trabalho tem por objetivo
embarcar um algoritmo genético em um dispositivo de hardware de baixo consumo de energia.
Este algoritmo através de variáveis pré-definidas irá evoluir um circuito para que sua
funcionalidade esteja dentro do esperado. Através de soluções de computação evolutiva como
esta (algoritmos genéticos), soluções de hardware evolutivo podem ser criadas de forma que
circuitos eletrônicos não precisem de monitoramento de variáveis, cálculos de otimização ou
intervenção humana para sua manutenção (TETSUYA HIGUCHI, et al, 1999).

1.1 Motivação

A principal motivação para o desenvolvimento deste projeto é a pesquisa em uma área

relativamente nova (evolução de hardware). O hardware evolutivo se adapta para a realização de
novas funcionalidades ou a alterações no ambiente durante seu funcionamento, reconfigurando
sua própria estrutura de hardware automaticamente.

10
 1.2 Definição do Trabalho

O projeto consiste no desenvolvimento de um circuito eletrônico capaz de evoluir por meio de

um algoritmo genético um. Este sistema (Figura 1) é composto por três módulos principais:
algoritmo genético (embarcado em FPGA), módulo evolutivo (simulado no software SMASH) e
módulo de avaliação (software desenvolvido em C++). O módulo avaliador opera em um
computador comum que se comunica com o algoritmo genético (AG) implementado em uma
FPGA.

O objetivo principal do projeto é embarcar uma variante de um algoritmo genético específico

(Algoritmo Genético Compacto) em FPGA. A evolução do hardware é utilizada como validação
da capacidade de busca de solução do AG embarcado com um problema complexo.

Fig. 1 - Módulos do projeto

11
 CAPÍTULO 2 – FUNDAMENTAÇÃO TEÓRICA

O projeto consiste na implementação de um algoritmo genético específico (algoritmo genético

compacto apresentado por GOLDBERG, et al., 1999) em um dispositivo lógico programável
(PLD) do tipo FPGA. A utilização deste AG para a solução de um problema de HE foi escolhida
porque problemas de hardware evolutivo (HE) são relativamente complexos e podem demonstrar
a robustez e aplicabilidade do AG.

A fundamentação teórica está divida em três partes, de forma a abranger estes três tópicos
fundamentais do projeto (PLD, AG e HE) e suportar as escolhas tomadas para a utilização de um
tipo específico de cada tecnologia.

2.1 Dispositivos Lógicos Programáveis

Um dispositivo lógico programável ou PLD é um componente eletrônico usado para construir

circuitos digitais. Diferente de uma porta lógica, que tem uma função fixa, um PLD tem uma
função indefinida no momento da fabricação. Antes que um PLD possa ser usado em um circuito
ele deve ser programado.

Quando soluções inovadoras para problemas difíceis de projeto de hardware são necessárias,
programação com algoritmos genéticos pode ser usada para criar projetos de hardware em
termos de linguagem de descrição de hardware. A estrutura de um dispositivo de hardware
reconfigurável pode ser alterada quantas vezes forem necessárias realizando no dispositivo o
download de string de bits, chamado de bits de configuração. FPGAs são um exemplo típico de
dispositivos reconfiguráveis de hardware (HIOGUCHI et al, 1999).

Entretanto, o objetivo de utilização de FPGAs neste circuito não é a evolução e reconfiguração

lógica de um dispositivo de hardware digital. A utilização de FPGA está relacionada à facilidade
de programação e testes para fins didáticos, como também o baixo consumo de energia e alta
velocidade de processamento para que o AG seja embarcado.

2.1.1 Field Programmable Gate Arrays (FPGA)

As FPGAs são uma classe específica de PLDs. Uma FPGA é um dispositivo semicondutor que
contém componentes de lógica programável e interconexões programáveis. Os componentes de

12
lógica programável podem ser configurados para duplicar a funcionalidade de portas lógicas
básicas como AND, OR, XOR, NOT ou funções combinacionais mais complexas como decoders
ou funções matemáticas simples. Na maioria das FPGAs estes elementos lógicos programáveis
(ou blocos lógicos, na linguagem de FPGA) também incluem elementos de memória, que podem
ser simples flip-flops ou blocos de memória mais completos.

A hierarquia das interconexões programáveis permite que blocos lógicos de uma FPGA estejam
interconectados conforme necessário de acordo com o sistema de elaboração de projeto. Estes
blocos lógicos e interconexões podem ser programados após a fabricação pelo cliente /
desenvolvedor (por isto o termo field programmable, de programável em campo) de forma que a
FPGA possa realizar qualquer função lógica necessária.

2.2 Computação Evolutiva

A computação evolutiva (CE) é uma área de desenvolvimento e pesquisa da ciência da

computação. Ela abrange a construção, aplicação e estudo de algoritmos baseados na seleção
natural. A CE é conduzida com a ajuda de algoritmos evolutivos.

Um algoritmo evolutivo (AE) utiliza alguns mecanismos inspirados na evolução biológica como:
reprodução, mutação, recombinação, seleção natural e sobrevivência do mais apto. Soluções
candidatas para o problema de otimização fazem o papel de indivíduos em uma população e a
função de custo determina o ambiente em que a solução “vive” (VAN ZUBEN, 2000).

Os sistemas baseados em computação evolutiva mantêm uma população de soluções potenciais,

aplicam processos de seleção baseados na adaptação de um indivíduo e também empregam
outros operadores “genéticos”. Diversas abordagens para sistemas baseados em evolução foram
propostas, sendo que as principais diferenças entre elas dizem respeito aos operadores genéticos
empregados (VAN ZUBEN, 2000). Segundo ZUBEN as principais abordagens propostas na
literatura são:
• algoritmos genéticos;
• estratégias evolutivas;
• programação evolutiva.

Uma extensão dos algoritmos genéticos, denominada programação genética, foi introduzida por
Koza (1992), e tem por objetivo básico evoluir programas de computador usando os princípios

13
da evolução natural. Atualmente a programação genética tem sido aplicada a uma grande
variedade de problemas, como na síntese de circuitos elétricos analógicos e na definição de
arquiteturas de redes neurais artificiais (VAN ZUBEN, 2000).

A estrutura de um algoritmo evolutivo pode ser dada na forma apresentada na Figura 2.

Fig. 2 - Estrutura de Algoritmo Evolutivo

O algoritmo evolutivo mantém uma população de indivíduos P(t ) = {x1t ,..., xnt } na iteração
(geração) t. Cada indivíduo representa um candidato à solução do problema em questão e, em
qualquer implementação computacional, assume a forma de alguma estrutura de dados S. Cada
solução xit é avaliada e produz alguma medida de adaptação, ou fitness.

Uma nova população é formada na iteração t + 1 pela seleção dos indivíduos mais adaptados.
Alguns indivíduos da população são submetidos a um processo de alteração por meio de
operadores genéticos para formar novas soluções. Após um número de gerações, a condição de
parada deve ser atendida, a qual geralmente indica a existência, na população, de um indivíduo
que represente uma solução aceitável para o problema, ou quando o número máximo de gerações
foi atingido (VAN ZUBEN, 2000).

2.2.1 Algoritmos Genéticos

Os AGs foram introduzidos por Holland em 1975 com o objetivo de formalizar

matematicamente e explicar rigorosamente processos de adaptação em sistemas naturais e
desenvolver sistemas artificiais (simulados em computador) que retenham os mecanismos

14
originais encontrados em sistemas naturais. Os algoritmos genéticos utilizam os operadores de
crossover e mutação.

A terminologia adotada em AGs é originada da teoria da evolução natural e da genética. Um

indivíduo da população é representado por um único cromossomo, o qual contém a codificação
(genótipo) de uma possível solução do problema (fenótipo). Cromossomos são usualmente
implementados na forma de listas de atributos ou vetores, onde cada atributo é conhecido como
gene. Os possíveis valores que um determinado gene pode assumir são denominados alelos.

O processo de evolução executado por um algoritmo genético corresponde a um procedimento

de busca em um espaço de soluções potenciais para o problema. Como enfatiza
MICHALEWICZ (1996), esta busca requer um equilíbrio entre dois objetivos aparentemente
conflitantes: o aproveitamento das melhores soluções e a exploração do espaço de busca
(exploitation × exploration). Este equilíbrio está muito longe de ocorrer quando se considera
outras técnicas de busca:

• métodos de otimização clássicos, como o método do gradiente, são exemplos de

métodos que apenas aproveitam a melhor solução na busca de possíveis
aprimoramentos, sem realizar uma exploração do espaço de busca;
• métodos de busca aleatória, por sua vez, são exemplos típicos de métodos que
exploram o espaço de busca ignorando o aproveitamento de regiões promissoras do
espaço.

Algoritmos genéticos constituem, assim, uma classe de métodos de busca de propósito geral que
apresentam um balanço notável entre aproveitamento de melhores soluções e exploração do
espaço de busca. Embora apresentem etapas não-determinísticas em seu desenvolvimento, os
algoritmos genéticos não são métodos de busca puramente aleatórios, pois combinam variações
aleatórias com seleção, polarizada pelos valores de adequação (fitness) atribuídos a cada
indivíduo. Outra propriedade importante dos algoritmos genéticos (assim como de todos os
algoritmos evolutivos) é que eles mantêm uma população de soluções candidatas enquanto que
os métodos alternativos processam um único ponto no espaço de busca a cada instante (VAN
ZUBEN, 2000).

O processo de busca é, portanto, multi-direcional, através da manutenção de soluções candidatas,

e encorajando a troca de informação entre as direções. A cada geração, soluções relativamente

15
“boas” se reproduzem, enquanto que soluções relativamente “ruins” são eliminadas. Para fazer a
distinção entre diferentes soluções, é empregada uma função de avaliação ou de adaptabilidade
(fitness) que simula o papel da pressão exercida pelo ambiente sobre o indivíduo (VAN ZUBEN,
2000).

Um algoritmo genético para um problema particular deve ter os seguintes componentes:

• uma representação genética para soluções candidatas ou potenciais (processo de

codificação);
• uma maneira de criar uma população inicial de soluções candidatas ou potenciais;
• uma função de avaliação que faz o papel da pressão ambiental, classificando as soluções
em termos de sua adaptação ao ambiente (ou seja, sua capacidade de resolver o
problema);
• operadores genéticos;
• valores para os diversos parâmetros usados pelo algoritmo genético (tamanho da
população, probabilidades de aplicação dos operadores genéticos, etc.)

2.2.2 Algoritmo Genético Compacto

O objetivo principal deste trabalho é a implementação em hardware (no caso, FPGA) de um

algoritmo genético. Diversos AEs baseados em hardware têm sido propostos nos últimos anos.
Cada um é uma variação do algoritmo genético simples (simple genetic algorithm, SGA)
adaptado para implementação em hardware, e cada um proporciona aumento de desempenho
sobre o mesmo algoritmo implementado em um computador.

Uma maneira em que memória significativa (e, portanto, potência e espaço) pode ser
economizada em AEs baseados em hardware é representar populações de soluções candidatas
como vetores de probabilidade ao invés de grupos de strings de bits. Um AG padrão representa
uma população candidata como um grupo de genomas de string de bits, necessitando de espaço
de memória RAM embarcada proporcional a LN onde L é o comprimento do genoma e N é o
número de candidatos da população. Um método baseado em vetor de probabilidades representa
a população como um único vetor de probabilidades em que cada bit em cada string de bits de
um candidato teria o valor de zero ou um. Adotando a interpretação da freqüência relativa de
probabilidade, cada elemento no vetor de probabilidades representa a proporção de membros de
uma população simulada que tem um ou zero na posição do bit correspondente. Presumindo uma

16
representação de probabilidade binária de precisão fixa seria necessário L(log 2 N ) bits de
memória para representar uma população de tamanho L com strings de N bits. Para genomas de
mesmo tamanho, AGs padrão iriam precisar memória de O (N ) , enquanto um AG baseado em
vetor de probabilidades precisaria de O (log 2 N ) .

Pelo menos dois AE que empregam codificação de população em vetores de probabilidade têm
sido explorados na literatura. Destes, o algoritmo genético compacto (AGC) é de interesse
particular porque ele simula algumas propriedades do SGA e porque já há na literatura uma
implementação em hardware elegante (GALLAGHER et al. 2004).

Segundo GALLAGHER et al (2004), o AGC simples não tem poder de busca suficiente para uso
em diversos projetos de HE. Portanto, para solucionar o problema do circuito evolutivo no
presente trabalho foi utiliza-se uma variável de uma família de AGC proposta por JOHN
GALLAGHER et al (2004) e a implementação de hardware também proposta no mesmo artigo.

Os fundamentos deste AGC são encontrados no modelo original de GOLDBERG et al. (1999).
Este modelo é descrito na Figura 3.

17
 Fig. 3 - Pseudocódigo do Algoritmo Genético Compacto

A família de AGC proposta por GALLAGHER et al. (2004) sobre o modelo de GOLDBERG et
al. (1999) e utilizada neste projeto possui duas modificações em relação ao AGC padrão:
elitismo e mutação.

2.3 Hardware Evolutivo

Hardware evolutivo é uma área de pesquisa que objetiva construir, por exemplo, circuitos
eletrônicos cujo modelamento ou operação são definidos através de um processo de evolução.
Hardware evolutivo é um novo campo que relaciona hardware reconfigurável, inteligência
artificial e sistemas autônomos e tolerantes a falhas. Hardware evolutivo se refere ao hardware
que pode mudar sua arquitetura e comportamento dinamicamente e autonomamente pela
interação com seu ambiente.

Na sua forma fundamental um AE manipula uma população de indivíduos onde cada indivíduo
descreve como construir um circuito candidato. A cada circuito é associado um fitness, que
indica quão bem o circuito candidato satisfaz a especificação de projeto. O AE usa operadores
aleatórios para evoluir novas configurações de circuitos a partir de configurações existentes.
Feito corretamente, o AE irá ao longo do tempo evoluir uma configuração de circuito que exibe
comportamento desejável.

Cada candidato pode ser tanto simulado quanto fisicamente implementado em um dispositivo
reconfigurável. Dispositivos reconfiguráveis típicos são FPGAs (para projetos digitais) ou field
programmabel analog arrays (FPAAs, para projetos analógicos).

Há diversas razões para evoluir circuitos. Em muitos casos os métodos convencionais (ex.
fórmulas) de projeto podem ser utilizados para desenhar circuitos. Mas em outros casos a
especificação de projeto não fornece informação suficiente para permitir o uso de métodos
convencionais. Por exemplo, a especificação pode somente estabelecer o comportamento do
hardware em questão. Em outros casos o circuito deve adaptar-se (ex: modificar sua
configuração) para compensar falhas ou talvez uma mudança operacional no ambiente.

18
Hardware evolutivo é um novo conceito no desenvolvimento de máquinas adaptativas on-line.
Em contraste com o hardware convencional onde a estrutura é irreversivelmente fixada no
processo de desenho, HE é designado para se adaptar a mudanças nos requisitos das tarefas ou
mudanças no ambiente através da sua habilidade de reconfigurar sua própria estrutura de
hardware on-line (dinamicamente) e autonomamente. Esta capacidade de adaptação, atingida por
AEs (como os AGs) tem grande potencial para desenvolvimento de aplicações industriais
inovadoras (HIGUCHI et al. 1999).

Apesar do conceito de HE ser relativamente novo, algumas aplicações de HE já estão sendo

avaliadas para uso comercial. Há na literatura artigos sobre aplicações reais de HE analógico e
digital. HIGUCHI et al (1999) apresenta cinco chips de HE e suas aplicações práticas,
demonstrando a aplicabilidade comercial de HE.

O fitness de um circuito evoluído pode ser medido através do quão bem ele está de acordo com a
especificação do projeto. O fitness em problemas de HE é determinado por dois métodos:

• Evolução extrínseca: todos os circuitos são simulados para avaliar seu desempenho;
• Evolução intrínseca: testes físicos são realizados em hardware.

Na evolução extrínseca apenas a melhor solução final da população final do AE é fisicamente

implementada enquanto que na evolução intrínseca todos os indivíduos em cada geração do AE
são fisicamente implementados e testados.

19
 CAPÍTULO 3 – ESPECIFICAÇÃO DO PROJETO

3.1 Especificação do Hardware

3.1.1 Separação Física

O hardware do projeto é composto por dois módulos principais: kit didático da FPGA e
computador pessoal. A Figura 4 ilustra a separação entre o os módulos do hardware.

Fig. 4 - Separação dos módulos de hardware

3.1.2 Separação Lógica

O módulo de avaliação dos indivíduos (desenhos de circuitos) gerados pelo algoritmo genético
está implementado em um computador. Apenas o processamento do AG é realizado na FPGA,
conforme diagrama em blocos do projeto (Figura 5).

20
Algoritmo genético implementado em FPGA para evolução de hardware - Blocos funcionais
Geração de indivíduos Avaliação dos indivíduos Apresentação do Resultado

Início
Incremento/
Algoritmo Genético (FPGA)

decremento do
vetor de
Não probabilidades

Gerador de
números
aleatórios

Número de Geração do
Comparação com indivíduos Sim indivíduo
o vetor de atingido? final
probabilidades e
geração do novo
inivíduo

Recebimento dos
dados (indivíduo)
Arquivo com
resultado da
Módulo Avaliador (PC)

simulação

Conversão dos dados

para formato texto
padrão dos Identificação e
parâmetros extração dos
parâmetros.

Arquivo
texto com
parâmetros Cálculo do fitness.
do indivíduo

Envio de dados
Software Smash (fitness)
Circuito Evolutivo (PC)

Recebimento dos
dados (indivíduo)
Arquivo
texto com
parâmetros
do indivíduo
Conversão dos
dados para
formato texto
padrão dos
parâmetros

Fim

Fig. 5 - Blocos funcionais do projeto e fluxo de dados

3.2 Especificação do Software

O software do projeto é responsável por realizar a comunicação de interface entre a FPGA e o

programa SMASH e calcular o fitness dos indivíduos. Conforme ilustrada na Figura 5, a
simulação e geração de dados de resposta do circuito são realizados pelo software de projeto e
simulação SMASH (DOLPHIN INTEGRATION, www.dolphin.fr). O software desenvolvido
para este projeto recebe os dados do indivíduo gerado na FPGA, configura os arquivos (.nsx e
.pat) que descrevem o circuito e sinais de entrada de acordo com o indivíduo, executa o SMASH

21
com comando de simulação, recebe a resposta por meio de arquivo de simulação do SMASH,
calcula o fitness e o envia para a FPGA.

Não há interação do usuário com o software do projeto. A simulação e evolução de hardware são
simuladas em software para facilitar a implementação e substituir o hardware que realizaria estas
funções.

A comunicação entre a FPGA e o software é realizada por meio da porta paralela do PC. O
software foi desenvolvido na linguagem de programação C++ e o computador pessoal utiliza o
sistema operacional Windows XP.

22
 CAPÍTULO 4 – DESENVOLVIMENTO E IMPLEMENTAÇÃO

4.1 Hardware

Com exceção do módulo de avaliação, todo o algoritmo genético está implementado em FPGA.
Para elaborar o circuito foi utilizado o software Quartus II da Altera. Os blocos elaborados, suas
funções e equipamentos utilizados estão descritos nos próximos tópicos.

4.1.1 Diagrama em blocos

Todo os blocos do algoritmo genético compacto foram desenvolvidos em linguagem de

descrição de hardware da Altera (AHDL). Cada componente foi compilado individualmente e
gerado o arquivo de inclusão de símbolo.

A Figura 6 relaciona os blocos e seus pinos. A estrutura representada do AGC é para um

indivíduo de n bits com fitness de y bits.
MUX4x1

MUX2x1

Fig. 6 - Diagrama em blocos do AGC

Os componentes do AGC da Figura 6 e seus pinos estão descritos abaixo:

Gerador de números aleatórios (RNG): O RNG é um gerador de números pseudoaleatórios do

tipo LFSR (Logical Feedback Shift Register). O pino <load> é ativado na inicialização do AGC.

23
A cada ciclo de clock o RNG gera um novo número aleatório, seja ele utilizado ou não no fluxo
de dados do AGC. O número aleatório do diagrama é composto por 8 bits para uma
representação de um número entre 0 e 1 com ponto fixo.

Registrador de probabilidade (B_PBR): O registrador de probabilidades armazena um valor entre

0 e 1 em uma representação em ponto fixo. Este valor é a probabilidade de um indivíduo na
população possuir o bit em 0 ou 1 em uma determinada posição do genoma. Quando o pino
<b_clear> é ativado o registrador é configurado para 0x80, indicando que a probabilidade é
iniciada em 50% para 0 ou para 1. Os pinos <b_inc> e <b_dec> respectivamente incrementam e
diminuem o valor da probabilidade de acordo com o valor configurado no desenho do
componente.

Registrador de mutação (M_PBR): O registrador de mutação é muito semelhante ao registrador

de probabilidade com a diferença da ativação do pino <m_clear> que zera o valor do registrador.
Com o registrador de mutação zerado não há mutação, desta forma, no processo de inicialização
do AGC o pino de incremento (<m_inc>) é ativado quantas vezes for necessário para determinar
a probabilidade de mutação desejada.

Buffer (BUF): O buffer possui apenas 2 registradores de armazenamento, acessados através de

duas saídas. A gravação é permitida através dos pinos <b_write> (para ativar a gravação) e
<i_sel> (para selecionar o registrador). Um multiplexador simples é utilizado para determinar
qual valor de registrador está disponível no barramento de saída.

Módulo de Ajuste (INC/DEC): O Módulo de ajuste faz alterações no registrador de

probabilidades todas as vezes que o pino <p_fix> é ativado. Comparando os bits presentes no
buffer e contendo a informação do registrador E (registrador do bit de elite) o módulo de ajuste
através de um circuito combinacional determina se a probabilidade de cada bit deve ser
incrementada ou diminuída, ou ainda, se não deve ser alterada. A probabilidade de um bit só
deve ser alterada se o indivíduo avaliado possui o bit diferente do indivíduo apontado como
campeão. O incremento ou decremento da probabilidade ocorre na direção do valor do bit do
indivíduo campeão.

Registrador do bit de elite (E_REG): O registrador do bit de elite indica qual registrador do
buffer contém o bit de elite (indivíduo campeão). Este componente do AGC é compartilhado por
todos os bits do genoma, ou seja, há apenas um registrador “E”. O pino <e_bit> é configurado

24
pelo módulo de avaliação, que após calcular o fitness, altera o valor do pino de acordo com o slot
em que se encontra o indivíduo melhor avaliado. O pino <e_load> é controlado pela unidade de
controle do AGC.

Comparador (CMP_2_1): O comparador desta estrutura de AGC possui duas entradas e uma
saída. As entradas são de 8 bits, utilizando a mesma representação de número com ponto fixo do
RNG e B_PBR. Se o valor da entrada do RNG é maior que a entrada do B_PBR (ou M_PBR) o
valor de saída é 0, caso contrário o valor de saída é 1.

Função de fitness (FUNCAO): O módulo de função de fitness é o componente que a partir dos
dados do barramento com os bits do indivíduo calcula o fitness. Sua saída <fitness> possui
largura y, dependendo de qual resolução se deseja do valor do fitness. O pino <r_write> indica
para o módulo quando o indivíduo já está disponível no barramento para que seja calculado seu
fitness. O pino <fit_ready> indica para o módulo controlador da avaliação que o resultado do
fitness do indivíduo já foi calculado e está disponível no barramento <fitness>.

Controlador de avaliação (FEV): A versão do AGC implementada contempla o elitismo do

indivíduo e para que não seja necessário em todas as rodadas de comparação de indivíduos
calcular novamente o fitness do atual campeão se faz necessário um registrador para seu
armazenamento. Este módulo possui dois registradores de largura y para armazenar o fitness do
indivíduo campeão e do competidor. Em cada rodada de avaliação apenas o fitness do
competidor é calculado. Após o cálculo pelo módulo FUNCAO e a gravação do fitness no
registrador do competidor (de acordo com o pino <i_sel>) o registrador que indica o indivíduo
campeão (E_REG) é ajustado de acordo com o registrador de fitness que possui maior valor.
Para realizar estes passos o componente possui uma máquina de estados que é iniciada pela
ativação do pino <p_eval>.

Controlador do AGC (CTRL): O componente foi omitido na Figura 6 por possuir muitas
conexões com os demais módulos, o que poderia poluir visualmente o diagrama. Ele é
responsável por gerenciar todo o fluxo de informações através dos demais componentes por meio
da ativação dos pinos de controle dos módulos. Este módulo possui uma máquina de estados
para determinar as ativações dos pinos de controle. Os estados, pinos de entrada e pinos de saída
do controlador do AGC estão descritos no capítulo 4 no tópico 4.2.3 (diagrama de estados do
controlador do AGC).

25
Outros componentes: A estrutura do AGC ainda é composta por dois multiplexadores (um de
quatro entradas e outro de duas entradas) e uma porta XOR simples.

4.1.2 Materiais

Os componentes do AGC foram desenvolvidos em AHDL e integrados através de esquemático

no software Quartus II da Altera. Para a implementação em hardware foi utilizada uma FPGA da
Altera disponível em um kit didático. O kit didático utilizado (Placa DE2, Figura 7) é para
desenvolvimento de aplicações com o processador NIOS. Ele possui uma FPGA Altera da
família Cyclone II, modelo EP2C35.

Fig. 7 - Placa DE2 da Altera

FONTE: ALTERA CORPORATION (WWW.ALTERA.COM)

Da família de FPGAs de baixo custo Cyclone II, o modelo EP2C35 é um modelo intermediário e
contêm 33216 blocos lógicos, 105 blocos de RAM e máximo de 475 pinos utilizáveis pelo
usuário (Tabela 1). Este kit foi o escolhido para desenvolvimento do projeto porque facilita a
configuração da FPGA e sua comunicação com o PC por meio dos barramentos de expansão.

TABELA 1 Características da família Cyclone II de FPGAs

Característica \ Modelo EP2C5 EP2C8 EP2C20 EP2C35 EP2C50 EP2C70
Elementos Lógicos 4.608 8.256 18.752 33.216 50.528 68.416
M4K RAM blocks (4 Kbits mais 512 parity bits) 26 36 52 105 129 250
Total RAM bits 119.808 165.888 239.616 483.84 594.432 1.152.000
Máximo pinos de E/S (usuário) 158 182 315 475 450 622

FONTE: Altera DE2 Development and Education Board User Manual

26
Não foi utilizado nenhum componente já disponível no kit para comunicação ou mesmo o
processador NIOS. Apenas a porta USB Blaster foi utilizada para a configuração da FPGA. Toda
a arquitetura do AGC e comunicação com o PC foram implementadas diretamente no chip
através de lógica desenvolvida em linguagem de descrição de hardware da Altera (AHDL).

A comunicação entre a FPGA e o computador através da porta paralela foi estabelecida através
de um cabo (Figura 8) montado para realizar esta ligação.

Fig. 8 -Cabo de conexão entre a porta paralela e a placa DE2

Foram utilizados os oito pinos de dados da porta paralela e os pinos wait, write e ground,
totalizando onze pinos. A conexão do cabo com a porta paralela do computador foi realizada por
meio do conector padrão DB25. A conexão entre o cabo e a placa DE2, conforme exibido pela
Figura 9, foi realizada por meio dos conectores do cabo ao barramento de pinos de expansão da
placa.

27
 Fig. 9 -Conexão entre a placa DE2 e o cabo que liga à porta paralela

4.2 Software

O software relacionado diretamente ao AGC é apenas o firmware do componente controlador do

AGC. Nele está a máquina de estados que controla todo o fluxo de informações entre os demais
componentes do AGC.

O software no computador tem o objetivo de comunicar-se com a FPGA para obter os valores
dos indivíduos, simular o circuito no software SMASH, calcular o fitness e enviar o valor para a
FPGA.

4.2.1 Diagrama de fluxo de dados do Controlador do AGC

A Figura 10 representa o diagrama de fluxo de dados do componente controlador do AGC

(CTRL). Os números do diagrama estão relacionados com a descrição dos passos. Os passos
contêm a descrição dos procedimentos realizados e sua relação com o algoritmo genético
utilizado (algoritmo genético compacto padrão com variação de elitismo e mutação). Eles estão
relacionados também com os estados da máquina do controlador.

Passo 1) Todos os registradores recebem o sinal de clear. Apenas os registradores que

representam o vetor de probabilidades são iniciados em 0,5 (0x80 em uma representação já
comentada de ponto fixo de 8 bits). Estas ações são realizadas no estado i00 do CTRL. Em

28
seguida, no estado i01, os registradores do gerador de números aleatórios são inicializados com
um valor pré-definido no gerador e os registradores de probabilidade de mutação são
inicializados de acordo com um valor definido de mutação (valores configurados no código em
AHDL).

Passo 2) Um indivíduo é gerado pelo comparador utilizando números aleatórios do RNG e

probabilidades do B_PBR. Este indivíduo é gravado no slot campeão do buffer. Este passo
corresponde ao estado g00 do CTRL.

Passo 3) O módulo de avaliação dos indivíduos (FEV) recebe sinal para avaliar o indivíduo do
slot campeão do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do fitness
do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da avaliação e
armazena o resultado no registrador interno indicado pelo bit de campeão. Este passo
corresponde aos estados g01 e g02 do CTRL.

Passo 4) Um indivíduo é gerado pelo comparador utilizando números aleatórios do RNG e

probabilidades do B_PBR. Este indivíduo é gravado no slot competidor do buffer. Este passo
corresponde ao estado g03 do CTRL.

Passo 5) O módulo de avaliação dos indivíduos (FEV) recebe sinal para avaliar o indivíduo do
slot competidor do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do
fitness do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da
avaliação e armazena o resultado no registrador interno diferente do bit indicador de campeão.
Este passo corresponde aos estados a00 e a01 do CTRL.

Passo 6) O FEV gera o bit correspondente ao slot do buffer que contém o indivíduo de melhor
fitness e o CTRL envia o sinal para o registrador E atualizar seu valor. Este passo corresponde ao
estado a01 do CTRL.

Passo 7) As linhas de ajuste de B_PBR (<b_inc> e <b_dec>) são ativadas de acordo com as
necessidades de ajuste calculadas pelo módulo INC/DEC. Este módulo é um circuito
combinacional e realiza ajuste no vetor de probabilidade fazendo com que ele sofra uma
alteração na direção do indivíduo campeão em um determinado bit caso ele seja diferente entre o
campeão e o competidor. Este passo corresponde ao estado c00 do CTRL.

29
Passo 8) Um indivíduo é gerado pelo comparador utilizando números aleatórios do RNG e
probabilidades do M_PBR. Os bits desse indivíduo passam por uma porta lógica XOR com os
bits do indivíduo do slot campeão do buffer. O indivíduo resultante é gravado no slot de
competidor do buffer. Este passo corresponde ao estado m00 do CTRL.

Passo 9) O módulo de avaliação dos indivíduos (FEV) recebe sinal para avaliar o indivíduo do
slot competidor do buffer. O FEV envia sinal para o módulo FUNCAO iniciar o cálculo do
fitness do indivíduo. Ao fim deste processo o FEV recebe um sinal indicando o término da
avaliação e armazena o resultado no registrador interno diferente do bit indicador de campeão.
Este passo corresponde aos estados m01 e m02 do CTRL.

Passo 10) O FEV gera o bit correspondente ao slot do buffer que contém o indivíduo de melhor
fitness e o CTRL envia o sinal para o registrador E atualizar seu valor. Este passo corresponde ao
estado m02 do CTRL.

Após o passo 10 é verificado se o processo de evolução chegou ao fim. Podem existir diversas
condições de parada como, por exemplo: número de gerações, convergência parcial do vetor de
probabilidades, convergência total do vetor de probabilidades, fitness mínimo atingido, etc.

Caso seja verificado que o processo de evolução não chegou ao fim o controlador executa
novamente o processo a partir do passo três. Nos casos descritos como teste do CGA a condição
de parada (quantidade de indivíduos desejada) foi determinada em software.

30
 Início

BUF[0], BUF[1], E ← 0
RNG(load)
B_PBR ← 0,5
M_PBR ← Taxa de Mutação
1

BUF[E] ← CMP(RNG, B_PBR)

2

FEV(E) ← FUNCAO(BUF[E])
3

BUF[!E] ← CMP(RNG, B_PBR)

4

FEV(!E) ← FUNCAO(BUF[!E])
5

E ← FEV(BIT_E)
6

B_PBR ← INCDEC(E, BUF[0], BUF[1])

7

Não
BUF[!E] ← XOR(CMP(RNG, M_PBR), BUF[E])
8

FEV(!E) ← FUNCAO(BUF[!E])
9

E ← FEV(BIT_E)
10

Fim do processo?

Sim

Fim

Fig. 10 - Diagrama de fluxo de dados do AGC

31
 4.2.2 Diagrama de fluxo de dados do software avaliador

O software responsável pelo cálculo do fitness dos indivíduos gerados pelo AGC na FPGA foi
completamente desenvolvido em linguagem de programação C++ com o uso do compilador
Borland C++ Builder 6.0. O programa não possui interface com o usuário e não é orientado a
objetos. Antes de executar o software o usuário já deve ter ligado a placa com a FPGA contendo
a programação do AGC. Ao chamar o programa de cálculo do fitness o mesmo já inicia a
comunicação com o AGC conforme o diagrama da Figura 12. Não há indicadores do andamento
do processo. Ao final das avaliações dos indivíduos (o programa está configurado para avaliar
301 indivíduos por execução) o programa é encerrado automaticamente e gera um arquivo texto
de log contendo as informações dos indivíduos gerados e dos fitness calculados na execução.

Fig. 11 - Código-fonte de configuração de arquivos e chamada de execução do SMASH

O software de simulação de circuitos SMASH é utilizado devido à complexidade dos cálculos

envolvidos. Para se comunicar com o software SMASH são utilizados dois arquivos de texto

32
contendo as configurações do circuito (arquivo .nsx) e os sinais de entrada (arquivo .pat). O
SMASH é chamado por linha de comando utilizando estes dois arquivos como parâmetros para
simulação e retorna dois arquivos com os resultados (arquivos com extensões .op e .dat). A
Figura 11 contém trechos de código do software com funções de configuração dos arquivos e
chamada do software SMASH com os parâmetros necessários para a simulação com os arquivos
configurados.

Fig. 12 - Diagrama de fluxo de dados do software de cálculo do fitness

33
 4.2.3 Diagrama de Estados do Controlador do AGC

A máquina de estados que controla o fluxo de informações entre os componentes do AGC está
no controlador do AGC. A Tabela 2 lista e descreve todos os estados, suas entradas e saídas. O
processo de evolução do AGC está dividido em 4 etapas: inicialização, geração de indivíduos,
avaliação dos indivíduos, ajustes no vetor de probabilidades e mutação.

TABELA 2 Estados da máquina do controlador do AGC

Entradas Saídas

f_evaluate

incdec_fix
mux2_sel
rng_load
all_clear

mux4_1

mux4_0

b_write
f_finished

Processo Comentários

e_load
b_sel

m_inc[]
Estado

Estado
e_bit

S9 S8 S7 S6 S5 S4 S3 S2 S1 S0

Todos os registradores são "zerados". Apenas os registradores

i00 X X 1 0 0 1 0 0 0 0 0 0 0 i01 do vetor de probabilidades assumem o valor 0xH0.
Os registradores do gerador de números aleatórios são inciados
com um valor pré-definido. Os registradores de probabilidade de
Inicializa
i01 X X 0 1 0 1 0 0 0 0 0 0 VCC i02 mutação são incrementados uma vez.
i02 X X 0 0 0 1 0 0 0 0 0 0 0 i03 Estado para aguardar o funcionamento normal do RNG.
i03 X X 0 0 0 1 0 0 0 0 0 0 0 i04 Estado para aguardar o funcionamento normal do RNG.
i04 X X 0 0 0 1 0 0 0 0 0 0 0 i05 Estado para aguardar o funcionamento normal do RNG.
i05 X X 0 0 0 1 0 0 0 0 0 0 0 g00 Estado para aguardar o funcionamento normal do RNG.
g00 X X 0 0 0 1 0 1 0 0 0 0 0 g01 Gera indivíduo e grava no slot campeão do buffer.
g01 X X 0 0 0 1 0 0 0 1 0 0 0 g02 Envia para avaliação indivíduo do slot campeão do buffer.

g02 X 0 0 0 0 1 0 0 0 0 0 0 0 g02 Aguarda FEV responder com sinal de término da avaliação.

Gera

g02 X 1 0 0 0 1 0 0 0 0 0 0 0 g03 Aguarda FEV responder com sinal de término da avaliação.

g03 0 X 0 0 0 1 1 1 0 0 0 0 0 a00 Gera indivíduo e grava no slot competidor do buffer.
g03 1 X 0 0 0 1 0 1 0 0 0 0 0 a00 Gera indivíduo e grava no slot competidor do buffer.

a00 0 X 0 0 0 1 0 0 1 1 0 0 0 a01 Envia para avaliação indivíduo do slot competidor do buffer.

a00 1 X 0 0 0 1 0 0 0 1 0 0 0 a01 Envia para avaliação indivíduo do slot competidor do buffer.

Avalia
a01 0 0 0 0 0 1 0 0 1 0 0 0 0 a01 Aguarda FEV responder com sinal de término da avaliação.

a01 1 0 0 0 0 1 0 0 0 0 0 0 0 a01 Aguarda FEV responder com sinal de término da avaliação.

Ajusta registrador E conforme slot do indivíduo com melhor
a01 X 1 0 0 0 1 0 0 0 0 0 1 0 c00 fitness .
Corrige c00 X X 0 0 0 1 0 0 0 0 1 0 0 m00 Ajusta vetor de probabilidades.
Gera mutação do indivíduo campeão e grava no slot competidor
m00 0 X 0 0 1 0 1 1 0 0 0 0 0 m01 do buffer.
Gera mutação do indivíduo campeão e grava no slot competidor
m00 1 X 0 0 1 0 0 1 1 0 0 0 0 m01 do buffer.

m01 0 X 0 0 0 1 0 0 1 1 0 0 0 m02 Envia para avaliação indivíduo do slot competidor do buffer.

Muta
m01 1 X 0 0 0 1 0 0 0 1 0 0 0 m02 Envia para avaliação indivíduo do slot competidor do buffer.

m02 0 0 0 0 0 1 0 0 1 0 0 0 0 m02 Aguarda FEV responder com sinal de término da avaliação.

m02 1 0 0 0 0 1 0 0 0 0 0 0 0 m02 Aguarda FEV responder com sinal de término da avaliação.

Ajusta registrador E conforme slot do indivíduo com melhor
m02 X 1 0 0 0 1 0 0 0 0 0 1 0 g03 fitness.

34
 4.2.4 Diagrama de Estados do componente de comunicação

Uma máquina de estados controla a comunicação entre a FPGA e o PC. Toda a comunicação é
feita um byte por vez. Todos os parâmetros do projeto são de um byte, inclusive o fitness. Desta
forma a FPGA envia n bytes para a o PC, no qual n é o número de parâmetros do indivíduo, e
recebe um byte relativo ao fitness do indivíduo avaliado. Os estados e suas descrições estão
comentados na Tabela 3.

TABELA 3 Estados da máquina do componente de comunicação

Entradas tri_estate Saídas

reg_write
reg_read
Processo Comentários
rd_end
estado

r_write

estado
ct_en
write

wait

Espera sinal indicando que valor a ser enviado para o PC já está

Gravação dos i00 0 0 X 0 0 0 0 0 i00 disponível no barramento.
dados do Sinal r_write ativo indicado que o valor para envio ao PC já está
barramento disponível no barramento. O pino reg_read é ativado, habilitando o
do CGA i00 0 1 X 0 0 1 0 0 r00 registrador para gravação.
Ativação do pino wait indicando ao computador que se a transmissão
r00 0 X X 1 0 0 0 0 r00 dos dados está para iniciar.

O computador responde com a ativação do pino write que está pronto

para receber o valor. Neste instante o pino tri_state é ativado, permitindo
r00 1 X X 1 1 0 0 1 r01 que a saída do registrador seja conectada ao barramento.
Envio dos
Enviado sinal para o PC através da desativação do pino wait indicando
parâmetros do
r01 1 X X 0 1 0 0 0 r01 que o valor para leitura já está disponível.
indíviduo ao
O PC responde que finalizou a leitura através da destaivação do pino
PC
write. Caso rd_end seja zero o processo de envio para o PC é realizado
r01 0 X 0 0 0 0 0 0 r00 novamente.
O PC responde que finalizou a leitura através da destaivação do pino
write. Caso rd_end seja um indica que todos os parâmetros foram
passados para o PC e assim a comunicação pode prosseguir para o
r01 0 X 1 0 0 0 0 0 w00 recebimento de dados.
O pino wait é ativado indicando que a FPGA está disponível para
w00 0 X X 1 0 0 0 0 w00 receber o valor do PC.
O pino write é ativado pelo PC indicando que o valor já se encontra
disponível no barramento. Nesta condição o pino reg_write é habilitado
Gravação do
w00 1 X X 1 0 0 1 1 w01 permitindo a gravação do valor no registrador.
fitness do
indivíduo
w01 1 X X 0 0 0 0 0 w01 O pino wait é desativado comunicando ao PC que o valor foi recebido.
avaliado pelo
PC
Estado de espera da desativação do pino write quando o PC comunica
que recebeu a mensagem de término do processo de gravação do valor
enviado. Após este estado todo o processo é iniciado novamente com o
w01 0 X X 0 0 0 0 0 i00 recebimento dos valores do barramento do CGA.

O trecho do código da Figura 13 é a função de comunicação implementada em C++ e contém os

comentários relacionados a máquina de estados de comunicação. A função wait_value deixa o
programa em um laço infinito até que o valor passado como parâmetro seja lido no pino wait na
porta paralela. A função set_write envia para o pino write da porta paralela o valor passado como
parâmetro. As demais funções lêem e enviam dados pela porta de dados da porta paralela
(inportb e outportb) e configuram os registradores da porta que indicam seu modo de operação
(leitura ou gravação).

35
Fig. 13 - Código da função de comunicação do computador com a FPGA

36
 CAPÍTULO 5 – VALIDAÇÃO E RESULTADOS

Todos os módulos e componentes dos módulos do projeto foram testados e avaliados

individualmente para garantir o funcionamento correto antes de serem integrados. As etapas
descritas de validação do projeto estão divididas entre simulação do AGC, validação do AGC e
comunicação e validação dos resultados para evolução de hardware. Cada etapa testou parte do
AGC e apresentou resultados relevantes para a validação do projeto e análise do funcionamento
do algoritmo genético.

5.1 – Simulação do AGC

Uma simulação do AGC foi realizada no software Quartus II para validar seu funcionamento e
convergência para busca do indivíduo ótimo de um problema simples. Foi elaborada uma função
em linguagem de descrição de hardware que possui entrada de doze bits e conta a quantidade de
bits 1. A saída da função possui largura de quatro bits, pois o menor resultado possível é zero
(indivíduo com todos os doze bits iguais a zero) e o maior resultado possível é doze (indivíduo
com todos os doze bits iguais a um).

Conforme descrito no tópico 4.1.1 o componente FUNCAO do diagrama em blocos da Figura 6

é o responsável pelo cálculo da função de fitness. A função para contar a quantidade de bits 1 foi
compilada em um componente no formato do FUNCAO e colocado no seu lugar. Devido ao fato
desta ser uma função simples ela é completamente formulada por lógica combinacional, desta
forma, a saída com o resultado é atualizada “instantaneamente” com a mudança da entrada.

Com esta configuração do AGC para avaliação do fitness foi simulada no Quartus II a sua
execução para verificar se o algoritmo convergia para um indivíduo com todos os bits iguais a
um. Na simulação realizada o algoritmo obteve um indivíduo com todos os bits iguais a um no
quadragésimo segundo indivíduo gerado (somando indivíduos gerados a partir do vetor de
probabilidades e mutações) e convergiu o vetor de probabilidades após 95 indivíduos avaliados.
Para correção no vetor de probabilidades após as avaliações foi utilizado um valor igual a 32
para incremento ou decremento. O vetor de probabilidades possui um byte de resolução para
cada bit, permitindo 256 níveis diferentes de probabilidade para cada bit. Com ajuste de valor 32
o AGC possuiu oito níveis diferentes de probabilidade para cada bit do indivíduo.

37
A Tabela 4 relaciona cada estado do AGC (descritos no tópico 4.2.3) e quantidade de ciclos de
clock observada na simulação. Para cada processo inteiro de geração de indivíduo a partir do
vetor de probabilidades até a mutação e avaliação da mutação são necessários nove ciclos.

TABELA 4 Estados do AGC e ciclos de clock

Estado Qtd de Ciclos
g03 1
a00 1
a01 2
c00 1
m00 1
m01 1
m02 2
Total 9

5.2 – Validação do AGC e comunicação com o computador

O objetivo final de validação da implementação do AGC é a sua utilização para a solução de

problemas de evolução de hardware. Entretanto, não é possível assim como na simulação do
AGC implementar uma função de fitness na própria FPGA devido à sua alta complexidade. Para
resolver este problema foi necessário desenvolver uma interface de comunicação com um
computador para que este calculasse o fitness. Esta etapa de testes teve o objetivo de validar o
funcionamento do AGC para um problema de complexidade maior do que o descrito no tópico
5.1 e também avaliar se a interface de comunicação com o PC estava funcionando
adequadamente.

O componente FUNCAO do AGC exibido no diagrama em blocos da Figura 6 foi substituído

por um componente que realiza a comunicação com o computador. Os estados deste componente
já foram descritos no tópico 4.2.4. Um software no computador foi elaborado para realizar o
cálculo de uma função de segundo grau (f(x,y) = -4x² +20x -3y² +15y +50) com duas variáveis
para obter seu resultado. O AGC foi configurado para que cada indivíduo fosse formado por 16
bits, permitindo que cada variável da equação fosse representada por um byte. O fitness foi
ajustado para também ser representado por um byte.

Para cada avaliação de indivíduo gerado pela FPGA os valores de x e y foram recebidos no PC e
normalizados. Após a normalização o cálculo do resultado da função foi realizado, foi

38
normalizado e enviado para a FPGA. O objetivo das simulações realizadas foi verificar que o
AGC encontraria o indivíduo com o valor máximo da equação.

Para as diversas simulações realizadas uma grande parte encontrou o indivíduo ótimo (f(x,y)
igual a 93) com sessenta ou menos indivíduos gerados. Para as demais simulações os resultados
obtidos eram próximos ao ideal, entretanto, identificamos um problema devido a forma de
codificação do indivíduo. Como os valores das variáveis estavam em representação binária cada
bit representava o dobro de valor do bit a sua direita. Quando um indivíduo com fitness quase
ótimo era gerado pelo AGC e com valores de x e y muito próximos aos da representação dos bits
(ex.: 127, 128, 64) o mesmo encontrava dificuldades para convergir para o indivíduo ótimo. Isto
ocorreu porque para haver a mudança de um valor de 127 para 128, por exemplo, é necessário
que todos os bits sejam alterados, contrariando a tendência do vetor de probabilidades que
convergia para um determinado valor de acordo com os últimos indivíduos gerados e avaliados.

Em algumas situações o indivíduo ótimo não era obtido por causa deste problema da
representação do indivíduo, mas ocorreram também algumas situações em que a mutação
conseguiu gerar o indivíduo com as modificações necessárias para que este fosse melhor que o
anterior e não convergir prematuramente.

Para estas simulações foi utilizado incremento e decremento do vetor de probabilidades igual a
32 (possibilitando oito níveis de probabilidade) e mutação também igual a 32 (probabilidade de
um de cada oito bits sofrer mutação).

5.3 – Validação do AGC para evolução de hardware

O software descrito no tópico 5.2 foi substituído pelo software final (conforme descrito no tópico
4.2.2) para validar o AGC com um problema de evolução de hardware. O objetivo desta
simulação é validar se o AGC é capaz de encontrar uma solução ótima para um problema
complexo, que neste caso é a evolução de um circuito. Esta evolução pode ser classificada como
off-line pois cada indivíduo (configuração de circuito) não é implementada, apenas a versão final
com a melhor configuração do circuito seria implementada.

O circuito escolhido para ser evoluído é um projeto de um amplificador de baixo ruído (LNA –
Low Noise Amplifier). Para saber o quanto o circuito evoluído está perto do circuito ótimo e
também para definir a função de fitness foi utilizada a metodologia proposta por BARONCINI e

39
GOUVEIA FILHO (2004) que usa tecnologia de circuitos integrados CMOS e modelagem de
transistores MOSFET do tipo enriquecimento com base em corrente. Foram utilizados os
resultados do relatório de PILLA JR. (2006), que contém os passos e valores obtidos para
desenho do circuito de acordo com a metodologia de BARONCINI, para comparação com os
resultados obtidos do AGC.

O circuito do LNA (Figura 14) possui diversos componentes eletrônicos, entretanto, de acordo
com a metodologia utilizada apenas alguns parâmetros são configuráveis e os resultados do
circuito devem respeitar algumas restrições.

Fig. 14 - Esquemático do circuito do LNA

Foram utilizados quatro parâmetros para a configuração do circuito. O primeiro parâmetro é a

largura (W) dos transistores M1 e M2. O segundo e terceiro parâmetros são as indutâncias dos
indutores Lg e Ls. O último e quarto parâmetro é o valor da fonte de sinal (Vs). Os valores
obtidos das simulações devem respeitar as condições da Tabela 5.

40
 TABELA 5 Restrições dos parâmetros do LNA
Parâmetro Descrição Restrição
Pdc Potência dissipada no LNA Menor que 30 mW
IIP3 Linearidade de resposta em 1GHz Maior que -10dB
ZMI Impedância do circuito Mais próximo possível de 50 ohms
ZFI Diferença de fase em 1GHz Mais próximo possível de zero graus

A fórmula de fitness do software no computador considerou os quatro parâmetros de resultado

do LNA. Cada parâmetro de configuração do circuito e o fitness foram representados por oito
bits, desta forma, o AGC foi configurado para largura de 32 bits. O valor de incremento do vetor
de probabilidades utilizado foi igual a 8, possibilitando 32 níveis de probabilidade. O valor de
probabilidade de mutação configurado para todos os bits foi de 64, estabelecendo uma
probabilidade de um quarto para mutação de cada bit.

A Tabela 6 apresenta os resultados obtidos nas 14 simulações realizadas e os valores de

configuração obtidos com a metodologia de BARRONCINI e GOUVEIA FILHO extraídos do
relatório de PILLA JR.

TABELA 6 Resultados das simulações

Entradas Saídas
Simulação Indivíduos Melhor
W Lg Ls Vs Pdc IIP3 ZMI ZFI
Relatório - - 1900,000 20,000 1,700 0,518 0,012 7,541 42,462 9,397
1 201 144 1521,961 22,596 1,773 0,540 0,013 11,654 52,541 0,127
2 401 320 2751,765 18,663 2,582 0,573 0,034 7,991 48,029 3,728
3 1001 176 2713,333 19,125 4,896 0,458 0,007 0,649 33,963 0,160
4 301 193 1618,039 29,653 6,169 0,461 0,004 0,896 56,689 0,281
5 301 186 1714,118 26,761 5,012 0,458 0,004 0,637 50,350 0,162
6 301 194 2886,275 13,110 1,310 0,617 0,052 5,664 48,084 1,367
7 301 232 1387,451 27,571 2,814 0,477 0,005 2,521 46,505 0,211
8 301 280 2444,314 20,629 3,276 0,543 0,021 20,817 49,716 0,654
9 301 282 1675,686 24,794 3,276 0,480 0,006 2,812 50,176 1,964
10 301 232 1752,549 29,190 7,557 0,447 0,004 -0,375 49,488 0,578
11 301 176 2175,294 24,100 3,624 0,568 0,025 11,723 57,544 1,185
12 301 288 1349,020 23,869 1,425 0,557 0,014 18,061 49,488 1,282
13 301 278 2002,353 28,843 10,912 0,450 0,004 -0,124 38,327 0,706
14 301 244 2943,922 15,655 2,351 0,524 0,020 11,112 40,041 0,913

A primeira simulação realizada obteve um indivíduo com parâmetros de configuração do circuito

muito próximos ao do relatório utilizado como referência. Esta simulação foi realizada com 201
indivíduos (segunda coluna da Tabela 6) e o melhor indivíduo obtido foi o de número 144
(terceira coluna da Tabela 6). Alguns indivíduos obtidos nas simulações tiveram resultados
superiores aos resultados do relatório, por exemplo, o indivíduo da oitava simulação. Apenas

41
algumas simulações geraram indivíduos com parâmetros não aceitáveis conforme descrito na
Tabela 5.

Apesar da alta velocidade de geração e mutação de indivíduos pela FPGA o processo de

avaliação no computador com o uso do software SMASH em modo batch se mostrou lento,
sendo este o gargalo de tempo no processo. O tempo médio para geração, avaliação e
comunicação do indivíduo entre o computador e a FPGA foi de aproximadamente seis segundos.

O sistema funcionou adequadamente conforme esperado convergindo para configurações de

circuito que atendem aos requisitos estabelecidos dentro de um espaço de 4.294.967.296 (quatro
parâmetros com 256 valores possíveis cada) soluções possíveis.

42
 CAPÍTULO 6 - CONCLUSÃO

Os resultados obtidos a partir das simulações realizadas foram satisfatórios e demonstraram o

correto funcionamento do algoritmo genético compacto implementado na FPGA. Além de
concluir sobre o funcionamento do AGC foi verificado que a modificação do AGC básico
implementada possui poder de busca suficiente no espaço de soluções possíveis para resolver
problemas complexos, por exemplo, evolução de hardware.

Devido à avaliação dos indivíduos ser realizada no computador (ao invés da FPGA ou outro
circuito) o tempo necessário para o sistema encontrar uma solução aceitável de configuração de
circuito não permite que o mesmo seja utilizado para aplicações que exijam respostas rápidas.
Para utilização prática do sistema em aplicações reais e on-line de evolução de hardware se faz
necessário o desenvolvimento de um circuito com interfaces digitais de configuração de
parâmetros e um circuito de avaliação com tempo de resposta mínimo para que o sistema inteiro
opere em tempo real, se adequando instantaneamente a mudanças de operação que possam
surgir.

Melhorias podem ser realizadas no AGC implementado com modificações que ajudem no
refinamento das soluções encontradas, por exemplo, mudanças individuais nas taxas de mutações
dos bits ou taxas de mutação diferentes de acordo com o progresso da execução das simulações.

43
 CAPÍTULO 7 - REFERÊNCIAS BIBLIOGRÁFICAS

GOLDBERG, D. E.; HARIK, G. R.; LOBO, F. G. The Compact Genetic Algorithm. IEEE
Transactions on Evolutionary Computation. VOL. 3, N. 4, November of 1999.

HIGUCHI, T., et al. Real-World Applications of Analog and Digital Evolvable Hardware. IEEE
Transactions on Evolutionary Computation. VOL. 3, N. 3, September of 1999.

ZUBEN, F. J. V. Computação Evolutiva: Uma Abordagem Pragmática. DCA/FEEC/Unicamp,

2000.

GALLAGHER, J. C.; VIGRAHAM, S.; KRAMER, G. A Family of Compact Genetic

Algorithms for Intrinsic Evolvable Hardware. IEEE Transactions on Evolutionary
Computation. VOL. 8, N. 2, April of 2004.

Altera DE2 Development and Education Board User Manual, Altera Corporation, 2006.

BARONCINI, V. H. V.; GOUVEIA FILHO, O. C.. Design of RF CMOS Low Noise Amplifiers
Using a Current Based MOSFET Model. Proceedings of 17th Symposium on Integrated
Circuits and Systems Design. Porto de Galinhas. New York: ACM press, 2004. v. 1, p. 82-87.

PILLA JR., VALFREDO. Projeto de um amplificador de baixo ruído (LNA – Low noise
amplifier). Programa de pós-graduação em engenharia elétrica, Universidade Federal do Paraná.
Curitiba, Brasil, 2006.

44