UNIVERSIDADE FEDERAL DA PARAÍBA
CENTRO DE CIÊNCIAS EXATAS E DA NATUREZA
DEPARTAMENTO DE INFORMÁTICA
PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA
ANDRÉ RICARDO CIRAULO DE SOUZA
DESENVOLVIMENTO E IMPLEMENTAÇÃO EM FPGA DE UM
SISTEMA PORTÁTIL PARA AQUISIÇÃO E COMPRESSÃO SEM
PERDAS DE ELETROCARDIOGRAMAS
João Pessoa,
ABRIL 2008
UNIVESIDADE FEDERAL DA PARAÍBA
CENTRO DE CIÊNCIAS EXATAS E DA NATUREZA
DEPARTAMENTO DE INFOMÁTICA
PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA
DISSERTAÇÃO DE MESTRADO
DESENVOLVIMENTO E IMPLEMENTAÇÃO EM FPGA DE UM
SISTEMA PORTÁTIL PARA AQUISIÇÃO E COMPRESSÃO SEM
PERDAS DE ELETROCARDIOGRAMAS
ANDRÉ RICARDO CIRAULO DE SOUZA
ORIENTADORES
JOSÉ ANTÔNIO GOMES DE LIMA
LEONARDO VIDAL BATISTA
JOÃO PESSOA
ABRIL 2008
II
UNIVESIDADE FEDERAL DA PARAÍBA
CENTRO DE CIÊNCIAS EXATAS E DA NATUREZA
DEPARTAMENTO DE INFOMÁTICA
PROGRAMA DE PÓS-GRADUAÇÃO EM INFORMÁTICA
DESENVOLVIMENTO E IMPLEMENTAÇÃO EM FPGA DE UM
SISTEMA PORTÁTIL PARA AQUISIÇÃO E COMPRESSÃO SEM
PERDAS DE ELETROCARDIOGRAMAS
ANDRÉ RICARDO CIRAULO DE SOUZA
ORIENTADORES
JOSÉ ANTÔNIO GOMES DE LIMA
LEONARDO VIDAL BATISTA
Dissertação
de
Mestrado
apresentada
ao
Programa de Pós-Graduação em Informática, da
Universidade Federal da Paraíba, como parte dos
requisitos para a obtenção do título de Mestre em
Informática.
Área de concentração: Ciências da Computação.
Linha de pesquisa: Processamento de Sinais e Sistemas Gráficos.
JOÃO PESSOA
ABRIL 2008
III
ANDRÉ RICARDO CIRAULO DE SOUZA
DESENVOLVIMENTO E IMPLEMENTAÇÃO EM FPGA DE UM
SISTEMA PORTÁTIL PARA AQUISIÇÃO E COMPRESSÃO SEM
PERDAS DE ELETROCARDIOGRAMAS
Esta dissertação foi julgada adequada para a obtenção
do título de Mestre em Informática e aprovada em sua
forma final pelos Orientadores e pela Banca
Examinadora.
____________________________________
Prof. Dr. José Antônio Gomes de Lima UFPB.
Doutor pela Universidade Federal de Campina Grande – Campina Grande, Brasil.
____________________________________
Prof. Dr. Leonardo Vidal Batista, UFPB.
Doutor pela Universidade Federal de Campina Grande – Campina Grande, Brasil.
Banca Examinadora:
Prof. Dr. Lucídio dos Anjos Formiga Cabral, UFPB.
Doutor pela Universidade Federal do Rio de Janeiro - Rio de Janeiro, Brasil.
Prof. Dr. Antonio Carlos Cavalcanti, UFPB.
Pós-Doutor pela Universidade Técnica de Lisboa - Lisboa, Portugal.
Prof. Dr. Elmar Uwe Kurt Melcher, UFCG.
Doutor pela Ecole Nationale Superieure des Telecommunications - Paris, França
Coordenadora do PPGI: _______________________________
PROFª.DRª. Valéria Gonçalves Soares
João Pessoa, Março 2008.
IV
FICHA CATALOGRÁFICA ELABORADA PELA BIBLIOTECA CENTRAL DA UFPB
S555d
2008
Souza, André Ricardo Ciraulo de
Desenvolvimento e implementação em FPGA de um sistema portátil para
aquisição e compressão sem perdas de Eletrocardiogramas/ André Ricardo
Ciraulo de Souza. – João Pessoa, 2008.
100fs.:il.
Referências.
Dissertação (Mestrado em Informática) – Universidade Federal da
Paraíba, Centro de Ciências Exatas e da Natureza, Departamento de
Informática, Programa de Pós-Graduação em Informática.
Orientadores: José Antônio Gomes de Lima e Leonardo Vidal Batista.
1 – Processamento de Sinais 2 – Processamento Digital 3 - IP Core 4 –
Prototipação 5 – FPGA 6 – VHDL 7 – Compressão sem perdas I – Título
CDU XXX.XXX-X
V
“Ainda que eu tenha o dom de profetizar e
conheça todos os mistérios e toda a ciência; ainda que
eu tenha tamanha fé ao ponto de transportar montes,
se não tiver Amor, nada serei.”
1 CORÍNTIOS, 13
VI
“E ali logo em frente, a esperar pela gente, o futuro está.
E o futuro é uma astronave que tentamos pilotar,
Não tem tempo nem piedade, nem tem hora de chegar.
Sem pedir licença muda nossa vida, depois convida a rir ou chorar.
Nessa estrada não nos cabe conhecer ou ver o que virá.
O fim dela ninguém sabe bem ao certo onde vai dar.
Vamos todos numa linda passarela
De uma aquarela que um dia, enfim, descolorirá.”
TOQUINHO - VINICIUS DE MORAES - M. FABRIZIO - G. MORRA
VII
DEDICATÓRIA
Dedico este estudo à minha família, em especial, à minha mãe Anamaria C. Ciraulo pelo
apoio irrestrito em todos os momentos, alguns difíceis, iluminando-me nos caminhos
enevoados com bastante dedicação, afeto, amor e luta para propiciar a vida e ensinar a vivê-la
com dignidade.
Dedico ainda este trabalho a memória da minha avó materna Maria José Cavalcanti Ciraulo,
referência primeira na formação dos meus princípios basilares éticos e morais, indispensáveis
na minha formação social e acadêmica.
De igual sorte ao meu Padrinho e amigo, Rivaldo, responsável por ajudar na minha formação
inicial, incentivando e contribuindo em momentos de difíceis de outrora.
Aos meus amigos verdadeiros, alguns de infância e outros colhidos no decorrer da vida, pelo
apoio e incentivo dispensado ao longo de nossa caminhada.
Por fim, não menos importante, à minha namorada Cibele P. Moura pela compreensão e apoio
nos momentos de ausentes durante a realização deste trabalho e principalmente pelo amor e
incentivo.
A habitual tendência de tentar encontrar uma forma verbal para exprimir minha gratidão,
agradecimento e carinho por todos aqui citados, revela minha impossibilidade de traduzir uma
emoção em palavras.
VIII
AGRADECIMENTOS
Agradeço inicialmente a Deus, por ter me concedido em essência a capacidade física e mental
para a realização deste trabalho de pós-graduação.
Agradeço ao meu orientador José Antônio Gomes de Lima por acreditar no meu trabalho e
conduzir-me na direção correta, dando a liberdade necessária para dividir expectativas e
questionamentos, a maiores reflexões e enriquecimento da pesquisa. Agradeço pela paciência
de ler e entender as idéias apresentadas. Minha especial admiração e gratidão.
Ao meu orientador Leonardo Vidal Batista, um agradecimento especial pela serenidade,
empenho e admirável paciência dispensados na orientação do meu primeiro artigo publicado;
bem como, pela oportunidade e acolhida no trabalho de pesquisa desenvolvido ao longo de
dois anos.
Ao Professor Antônio Carlos que ministrou a disciplina Arquitetura de Computadores e
contribuiu de maneira significativa para a realização desta etapa acadêmica Agradeço pelas
aulas, por todos os conselhos e conversas, e por toda ajuda concedida em momentos cruciais,
inclusive apontando novos caminhos profissionais.
Ao Professor Lucídio dos Anjos Formiga por ter me apresentado á área de Complexidade de
Algoritmos e Teoria da computação e por toda paciência dispensada durante todo o processo
de meu estudo, principalmente pela sabedoria argumentativa empregada nas explanações de
idéias e pontos de vista o que me fez aprender bastante.
IX
À Coordenação do PPGI, Programa de Pós Graduação em Informática, pela presteza e
dedicação para o funcionamento do curso visando à qualidade do ensino. À Professora
Valéria pelo grau de compromisso e ajuda dispensada, meus agradecimentos.
Agradeço aos Professores Hamilton e Luiz Carlos, bem como a todos os professores que
participaram desta caminhada, sempre solícitos, até mesmo fora do horário do curso, sempre
dispostos a ajudar e formar novas idéias. Meus sinceros agradecimentos.
Aos meus queridos colegas e amigos do Mestrado pelos momentos de convívio, riso, estudos,
troca de idéias e experiências nas listas do Professor Lucídio e nos trabalhos do Professor
Antônio Carlos. Quero agradecer a Fernando Lordão pelos esclarecimentos e amizade; assim
também como aos companheiros de jornada, Christhiny Sanson, Fabrizia Medeiros, André
Marinho, Carlos Alberto, Maria das Graças; aos amigos do LASID Eduardo Serafim,
Eudisley Gomes, Gustavo Viana, Guilherme, Yuri, dentre outros pelo apoio, amizade, o
prazer em ajudar e também pelos momentos de descontração e alegria que passamos juntos.
Agradeço a todos os funcionários do DI/PPGI que direta ou indiretamente contribuíram para
este trabalho.
Ao CNPq pelo apoio financeiro.
E a todos os que de alguma forma vibraram positivamente para a realização desse trabalho.
X
RESUMO
Com a popularização do computador o uso de eletrocardiogramas tornou-se uma importante
ferramenta, e a mais utilizada no diagnóstico das doenças cardíacas. Aliado a isso, a
computação reconfigurável vem crescendo devido ao avanço dos dispositivos reprogramáveis.
Nesse contexto, o sistema proposto na presente Dissertação de Mestrado “Desenvolvimento e
Implementação em FPGA de um Sistema Portátil para Aquisição e Compressão Sem Perdas
de Eletrocardiogramas” é composto por um conversor analógico digital (ADC) de doze bits
com oito entradas analógicas multiplexadas e saída de dados para porta USB, controlado por
circuitos desenvolvidos especialmente para este fim, utilizando ambientes de projeto auxiliado
por computador EDAs (Electronic Design Automation) para circuitos integrados FPGA (Field
Programmable Gate Array). Como a Dissertação contempla o uso em dispositivos portáteis,
foi desenvolvido um compressor em tempo real utilizando o Prediction by Partial Matching
(PPM) modificado para o alfabeto binário com um codificador aritmético, aplicando o código
Gray e separando em plano de bits. Este compressor foi modelado usando a linguagem de
descrição de hardware VHDL (VHSIC Hardware Description Language) e após as
simulações necessárias, incorporado ao controlador do conversor de forma a se obter o menor
número possível de circuitos integrados componentes do sistema, bem como sua possível
reutilização em projetos futuros.
XI
ABSTRACT
With computer popularization, the electrocardiograms has become an important tool and the
most used in heart diseases diagnosis. Additionally, the reconfigurable computing is growing
because of the advancement of reprogrammable devices. In this context, the
system,
proposed in this master dissertation: "Development and Implementation of an FPGA in
Portable System for Acquisition and Compression Lossless of Electrocardiograms", is
composed by a twelve bit analog digital converter (ADC) with eight multiplexed analogical
inputs and an USB output port, controlled by a circuit especially developed for this purpose,
using computer design environment, well-known as EDAs (Electronic Design Automation)
for integrated FPGA (Field Programmable Gate Array) circuits. As dissertation contemplates
portable devices uses, was developed a real time compressor using Prediction by Partial
Matching (PPM) modified binary alphabet with arithmetic encoder, Gray code and separating
in bit plans. The developed compressor was modeled using hardware description language
VHDL (VHSIC Hardware Description Language). After the simulations, the compressor was
added to ADC controller , configuring a complete system with a smaller number of integrated
circuits components, allowing possible reuse in future projects.
.Keywords: Eletrocardiogram. FPGA. Signal Processing. PPM. Lossless compression.
Data compression.
XII
SUMÁRIO
DEDICATÓRIA
VIII
AGRADECIMENTOS
IX
RESUMO
XI
ABSTRACT
XII
SUMÁRIO
XIII
ÍNDICE DE FIGURAS
XVI
ÍNDICE DE TABELAS
XVIII
LISTA DE ABREVIATURAS E SIGLAS
XX
CAPÍTULO I
1
1
1
INTRODUÇÃO
1.1
Motivação
3
1.2
Objetivos
4
1.3
Organização do Trabalho
4
CAPÍTULO 2
6
2
6
REVISÃO LITERÁRIA
2.1
O Eletrocardiograma
6
2.1.1
História .........................................................................................................6
2.1.2
Noções de Eletro-fisiologia ..............................................................................7
2.1.3
Derivações ....................................................................................................9
2.1.4
2.1.5
Plano Frontal – Derivações Clássicas dos Membros .......................................... 10
Derivação I ................................................................................................. 10
2.1.6
2.1.7
Derivação I I ............................................................................................... 10
Derivação I I I ............................................................................................. 10
2.1.8
2.1.9
Plano Frontal – Derivações Unipolares Aumentadas dos Membros...................... 11
Plano Horizontal – Derivações Precordiais ....................................................... 12
2.1.10
Morfologia de um sinal de ECG normal........................................................ 13
XIII
2.2
Processamento Digital de Sinais
15
2.2.1 Amostragem................................................................................................ 15
2.2.2
2.3
Quantização ................................................................................................ 16
Sistemas embutidos
18
2.3.1
IP core........................................................................................................ 19
2.3.2
Sistemas Integrados em um único chip........................................................... 19
2.3.3
Arquitetura Dedicada.................................................................................... 20
2.3.4
Um modelo de desenvolvimento .................................................................... 21
2.4
Computação Reconfigurável
2.4.1
26
Dispositivos Lógicos Programáveis ................................................................. 26
2.4.1.1
2.4.1.2
2.4.2
Arranjo Lógico Programável....................................................................... 27
Arranjos de Portas Programáveis................................................................ 28
VHDL - VHSIC Hardware Description Language ............................................... 32
2.4.2.1
História ................................................................................................... 32
2.4.2.2
Definição................................................................................................. 33
2.4.2.3
2.4.2.4
Vantagens e desvantagens ........................................................................ 33
Fluxo de projeto bem definido em VHDL ..................................................... 34
2.5
Compressão de Dados
36
2.5.1 Informação e Entropia ..................................................................................37
2.5.2
Modelagem ................................................................................................. 38
2.5.3
Modelagem Estatística ..................................................................................38
2.5.4
Codificação da Entropia ................................................................................ 40
2.5.5
Codificação de Huffman ................................................................................ 40
2.5.6
Codificação de Golomb ................................................................................. 44
2.5.7
LZW e LZ78................................................................................................. 45
2.5.8
Codificação aritmética...................................................................................46
2.5.9
PPM............................................................................................................ 53
2.6
Barramento USB
55
2.7
Trabalhos Relacionados
56
CAPÍTULO 3
58
3
58
SISTEMA PROPOSTO
3.1
Modelo de referência implementado em JAVA
58
3.2
Estudo comparativo preliminar
58
3.3
Descrição do Sistema
61
3.4
Ferramental utilizado
63
3.5
Aplicação desenvolvida
64
3.6
Protótipo do Conversor A/D
65
3.6.1
Interface USB .............................................................................................. 67
3.6.2
Micro-controlador......................................................................................... 70
3.6.3
Conversor A/D ............................................................................................. 71
3.7
Compressor
72
3.7.1 Módulos do compressor ................................................................................ 76
3.7.1.1
Code Gray ............................................................................................... 76
XIV
3.7.1.2
3.7.1.3
Segmentação em plano de bits .................................................................. 77
PPM Binário ............................................................................................. 77
3.7.1.4
Codificador Aritmético............................................................................... 78
3.7.2
Implementação do compressor ...................................................................... 79
CAPÍTULO 4
81
4
81
RESULTADOS OBTIDOS
4.1
Protótipo Conversor AD e o Aplicativo LASID-USB
81
4.2
Validação dos Módulos do compressor
84
4.2.1
Validação do PPM......................................................................................... 86
4.2.2
Validação do Codificador Aritmético................................................................ 88
4.2.3
Validação do Compressor com um modelo PPM ............................................... 90
4.3
Síntese
92
CAPÍTULO 5
100
5
CONCLUSÃO
100
6
REFERÊNCIAS
103
7
GLOSSÁRIO
108
APÊNDICE A - TESTBENCH DO PPM BINÁRIO
110
APÊNDICE B - TESTBENCH DO CODIFICADOR ARITMÉTICO
114
APÊNDICE C - TESTBENCH COMPRESSOR PPM BINÁRIO E CÓD.ARITMÉTICO
156
XV
ÍNDICE DE FIGURAS
1.1 – Tela de abertura do BioMed. Fonte [31]. ....................................................... 3
2.1 – Fibra miocárdica. Fonte[35].......................................................................... 8
2.2 – Fibra cardíaca ativa e em repouso................................................................. 8
2.3 – Processo de despolarização e repolarização.................................................... 9
2.4 – Dipolo........................................................................................................ 9
2.5 – Derivações eletrocardiográficas clássicas. Fonte[35]..................................... 11
2.6 – Derivações Precordiais ............................................................................... 12
2.7 – Morfologia de um ciclo típico de um sinal de ECG.......................................... 13
2.8 – Processo de conversão AD. ........................................................................ 15
2.9 – Amostragem de um sinal analógico. ............................................................ 16
2.10 – Quantização do sinal................................................................................ 17
2.11 – Modelo de IP Business. Fonte [52]. ........................................................... 20
2.12 – Ciclo de desenvolvimento. ........................................................................ 21
2.13 – Procedimento de teste – caso geral. Adaptada da fonte [17]. ....................... 24
2.14 – Dispositivos Lógicos Programáveis............................................................. 27
2.15 – Arquitetura Interna de uma PLA. Fonte[56]. ............................................... 28
2.16 – CPLD. .................................................................................................... 29
2.17 – Arquitetura Interna de um FPGA. Fonte[50]. .............................................. 30
2.18 – Ciclo de vida VHDL. Fonte [57]. ................................................................ 34
2.19 – Formação da árvore de Huffman, passos 1-3.............................................. 42
2.20 - Formação da árvore de Huffman, passos 4-6. ............................................. 43
2.21 - Passo1 exemplo da codificação aritmética. Fonte[62]................................... 48
2.22 – Passo 2 exemplo da codificação aritmética. Fonte[62]. ................................ 48
2.23 – Passo 3 exemplo da codificação aritmética. Fonte[62]. ................................ 48
2.24 – Final do processo de codificação. Fonte[62]. .............................................. 49
2.25– Intervalo - HALF PART. ............................................................................. 50
2.26 – Exemplo de half point zooming. Fonte [67]. ............................................... 50
2.27 – Exemplo de quarter-point zooming.. Fonte [67]. ......................................... 51
2.28 – Subdivisão interna do intervalo no QM-coder. Fonte [67]. ............................ 52
XVI
2.29 – Codificador Aritmetico X QM-coder. Fonte[67]. ........................................... 53
3.1 – ECG 215 – primeiro canal – do MIT-BIH. ..................................................... 59
3.2 – Gráfico da compressão percentual média. .................................................... 60
3.3 – Arquiterura do Projeto. .............................................................................. 64
3.4 – Software de controle – Conversor LASID USB 12Bits. .................................... 64
3.5 – Protótipo Conversor AD sem o módulo compressor. ...................................... 66
3.6 - DLP-USB245M.
Fonte [68]. ...................................................................... 67
3.7 – FT245BM. Fonte[68].................................................................................. 67
3.8 - Ciclo de escrita do DLP-USB245M Fonte[69]. ................................................ 68
3.9 - Ciclo de leitura do DLP-USB245M. Fonte[69]................................................. 69
3.10 - Descrição em VHDL do Protótipo do Conversor AD. ..................................... 70
3.11 - Conversor AD574A. .................................................................................. 71
3.12 - Estrutura da memória............................................................................... 72
3.13 - Decomposição em planos de bits. .............................................................. 74
3.14 - Diagrama em blocos do compressor proposto ............................................. 74
3.15 – Diagrama em blocos expandido do compressor........................................... 75
3.16 – Code Gray para 4 bits. ............................................................................. 77
3.17 – PPM binário ............................................................................................ 78
3.18 – Codificador Aritmético.............................................................................. 78
3.19 – Compressor PPM binário com um modelo................................................... 79
4.1 - EPM 7128SLC84-7 ..................................................................................... 82
4.2 – Protótipo Conversor AD. ............................................................................ 82
4.3 – Exemplo dos arquivos gerados.................................................................... 83
4.4 – Verificação de aquisição de sinal senoidal. ................................................... 84
4.5 – Estímulos no modelo alto e baixo nível. ....................................................... 85
4.6 – Testbench do módulo PPM. ........................................................................ 86
4.7 – Forma de onda do PPM gerada no testbench................................................ 87
4.8 – Testbench do codificador Aritimético. .......................................................... 88
4.9 - Forma de onda do codificador aritmético gerada no testbench. ...................... 89
4.10 - Testbench do compressor PPM binário com um modelo................................ 90
4.11 - Forma de onda do compressor PPM Binário gerada no testbench. ................. 91
XVII
ÍNDICE DE TABELAS
2.1 – Classificação de IP cores. Fonte [51]. .......................................................... 19
2.2 – Freqüências indicadas. Fonte[60]................................................................ 41
2.3 – Exemplos de códigos Golomb e Golomb Rice, m=1 até 5............................... 45
2.4 - Modelo PPM após processamento da string abracadabra. Fonte[61]. ............... 54
3.1 – Código Gray. ............................................................................................ 73
3.2 – Código Gray para 4 bits. ............................................................................ 77
4.1 – Síntese Conversor AD. ............................................................................... 92
4.2 – Síntese do módulo PPM. ............................................................................ 95
4.3 – Síntese do módulo Codificador Aritmético. ................................................... 96
4.4 – Síntese do módulo compressor com um modelo PPM. ................................... 97
4.5 – Síntese do Compressor com 12 modelos. ..................................................... 98
4.6 – Síntese do compressor com 12 modelos mais o conversor AD. ....................... 99
XVIII
ÍNDICE DE EQUAÇÕES
1.1.... .............................................................................................................. 11
2.1.... .............................................................................................................. 16
2.2.... .............................................................................................................. 36
2.3.... .............................................................................................................. 37
2.4.... .............................................................................................................. 37
2.5.... .............................................................................................................. 37
2.6.... .............................................................................................................. 38
2.7.... .............................................................................................................. 45
3.1.... .............................................................................................................. 72
3.2.... .............................................................................................................. 77
XIX
LISTA DE ABREVIATURAS E SIGLAS
A/D
ADC
ALU
API
CLB
CPLD
D/A
DSP
DUV
DVD
ECG
ECGs
FIFO
FPGA
GPP
HDL
HLA
IOB
IP Core
MIT-BIH
NoC
OCP-IP
PC
PDA
PDSV
PPM
RAM
ROM
RTL
RTOS
SoC
SRAM
TCL
VHDL
VHSIC
USB
Analógico/Digital
Conversor Analógico/Digital
Aritmetic Logic Unit
Application Programming Interface
Configurable Logic Block
Complex Programmable Logic Device
Digital/Analógico
Digital Signal Processor
Design Under Verification
Digital Versatile Disc
Eletrocardiograma
Eletrocardiogramas
First In First Out
Field-Programmable Gate Array
General Purpose Processor
Hardware Description Language
High Level Architecture
Input Output Block
Intellectual Property Core
Massachussetts Institute of Technology – Beth Israel Hospital (Instituto de
Tecnologia de Massachussets – Hospital Israelita Beth)
Network-on-chip
Open Core Protocol – International Partnership
Personal Computer
Personal Digital Assistant
Processamento Digital de Sinais de Voz
Prediction by Partial Matching
Random Access Memory
Read Only Memory
Register Transfer Level
Real Time Operation System
System-On-Chip
Static Random Access Memory
Tool Command Language
VHSIC Hardware Description Language
Very High Speed Integrated Circuits
Universal Serial Bus
XX
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CAPÍTULO I
1 Introdução
O eletrocardiograma (ECG) é um dos sinais fisiológicos mais usados para diagnóstico e
monitorização. Após a coleta do sinal, pode ser desejável armazenar os registros para posterior
comparação e avaliação ou transmiti-los por enlaces de dados para avaliação remota [1].
A conversão dos dados para o formato digital traz uma série de vantagens. Womble et al. [2]
relata a necessidade de conversão dos registros da Biblioteca Eletrocardiográfica Central da
USAFSAM (United States Air Force School of Aerospace Medicine) para o formato digital, com
vistas a automatizar a obtenção de parte das medidas extraídas dos traçados pelos cardiologistas,
tornar os dados mais facilmente acessíveis, e reduzir os problemas causados por ruídos na
transmissão rotineira de ECGs através de linhas telefônicas, na forma de sinais de FM.
Os sistemas de registros computadorizados de sinais biológicos costumam gerar elevadas
quantidades de dados, impondo dificuldades para o armazenamento ou transmissão dos
resultados. Um eletrocardiógrafo digital de 12 derivações, operando com valores de 12 bits e taxa
de amostragem de 500 Hz, produz mais de 30 Mbytes por hora.
Quanto maior a quantidade de dados gerada, maiores os custos com armazenamento e
transmissão. Os aparelhos de Holters devem apresentar dimensões reduzidas e baixo consumo de
energia, para que possam ser transportados pelos pacientes [3].
Todos estes fatos mostram a importância de utilizar algum método de compressão de dados que
mantenha as características essenciais do registro original. Antoniol e Tonella [3] relatam que
1
Dissertação de Mestrado– LASID - PPGI/DI UFPB
determinadas técnicas de compressão permitiram o desenvolvimento de um sistema de tele
medicina capaz de transmitir sinais de ECG em tempo real, da residência do paciente para o
hospital, através de linhas telefônicas.
Um esquema de compressão sem perdas permite a reconstrução perfeita do sinal original a partir
do sinal comprimido, devendo ser aplicado quando qualquer alteração nos dados originais é
inaceitável. Na compressão sem perdas, portanto, o sinal é integralmente preservado, procurandose unicamente reduzir a redundância na representação dos dados. Qualquer método de
compressão de ECG deve procurar preservar a informação clínica relevante para não conduzir a
diagnósticos errôneos.
Muitos métodos de compressão de ECG foram desenvolvidos nos últimos 35 anos, com razões de
compressão (RC) variando de aproximadamente 2:1 a 50:1 [4, 5, 6]. Bilgin et al. [74] afirmam
que para imagens radiológicas tem sido largamente preferida o uso de compressão sem perdas em
sinais de ECG e uma das razões seria temor de que as perdas possam conduzir a diagnósticos
errôneos. Entretanto é surpreendentemente baixo o número de artigos que tratam sobre
compressão sem perdas de ECG.
Koski [7] apresenta um dos poucos resultados de testes sistemáticos e consistentes envolvendo
compressão sem perdas de ECG. Koski afirma que a freqüência de amostragem e a resolução das
amostras são os fatores que mais influenciam a razão de compressão sem perdas. Comparações
precisas entre técnicas diferentes devem necessariamente ser efetuadas sobre um mesmo corpo de
sinais de teste. Contudo, os resultados de Koski foram obtidos com registros colhidos em um
laboratório local, que não podem ser facilmente acessados por outros pesquisadores, o que
dificulta uma comparação justa com outros métodos. Para minimizar esse tipo de problema,
Jalaleddine [5] sugere a utilização de bancos padrões de ECG, disponíveis aos pesquisadores de
todo o mundo, como o MIT-BIH Arrhythmia Database [8], certamente o mais empregado nos
testes de compressores de ECG divulgados na literatura.
Batista et al. [9] investigaram métodos de compressão sem perdas de sinais de eletrocardiograma
(ECG) que utilizavam, na etapa de descorrelação diversos preditores e transformadas wavelet e
na etapa de codificação, os algoritmos de Huffman, Golomb, LZ78 e LZW. Sua avaliação
experimental foi feita usando todo o banco padrão de ECGs MIT-BIH Arrhythmia Database,
2
Dissertação de Mestrado– LASID - PPGI/DI UFPB
onde o melhor método avaliado nomeado no trabalho de P2 + Huffman, atingiu uma razão de
compressão (RC) média de 2,69:1 e o segundo melhor 2,65:1, comparável à RC de alguns
compressores com perdas de sinais de ECG.
Para atender a motivação apresentada na secção 1.1, foi desenvolvido no LASID um sistema de
aquisição analógico-digital (ADC), via barramento USB, que graças a técnicas de SoC’s foi
possível obter um dispositivo com tamanho reduzido. Uma vez testada suas funcionalidades,
surgiu possibilidade de acoplar a esse dispositivo um módulo de compressão de dados e assim
através de técnicas de SoC’s e IP core, obter um dispositivo portátil (Holter). Estudos
desenvolvidos para a publicação do artigo “Compressão Contextual sem Perdas de
Eletrocardiogramas utilizando Recursos Reduzidos de Memória” [14] permitiram obter um
compressor PPM binário possível de se implementar em hardware.
1.1
Motivação
O sistema de aquisição de sinais biológicos BioMed, utilizado por médicos e fisioterapeutas, e
desenvolvido no Laboratório de Processamento de Sinais Biológicos e Instrumentação Biomédica
do NETEB / UFPB possuía como plataforma de hardware uma placa de conversão A/D baseada
no barramento ISA e como plataforma de software o Delphi 1.0, rodando em Windows 98. As
funcionalidades e rotinas implementadas no BioMed, apresentado na Figura 1.1, bastante
complexas, motivaram a necessidade de atualização da plataforma de hardware e software do
sistema.
1.1 – Tela de abertura do BioMed. Fonte [31].
3
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Motivaram também a automatização da obtenção de medidas extraídas dos traçados de ECG; a
diminuição das elevadas quantidades de dados gerados pelos registros computadorizados de
sinais biológicos; a diminuição dos custos com armazenamento e transmissão e a mobilidade
necessária para ser transportado pelos pacientes;
1.2
Objetivos
O presente trabalho propõe um sistema completo com aquisição analógico-digital (ADC) e
transmissão de dados obtidos através do barramento USB para dispositivos portáteis, usando
método de compressão sem perdas, baseado em uma versão binária do algoritmo Prediction by
Partial Matching (PPM), para sinais de ECG. O método apresenta reduzida complexidade
computacional visando sua implementação em hardware através de modelagem com linguagem
de descrição de hardware, utilizando o paradigma de desenvolvimento em FPGA, para aplicações
em equipamentos portáteis.
Como objetivos específicos, têm-se:
•
Especificação de uma arquitetura de hardware para aquisição e compressão de
eletrocardiogramas para dispositivos portáteis;
•
Definição dos blocos lógicos a serem implementados para o compressor PPM
binário em hardware;
•
Refinamento da arquitetura proposta para atender restrições de memória dos
dispositivos portáteis;
•
Implementação de protótipos que contemplem a arquitetura ou parte dela a fim de
demonstrar sua exeqüibilidade.
1.3
Organização do Trabalho
O trabalho está dividido em cinco capítulos. O Capítulo 2 apresenta uma revisão literária
acerca dos assuntos e conceitos que de algum modo foram utilizados no documento, como
Eletrocardiograma, Processamento Digital de Sinais, Sistemas Embutidos, Computação
Reconfigurável e Compressão de Dados, Barramento USB e por fim alguns trabalhos
relacionados. No Capítulo 3, é apresentado o sistema proposto. Inicialmente é apresentado o
4
Dissertação de Mestrado– LASID - PPGI/DI UFPB
modelo de referência em alto nível para o compressor em baixo nível e o estudo que
culminou na configuração do compressor utilizado. É feita ainda a descrição do sistema,
dividido na aplicação (software), ADC e compressor PPM binário.
O Capítulo 4 apresenta os resultados obtidos em cada uma das fases do projeto. Começando
pelo Protótipo do ADC e o Aplicativo denominado LASID-USB. Em seguida, é abordada a
validação dos módulos do compressor: PPM binário, Codificador Aritmético e um
compressor contendo um modelo PPM binário e o Codificador Aritmético. Finalmente uma
comparação da síntese de cada parte do projeto em diversos dispositivos de algumas das
famílias de componentes mais importantes da Altera. O Capítulo 5 é responsável por
apresentar as considerações finais, uma breve discussão sobre trabalhos futuros e por fim a
conclusão do presente trabalho.
5
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CAPÍTULO 2
2 Revisão Literária
2.1
O Eletrocardiograma
Não há dúvida a respeito da importância do ECG como uma técnica que tem contribuído para
entender e tratar os mais diversos tipos de doenças cardíacas. A eletrocardiografia permanece
como o principal método direto para avaliar as alterações de ritmo cardíaco. Além disso, o ECG é
essencial no manejo de anormalidades metabólicas e no acompanhamento do efeito e toxicidade
de drogas (por ex: digital, antidepressivos tricíclicos e antiarrítmicos) [32].
Denomina-se eletrocardiograma de superfície (ECG) o registro dos sinais elétricos de origem
cardíaca captados em pontos particulares da superfície do corpo humano (derivações). O ECG é
um método, não invasivo, de simples realização, seguro, reproduzível, podendo ser usado em
grandes estudos devido ao seu baixo custo, o que permite sua utilização para análises e
diagnósticos de anomalias cardíacas [32].
2.1.1
História
O eletrocardiógrafo, que permitiu registrar a atividade elétrica do coração, pode ser considerado
como um dos maiores avanços da história da cardiologia [36]. Einthoven, seu inventor,
considerado o pai da eletrocardiografia era médico fisiologista, professor na Universidade de
Leiden (1886-1927), e ganhou o Prêmio Nobel de Fisiologia ou Medicina (1924)[38];
Os primeiros estudos sobre fisiologia cardíaca datam do início do século XVII por William
Harvey, mas só em 1887 Augustus Waller registrou pela primeira vez o potencial elétrico
cardíaco a partir da superfície corpórea, sendo o primeiro a usar o termo eletrocardiograma. A
6
Dissertação de Mestrado– LASID - PPGI/DI UFPB
partir daí, outros estudiosos como Eithoven e Nürr desenvolveram novos aparelhos para registro
da atividade elétrica cardíaca e conceitos na eletrocardiografia, passando a ser utilizada como
auxílio no diagnóstico [39].
Em 1842, Carlo Matteucci, físico italiano, demonstra que cada batimento cardíaco é
acompanhado de uma corrente elétrica. Anos depois (1887), Augustus Waller, um fisiologista
inglês, publica o primeiro eletrocardiograma de uma derivação em um homem, utilizando o
eletrômetro fotográfico desenvolvido por Lippmann[37] em 1872.
Willeim Einthoven em 1895, distingue as ondas do coração e introduz a nomenclatura P,Q,R,S e
T. Einthoven dedica-se ao estudo do galvanômetro de bobina criado por Clement Ader em 1897,
engenheiro francês, para uso em linhas telegráficas submarinas, sistema de amplificação de
registros, denominado "Galvanômetro de Corda".
Já em 1901, depois de modificar aparelho elaborado por Ader, Einthoven registra seu primeiro
eletrocardiograma e em 1912 descreve as derivações bipolares I, II e III, como os lados de um
triângulo eqüilátero que posteriormente foi chamado "Triângulo de Einthoven".
Frank Wilson em 1931 desenvolve o sistema de 6 derivações precordiais ligadas a um eletrodo
indiferente: o terminal central de Wilson, posteriormente simplificadas e integradas ao ECG por
Emanuel Goldberger. Em 1938 As Sociedades Americana e Britânica de Cardiologia definem o
posicionamento das derivações V1 a V6.
Emanuel Goldberger em 1942, acrescenta as derivações aVR, aVL, aVF e as três de Einthoven e
às 6 de Wilson, determinando o eletrocardiograma de 12 derivações utilizado até hoje [45].
2.1.2
Noções de Eletro-fisiologia
Quando a fibra miocárdica, Figura 2.1, está em repouso, polarizada, tem elevada concentração de
potássio e apresenta-se negativa em relação ao meio externo que tem elevada concentração de
sódio [40], ou seja, o estado de repouso da membrana de negatividade interna e positividade
externa [34].
7
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.1 – Fibra miocárdica. Fonte[35].
Quando a permeabilidade da membrana ao sódio aumenta subitamente, muitos dos íons de sódio
que estão presentes em alta concentração na face externa da fibra precipitam-se, levando cargas
positivas, para o interior, em número suficiente para produzir o desaparecimento total do
potencial de repouso normal negativo e, em geral, é transportado número suficiente de cargas
para a produção do estado de positividade no interior da fibra. Essa perda súbita do potencial
normal negativo denomina-se “despolarização”. O potencial positivo que se desenvolve
momentaneamente no interior da fibra é chamado “potencial de inversão” [34], apresentado na
Figura 2.2.
----------------
+++++++
+++++
----------------
despolarizada
repolarizada
(Ativa)
(repouso)
2.2 – Fibra cardíaca ativa e em repouso.
Durante o processo de “despolarização” [34], o potencial negativo normal do interior da fibra é
perdido e o potencial da membrana, na verdade, se inverte, isto é, torna-se ligeiramente positivo
dentro e negativo fora.
8
Dissertação de Mestrado– LASID - PPGI/DI UFPB
DESPOLARIZAÇÃO
REPOLARIZAÇÃO
-+++++++
----------------
+-----------
+++++++
+-----------
+++++++
-+++++++
-----------
(INÍCIO)
(FIM)
(INÍCIO)
(FIM)
2.3 – Processo de despolarização e repolarização.
No processo de despolarização e repolarização, (Figura 2.3) surge o dipolo que é quando uma
carga negativa e outra positiva são adjacentes. Com a estimulação da célula, a atividade elétrica
avança, sendo representada por um dipolo (- +) que se propaga ao longo da membrana celular e
forma um limite móvel entre a parte estimulada e a parte ainda em repouso. Podemos representar
o dipolo por um vetor que apresenta uma grandeza infinitamente pequena, uma direção e um
sentido, mostrado na Figura 2.4, que é dado pelo pólo positivo [41].
-
+
dipolo
-
+
vetor
2.4 – Dipolo.
Uma onda progressiva de despolarização pode ser considerada como uma onda móvel de cargas
positivas; deste modo, quando a onda positiva de despolarização mover-se em direção a um
eletrodo na pele (eletrodo positivo), é registrado no ECG uma deflexão positiva, por outro lado,
quando a onda estiver em sentido oposto, ou seja, quando a onda de despolarização se afasta do
eletrodo, tem-se uma deflexão negativa registrada no ECG [40]. O registro fica isoelétrico
quando não ocorre atividade elétrica.
2.1.3
Derivações
Durante o ciclo sístole-diástole (contração/relaxamento) podem ser registrados os potenciais
gerados pelo coração aplicando-se eletrodos em diferentes posições do corpo, onde é medida a
9
Dissertação de Mestrado– LASID - PPGI/DI UFPB
diferença de potencial elétrico entre dois pontos no campo elétrico gerado pelo dipolo elétrico
cardíaco ao longo do ciclo cardíaco.
Cada local destas ligações é padronizado e conhecido como uma derivação do eletrocardiograma,
ou seja, a atividade elétrica do coração é captada através da colocação de eletródios em
determinados pontos da superfície corporal. Os estudos do coração são feitos através de dois
planos elétricos principais: O Plano frontal e o Plano horizontal.
2.1.4
Plano Frontal – Derivações Clássicas dos Membros
As possibilidades de derivações na superfície do corpo são infinitas, surgindo daí a necessidade
de se estabelecer como convenção O Triângulo de Einthoven, que especifica três derivações
dispostas de modo a formar os lados de um triângulo eqüilátero com os vértices nos braços
direito, esquerdo e perna esquerda em que os lados são conhecidos como linhas de derivação.
2.1.5
Derivação I
É a primeira derivação bipolar, conhecida por Derivação 1 ou simplesmente D1. É a diferença de
potencial entre o braço esquerdo e o braço direito. O pólo positivo da Derivação 1 é o lado
esquerdo, conforme mostrado na Figura 2.5.
2.1.6
Derivação I I
A segunda derivação é conhecida como Derivação 2 ou D2, e mede a diferença de potencial entre
perna esquerda e braço direito. O Terminal negativo do eletrocardiógrafo é ligado ao braço
direito e o terminal positivo à perna esquerda. Portanto quando o braço direito é negativo em
relação à perna esquerda, o eletrocardiógrafo registra positividade[35], conforme mostrado na
Figura 2.5;
2.1.7
Derivação I I I
A terceira derivação ( Derivação 3 ou D3) mede a diferença de potencial entre perna esquerda e
o braço esquerdo, sendo o braço esquerdo ligado ao terminal negativo e a perna esquerda ao
terminal positivo, conforme mostrado na Figura 2.5.
10
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.5 – Derivações eletrocardiográficas clássicas. Fonte[35].
A lei de Einthoven estabelece simplesmente que se os potenciais elétricos de duas das três
derivações eletrocardiográficas clássicas são conhecidas em qualquer momento, o da terceira
pode ser determinado matematicamente pela simples soma dos dois primeiros.
D1 = D 2 + D3
1.1
A Equação 1.1 corresponde à lei das Tensões de Kirchhoff [43][44], onde, a qualquer instante em
um caminho fechado de um circuito, tanto em sentido horário quanto em sentido anti-horário, a
soma algébrica das quedas de tensão é igual à zero, ou seja, para qualquer malha fechada em
uma rede que seja percorrida em um único sentido, a soma algébrica das tensões presentes é
zero[42].
2.1.8
Plano Frontal – Derivações Unipolares Aumentadas dos Membros
Nas derivações unipolares dos membros o eletrodo relacionado com pólo positivo, dito eletrodo
explorador, é colocado sucessivamente no braço direito, no braço esquerdo e na perna esquerda.
Enquanto o eletrodo positivo está em um dos membros por vez, os outros dois membros são
11
Dissertação de Mestrado– LASID - PPGI/DI UFPB
ligados por meio de resistências elétricas ao terminal negativo do eletrocardiógrafo[34]. Deste
modo, registram-se os potenciais absolutos VR, VL e VF.
As correntes captadas com o sistema unipolar de Wilson apresentam-se com voltagem
relativamente pequena e, por esta razão, Goldberger propôs derivações unipolares aumentadas,
em que a amplitude das deflexões aumentava cerca de 50%, sendo chamadas de aVR, aVL e aVF
(a letra “a” refere-se a “aumentadas”).
Quando o terminal positivo está no braço direito, a derivação é conhecida como derivação aVR;
quando está no braço esquerdo, é conhecida como aVE; e, quando está na perna esquerda,
derivação aVF [34].
2.1.9
Plano Horizontal – Derivações Precordiais
O eletrodo negativo chamado de “eletródio indiferente” é normalmente ligado, através de
resistências, ao braço direito e esquerdo e à perna esquerda. Comumente seis derivações
precordiais diferentes são registradas com os eletródios sendo colocados nos seis pontos da
parede anterior do tórax [34] mostrados na Figura 2.6.
2.6 – Derivações Precordiais [34].
As derivações precordiais, posicionadas na face anterior do tórax são denominadas: V1: 4°
espaço intercostal direito (EID);V2: 4° espaço intercostal esquerdo (EIE).;V3: entre V2 e V4.;V4:
12
Dissertação de Mestrado– LASID - PPGI/DI UFPB
5° EIE na linha hemiclavicular.;V5: 5° EIE na linha axilar anterior.;V6: 5° EIE na linha axilar
média.
2.1.10
Morfologia de um sinal de ECG normal
O Eletrocardiograma é o registro da variação dos potenciais elétricos gerados pela atividade
cardíaca. O traçado de um ECG típico é formado por eventos claramente identificáveis: onda P;
complexo QRS; pelas ondas Q, R e S; e uma onda T. Há ainda uma onda U com significado
incerto e que pode refletir a repolarização da fibra de Purkinje; geralmente observada quando o
nível sérico de potássio do paciente é baixo.
A Figura 2.7 mostra os eventos de um ciclo típico de um ECG, onde suas características podem
ser claramente identificadas como a amplitude, segmentos, intervalos, ondas, duração e ritmo. A
seguir são fornecidas as principais partes constituintes de um ECG normal [47]:
Complexo
QRS
R
Segmento PQ
P
Onda T
Segmento ST
Onda P
Onda U
T
U
Q S
Intervalo
Intervalo QT
PQ ou PR
Intervalo QU
2.7 – Morfologia de um ciclo típico de um sinal de ECG.
13
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Onda P: despolarização dos átrios;
Complexo QRS: despolarização dos ventrículos;
Onda T: repolarização dos ventrículos;
Intervalo PQ ou PR: inicio da onda P, contração atrial, até o início do complexo QRS, contração
ventricular.
Onda Q: quando presente, ocorre no início do complexo QRS, de curta duração, é a primeira
deflexão negativa no ECG normal.
Onda S: deflexão negativa que ocorre no final do complexo QRS.
Intervalo QT: compreende a extensão do inicio do complexo QRS até o final da onda T.
Intervalo P-P ou ciclo PP: é o intervalo entre duas ondas P, ou seja, a freqüência atrial.
Intervalo R-R ou ciclo RR: é o intervalo entre duas ondas R, ou seja, a freqüência ventricular.
14
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.2
Processamento Digital de Sinais
O Processamento Digital de Sinais – PDS ou, em inglês, DSP (Digital Signal Processing)
consiste na análise ou modificação de sinais de forma a extrair informações dos mesmos e,
quando necessário, torná-los mais apropriados para alguma aplicação específica.
A origem do processamento de sinal está na engenharia elétrica, onde o termo sinal significa um
sinal elétrico conduzido por qualquer meio, (fio, onda de rádio, etc) e pode ser encarado como
uma sequência de valores que representam informação sobre o comportamento ou estado de
algum fenômeno.
Os sinais elétricos podem ser digitais ou analógicos. Enquanto os analógicos variam
continuamente no tempo ou espaço assumindo um número infinito de valores dentro de uma
faixa de valores, os digitais são caracterizados por assumirem valores finitos em um intervalo.
A maioria dos sinais encontrados na natureza são analógicos, o que requer a conversão de
analógico para digital, para processar por computador. O processo de digitalização pode ser visto
na Figura 2.8.
Sinal
Analógico
Amostragem
Sinal
Amostrado
Quantização
Sinal
Digital
2.8 – Processo de conversão A/D.
O sinal digital é obtido a partir de um sinal analógico que inicialmente é amostrado e depois
quantizado, ou seja, seus valores devem ser arredondados ou truncados obtendo-se assim um
sinal de tempo discreto que assume valores discretos dentro de um conjunto de possíveis valores.
2.2.1
Amostragem
O teorema da amostragem ou de Nyquist mostra que um sinal pode ser amostrado e recuperado
sem perda de informação se “A freqüência de amostragem for no mínimo o dobro da maior
freqüência contida no sinal”.
15
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Fam > 2F max
2.1
Para que a amostragem do sinal analógico seja feita corretamente é preciso que a freqüência de
amostragem escolhida Fam seja maior que duas vezes a maior componente de freqüência
presente no sinal analógico Fmax, ou seja, é necessário conhecer o sinal a ser amostrado.
Se Fam for adequadamente escolhida, todas as freqüências presentes no sinal analógico original
são representadas sem redundância no sinal digital permitindo sua reconstrução sem que haja
distorções, (Figura 2.9).
Instantes de amostragem
Sinal
analógico
Sinal
amostrado
Amostragem
2.9 – Amostragem de um sinal analógico.
2.2.2
Quantização
Uma vez o sinal devidamente amostrado, podemos realizar o processo de quantização, que é o
processo de atribuição de valores discretos para um sinal cuja amplitude assume valores no
conjunto dos reais, ou seja, discretizar a amplitude do sinal, Figura 2.10. O processo de
quantização é caracterizado por aproximar cada saída do amostrador para um valor discreto,
definido por certo número N de bits
16
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.10 – Quantização do sinal.
Após a quantização, cada amostra quantizada é representada por uma palavra de código. Evidente
que quanto maior for à quantidade de bits para a quantização, melhor será a qualidade do sinal,
contudo é importante ponderar que o referido aumento é diretamente ligado ao tamanho dos
arquivos e assim, maior será o custo computacional para manipular e operar tais informações.
17
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.3
Sistemas embutidos
A transformação mundial vivenciada atualmente no setor de tecnologia acarretou uma crescente
demanda na produção de hardware e software para sistemas embarcados, exigindo assim, que o
tempo de projeto seja cada vez mais curto na cadeia de produção de circuito integrado, que
engloba geralmente as seguintes etapas: projeto, fabricação da pastilha (a qual utiliza processos
físico-químicos cada vez mais sofisticados), encapsulamento e testes.
O sistema embutido é implementado para realizar uma tarefa bem definida dentro de um outro
sistema maior. Diante disso, surge o conceito de sistema embutido (embarcado), que é a
combinação de hardware e software, e algumas vezes peças mecânicas, desenvolvidos para
realizar uma função específica [48], ou seja, colocar capacidade computacional dentro de um
circuito integrado, equipamento ou sistema.
Devido à diversidade das aplicações em hardware de sistemas embutidos, a terminologia dos
sistemas embutidos não é muito consistente. A definição mais antiga, diz que um sistema
embarcado é um sistema microprocessado no qual o computador é completamente encapsulado
ou dedicado ao dispositivo ou sistema que ele controla.
Cada vez mais, esses componentes e seus programas são embutidos em produtos para os
tornarem mais “inteligentes” como elevadores, carros (motores, suspensão), termostatos,
instrumentos médicos, científicos, de telecomunicações, dentre outros.
O projeto de um sistema embarcado pode ser complexo, por requerer conhecimentos diversos.
Dentre eles, questões geralmente pouco exploradas ou ignoradas em aplicações desktop, como
por exemplo, a restrição ao consumo de energia e a pouca disponibilidade de memória. Outro
complicador está relacionado ao espaço arquitetural, que torna a exploração das opções para a
construção de um sistema ainda mais difícil [49].
A arquitetura de hardware de um sistema embarcado pode conter um ou mais processadores,
memórias de vários tipos, interfaces para periféricos e blocos dedicados.
18
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.3.1
IP core
Uma descrição de um sistema digital pode ser chamada de Core. Nos últimos anos a sua
utilização na construção de aplicações e sistemas maiores em circuito integrado, tem se mostrado
uma tendência de mercado. Os cores podem ser classificados de três modos, como indicado na
Tabela 2.1.
2.1 – Classificação de IP cores. Fonte [51].
IP Cores (Intellectual Property Cores) são blocos em hardware que executam tarefas específicas
e são projetados para permitir sua reutilização em outros sistemas. Com isso, os sistemas
integrados em um único chip (SoCs) podem conter diversos IP Cores que podem ser ligados por
um barramento ou uma rede mais complexa, conhecida como network-on-chip (NoC) [49].
2.3.2
Sistemas Integrados em um único chip
O mercado atual de projetos VLSI exige um baixíssimo tempo de projeto aliado a uma alta
complexidade e elevado desempenho, o que somente é possível com o uso de IP cores, e SoCs.
O SoC, é um sistema em um único chip, que pode conter um ou mais IP cores (processadores,
memórias, interfaces para periféricos e blocos dedicados), todos recursos disponíveis em chips
mais modernos com alta capacidade de integração, fato que torna o projeto e desenvolvimento
cada vez mais complexo.
19
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Pode-se destacar como vantagens associadas ao uso de SOCs o uso de cores; baixo custo de
fabricação em série; alta qualidade; diminuição de defeitos de montagem e fabricação em geral;
baixa potência consumida; pequeno tamanho e alta velocidade.
O uso e reuso de IP cores na indústria de semicondutores possibilitou o surgimento de um novo
mercado, chamado IP Business [52]. Esse novo mercado é descrito na Figura 2.11 e engloba três
segmentos: Produtores de IP; Utilizadores de IP e Desenvolvedores de ferramentas de IP.
2.11 – Modelo de IP
2.3.3
Business. Fonte [52].
Arquitetura Dedicada
Existe certa dificuldade em classificar um determinado sistema com o termo “Sistema
Embarcado” devido ao avanço das possibilidades e tecnologias para implementação. Contudo
uma alternativa consiste na implementação do sistema através de uma Arquitetura Dedicada por
meio de hardware com arquitetura específica, o que contribui significantemente ao incremento da
velocidade do sistema.
Caso as restrições de recursos como consumo, tempo e memória tornem-se críticas, pode ser
indispensável o desenvolvimento de um ASIC (Application-Specific Integrated Circuit) ou um
FPGA (Field Programmable Gate Array).
As referidas tecnologias de implementação em hardware permitem que o desempenho global do
sistema seja muito maior, além de reduzir o tempo de chegado do produto ao mercado (time-tomarket).
20
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.3.4
Um modelo de desenvolvimento
O processo de desenvolvimento se constitui de: Especificação – Projeto Arquitetural –
Construção de modelo(s) RTL – Verificação Funcional – Síntese – Cosimulação - Prototipação.
Inicialmente, definem-se quais funcionalidades o sistema deve ou não conter.
Especificação
Projeto
Arquitetural
Construção de
modelos RTL
Verificação
Funcional
Síntese
Cosimulação
Prototipação
2.12 – Ciclo de desenvolvimento.
Em sistemas complexos, a exemplo de SoCs, as especificações são feitas de modo top-down e
implementados de forma bottom-up. Partindo de uma visão geral do sistema, com alto nível de
abstração, ele é decomposto em partes menores, IP cores, que são implementados e depois
interligados para formar o sistema completo. Durante esse processo é possível definir estratégias
de verificação e testes do sistema, a fim de constatar seu correto funcionamento.
No Projeto Arquitetural, procura-se implementar as funções contidas na especificação inicial
através de uma arquitetura abstrata, ou seja, projeto de alto nível.
Ao contrário do que ocorre nas fases de projeto anteriores, a arquitetura abstrata estabelece uma
ligação onde cada função do sistema é atribuída a um bloco dedicado de hardware. O projeto
arquitetural compreende a alocação de recursos para realizar as operações e o escalonamento no
tempo destas operações supondo-as realizadas pelos recursos citados. Recursos estes, tipicamente
componentes estruturais de sistemas digitais, tais como ULAs, registradores, multiplicadores, etc.
A exploração do espaço de projeto deve encontrar uma solução ótima para três questões básicas
[53]: 1) Quantos e quais são os processadores e blocos dedicados de hardware necessários? 2)
Qual é o mapeamento ideal entre funções e componentes de hardware? 3) Qual é a estrutura de
comunicação ideal para conectar os componentes entre si, tendo em vista as trocas de
informações que devem ser realizadas entre as funções mapeadas para os componentes?
Para uma exploração efetuada rapidamente, é fundamental a existência de estimadores que sejam
capazes de informar os valores de métricas importantes de projeto (desempenho, consumo de
21
Dissertação de Mestrado– LASID - PPGI/DI UFPB
potência, área) que irão resultar de cada alternativa arquitetural (uma macro-arquitetura e um
mapeamento de funções) a partir da especificação funcional do sistema [48].
Devido a multiplicidade quase infindável de soluções arquiteturais possíveis e a uma elevada
complexidade computacional, em busca de uma solução ótima ou mesmo aproximada, a etapa do
projeto arquitetural é usualmente simplificada pela escolha prévia de uma plataforma arquitetural
conhecida e adequada ao domínio da aplicação. Uma vez definida a macro-arquitetura, é
necessária a geração do software para a mesma, a partir da especificação funcional do sistema. A
geração do software é bastante facilitada se a especificação funcional inicial tiver sido feita sobre
uma interface de programação da aplicação padronizada (API – Application Programming
Interface) que ofereça recursos para comunicação entre as tarefas e para a qual exista uma
implementação sobre a plataforma arquitetural selecionada. É também necessário um compilador,
que traduza a especificação funcional para uma linguagem de programação adequada a cada
processador. Componentes de hardware e software selecionados para a macro-arquitetura podem
ter interfaces heterogêneas, implementando diferentes protocolos de comunicação. Neste caso, é
necessária a síntese da comunicação entre os componentes [48].
Em todas as etapas da metodologia de projeto é preciso avaliar e verificar as descrições
funcionais e arquiteturais geradas, onde normalmente essas verificações e validações se dão por
simulação.
A construção de modelo(s) RTL (Register Transfer Level) é a descrição do projeto através do uso
de registradores, ou seja, o projeto é visto através do fluxo (transferência) de dados entre os seus
registradores.
A implementação em nível RTL é feita através de alguma linguagem de descrição de hardware
(HDL), muitas vezes usada no processo chamado de síntese lógica que consiste em um outro
nível de abstração em que todo o modelo RTL é transformado noutro modelo em nível de portas
lógicas.
A verificação funcional tem o objetivo de checar todas as funcionalidades de projeto e assegurar
que estas estão ocorrendo da maneira especificada; e é uma das principais tarefas do fluxo de
desenvolvimento [48].
22
Dissertação de Mestrado– LASID - PPGI/DI UFPB
A fase de verificação é uma etapa crítica, por se concentrar nas conexões dos módulos, já que
esses já foram testados independentemente. Outras metodologias ainda devem ser utilizadas para
a verificação das partes desenvolvidas, tanto em hardware como em software, utilizando
ferramentas adequadas para a verificação de sistemas desse nível. Dado o modelo funcional do
sistema pode-se usar software real ou outra estratégia de teste para garantir a compatibilidade
com as especificações iniciais e assim enviá-lo a produção.
Ao testar uma descrição, pode-se utilizar diferentes métodos, e a escolha da abordagem mais
adequada deve ponderar questões como facilidade na elaboração, compatibilidade entre
ferramentas de diferentes fornecedores, tempo de execução, necessidade de armazenar resultados,
dentre outros aspectos [17].
Os testes em projetos de hardware são realizados através de elementos chamados testbenches,
escritos em linguagem formal, e usados para criar simulações para o modelo do Design Under
Verification (DUV) ou Entidade Sob Teste (EST) que é representado em alguma linguagem de
descrição de hardware. A função do testbench é criar estímulos que conseguem ativar as
funcionalidades desejadas no EST.
A EST fica envolta pelo testbench, que confrontará a sua funcionalidade com o modelo de
referência que pode ser até mesmo um software escrito em alguma linguagem de alto nível como
C, C++, Java, Pascal,etc.
O modelo de referência pode ser entendido como um projeto de software que contém as
funcionalidades especificadas inicialmente no projeto e que está sendo usando neste caso para ser
confrontado com o modelo de hardware.
A Figura 2.13 mostra o caso geral de uma estrutura de teste utilizando o emprego dos recursos da
linguagem (VHDL) como uma maneira eficiente de realizar parte ou toda operação de teste de
uma entidade de projeto [17].
Os estímulos de teste podem ser gerados por uma constante do tipo vetor, por um conjunto de
comandos próprios da linguagem, ou por arquivo de dados. Os valores obtidos com a simulação
da entidade de projeto podem ser observados através de uma janela própria da ferramenta de
23
Dissertação de Mestrado– LASID - PPGI/DI UFPB
simulação, porém a verificação das formas de onda em descrições complexas exigem a análise de
muitas condições, o que dificulta a detecção de falhas de forma visual [17].
Valores para
o teste
Valores de
referência
2.13 – Procedimento de teste – caso geral. Adaptada da fonte[17].
Outra opção é realizar uma comparação entre os valores obtidos e os valores corretos, gerados
pelo modelo de referência, segundo as especificações de projeto. Nesse caso, os valores corretos
podem ser gerados de modo semelhante ao formato dos estímulos de teste: constantes, comandos,
arquivos ou uma composição desses. A descrição que controla as operações se encarrega da
comparação dos resultados, gerando mensagens de alerta e armazenamento dos resultados em
arquivo. A vantagem dessa opção é a independência com a ferramenta empregada, permitindo
que o procedimento seja aplicado por qualquer simulador VHDL de modo automático, com a
documentação em forma de arquivos [17].
A síntese poderá ser feita logo após definidos e validados os componentes de hardware da macroarquitetura, incluindo a infra-estrutura de comunicação e os eventuais adaptadores [48].
Numa primeira etapa, a macro-arquitetura pode ser expandida para uma micro-arquitetura (ou
arquitetura RTL), contendo o detalhamento de todos os componentes e suas interconexões, pinoa-pino e considerando o funcionamento do circuito com precisão de ciclo de clock. Numa
segunda etapa, podem ser usadas ferramentas convencionais para síntese de hardware, que a
partir da micro-arquitetura irão gerar o layout final do circuito. Para tanto, é necessário que a
24
Dissertação de Mestrado– LASID - PPGI/DI UFPB
micro-arquitetura esteja descrita numa linguagem apropriada para estas ferramentas, como
VHDL ou Verilog. A existência prévia de layouts para os componentes de hardware selecionados
facilita bastante esta síntese, que se limita então ao posicionamento e roteamento de células [48].
Uma vez realizada a síntese, questões específicas do dispositivo escolhido passam a ser
consideradas, como por exemplo os atrasos das portas lógicas durante a execução do sistema
devem obedecer os limites esperados de não comprometer a corretude. Por fim, a etapa de
prototipação consiste na implantação do código gerado pela síntese em algum dispositivo de
hardware.
25
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.4
Computação Reconfigurável
A computação reconfigurável surgiu como uma solução intermediária entre as soluções em
hardware e software para atender as metas e motivações relacionadas com a melhoria de
desempenho, flexibilidade, generalidade, eficiência, custo e outros. A seguir, algumas citações
definindo computação reconfigurável:
"Dispositivo que realiza computação usando conexão espacial "pós
fabricação" de elementos de computação" [55].
"Computação reconfigurável representa uma nova idéia em filosofia de
computação, na qual algum agente de hardware de propósito geral é
configurado para realizar uma tarefa específica, mas pode ser reconfigurado
sob demanda para realizar outras tarefas específicas." [74]
"Um novo paradigma de computação no qual circuitos integrados
programáveis são usados em conjunto com software para reconfigurar
circuitos integrados FPGA dinamicamente e produzir arquiteturas de
computador sob demanda." [75]
As principais características e atributos desejáveis em soluções que utilizam sistemas
computacionais reconfiguráveis, são: regularidade de comportamento, flexibilidade, desempenho,
generalidade, eficácia e custo.
Outra vantagem é que o hardware é otimizado para executar uma aplicação específica sem que
haja a necessidade de fabricação de chips, protótipo ou a versão final do projeto desenvolvido.
2.4.1
Dispositivos Lógicos Programáveis
Os componentes da lógica programável são dispositivos que possuem em sua lógica interna
centenas ou milhares de portas lógicas, flip-flops e registradores e são chamados de dispositivos
lógicos programável (PLD – Programmable Logic Devices), mostrado na Figura 2.14, e se
dividem em:
26
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1. Simple Programmable Logic Devices (SPLDs): possuem funções lógicas mais simples,
como funções AND e OR;
2. High Capacity Programmable Logic Devices (HCPLDs): são dispositivos lógicos
programáveis de alta capacidade por oferecerem mais de 600 portas disponíveis.
a. Complex Programmable Logic Devices (CPLDs): possuem vários blocos de
SPLDs num único chip;
b. Field-Programmable
Logic
Devices
(FPLDs):
os
FPLDs
mais usados
comercialmente são os Field-Programmable Gate Arrays (FPGAs)
PLD
PLA
SPLDs
PLDs Simples
HCPLDS
PLDs de alta capacidade
Arranjos
Lógicos
Programáveis
Arranjos
de Portas
Programáveis
PAL
PROM
FPGAs
CPLDs
2.14 – Dispositivos Lógicos Programáveis
2.4.1.1
Arranjo Lógico Programável
Um arranjo lógico programável, Figura 2.15, consiste de um circuito que possui uma estrutura
interna baseada em um conjunto de portas AND-OR (o conjunto de portas AND e OR é chamado
de arranjos).
27
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.15 – Arquitetura Interna de uma PLA. Fonte[56].
PROM - As PROMs são dispositivos onde o arranjo AND é pré definido em fábrica e somente o
arranjo OR é programável, portanto capaz de gerar qualquer função lógica das suas variáveis de
entrada pelo fato de poder gerar cada um dos possíveis produtos AND de tais variáveis.
PAL – Programmable Array Logic - O PAL tem as a portas AND programáveis, ou seja,
enquanto as portas OR são pré-conectadas em fábrica, todas as portas AND podem ser
programadas.
PLA – Programmable Logic Arrays - Um PLA possui tanto a matriz de portas AND quanto a
matriz de portas OR programáveis combinando as características de uma PROM e de um PAL.
2.4.1.2
Arranjos de Portas Programáveis
Os arranjos de portas programáveis são estruturas mais genéricas e versáteis que as baseadas na
estrutura tradicional AND-OR dos arranjos lógicos programáveis. A principal vantagem deste
tipo de circuito é a possibilidade de reprogramação do comportamento de um circuito quantas
vezes forem necessárias, ao contrário dos arranjos lógicos programáveis que só podem ser
programados uma vez, ou seja, definida sua função lógica ela não poderá ser mudada.
CPLD – Complex PLD - Os CPLDs podem ser vistos como dispositivos que utilizam em sua
estrutura vários PLD´s (PLA ou PAL). Figura 2.16.
28
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.16 – CPLD.
Cada PLA ou PAL formam células que são interligadas através de conexões programáveis.
FPGA – Field Programmable Gate Array - É um dispositivo lógico programável que possui uma
arquitetura baseada em blocos lógicos configuráveis, chamados de CLB (Configuration Logical
Blocks) que são formados por portas lógicas e flip-flops que implementam funções lógicas.
O FPGA também é formado por estruturas chamadas de blocos de entrada e saída (IOB – In/Out
Blocks), os quais são responsáveis pelo interfaceamento entre as saídas provenientes das
combinações de CLBs.
A típica estrutura interna de um bloco lógico configurável de um FPGA, consiste em flip-flops,
um determinado número de multiplexadores e uma estrutura de função combinatória para
implementar as funções lógicas.
Introduzida pela empresa Xilinx Inc. no ano de 1985, esta tecnologia consiste em dispositivos
lógicos programáveis que suportam a implementação de circuitos lógicos relativamente grandes
[56], mostrados na Figura 2.17.
29
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Rede de Interconexão
Programável
IOB (Input/Output Block)
CLB (Configurable Logic
Block)
2.17 – Arquitetura Interna de um FPGA. Fonte[50].
Um FPGA possui três tipos principais de recursos:
1. blocos lógicos,
2. blocos de entrada e saída, e
3. chaves de interconexão programáveis.
Os blocos lógicos formam um arranjo bi-dimensional e as chaves de interconexão são
organizadas como canais de roteamento horizontais e verticais entre as linhas e colunas de blocos
lógicos. Cada um destes canais possui chaves programáveis que permitem conectar os blocos
lógicos de maneira conveniente, em função da necessidade de cada projeto [56].
A funcionalidade de uma FPGA é definida através de comutadores elétricos programáveis cujas
propriedades, tamanho, resistência em condução e capacitância parasita, definem a eficiência e o
desempenho do dispositivo. Outros atributos a ter em conta são: a volatilidade da sua
programação, a possibilidade de reprogramação e a complexidade do processo de fabricação. As
tecnologias mais usadas na implementação desses comutadores são as tecnologias de
30
Dissertação de Mestrado– LASID - PPGI/DI UFPB
programação baseadas em memória estática (SRAM-based), anti-fusível e porta flutuante
(floating gate) [56].
Os recursos de configuração ou reconfiguração do dispositivo, como conceitos e características
arquiteturais, que podem apresentar as seguintes características:
•
Capacidade de realizar uma única configuração ou muitas reconfigurações,
•
Reconfiguração estática ou dinâmica, ou seja, pode ser realizada em tempo de
compilação ou em tempo de execução,
•
Reconfiguração parcial ou total,
•
Modo de configuração único ou múltiplo,
•
Quantidade de configurações armazenadas simultaneamente no dispositivo,
•
Tempo gasto com a configuração ou a reconfiguração.
Uma característica importante dos FPGA é sua capacidade de ser programado em campo pois sua
funcionalidade não é definida na fundição do chip e sim pelo projetista da aplicação final, que usa
métodos de reconfiguração, classificados como:
•
Reconfiguração Total: todo o dispositivo programável é reconfigurado.
•
Reconfiguração Parcial: apenas uma parte do dispositivo é reconfigurada. Se afetar
outras partes não reconfiguradas, todo o sistema deve ser reiniciado.
•
Reconfiguração Dinâmica: reconfiguração em tempo de execução. Reconfiguração
realizada durante o funcionamento do dispositivo.
31
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.4.2
VHDL - VHSIC Hardware Description Language
VHDL é um acrônimo de VHSIC Hardware Description Language, onde VHSIC é um acrônimo
de Very High Speed Integrated Circuit..
2.4.2.1
História
A VHDL foi originalmente desenvolvida sob o comando do Departamento de Defesa (DoD) dos
Estados Unidos, em meados da década de 80, para documentar o comportamento de ASICs que
compunham os equipamentos vendidos às Forças Armadas americanas. Isto quer dizer que a
linguagem VHDL foi desenvolvida para substituir os complexos manuais que descreviam o
funcionamento dos ASICs. Até aquele momento, a única metodologia largamente utilizada no
projeto de circuitos era a criação através de diagramas esquemáticos. O problema com esta
metodologia é o fato de que desenhos têm menor portabilidade, são mais complexos para
compreensão e são extremamente dependentes da ferramenta utilizada para produzi-los [57].
Uma vez que o projeto VHSIC era de alta prioridade militar e havia dezenas de fornecedores
envolvidos, o DoD estava preocupado principalmente com as questões de portabilidade,
documentação e compreensibilidade dos projetos. Cada um destes fornecedores atuava
desenvolvendo partes dos projetos ou mesmo fornecendo componentes que viriam a se encaixar
em outros sistemas maiores. Desta forma o DoD optou por buscar desenvolver uma linguagem
que servisse como base para troca de informações sobre estes componentes e projetos. Uma
linguagem que, independente do formato original do circuito, pudesse servir como uma descrição
e documentação eficientes do circuito, possibilitando os mais diferentes fornecedores e
participantes a entender o funcionamento das outras partes, padronizando a comunicação [57].
O desenvolvimento da VHDL serviu inicialmente aos propósitos de documentação do projeto
VHSIC. Entretanto, nesta época buscava-se uma linguagem que facilitasse o projeto de um
circuito; ou seja, a partir de uma descrição textual, um algoritmo, desenvolver o circuito, sem
necessidade de especificar explicitamente as ligações entre componentes. A VHDL presta-se
adequadamente a tais propósitos, podendo ser utilizada para as tarefas de documentação,
descrição, síntese, simulação, teste, verificação formal e ainda compilação de software, em alguns
casos [57].
32
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Após o sucesso inicial do uso da VHDL, a sua definição foi posta em domínio público, o que
levou a ser padronizada pelo IEEE (Institute of Electrical and Electronic Engineers) em 1987. O
fato de ser padronizada e de domínio público ampliou ainda mais a sua utilização, novas
alterações foram propostas, como é natural num processo de aprimoramento e a linguagem sofreu
uma revisão e um novo padrão mais atualizado foi lançado em 1993. Atualmente ela continua a
ser revisada e deverá ser lançado um novo padrão[57].
2.4.2.2
Definição
VHDL é uma linguagem estruturada que oferece a possibilidade de descrever e simular o
hardware antes de sua síntese, facilitando a validação ou verificação, tanto em termos de
funcionamento quanto em termos de tempos de atraso dos componentes e desempenho, sem a
necessidade da prototipação do sistema.
Um programa em VHDL pode ser dividido e implementado em parte como software (hardware
programável) e outra, em hardware reconfigurável.
Pode ser escrito basicamente usando dois tipos (modelos) de descrição: estrutural e
comportamental. Na descrição estrutural, a organização física e topológica do sistema é descrita,
ou seja, são especificadas as entradas e/ou saídas, os componentes lógicos, a interligação deles e
os sinais que compõem o sistema.
Na descrição comportamental, não é preciso descrever a organização física e topológica do
sistema, somente o comportamento. São descritas as funções (comportamento) do sistema. Um
programa que utiliza esse tipo de descrição possui o mesmo formato de um programa fonte
escrito em uma linguagem de programação de alto nível, como C++. Essa abordagem diminui a
necessidade de conhecimento em projeto de hardware, aumentando a facilidade de
desenvolvimento do sistema.
2.4.2.3
Vantagens e desvantagens
Algumas vantagens no uso de VHDL são: projetos independentes da tecnologia; maior facilidade
de atualização dos projetos; exploração de alternativas arquiteturais em um nível mais alto de
abstração; redução do tempo de projeto e custos; e simplificação da documentação. Como
33
Dissertação de Mestrado– LASID - PPGI/DI UFPB
desvantagem o hardware gerado é menos otimizado, simulações mais lentas e falta de pessoal
treinado para lidar com a tecnologia.
2.4.2.4
Fluxo de projeto bem definido em VHDL
2.18 – Ciclo de vida VHDL. Fonte [57].
Especificação de Requisitos – Durante a etapa de Especificação de Requisitos, mostrado na
Figura 2.18, o projetista e o usuário (em muitos casos podem ser a mesma pessoa), fazem um
estudo e levantam todos os requisitos e características do sistema e definem o seu funcionamento.
Esta fase é muito importante, pois permite o correto entendimento do funcionamento do sistema,
o que evita a ocorrência de erros futuros. [57].
Modelamento - O projeto é iniciado de fato na etapa de modelamento, onde com base nas
especificações da etapa inicial, o projetista escreverá os modelos que representam o circuito [57].
Síntese – A Síntese de Alto Nível está para o hardware assim como a compilação está para o
software. Na síntese, o modelo descrito será convertido para estruturas de dados representando as
conexões, blocos, componentes e portas lógicas. Esta etapa é automática, e dependente da
ferramenta de software utilizada. Durante a síntese são pré-avaliados os requisitos do sistema a
fim de indicar se o circuito irá atendê-los adequadamente. Após a síntese ainda não está definido
o circuito a ser implementado, a especificação intermediária que é resultante é ainda bastante
34
Dissertação de Mestrado– LASID - PPGI/DI UFPB
genérica e pode ser direcionada para uma de muitas possibilidades de tecnologias de
implementação.
Mapeamento Tecnológico – O Mapeamento Tecnológico permite que o circuito seja definido
dentro da tecnologia em que será implementado, pouco influindo nesse processo o projetista, que
poderá apenas especificar parâmetros de otimização desejados. Para entender essa etapa
adequadamente é preciso conhecer as diferentes tecnologias disponíveis no mercado, como full
custom, gate array, FPGAs, entre outros [57].
Implementação – Na etapa de implementação/fabricação são criados os primeiros protótipos,
avaliadas as condições finais, detalhes de produção entre outros detalhes de implementação final.
Testes – Em seguida à fabricação, os circuitos são testados para que possam ser entregues ao
usuário com garantia de isenção de falhas.
35
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.5
Compressão de Dados
Compressão de dados é o ato de reduzir a quantidade de bits necessários para representar os
dados, ou seja, reduzir a redundância da representação da informação gerada pela fonte
procurando-se preservar a informação em si.
Nos próximos itens serão apresentados técnicas de compressão sem perdas com códigos baseados
em modelos estatísticos e em dicionários a exemplo de código de Golomb, código de Huffman,
código aritmético, código de Lempel-Ziv (L-Z) e PPM.
Os dados são comprimidos para eliminação da redundância objetivando economizar espaço em
dispositivos de armazenamento, como discos rígidos, ou ganhar desempenho (diminuir tempo)
em transmissões.
Uma medida comumente usada para quantificar o grau de compressão é a razão de compressão
ou, abreviadamente, RC. Se o número de bits usados na representação da mensagem original
(entrada do compressor) é n e o número de bits usados na
representação da mensagem
comprimida (saída do compressor) é m, a RC é definida como:
RC =
n
m
2.2
Alternativamente, a RC pode ser representada na forma (n / m):1.
A taxa de bits de uma mensagem (taxa) é definida como a razão entre o número de bits usados na
representação da mensagem e o número de elementos na mensagem [58] original. Abrevia-se a
taxa de bits por R (do inglês rate, taxa).
Um texto com 10 caracteres codificados em ASCII utiliza 8x10 = 80 bits. Portanto, R = 80/10 = 8
bits/símbolo. Se este texto é comprimido (com ou sem perdas) gerando uma seqüência de 40 bits,
tem-se RC = 80/40 = 2, ou RC = 2:1, e R= 40/10 = 4 bits/símbolo.
Quando há eliminação de informação, a mensagem original não pode mais ser perfeitamente
reconstruída. Por este motivo, esta modalidade é chamada de compressão com perdas. Neste
36
Dissertação de Mestrado– LASID - PPGI/DI UFPB
caso, a descompressão constrói apenas uma aproximação para a mensagem original, exigindo a
adoção de medidas que permitam aferir a distorção entre a mensagem original e a mensagem
descomprimida.
Existem dois tipos de compressão: Com perdas e sem perdas. Um esquema de compressão sem
perdas permite a reconstrução perfeita do sinal original a partir do sinal comprimido, devendo ser
aplicado quando qualquer alteração nos dados originais é inaceitável. Na compressão sem perdas,
portanto, o sinal é integralmente preservado, procurando-se unicamente reduzir a redundância na
representação dos dados.
2.5.1
Informação e Entropia
Seja uma fonte de informação S produzindo elementos com seus valores selecionados do
conjunto A = {a0, a1,...,aM-1}. Este conjunto é o alfabeto de S e os seus elementos são conhecidos
como letras ou símbolos. Um elemento x gerado por S pode ser considerado uma variável
aleatória que assume o valor ai com probabilidade P( x = ai ), i = 0, 1,..., M-1. Define-se a autoinformação, I(ai), associada à ocorrência do símbolo ai como[58]:
I (a i ) = log 2
1
bits
P( x = ai )
2.3
Caso x0 x1... xN-1 sejam elementos gerados por S, a entropia da fonte é definida como segue:
H ( S ) = lim
N →∞
1
GN bits/símbolo
N
2.4
Onde;
M −1 M −1
M −1
i0 = 0 i1 = 0
i n −1 = 0
G N = − ∑ ∑L
∑
P( x0 = ai 0 , x1 = ai1 ,..., x n −1 = aiN −1 ) log 2 P( x 0 = ai0 , x1 = ai1 ,..., x n −1 = aiN −1 )
2.5
37
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Caso as variáveis aleatórias que constituem a mensagem forem independentes e identicamente
distintas (IID), a Equação 2.5 pode então ser simplificada para expressar a entropia de ordem 1 de
S [58].
M −1
H ( S ) = − ∑ P( x = ai ) log 2 P( x = ai ) bits/símbolo
2.6
i0 = 0
Claude Shannon mostrou que é possível codificar sem perdas a saída de uma fonte qualquer de
informação usando um número médio de bits por símbolo arbitrariamente próximo à entropia,
mas no inferior a ela [12][58]. Assim pode-se usar a entropia para avaliar a eficiência da
codificação efetuada, sendo o código ótimo aquele cujo comprimento médio é igual a entropia
[58].
2.5.2
Modelagem
Um dos grandes avanços na área de compressão de dados foi a separação do processo de
compressão em: modelagem e codificação. Tal avanço permitiu tratar uma enorme variedade de
compressores como a associação entre alguns poucos modelos e codificadores.
2.5.3
Modelagem Estatística
Diretamente relacionado com a definição das probabilidades associadas aos símbolos gerados
pela fonte está o conceito de entropia, por conseguinte o de código ótimo. A entropia é calculada
a partir da definição de um modelo estatístico para a fonte de informação. Um modelo que
captura mais precisamente as características reais da fonte “reduz sua entropia”, aumentando as
oportunidades de compressão. Em uma mensagem onde seus elementos são estatisticamente
dependentes, a entropia associada a um modelo que reflita este comportamento será menor que
aquele associado a um modelo IID [58].
38
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Ganhos de compressão podem ser obtidos com modelos mais precisos, uma vez que a codificação
ótima é um problema já solucionado e a modelagem permanece um ativo campo de pesquisa
[58].
Um modelo estatístico simples consiste em assumir que os valores gerados pela fonte, com
alfabeto A = {a0, a1,...,aM-1}, são independentes e assumem o valor ai com probabilidade P(x=ai),
i = 0, 1,..., M-1. Caso a suposição de independência não seja satisfatória, os modelos de Markov,
estão entre os mais comumente usados para representar a relação existente entre símbolos.
Se a distribuição de probabilidades de um elemento depende dos K símbolos que o antecedem, a
mensagem segue o modelo de Markov de K-ésima ordem; mister se faz portanto, estimar as
probabilidades P(Xn=ai | xn-1,xn-2,...,xn-k), i=0,1...,M-1. Os modelos de Markov são conhecidos
como modelos de contexto finito por usarem os K símbolos precedentes para construir o contexto
a partir do qual a probabilidade de ocorrência do próximo elemento é estimada[58].
Caso uma fonte gere símbolos dependentes estatisticamente dos valores presentes em um
contexto C de tamanho L, um modelo de Markov de ordem K com K ≤ L, é capaz de representar
com maior precisão as características da fonte do que um modelo de ordem K-1 e, portanto,
conduzir a uma maior redução na entropia [58].
Teoricamente empregar modelos de ordem elevada melhoraria os níveis de compressão, contudo,
surgem alguns problemas de ordem prática que limitaria aplicabilidade da técnica. Tem-se Mk
possíveis contextos para um modelo de ordem K e um alfabeto de tamanho M, onde o número de
contextos diferentes cresce exponencialmente com a ordem do modelo[58].
Como exemplo, com M=256 e K=5 para obter um número de um trilhão de contextos diversos, o
que claramente compromete a computação, nos dias de hoje, no tocante a problemas de requisitos
de memória, cálculo das estimativas, dentre outros. Por este motivo os modelos de Markov de
ordem zero e de primeira ordem são os mais utilizados em situações reais [58].
39
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.5.4
Codificação da Entropia
Entenda-se por codificação, no presente trabalho, a representação de dados através de
identificadores binários, denominados palavras-códigos, onde o conjunto de todas as palavras
códigos para uma determinada fonte constitui um código. O comprimento de uma palavra código
é o seu número de bits, donde surgem duas categorias: palavras código de comprimento variável
e palavras código de comprimento fixo. Uma maneira de reduzir o comprimento médio dos
identificadores e a taxa das mensagens geradas pela fonte é atribuir menos bits à representação
dos valores com maior probabilidade de ocorrência[58].
Para evitar o problema da ambigüidade na recuperação da mensagem é importante utilizar um
código unicamente decodificável, o que pode se tornar um processo complexo, entretanto são
facilmente decodificáveis se também forem código de prefixo (quando nenhuma de suas palavras
código é prefixo de outra.).
2.5.5
Codificação de Huffman
Em 1952, Huffman apresentou um procedimento sistemático para a construção de código de
prefixo ótimo, chamados de códigos de mínima redundância, dadas as probabilidade previamente
definidas na etapa de modelagem[59][58].
O algoritmo idealizado por Huffman associa uma árvore ponderada a cada letra do alfabeto da
fonte de informação. Inicialmente, cada árvore possui um único nó, com peso igual à
probabilidade de ocorrência do símbolo a ela associado. A cada iteração do algoritmo, as duas
árvores de menor peso são substituídas por uma nova árvore cujo peso é a soma dos pesos das
primeiras. A árvore de menor peso se torna a sub-árvore esquerda e a outra se torna a sub-árvore
direita da nova árvore.
Na ordenação dos pesos, empates são resolvidos por qualquer regra sistemática. O procedimento
pára quando resta apenas uma única árvore. A palavra-código para qualquer letra é obtida
percorrendo-se esta árvore desde a raiz até a folha correspondente à letra em questão, registrando
0 para cada ramo esquerdo e 1 para cada ramo direito.
40
Dissertação de Mestrado– LASID - PPGI/DI UFPB
A codificação é feita concatenando as palavras código que representam cada caractere no
arquivo.
Como exemplo, considere-se um arquivo de dados contendo 100.000 caracteres, distribuídos
entre “a”, “b”, “c”, “d”, “e” e “f”, e freqüências indicadas na Tabela 2.2. Se cada caractere for
codificado com uma palavra código de 3 bits, o arquivo ficará com 300.000 bits ao passo que o
mesmo arquivo poderá ser codificado com apenas 224.000 bits se for codificado usando palavra
código de comprimento variável [60].
Observando as freqüências indicadas é possível exemplificar a construção da árvore de Huffman,
na Figura 2.19, cada passo mostra o conteúdo da fila ordenado em ordem crescente por
freqüência. Em cada passo as duas árvores com freqüências menores são intercaladas.
2.2 – Freqüências indicadas. Fonte[60].
a
b
c
d
e
f
Freqüência (em milhares)
45
13
12
16
9
5
Palavra código de comprimento fixo
000
001
010
011
100
101
0
101
100
111
1101
1100
Palavra código de comprimento variável
Os retângulos representam as folhas contendo um caractere e sua freqüência e os círculos
representam nós internos contendo a soma das freqüências de seus filhos. Arestas ligando um nó
interno a filho esquerdo é identificado com 0 e identificado com 1 aresta que ligar nó interno
com filho localizado à direita. Percorrendo a seqüência formada pelas arestas desde a raiz ate a
folha correspondente a esse caractere se obtém a palavra-código [60].
41
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1)
2)
f:5
e:9
c:12 b:13 d:16 a:45
c:12 b:13
0
f:5
3)
f:5
1
e:9
d:16
14
0
d:16 a:45
14
1
e:9
a:45
25
0
1
c:12 b:13
2.19 – Formação da árvore de Huffman, passos 1-3.
A Figura 2.19 passo 2 mostra a junção das sub-árvores de menor peso (5 e 9) e a formação de
uma nova árvore de peso 14 e ordenada de modo crescente em meio as outras árvores.
No passo 3, é mostrado a formação de uma nova árvore de peso 25 como resultado da
composição das árvores de peso 12 e 13, ficando as árvores ordenadas na seqüência 14, 16, 25 e
45.
Por fim a Figura 2.20 mostra os passos 4, 5 e 6 da formação da árvore de Huffman. A árvore final
pode ser vista no passo 6. Para qualquer letra pode-se obter a palavra código, bastando percorrer
a árvore.
42
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4)
25
0
1
0
c:12 b:13
1
d:16
14
0
1
f:5
5)
a:45
30
e:9
a:45
55
0
1
25
0
30
1
0
c:12 b:13
d:16
14
0
1
f:5
6)
1
e:9
100
0
1
a:45
55
0
1
25
0
30
1
0
c:12 b:13
1
d:16
14
0
f:5
1
e:9
2.20 - Formação da árvore de Huffman, passos 4-6.
O código de Huffman possui uma redundância residual que decorre da atribuição de um número
inteiro de bits a cada letra do alfabeto[58].
43
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.5.6
Codificação de Golomb
Solomon W. Golomb em 1966 propôs um esquema simples de codificação de valores inteiros não
negativos. É conhecido como a codificação de Golomb que é um conjunto de códigos de prefixo
que podem ser utilizados na compressão de dados, apresentando resultados ótimos para
determinadas distribuições de probabilidade dos símbolos codificados.
Dado um parâmetro inteiro positivo m, o código de Golomb de um inteiro não negativo n é a
concatenação da codificação unária de n / m com a codificação binária ajustada de n mod m
[58].
A codificação unária de um inteiro não negativo v é uma seqüência de v bits com valor ‘1’
finalizada por um bit com valor ‘0’. Para descrever a codificação binária ajustada [9], considerese um alfabeto de tamanho m = 2k+b, composto pela seqüência de inteiros 0, 1, 2,..., 2k+b-1, onde
k é o maior inteiro tal que 2k ≤ m, e b é um inteiro não negativo[58].
Na representação binária convencional, cada símbolo deste alfabeto seria codificado com
log 2 m bits. Assim, as palavras-código teriam k bits se b = 0, e k+1 bits se b ≠ 0. Para b = 0, a
codificação binária ajustada é idêntica à codificação binária convencional, mas para b ≠ 0, parte
dos símbolos é codificada com k bits, e o restante com k+1 bits. Mais especificamente, a
codificação binária ajustada de um símbolo no intervalo [0, 1,..., 2k-b-1] é simplesmente sua
representação binária convencional com k bits, enquanto a codificação binária ajustada de um
símbolo de valor w fora deste intervalo é a representação binária, com k+1 bits, de w + m - 2b.
Para m = 5, por exemplo, tem-se k = 2 e b = 1. Neste caso, os símbolos 0, 1 e 2, na codificação
binária ajustada, tornam-se 00, 01 e 10, respectivamente, enquanto que os símbolos 3 e 4 são
codificados como 110 e 111.[58]
O código de Golomb é ótimo para distribuições de probabilidade geométricas, também
conhecidas como geométricas unilaterais dadas por:
44
Dissertação de Mestrado– LASID - PPGI/DI UFPB
P( x = n) = (1 − p ) p n
2.7
onde P(x=n) é a probabilidade de x assumir o valor inteiro n ≥ 0, e 0 < p <1. Para distribuições
genéricas o código de Golomb produz o menor comprimento médio dentre todos os códigos
unicamente decodificáveis[58].Podemos observar um exemplo de código Golomb na Tabela 2.3.
2.3 – Exemplos de códigos Golomb, m=1 até 5
Golomb:
n=0
1
2
3
4
5
6
7
8
9
:
2.5.7
m=1
m=2
m=3
m=4
m=5
0
10
110
1110
11110
111110
:
:
:
:
:
00
01
100
101
1100
1101
11100
11101
111100
111101
:
00
010
011
100
1010
1011
1100
11010
11011
11100
:
000
001
010
011
1000
1001
1010
1011
11000
11001
:
000
001
010
0110
0111
1000
1001
1010
10110
10111
:
LZW e LZ78
Ziv e Lempel definiram um esquema de codificação simples capaz de explorar as dependências
estatísticas entre os símbolos produzidos por uma fonte de informação. O algoritmo deu origem a
uma grande família de compressores práticos de bom desempenho, amplamente utilizados até
hoje. Considere uma fonte de informação que produza seqüências de símbolos selecionados de
um alfabeto A = {ao, a1,..., aM-1}. Uma frase é qualquer seqüência de símbolos selecionados de A.
O tamanho de uma frase é o número de símbolos que a constituem. Um dicionário é uma lista de
frases[9].
No LZ78, o dicionário contém inicialmente apenas uma frase vazia ou nula, ou seja, uma frase de
tamanho zero. Essa frase ocupa o índice zero no dicionário. Seja x = x0x1x2... a seqüência de
símbolos a ser codificada, e f uma frase inicialmente vazia. Os símbolos de x são seqüencialmente
45
Dissertação de Mestrado– LASID - PPGI/DI UFPB
concatenados a f até que a concatenação de um dado símbolo xi produza uma frase que não se
encontre no dicionário. A frase f é então codificada como um par (d, xi), onde d é o índice da
última frase coincidente no dicionário, e f é adicionada ao dicionário. A frase f é novamente
anulada e o processo de codificação se repete a partir do símbolo xi+1. Quando há D frases no
dicionário, d é representado pela codificação binária ajustada, com log 2 D  ou com log 2 D  -1
bits.
No LZW [3], o dicionário é inicialmente carregado com todas as frases possíveis de tamanho um.
Assim, para um alfabeto A = {ao, a1,..., aM-1}, o dicionário contém inicialmente M frases de
tamanho unitário. Como no LZ78, os símbolos de x são seqüencialmente concatenados a f até
que a concatenação de um dado símbolo xi produza uma frase que não se encontre no dicionário.
A ultima coincidente é então codificada pelo seu índice d no dicionário e f é adicionada ao
dicionário. A frase f é novamente anulada e o processo de codificação se repete a partir do
símbolo que quebrou a coincidência, xi. Observe-se que, no LZW, os códigos das frases são
unicamente os índices das frases coincidentes, representados usando a codificação binária
ajustada.
2.5.8
Codificação aritmética
O codificador aritmético elimina a associação entre símbolos individuais e palavras-códigos de
comprimento inteiro e, com isto, é capaz de praticamente igualar a entropia da fonte em todos os
casos.
O método de codificação aritmética foi sugerido por Peter Elias, e apresentado por Abramson no
texto “Information Theory and Coding” [64]. Em 1976, Rissanen e Pasco descobrem novas
classes de códigos, onde o cálculo poderia ser feito com precisão aritmética finita e em tempo
linear. O código de Rissanene utilizava estruturas LIFO (last-in frst-out) produzindo o código em
ordem reversa. O código de Pasco, diferentemente, utilizava estruturas FIFO ( first-in first-out), e
mantinha todo o código em memória, ate que o ultimo símbolo fosse codificado [65].
Na mesma época, Rubin, Guazzo e Rissanen e Langdon apresentam os conceitos modernos de
codificação aritmética: precisão aritmética; operação incremental (símbolo a símbolo) e
estruturas tipo FIFO [65].
46
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Muitos pesquisadores tiveram a mesma idéia de forma independente. No campo da codificação
aritmética foram feitos diversos estudos, divididos basicamente em códigos para alfabetos
binários e para alfabetos com mais de dois símbolos. Em 1982, Langdon e Rissanen
implementaram um código aritmético muito simples para alfabetos binários. Langdon em 1981
desenvolve um tutorial no campo da codificação aritmética, e, em 1984 publica uma versão mais
atualizada que inclui a historia do método. Ian Witten, Radford M. Neal & John G. Cleary obtém
uma implementação completa do mesmo, em 1987 [65].
Uma técnica de codificação aritmética que não usa multiplicações nem divisões foi estudada por
Rissanen e Mohiuddin e, é baseado no código para alfabeto binário, porém, se aplica também a
alfabetos com mais de dois símbolos. Uma implementação foi obtida por Radford M. Neal em
1991 [65].
O algoritmo de codificação aritmética consiste em representar a probabilidade de ocorrência de
cada caractere com intervalos. Parte-se do intervalo [0,1) e nele identifica-se o subintervalo ao
qual corresponde o primeiro símbolo lido do arquivo. Para cada símbolo subseqüente, subdividese o intervalo atual em sub-intervalos proporcionais às probabilidades dos símbolos, e encontrase novamente o intervalo que corresponde ao próximo símbolo. Ao final do processo, teremos um
intervalo que corresponde a probabilidade da ocorrência de todos os símbolos na ordem correta.
A saída do algoritmo é então um valor que esteja contido neste intervalo e possa ser representado
com o menor número possível de dígitos.
Um pseudo-algorítimo seria [58]:
1. Cria-se o intervalo [0,1).
2. Para cada elemento da mensagem faça:
a. Divide-se o intervalo corrente em subintervalos, um para cada letra do alfabeto. O
tamanho do subintervalo associado a uma dada letra é proporcional à
probabilidade de que esta letra seja o próximo elemento da mensagem, ou seja, o
comprimento do subintervalo é igual às probabilidades dos símbolos, de acordo
com o modelo assumido.
47
Dissertação de Mestrado– LASID - PPGI/DI UFPB
b. O subintervalo correspondente à letra que é realmente o próximo elemento é
selecionado como novo intervalo corrente.
3. A mensagem é codificada com o menor número de bits necessário para distinguir o
intervalo final de todos os outros possíveis intervalos finais.
Dois problemas práticos decorrentes da implementação básica são: o cálculo dos limites do
intervalo corrente para mensagens genéricas, potencialmente grandes, que exige aritmética de
altíssima precisão; e nenhuma codificação é produzida ate que toda mensagem tenha sido
processada [58].
Como exemplo, seja uma fonte que produz os símbolos A e B com as probabilidades 0,6 e 0,4,
respectivamente. Inicialmente o intervalo [0,1) é criado. Ao símbolo A é associado o intervalo
semifechado de 0 a 0,6 ao símbolo B vamos associar o intervalo semifechado de 0,6 a 1 [62],
conforme Figura 2.21.
2.21 - Passo1 exemplo da codificação aritmética. Fonte[62].
No passo seguinte cada um dos intervalos é dividido em outros dois com a mesma proporção
(60% e 40%) obtemos quatro intervalos menores, [0;0,36[, [0,36;0,6[ [0,6;0,84[ e [0,84;1[.
2.22 – Passo 2 exemplo da codificação aritmética. Fonte[62].
Prosseguindo a subdivisão obteríamos oito intervalos ainda menores:
2.23 – Passo 3 exemplo da codificação aritmética. Fonte[62].
48
Dissertação de Mestrado– LASID - PPGI/DI UFPB
À mensagem “AAA” corresponde o intervalo de 0 a 0,216 (com largura igual a P(A)3=0,216), a
“BAB”
corresponde
o
intervalo
de
0,744
até
0,84
(com
largura
0,84-0,744=
P(B)P(A)P(B)=0,096), e assim por diante.
Por fim, pode-se codificar a mensagem “AAA” escolhendo um número dentro do intervalo
correspondente, e de preferência um que seja representado pelo menor número de bits: Figura
2.24.
2.24 – Final do processo de codificação. Fonte[62].
Um intervalo necessita de um limite inferior, um comprimento e, por conseguinte um limite
superior. Com as sucessivas repartições um intervalo pode ficar tão pequeno ou a representação
do limite inferior tão longo que não é possível expressá-lo em memória por números inteiros de
16 ou 32 bits.
Observando a Figura 2.25 é possível notar que para um número binário compreendido num
determinado intervalo, escolhendo qualquer valor abaixo do meio 0.5 (half part) a palavra código
inicia com bit 0.
49
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1.0
0.5
0.0
1111
1110
1101
1100
1011
1010
1001
1000
0111
0110
0101
0100
0011
0010
0001
0000
2.25 – Intervalo - HALF PART.
Fazendo o mesmo para a parte superior, a palavra código inicia com o bit 1.Em todos os casos, o
bit inicial poderia ser enviado para a saída e o processamento poderia ser limitado a metade do
intervalo em que ocorreu o número, tomando por limite os valores de [0, 0.5], para abaixo e
[0.5, 1] para cima de half part. [67].
Este procedimento é conhecido como zooming e é mostrado na Figura 2.26.
1.0
1.0
0.5
0.5
0.6
0.4
0.3
0.2
0.0
0.0
2.26 – Exemplo de half point zooming. Fonte [67].
50
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Para os casos em que o limite inferior do intervalo desce abaixo do half ponit e o limite superior
fica a cima do half point o caso de “half-point zoom” não pode ser aplicado. A solução está
exemplificada na Figura 2.27 e, é chamada de “quarter-point zooming”.[67].
1.0
1.0
1.0
0.9
0.75
0.75
0.6
0.7
0.5
0.5
0.75
0.5
0.4
0.25
0.25
0.0
0.0
0.3
0.25
0.0
0.1
2.27 – Exemplo de quarter-point zooming. Fonte[67].
A condição de “quarter-point zooming” é que o limite inferior do intervalo não ultrapasse 0.25 e
o limite superior não exceda 0.75. Agora é sabido que se o intervalo está abaixo do half point o
stream de bits é qualquer um da forma “01xxx” ou “10xxx” se o intervalo final estiver acima do
half point, onde xxx é o resto do stream. [67].
Pode ser mostrado que se o próximo bit devido a um half-point zooming for um bit “b” este será
seguido por bits opostos a b tantos quantos forem os quarter-point zoomings antes do próximo
half-point zooming.
Desde que o intervalo alcance qualquer valor no range [0.25, 0.5] ou [0.5, 0.75] a codificação
pode ser encerrada enviando o par de bits “01” se o limite superior do intervalo estiver abaixo de
0.75 ou “10” se o limite inferior exceder 0.25.
Com base no codificador aritmético, surgiram algumas variações do método. Como exemplo.
1. Q-coder,
2. QM-coder usado nos padrões JBIG e JPEG Arithmetic (IBM, Mitsubishi e Lucent)
3. MQ-Coder: Usado nos padrões JBIG2 e JPEG2000 (IBM e Mitsubishi)
51
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4. M-coder
O Q-coder é uma nova forma de codificador aritmético binário adaptativo. A codificação binária
aritmética parte da técnica derivada de conceitos básicos introduzidos por Rissanen, Pasco, e
Langdon, porém com certas convenções a fim de resolver problemas práticos de implementação.
O Q-coder incorpora uma nova técnica para estimar as probabilidades com extrema simplicidade
aliado a um robusto mecanismo para estimar as probabilidades adaptativamente durante o
processo de codificação [66]
O Q-coder tem por características a separação entre o modelo de codificação e máquina usada na
codificação; a quantização das probabilidades em frações potências de 2(2-Q); Precisão finita e
tratamento de Carry-over: Bit stuffing.
O QM-coder tem o alfabeto de entrada no formato binário, e para ganhar velocidade eliminou
multiplicações e possui seus próprios meios de modelagem. É implementado comercialmente,
pela MITSUBISHI SEMICONDUCTOR (LSI) - M65762FP(QM-CODER).
No QM-coder as multiplicações foram substituídas por operações de aproximação ou rolagem de
bits a esquerda. O símbolo com maior probabilidade no modelo fica em MPS (Most. Probable.
Symbol) e os de menor probabilidade no LPS (Least. Probable Symbol). O intervalo no QMcoder é dividido de modo que o subintervalo LPS está na parte superior ao subintervalo MPS. O
intervalo é “A” a probabilidade estimada de LPS é “Qe”. A probabilidade ideal estimada de MPS
poderia ser (1-Qe). O comprimento do respectivos subintervalos são A ⋅ Qe e A ⋅ (1 − Qe) [67].
A+C
LPS
A Qe
C+A-Qe A
MPS
A (1-Qe)
C
2.28 – Subdivisão interna do intervalo no QM-coder. Fonte [67].
52
Dissertação de Mestrado– LASID - PPGI/DI UFPB
A seguir, na Figura 2.29, tem-se uma comparação entre o codificador aritmético e o QM-coder:
Compression with
arithmetic coding
Modelling:
Coding:
Compression
with QM-coder
Modelling:
Processing
the image
Determining
the context
Determining
the prob.
distribution
Arithmetic
Coding
Processing
the image
QM-coder:
Determining
the prob.
distribution
Determining
the context
Updating
model
Arithmetic
Coding
Updating
model
2.29 – Codificador Aritmético X QM-coder. Fonte[67].
2.5.9
PPM
O algoritmo Prediction by Partial Matching (PPM) [10][11], introduzido em 1984 por Cleary e
Witten, é uma técnica de compressão baseada na modelagem estatística adaptativa e na predição
por contexto. O PPM é considerado um dos compressores de propósito genérico mais eficaz da
atualidade na sua variação PPM-C introduzido por Mofaft.
O modelo PPM utiliza um conjunto de no máximo K símbolos precedentes como contexto para
estimar a distribuição de probabilidades condicionais para o próximo símbolo da mensagem. O
modelo alimenta um codificador aritmético, que atribui a cada símbolo um número de bits
praticamente igual a sua informação condicional, que por sua vez depende da probabilidade de
ocorrência do símbolo condicionada ao contexto [12]. Assim, o esquema de codificação
aritmética é capaz de praticamente igualar a entropia da fonte em todos os casos, atingindo
compressão máxima para o modelo utilizado [10][12].
Algumas características do PPM são :a alta taxa de compressão devido a sua adaptabilidade, ao
uso de contexto e ao uso do codificador aritmético; ineficiência em termos de tempo para
compressão devido a complexas estruturas de dados utilizadas para armazenamento de dados de
contexto, à grande quantidade de cálculos de precisão flutuante para geração do código de saída,
e a atualização de todas as freqüências para cada nova entrada;
devido à sua simetria a
53
Dissertação de Mestrado– LASID - PPGI/DI UFPB
descompressão exige tempo na mesma ordem de grandeza que a descompressão;
requer
implementação cuidadosa para obter-se a taxa de compressão ótima que o método pode oferecer.
O PPM mantém contextos de todos os tamanhos inteiros menores que k, e efetivamente combina
as diferentes distribuições, usando um mecanismo de escape. Inicia-se o modelo com o valor
mais alto de k. Se um novo caractere é encontrado no contexto, significa que o contexto não pode
ser usado para a codificação do caractere então um símbolo de escape é transmitido como sinal
para a saída, situação denominada evento de escape. Sendo assim, o algoritmo continua sua busca
no contexto para o próximo valor inferior de k .
Este processo é repetido para tamanhos cada vez menores de k até que se encontre o símbolo em
questão. Nesse caso, o caractere é codificado com a distribuição de probabilidades condicionadas
àquele contexto. A estrutura de dados é usada para armazenar todas as probabilidades nos
diferentes modelos de contexto, como mostrado na Tabela 2.4, um exemplo clássico do modelo
PPM após o processamento da string abracadabra [61].
2.4 - Modelo PPM após processamento da string abracadabra. Fonte[61].
54
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.6
Barramento USB
Em meados da década de 1990 surgiu o USB (Universal Serial Bus) promovido principalmente
pela Intel. No final da década de 1990 o USB começou a conquistar espaço no mercado de PCs.
Sua função principal é promover a conexão de vários tipos de periféricos e equipamentos de
modo simples, eficiente e com bom desempenho em contraste ao modo anterior em que se
necessitava de interfaces complexas e variadas.
O USB possui algumas características próprias, tais como:
• Padronização dos conectores.
• O cabo USB possui quatro fios, sendo dois para a transmissão de dados e dois para
alimentação, proporcionando aos dispositivos a obtenção de alimentação diretamente pelo
cabo.
• Plug and Play, tecnologia criada com o objetivo de fazer com que o computador reconheça
e configure automaticamente dispositivos que seja instalado, facilitando a expansão
segura dos computadores e eliminando a configuração manual.
• Hot Plugging, que é a possibilidade de conectar e desconectar dispositivos com o
computador ligado. No instante em que um dispositivo USB é conectado, ele informa ao
computador sobre a sua presença.
O USB possui um conector universal que permite ao usuário adicionar periféricos, apenas
conectando-os ao computador através de um cabo, permitindo transferências a 1,5 ou 12 Mbits/s
para a versão 1.0/1.1 e até 480 Mbits/s para a versão 2.0.
Dois identificadores são usados para marcar um dispositivo: o ID de vendedor e o ID de produto.
Ambos IDs são registrados no descritor do dispositivo USB. O ID de vendedor (VID) marca o
fabricante e é normalmente designado pelo USBIF (Universal Serial Bus Implementers Forum).
O ID de produto (PID) é (como o VID) um número de 16 bits e marca o produto. A atribuição é
feita pelo fabricante do dispositivo. Para o PID não há nenhuma restrição administrativa do
USBIF como no VID.
55
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2.7
Trabalhos Relacionados
Foram estudados os algoritmos de codificação de Huffman, de Golomb, o LZ78 e o LZW, PPM
Binário + codificador Aritmético. Contudo apenas o PPM binário como codificador aritmético
mostrou-se apto a atender as necessidades impostas no trabalho.
O código de Huffman e o de Golomb já foram implementados no LASID da UFPB; o LZ78 e o
LZW são técnicas que usam dicionário o que consome muita memória; As técnicas introduzidas
por Batista[58] e POEL[42] mostram excelentes resultados e em alguns caso com níveis de
compressão excelentes, utilizando compressão baseada em DCT (Discrete Cosine Transform);
quantização e codificação.
(Batista, [58])
Batista [58] propôs um método de compressão de sinais eletrocardiográficos baseada na
transformada do cosseno discreta. Em seu compressor específico para ECG, enfatiza-se a
qualidade da reconstrução, pois com uma PRD de apenas 3%, atingiu-se uma RC média de 13,3:1
e em alguns sinais com a mesma PRD chegou-se a RCs superiores a 40,0:1. O compressor
combina DCT, quantização uniforme com zona morta ótima e codificação de entropia. O
compressor utiliza compressão com perdas.
(POEL, [42])
POEL [42] propôs um método para a codificação e compressão de sinais eletrocardiográficos
com perda baseado na transformada discreta do cosseno, também com ótimos resultados.
(Choong et al, [72])
O trabalho apresenta a implementação de um compressor sem perdas utilizando o PPM com o
codificador aritmético implementado em FPGA. Contudo, por questões de simplificação o
método apresentado usa o modelo de Markov de ordem 0.
56
Dissertação de Mestrado– LASID - PPGI/DI UFPB
(Zúñiga-Grajeda et al, [73])
Zúñiga-Grajeda et al propõem a implementação do PPMC em FPGA para incrementar a
velocidade de compressão. Por motivos de simplicidade o algoritmo PPMC é implementado
apenas em ordem 0 com dois dicionários de contexto, um pra ordem 0 e outro pra ordem -1.
É bastante complexo o projeto de hardware, por envolver conceitos pouco analisados pela
computação de alto nível tais como, questões de consumo, potência, tempo de processamento,
mobilidade, baixos recursos de memória e confiabilidade. Além do que, não raro, projetos na área
de hardware envolvem equipes multidisciplinares (equipe digital, equipe analógico, equipe de
software e de testes).
Os módulos desenvolvidos neste trabalho podem ser reutilizados em aplicações de hardware
bastando apenas o conhecimento de suas interfaces, além do que, modificações ou manutenções
em qualquer um dos módulos podem ser feitas sem interferência ao demais, desde que não mude
a interface.
O modelo PPM implementado possui um K máximo ajustável, bastando mudar seu valor na
cláusula apropriada, faz chaveamento de contexto, escape e possui limites ajustáveis em tempo de
execução. Os limites são fixados também em uma cláusula apropriada, e em tempo de execução
são renormalizados. O código aritmético implementado possui os limites de precisão máxima
igualmente ajustáveis; totalmente implementado sem uso de aritmética flutuante e com as
funções internas bem comentadas permitindo sua substituição ou manutenção de modo fácil e
rápido. O algoritmo manteve em sua lógica as características de generalidade podendo facilmente
ser reutilizado em outros projetos.
O exposto acima, reflete, portanto, o diferencial deste trabalho e sua importância para outros
trabalhos que podem utilizar os módulos ora desenvolvidos para objetivos outros que não os
deste trabalho.
57
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CAPÍTULO 3
3 Sistema Proposto
3.1
Modelo de referência implementado em JAVA
Uma vez escolhido o método de compressão adequado e suas características, foi implementado
um modelo de referência, utilizando linguagem de alto nível, JAVA, contendo o modelo PPM
Binário mais o codificador aritmético, utilizando código Gray e decomposição em planos de bits,
onde para cada plano se associa um modelo PPM binário.
3.2
Estudo comparativo preliminar
Com o modelo em alto nível, foram utilizados 16 sinais do banco de dados MIT-BIH Arrhythmia
Database, muitos dos quais escolhidos por serem dos mais difíceis de comprimir, devido à
presença de ruído ou arritmias severas, visando avaliar casos desafiadores para dispositivos
portáteis como Holters.
O MIT-BIH foi desenvolvido por pesquisadores que investigavam métodos para análise em
tempo real do ritmo cardíaco através de ECGs (1975 -1979), nos laboratórios do MIT
(Massachusetts Institute of Technology – Instituto de Tecnologia de Massachusets) e do BIH
(Beth Israel Hospital). Devido ao crescimento das pesquisas, os pesquisadores resolveram
compartilhar o banco com a comunidade cientifica e acadêmica, o que aconteceu em 1980
(primeira edição); em 1988 (segunda edição) e em 1992 (última edição, que pode ser adquirida na
internet desde 1997).
O banco tem sua maioria formada com dados colhidos dos próprios pacientes do BIH para
tratamento. O primeiro grupo de registros, escolhidos aleatoriamente, é numerado de 100 a 124
totalizando 23 registros por estar ausente os números 110 e 120.
58
Dissertação de Mestrado– LASID - PPGI/DI UFPB
No segundo grupo os sinais são de pacientes portadores de fenômenos cardíacos raros e são
numerados de 200 a 234 totalizando 25 registros por ausência de 10 números. Cada registro
contem dois canais (canal 0 e canal 1), coletados quase simultaneamente, com 65024 amostras
por canal.
Foram utilizados 16 sinais do banco de dados MIT-BIH Arrhythmia Database, muitos dos quais
escolhidos por serem dos mais difíceis de comprimir, devido à presença de ruído ou arritmias
severas, visando avaliar o pior caso de compressão para dispositivos portáteis como Holters. O
sinal 215, canal 1, representado na Figura 3.1 foi o que resultou na menor compressão, com RC =
2,10:1 para K=7.
Foram testados valores de contexto máximo K entre 0 e 10. O gráfico representado na Figura 3.2,
mostra que a compressão melhora substancialmente quando se passa de K =0 para K=1 e se
mantém praticamente estável para K>1 decrescendo após o K=7. Com K=7 atinge-se a RC
máxima de 2,46:1.
Sinal 215 canal 1
3.1 – ECG 215 – primeiro canal – do MIT-BIH.
Para implementações em hardware, que exigem soluções com recursos reduzidos, o estudo
mostra que, ao se escolher um K=1, já se obtém uma compressão próxima da máxima para o
método proposto a um custo muito menor do que com o K ótimo, K=7. Com um K=7, a RC é de
2,46:1 utilizando 510 elementos no vetor para os contadores. Com K=4 o tamanho do vetor é de
62 elementos, ocorrendo assim, uma redução da quantidade de memória de aproximadamente
oito vezes em relação a K= 7, mantendo a compressão média em aproximadamente 2,44:1. Para
K=1, o tamanho do vetor cai para apenas seis elementos, cerca de 85 vezes menor do que com
K=7 e com RC = 2,38:1 muito próxima da máxima.
59
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2,5
k0
k1
2
k2
k3
1,5
k4
k5
1
k6
k7
0,5
k8
k9
0
Compressão / Médias de k´s
k10
3.2 – Gráfico da compressão percentual média.
O referido estudo foi realizado em um microcomputador com processador INTEL x86 Family 15
Model 4 Stepping 1 GenuineIntel ~2400 MHz, 512 MBytes de memória RAM, disco rígido
SATA com 80 GBytes, sistema operacional Windows XP 5.1.2600 Service Pack 2, Máquina
Virtual Java versão 1.5.0_06-b05 com o Eclipse 3.2.0. Um arquivo de 317Kbytes, com 65024
amostras é comprimido/descomprimido em aproximadamente 550 milisegundos, aí inclusos o
tempo de leitura e escrita em disco rígido. Este tempo inclui todas as etapas, com operações
muito rápidas quando comparadas às operações de leitura e escrita em disco.
Este estudo revelou que o método de compressão de arquivos utilizando código Gray,
decomposição em planos de bits e o algoritmo PPM indica que a melhor compressão ocorre
observando um contexto de tamanho máximo igual a sete, resultando em uma RC de 2.46:1. Isso
significa que o compressor proposto foi capaz de reduzir arquivos a menos da metade do seu
tamanho original, sem perda de informação.
Contudo, com a utilização de um contexto extremamente limitado, de tamanho máximo um, se
obtém uma RC = 2,38, muito próxima à máxima, com redução da ordem de 85 vezes nos
requisitos de memória.
Batista et al. [9] apresentam o melhor resultado com razão de compressão (RC) média de 2,69:1
utilizando P2 + Huffman; contudo, deve-se levar em consideração a dificuldade de
60
Dissertação de Mestrado– LASID - PPGI/DI UFPB
implementação do algoritmo de Huffman em hardware pela necessidade de ordenação da árvore
binária e seu crescimento dinâmico, que torna muito complexa a descrição e síntese do circuito
por requerer técnicas como máquinas de estados.
Com uma RC média de 2.38:1 para um K=1, o método proposto atinge RC próxima da RC do
compressor P2 + Huffman abordado por Batista et al. [9], sendo porém, muito mais simples de
implementar por usar estruturas fixas e pouca memória, dispensando alocação dinâmica,
ordenamento e cálculos complexos.
O estudo revelou ainda que os resultados indicam que um esquema de modelagem avançado
produz uma compressão eficaz e foi publicado como artigo no IV Congresso Latino Americano
de Engenharia Biomédica [14].
3.3
Descrição do Sistema
As arquiteturas muitas vezes são construídas através de descrições informais e usualmente,
representadas de forma abstrata utilizando diagramas de caixa e linha, acompanhadas de texto
explicativo, num processo empírico. A informalidade destas descrições podem acarretar
complicações, tais como: o significado do projeto pode não ser claro; comprometimento da
consistência, completeza e correção dos diagramas, que não podem ser formalmente analisadas;
restrições arquitetônicas assumidas no início do projeto podem não ser asseguradas à medida que
o projeto/sistema evolui. São necessárias notações formais para descrições arquitetônicas e
técnicas de análise mais rigorosas, como por exemplo, as abordadas no item 2.3.4.
O projeto apresenta adequações dos modelos necessários ao processo de implementação da
arquitetura dedicada em hardware, procurando manter as características desejáveis a exemplo de
uma abordagem visando o reuso, facilitando projetos futuros, em que várias partes necessárias
para se produzir um sistema já existem e já foram testadas, restando somente colocá-las em
conjunto, ou criar outras partes, quando necessário. O reuso é um problema de funcionalidade e
não de estrutura.
Os módulos desenvolvidos possuem características como estilo de código, comentários,
especificação de testes e documentação, indispensáveis em um core reusável. A elaboração e
61
Dissertação de Mestrado– LASID - PPGI/DI UFPB
testes foram realizados com ferramentas de EDAs (Eletronic Design Automation) disponíveis no
mercado e detalhadas a seguir.
Obter uma arquitetura de hardware e software adequadamente especificada é um fator crítico para
o sucesso no desenvolvimento de um sistema que contemple as necessidades de compressão do
sinal de eletrocardiograma.
O sistema completo de aquisição e compressão de sinais de ECG pode ser visto na Figura 3.3
abaixo.
Sistema Portátil
Microcontrolador
+
Compressor
Memória
3.3 - Arquitetura do Projeto.
Em um dos extremos da arquitetura temos a aplicação e no outro extremo os canais de sinais
analógicos. A aplicação é o sistema responsável pela exibição dos dados coletados no dispositivo
portátil. O dispositivo por sua vez, é responsável pelo processo de conversão de sinais analógicos
e compressão dos mesmos depois de digitalizados.
O processo de conversão é iniciado após a configuração do sistema portátil, em que é informada a
freqüência de amostragem e dos canais de atuação para o circuito controlador utilizando a
interface USB DLP-USB245M. Uma vez realizada a configuração, o controlador informa ao
conversor AD574A a taxa de amostragem em que ele deve operar e, ao multiplexador os canais
que serão utilizados na digitalização, já que há a possibilidade de conversão de até oito canais
62
Dissertação de Mestrado– LASID - PPGI/DI UFPB
distintos. A conversão é iniciada ao comando do usuário e, durante o processo de aquisição a
cada pulso de relógio os dados gerados pelo ADC são digitalizados e enviados ao compressor,
que após compactá-los, os envia ao micro-controlador que se responsabiliza pelo seu
armazenamento em memória.
Para cada dado recebido, o controlador anexa a indicação do canal de onde foi retirada a amostra
e envia este novo dado para armazenamento. É durante esse processo de conversão que há uma
completa interação entre todos os elementos da arquitetura. O término desse processo é dado após
o comando de encerramento enviado pelo usuário.
3.4
Ferramental utilizado
Para poder desenvolver o sistema proposto foi necessária a utilização de ferramentas variadas,
devido às necessidades de implementação específicas em cada etapa.
Linguagens de programação e linguagens de descrição de hardware:
1. VHDL;
2. Pascal;
3. JAVA;
A parte relacionada com o desenvolvimento em hardware foi necessária a utilização de CADs
(Computer Aided Design) específicos de EDAs.
• Quartus II da Altera;
• ModelSim SE 6.3
Para o desenvolvimento em software foram utilizados as ferramentas:
• Borland Delphi
• Eclipse SDK 3.3.1
63
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Outros recursos utilizados foram o SDL Suíte, DLP-USB245M
Manual e o D2XX
Programmer's Guide.
3.5
Aplicação desenvolvida
A aplicação LASID-USB que controla o conversor foi desenvolvida em Delphi e está dividido na
parte de controle e aquisição dos dados e na parte de visualização dos dados capturados bem
como sua visualização em tempo real (SDL Suite).
A aplicação desenvolvida, Figura 3.4, está basicamente dividida em:
Controle de protocolo: Parte responsável por montar as palavras de controle e enviar para o
conversor AD no padrão do protocolo de comunicação desenvolvido, para determinar a
velocidade, freqüência de operação, os canais a serem amostrados, abrir e fechar porta de
comunicação, iniciar e parar a aquisição dos dados segundo o operador do sistema.
software
Conversor AD
Interface USB
hardware
Controle
Protocolo
Visualização
On line
Tempo real
Validação
e
Tratamento
Controle
de
Armazenamento
Controle
TEMPO
Visualização
Off line
Dados
3.4 – Software de controle – Conversor LASID USB 12Bits.
Controle de tempo: é o módulo responsável por controlar a quantidade de tempo em que o
sistema deve operar realizando a aquisição de dados. O tempo é definido em segundos, e ao seu
termino o sistema é automaticamente desligado, o que permite monitoramento por um período
64
Dissertação de Mestrado– LASID - PPGI/DI UFPB
longo de tempo. Alternativamente o módulo também permite que seja determinado, ao invés de
tempo, um número de amostras predefinidas. Por exemplo, realizar aquisição de dados até que
sejam totalizadas 65000 amostras no arquivo.
Validação e Tratamento: Este módulo é responsável por fazer a leitura dos dados do buffer do
dispositivo USB e recompor as amostras verificando sua integridade e realizando tratamento de
erro a fim de detectar possíveis perdas de amostras. Ao final desse processo é contabilizado e
disponibilizado um relatório de verificação de integridade.
Controle de Armazenamento: Módulo responsável por receber os dados e realizar a identificação
e separação por canais ao mesmo tempo em que os grava em arquivo ou os envia para o módulo
de visualização em tempo real.
Visualização Off line: Módulo responsável por visualizar os sinais digitalizados a qualquer
tempo, ou imediatamente após o término da aquisição dos sinais ou abrindo um sinal já
existente e armazenado. Esse módulo implementado com o recurso das bibliotecas Tchar do
Delphi também permite a visualização individual ou simultânea dos oito canais amostrados.
Visualização On line: Este módulo permite a visualização do sinal ao mesmo tempo em que está
sendo amostrado. O recurso é implementado com o uso das bibliotecas SDL Component Suíte
que é uma coleção de componentes com apoio ao uso científico e da engenharia. O pacote
ChatPack contém suporte a gráficos e diagramas para uso com escalas arbitrárias, gráficos em 3D
que podem ser manipulados e rotacionados de forma interativa além de gráficos em tempo real.
3.6
Protótipo do Conversor A/D
O protótipo do conversor A/D é um dos principais elementos da arquitetura, pois ele engloba
todos os componentes físicos necessários para que a conversão de sinais analógicos em digitais
possa ser realizada.
Inicialmente o conversor A/D foi desenvolvido sem o uso do módulo compressor, Figura 3.5. O
módulo compressor, detalhadamente abordado mais a frente, foi desenvolvido para permitir sua
inclusão de forma “modularizada”. Como conseqüências diretas dessa decisão de projeto surgem
65
Dissertação de Mestrado– LASID - PPGI/DI UFPB
vantagens como o reuso do compressor, sua troca de modo facilitado, o aperfeiçoamento do
sistema bem como a facilidade de sua manutenção.
3.5 – Protótipo Conversor AD sem o módulo compressor.
Em um dos extremos da arquitetura temos a aplicação e no outro extremo os canais de sinais
analógicos. A aplicação é o sistema responsável pelo início e fim de todo o processo de
conversão de sinais analógicos e também pelo tratamento dos dados digitalizados. A aplicação
utiliza a dll “d2xx.dll” para chamar as funções implementadas na interface USB.
O processo de conversão é iniciado quando a aplicação envia um sinal contendo a configuração
da freqüência de amostragem e dos canais de atuação para o circuito controlador utilizando a
interface USB DLP-USB245M. De posse desse sinal, o controlador informa ao conversor
AD574A a freqüência de amostragem que ele deve operar e informa ao multiplexador os canais
que serão utilizados na digitalização, já que há a possibilidade de conversão de até oito canais
distintos. A conversão é então iniciada e, durante o processo, a aplicação se responsabiliza pela
aquisição e o armazenamento dos dados digitalizados, que são gerados pelo conversor A/D a cada
pulso de relógio e enviados ao compressor, que após compactar os dados, os envia ao
controlador.
Para cada dado recebido, o controlador anexa a indicação do canal de onde foi retirada a amostra
e envia este novo dado à interface USB, que irá aguardar a próxima leitura e enviar os dados para
a aplicação. É durante esse processo de conversão que há uma completa interação entre todos os
elementos da arquitetura. O término desse processo ocorre após o envio de um sinal de
66
Dissertação de Mestrado– LASID - PPGI/DI UFPB
encerramento pela aplicação, que então pode fazer a representação gráfica do sinal sob a forma
digital.
3.6.1
Interface USB
O trabalho utiliza uma interface de comunicação USB criada pela DLP Design que possui baixo
custo e uma alta usabilidade na construção dos mais variados tipos de sistemas digitais
(prototipagem de dispositivos). A interface DLP-USB245M, Figura 3.6, funciona basicamente
como uma fila do tipo FIFO, o que a torna um método fácil e eficaz na transmissão de dados
entre o host e o controlador.
3.6 - DLP-USB245M.
Fonte [68].
Em sua composição consta um de uma EEPROM de referência 93C46 e um outro chip de nome
FT245BM cuja fabricação pertence à FTDI (Future Technology Devices International Ltd). A
EEPROM possibilita a customização de parte da configuração básica da interface, como a taxa de
transmissão e a forma de comunicação, informações como o PID e VID da interface USB, bem
como seu número serial. O responsável por implementar uma FIFO tanto de leitura como de
escrita que utiliza os 8 bits do barramento de comunicação de forma bidirecional é o FT245BM,
mostrado na Figura 3.7.
3.7 – FT245BM. Fonte[68].
O dispositivo DLP-USB245M, possui 24 pinos de comunicação. Destes pinos 8 são reservados
para a comunicação bidirecional, formando assim um barramento de 8 bits. Os pinos WR, RD#
67
Dissertação de Mestrado– LASID - PPGI/DI UFPB
são pinos de entrada e servem para que um dispositivo externo dispare o ciclo de escrita ou de
leitura, respectivamente. Os pinos TXE# e RXF# indicam o estado atual da FIFO, ou seja, se a
FIFO de transmissão está cheia ou se a FIFO de recepção está vazia, respectivamente.
O DLP-USB245M é dotado de um cristal de quartzo com freqüência de 6Mhz. Através dele é
possível disparar os ciclos de leitura e escrita. A Figura 3.8 ilustra um ciclo de escrita no
dispositivo, bem como os tempos máximos e mínimos dos sinais, definidos pelo fabricante.
De acordo com o manual do usuário do dispositivo, a escrita de um byte na FIFO de transmissão
é feita através do barramento D[7..0] e do sinal WR.
O dado presente no barramento é escrito na FIFO na transição negativa do sinal WR. O sinal
TXE# indica quando a FIFO está cheia (TXE#=1).
3.8 - Ciclo de escrita do DLP-USB245M Fonte[69].
68
Dissertação de Mestrado– LASID - PPGI/DI UFPB
O ciclo de leitura, Figura 3.9, se assemelha bastante com o de escrita, lembrando que se deve
seguir rigorosamente os tempos pré-estabelecidos pelo fabricante do dispositivo.
O sinal RXF# indica quando a FIFO está pronta para ser lida, ou seja, há no mínimo 1 byte na
FIFO (RXF# = 0). Jogando o sinal RD# para zero, faz-se com que os dados existentes no buffer
de recepção sejam lidos. Para a captação desses dados, o sinal de RD# dever permanecer em zero
por no mínimo 50 ns.
3.9 - Ciclo de leitura do DLP-USB245M. Fonte[69].
69
Dissertação de Mestrado– LASID - PPGI/DI UFPB
3.6.2
Micro-controlador
O circuito controlador USB/Conversor A/D é implementado em um chip FPGA fabricado pela
ALTERA, o EPM7128SLC84-7 (no caso sem o módulo compressor), Figura 3.10. Para o
desenvolvimento desse controlador foi utilizada a ferramenta de desenvolvimento da ALTERA, o
QUARTUS II. Essa ferramenta integra descrição da entidade e do comportamento em linguagem
VHDL, depuração e simulação do circuito, validando a arquitetura.
3.10 - Descrição em VHDL do Protótipo do Conversor AD.
Os blocos principais nesse circuito controlador são:
•
módulo de base de tempo, responsável por gerar as freqüências menores, a partir de um
cristal de 25Mhz, de 1MHz, 100KHz, 1KHz e assim obter um valor bastante aproximado
do solicitado pelo usuário;
70
Dissertação de Mestrado– LASID - PPGI/DI UFPB
•
controlador do conversor, responsável pelo gerenciamento dos dados fornecidos pelo
conversor A/D, que de posse da freqüência de amostragem, gerada pelo bloco anterior,
faz a leitura dos dados entregues pelo conversor A/D, na freqüência solicitada e nos
canais solicitados;
•
controlador da USB, que envia os dados para o barramento USB reagrupando-os de 12
para 8 bits.
3.6.3
Conversor A/D
A conversão de sinais analógicos em seus correspondentes digitais é realizada através de técnicas
e algoritmos de conversão. O conversor utilizado neste trabalho, o AD574A, produzido pela
Analog Devices, Figura 3.11, e se baseia na técnica de aproximações sucessivas. A técnica de
aproximações sucessivas introduz a maneira de pesagem das balanças de fiel ao centro. Nestas
balanças, quando uma massa desconhecida (tensão amostrada) é colocada num dos pratos, o
operador começa por colocar no outro prato o maior peso-referência de que dispõe (o bit mais
significativo, ou MSB) e decide, observando o fiel, se ele é excessivo ou se tem que adicionar o
peso-referência seguinte.
3.11 - Conversor AD574A.
Na primeira hipótese, retira-se o peso-referência do prato (atribuindo zero ao bit). Na segunda
hipótese, o peso-referência utilizado permanece no prato (atribuindo um ao bit). Esta operação se
repete sucessivamente até chegar ao último peso-referência de que se dispõe (o bit menos
significativo, ou LSB).
Este conversor foi escolhido por sua estabilidade na conversão de sinais analógicos, contendo
uma variação máxima, para mais ou para menos, de 1 LSB, e por possuir 12 bits de resolução, o
71
Dissertação de Mestrado– LASID - PPGI/DI UFPB
que significa que os dados convertidos representam a entrada analógica como uma fração de sua
escala, que varia de 0 a 4095, adequada para sinais de ECG, de acordo com as recomendações de
qualidade da AHA (American Heart Association) [75].
3.7
Compressor
O método de compressão apresentado consiste em codificar o sinal com o código Gray e em
seguida fazer sua decomposição em planos de bits, que são então codificados separadamente por
um PPM adaptado para alfabeto binário. Esta abordagem simplifica consideravelmente as
estruturas utilizadas reduzindo os requisitos computacionais do compressor e tornando possível
sua implementação em hardware inclusive utilizando FPGA.
Trabalhando com vetores fixos, sem alocação dinâmica de estruturas de dados e com um K
pequeno, mas suficiente para obter um bom nível de compressão, os requisitos de memória são
muito reduzidos, permitindo a implementação em hardware voltada para dispositivos portáteis.
Na Figura 3.12 é possível observar a organização do vetor de memória para um determinado K.
Apenas a informação dos contadores de ocorrências de 0’s e 1’s, Cont0 e Cont1 em cada contexto
precisa ser armazenada em memória, devido à organização rígida da estrutura. Pela posição dos
contadores, fica implícito que os dois primeiros correspondem aos contadores de 0 e 1 para K=0;
os dois próximos são os contadores de 0 e 1 no contexto 0, para K =1; os dois seguintes são os
contadores de 0 e 1 no contexto 1 para K =1, e assim sucessivamente. Quando K = c, onde c é
uma constante positiva, é necessário armazenar todos os contadores para K menor ou igual a c.
K= 0
K= 1
Contexto 0
Cont 0
Cont 1
Cont 0
Cont 1
K= 2
Contexto 1
Cont 0
Cont 1
...
Contexto 00
Cont 0
Cont 1
3.12 - Estrutura da memória.
72
Dissertação de Mestrado– LASID - PPGI/DI UFPB
A parte inferior da Figura 3.12 ilustra a estrutura do vetor para K=0 com 2 células, K=1 com 6
células, sendo 2 do K=0 e 4 do K=1, e assim por diante.
Do acima exposto, utiliza-se a Equação 3.1 para mensurar o número de elementos do vetor fixo:
T= 2 ( K + 2) – 2
3.1
Na entrada do PPM é acoplado um módulo para converter o sinal para o código Gray, que é um
tipo de representação binária, onde dois números sucessivos diferenciam-se exatamente por um
bit. Alguns exemplos apresentados na Tabela 3.1.
3.1 – Código Gray.
Decimal
0
1
2
3
4
5
6
7
Binário
000
001
010
011
100
101
110
111
Gray
000
001
011
010
110
111
101
100
Em sinais digitais extraídos de sistemas físicos como eletrocardiogramas, os valores de duas
amostras adjacentes não variam muito devido à natureza contínua dos sinais, e assim, utilizando o
código Gray há uma redução acentuada na variação da representação binária entre amostras
sucessivas.
A decomposição em planos de bits permite que um sinal S de n bits por amostra seja dividido em
n seqüências binárias S0, S1, ..., Sn-1. Um bit na seqüência Si equivale ao i-ésimo bit da amostra na
mesma posição em S. A Figura 40 mostra a decomposição em planos de bits. Nesse exemplo,
Figura 3.13, cada amostra no sinal original possui 11 bits. Assim a decomposição gera 11 sinais
binários. O primeiro S0,é formado pelos bits menos significativos de cada amostra, e assim
sucessivamente.
73
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Amostra 1
Amostra 2
Amostra 3
Amostra 4
0
0
0
0
1
1
1
1
1
1
1
1
1
1
1
1
0
0
0
0
1
1
1
1
0
0
0
0
0
0
1
1
1
1
0
0
1
1
1
0
1
0
0
1
...
S10
...
S1 S0
3.13 - Decomposição em planos de bits.
O compressor foi dividido em módulos independentes. O diagrama em blocos do compressor
proposto está mostrado na Figura 3.14.
ARQUIVO
ORIGINAL
CÓDIGO
GRAY
DECOMPOSIÇÃO
EM BITS
PPM + ARITIMÉTICO
(COMPRESSOR)
ARQUIVO
COMPRIMIDO
3.14 - Diagrama em blocos do compressor proposto
74
Dissertação de Mestrado– LASID - PPGI/DI UFPB
O método de compressão proposto na Figura 3.15, consiste em codificar o sinal com o código
Gray e em seguida fazer sua decomposição em planos de bits para alimentar os modelos S0 a
S11, de compressores PPMs adaptados para alfabeto binário. Em seguida, na ordem em que
foram separados, os bits são enviados para o codificador aritmético,
ARQUIVO
ORIGINAL
CÓDIGO
GRAY
Segmentação em plano de bits
Compressor
PPM Bin
Modelo S0
PPM Bin
Modelo S1
PPM Bin
Modelo S2
PPM Bin
Modelo S3
PPM Bin
Modelo S4
PPM Bin
Modelo S5
PPM Bin
Modelo S6
PPM Bin
Modelo S7
PPM Bin
Modelo S8
PPM Bin
Modelo S9
PPM Bin
Modelo S10
PPM Bin
Modelo S11
ArithEncoder
BitOutput
ARQUIVO
COMPRIMIDO
3.15 – Diagrama em blocos expandido do compressor.
Trabalhando com vetores fixos, o PPM Bin constrói o modelo estatístico e alimenta o módulo
responsável pela codificação aritmética. O módulo BitOutPut envia os dados para a saída onde se
obtém um sinal com bom nível de compressão e baixos requisitos de memória.
75
Dissertação de Mestrado– LASID - PPGI/DI UFPB
3.7.1
Módulos do compressor
O compressor mostrado na Figura 3.15 possui uma configuração projetada para aumentar a RC.
Essa configuração usa o recurso de segmentação em planos de bits, apresentado na Figura 3.12,
código Gray e 12 modelos PPM binários. Os modelos são instanciados 12 vezes como cópia de
um mesmo objeto.
Componentes do sistema, de fato, são as classes:
1. Code Gray;
2. Segmentação em plano de bits;
3. PPM Binário
a. PPM Bin;
b. PPM Model;
4. Codificador Aritimético
a. ArithEncoder
b. BitOutPut;
3.7.1.1
Code Gray
Na Tabela 3.1 foi exemplificada a entrada em binário ou decimal de 0 até 7 e a saída em código
Gray. Dependendo da utilização do módulo é possível utilizá-lo com sua entradas em inteiro ou
em binário; contudo a função de conversão obedecerá a mesma lógica.
76
Dissertação de Mestrado– LASID - PPGI/DI UFPB
3.16 – Code Gray para 4 bits.
A mesma funcionalidade descrita em VHDL obedece a Equação 3.2, exemplificada na Tabela
3.2, como alternativa a implementação da Figura 3.16.
G(i) = B(i + 1) xor B(i)
3.2
3.2 – Código Gray para 4 bits.
3.7.1.2
Linha nº
Comandos
1
G(0) <= B(1) xor B(0);
2
G(1) <= B(2) xor B(1);
3
G(2) <= B(3) xor B(2);
4
G(3) <= B(3);
Segmentação em plano de bits
Na segmentação, utilizamos um MUX controlado de modo a fazer a leitura seqüencial das
entradas e no tempo certo entregar os bits lidos no módulo PPM correto, de 0 a 11, conforme
visto na Figura 3.16.
3.7.1.3
PPM Binário
O PPM Binário está dividido em duas classes, a PPM Bin e PPM Model.
77
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Stream de bits
Saida (Low,High,Total)
PPM Bin
Modelo PPM
3.17 – PPM binário
PPM Bin é a entidade responsável por realizar o controle do modelo PPM, Figura 3.17,
atualização e envio das estatísticas ao codificador aritmético, chaveamento de contexto e escape.
Ele interage diretamente com o PPM Model.
PPM Model é a parte responsável por realizar todo o levantamento estatístico dos símbolos que
apareceram na mensagem, Figura 3.17. Esse modelo é de difícil implementação no PPM
genérico, por precisar de sistemas com complexas estruturas de dados. Fato simplificado com o
uso do alfabeto binário, necessitando para isso a estrutura de memória exemplificada na Figura
39.
3.7.1.4
Codificador Aritmético
Está dividido em duas partes, o ArithEncoder e o BitOutPut (Figura 3.18).
Entrada
(Low, ,High, Total)
Saída seq. inteiros
ArithEncoder
BitOutput
3.18 – Codificador Aritmético.
78
Dissertação de Mestrado– LASID - PPGI/DI UFPB
ArithEncoder é a parte responsável por realizar toda a aritmética de alta precisão em que os
intervalos são sucessivamente criados para gerar a codificação.
O ArithEncoder possui alguns aspectos de implementação para evitar os aspetos indesejáveis
discutidos na seção 2.5.8.
O BitOutPut é responsável por guardar os bits enviados para a saída pelo ArithEncoder em um
buffer de 8 bits. Os bits são armazenados e obedecendo algumas regras vão se acumulando até
que sejam enviados para a saída do codificador aritmético definitivamente. Ele acumula os bits
enviados por half-point zooming ou os acumulados seguidamente por quarter-point zoomings.
3.7.2
Implementação do compressor
Com a arquitetura já definida e os elementos componentes implementados e testados um a um
por ferramental específico foi possível a simplificação da arquitetura exposta na Figura 3.15, que
teve por objetivo a avaliação do comportamento dos componentes do compressor operando em
conjunto.
Stream de bits
(Low,High,Total)
PPM Bin
Modelo PPM
ArithEncoder
BitOutput
ARQUIVO
COMPRIMIDO
3.19 – Compressor PPM binário com um modelo.
A Figura 3.19 mostra o compressor PPM binário contendo um modelo estatístico que recebe um
stream de bits e então procede com o levantamento estatístico enviando para o Codificador
Aritmético um intervalo (Low, High, Total), um para cada símbolo de entrada. O codificador
79
Dissertação de Mestrado– LASID - PPGI/DI UFPB
aritmético por sua vez, não envia para a saída um elemento por intervalo (Low, High, Total), que
recebeu. Dependendo da quantidade de half-point zooming ou quarter-point zoomings o
codificador pode até enviar em um único ciclo de clock mais de uma saída.
80
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CAPÍTULO 4
4 Resultados Obtidos
Os resultados ora apresentados são baseados no que foi produzido nas principais etapas do
projeto em hardware, objetivando não apenas sua correção funcional, mas também questões
como reutilização de componentes, e parametrizável com bastante facilidade de manutenção.
Serão descritos os resultados obtidos em cada etapa de desenvolvimento.
A Verificação funcional, secção 2.3.4, foi uma etapa bastante árdua como processo de
demonstração do correto funcionamento dos modelos apresentados, chegando a alguns casos a
consumir cerca de 70% do esforço de projeto e os testbenches representando até 80% do volume
total de código.
No desenvolvimento desse projeto foi utilizada a ferramenta de desenvolvimento da ALTERA, o
QUARTUS II, ferramenta que integra a descrição da entidade e do comportamento em linguagem
VHDL, depuração e simulação do circuito, validando a arquitetura. Contudo para a validação do
módulo compressor será necessário o uso de ferramental auxiliar de simulação para validar a
arquitetura, como o ModelSim previamente citados no item 3.4.
4.1
Protótipo Conversor AD e o Aplicativo LASID-USB
O protótipo do conversor foi implementado inicialmente no dispositivo EPM 7128SLC84-7 (sem
o módulo compressor), conforme visto na Figura 4.1.
81
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.1 - EPM 7128SLC84-7
A Figura 4.2 mostra em detalhes a implementação do conversor como protótipo em uma caixa
plástica, contudo pode ser observado que as dimensões do circuito, cabem perfeitamente em um
dispositivo com dimensões bastante reduzida da ordem de alguns poucos centímetros.
4.2 – Protótipo Conversor AD.
Para controlar o protótipo do conversor foi necessário desenvolver uma API em Delphi,
Aplicativo LASID USB, responsável pela aquisição e visualização em tempo real dos dados
enviados pelo protótipo do conversor com o uso de geradores de funções, fornecendo os sinais
elétricos com a possibilidade de variação de amplitude, freqüência e tipos de formas de onda,
como ondas do tipo quadradas, triangular ou dente de serra e senoidal. Ao final da aquisição, é
82
Dissertação de Mestrado– LASID - PPGI/DI UFPB
realizado uma etapa de verificação de integridade do sinal colhido e então o sinal é separado por
canal, um arquivo para cada canal.
Esses arquivos são separados observando a seguinte nomenclatura: Sinal completo (todos os
canais): “nome do experimento.txt”; Sinal separado por canais: “nome do experimento + canal +
data + hora + mim + seg . txt”; Verificação de integridade: “nome do experimento + resumo +
data + hora + mim + seg . txt”.
O arquivo é separado em 8 novos arquivos, cada um contendo os dados de seu respectivo canal,
desprezando o cabeçalho primeiro dígito do dado, que representa o canal convertido. No exemplo
da Figura 4.3, os dois primeiros bytes 01 e B0 são combinados 01B0 e o primeiro dígito
representa o canal ao qual esta informação pertence, no caso 1B0 está relacionado com o arquivo
“Teste1_Ch_1_2-3-2007_10-19-54.txt”.
4.3 – Exemplo dos arquivos gerados.
A Figura 4.4 ilustra um teste realizado através de verificação funcional onde a conversão e
plotagem do sinal foram realizadas sobre uma função senoidal, com amplitude próxima a mais ou
menos 3,0 Volts. A Arquitetura de software desenvolvida também contempla um módulo para
plotagem em tempo real dos dados com uso de estruturas FIFO.
83
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.4 – Verificação de aquisição de sinal senoidal.
4.2
Validação dos Módulos do compressor
A validação dos módulos do compressor, devido a complexidade natural imposta pelo método e
ao elevado volume de dados gerada em todas as etapas da codificação, foi realizada com
testbench seguindo a metodologia apresentada na Figura 2.13 [17] como referência e ainda,
utilizando como ferramenta de simulação o ModelSim SE PLUS 6.3 da
Mentor Graphics
Corporation.
Outro complicador é a compressão em tempo real, que necessitou um tratamento mais cuidadoso
para que as reações dos estímulos oriundos do seu ambiente ocorressem em prazos específicos,
revelando assim, a dicotomia existente entre os elementos teóricos e a prática no mundo real.
Cada um dos componentes do compressor foi utilizado isoladamente para garantir a integridade
de cada um. Para cada módulo foi criada uma Entidade de Teste específica. Uma vez cada
módulo validade eles foram unidos numa versão mais simples do codificador, exposto na Figura
3.19. Agora com os elementos unidos, foi criada uma entidade de teste para validar o
comportamento de todo o conjunto. O modelo de referencia em JAVA com 12 modelos PPM,
mostra que os níveis de compressão são interessantes e indicam a viabilidade do sistema. Como
cada módulo foi validado separadamente, a junção entre os módulos pode ocorrer de acordo com
as especificações de cada projeto, no entanto um segundo modelo de referencia em JAVA foi
84
Dissertação de Mestrado– LASID - PPGI/DI UFPB
criado, este agora para validar o modelo em hardware contendo um modelo PPM, apresentado
na Figura 4.5.
Modelo Alto nível - JAVA
ENTRADA
A
PPM Bin
ArithEncoder
SAÍDA
Modelo PPM
PPM
BitOutput
J
Codificador Aritmético
Modelo Baixo nível - VHDL
ENTRADA
A
PPM Bin
ArithEncoder
SAÍDA
Modelo PPM
PPM
BitOutput
V
Codificador Aritmético
4.5 – Estímulos no modelo alto e baixo nível.
Submetendo na entrada do modelo de alto nível como estímulo de entrada o arquivo “A”,
obtemos na saída do modelo um arquivo “J”. Fazendo o mesmo procedimento no modelo de
baixo nível VHDL, como mesmo arquivo de entrada, obtemos o arquivo de saída “V”. Tomando
por base que o modelo de alto nível está correto e serve como referencia para o modelo de baixo
nível, podemos concluir que o modelo de baixo nível é válido caso os arquivos “J” e “V” sejam
exatamente idênticos.
No modelo de alto nível JAVA, apresentado na Figura 4.5, foram submetidos 16 sinais do MITBIH, e colhidos 16 arquivos comprimidos como saída, para servirem de comparação com os
resultado apresentados no item 4.2.3.
85
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.2.1
Validação do PPM
Para a validação do módulo PPM foi criado uma entidade de teste test_ppm.vhd apresentado na
Figura 4.6 para testar a descrição do módulo PPM ppmen.vhd.
Entidade de projeto para o Teste
Driver
Checker
Arquivos
de
entrada
Arquivos
de
saída
Entidade Sob Teste
4.6 – Testbench do módulo PPM.
O modelo de referência em alto nível JAVA foi alimentado com os sinais de ECG do MIT-BIH,
105, 115, 119, 205, 215, 220, 230, todos com os dois canais (canal 0 e canal1), produzindo saídas
da forma (Low, High, Total), um arquivo para cada canal de todos os sinais.
Alimentando a entidade de projeto para o teste test_ppm.vhd com os mesmos sinais de entrada o
driver da entidade de teste converte os dados colhidos do arquivo em estímulos para a entidade
sob teste, no caso ppmen.vhd. À medida que os estímulos vão produzindo resultados o checker
vai verificando e armazenando a saída em disco ao mesmo tempo em que os estímulos de reposta
também são exibidos na tela em forma de onda, apresentados na Figura 4.7, em que os sinais que
refletem a saída estão indicados como low1,high2 e total3 (as três primeiras linhas) . O sinal
arithClose é responsável pela finalização do codificador aritmético quando seu valor vai para ‘1’,
o que acontece ao final da compressão quando o PPM envia o último conjunto low, high e total.
O sinal arithenable é responsável por habilitar o codificador aritmético e deve estar ativo em ‘1’
durante todo o processo de compressão. O sinal ppmEnable habilita o módulo PPM para iniciar a
compressão ativo em ‘1’ e o encoderClose é ativado quando do fim da última amostra e é ativo
86
Dissertação de Mestrado– LASID - PPGI/DI UFPB
em ‘1’ . Os dados são alimentados no compressor com o sinal bitIn, o qual aceita um stream de
bits como entrada.
4.7 – Forma de onda do PPM gerada no testbench.
Uma vez finalizado o teste, a comparação é feita de forma automática entre a saída do modelo de
referencia em alto nível com a saída do modelo de baixo nível. Em todos os casos, o modelo sob
teste correspondeu integralmente ao modelo de referência.
87
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.2.2
Validação do Codificador Aritmético
Para a validação do módulo do codificador Aritmético foi criado uma entidade de teste
test_arithen.vhd apresentado na Figura 4.8 para testar a descrição do módulo codificador
aritmético arithen.vhd.
Entidade de projeto para o Teste
Driver
Checker
Arquivos
de
entrada
Arquivos
de
saída
Entidade Sob Teste
4.8 – Testbench do codificador Aritimético.
O modelo de referência em alto nível JAVA foi alimentado com os sinais já citados
anteriormente, a diferença agora é que o conjunto de testes gerado é na forma da entrada do
arithen, ou seja, (Low, High, Total).
Alimentando a entidade de projeto para o teste test_arithen.vhd com os mesmos sinais de entrada
o driver da entidade de teste converte os dados colhidos do arquivo em estímulos para a entidade
sob teste, no caso arithen.vhd. À medida que os estímulos vão produzindo resultados o checker
vai verificando e armazenando a saída em disco ao mesmo tempo em que os estímulos de reposta
também são exibidos na tela em forma de onda, apresentada na Figura 4.9. Podemos notar como
entrada deste módulo os sinais low1, high2 e total3 ao passo em que a saída pode ser observada
nos sinais saída, saida2 e saida3. As saídas ficam ativas quando os sinais saidaativa, saida2ativa
e saida3ativa ficam ativas em ‘1’.
88
Dissertação de Mestrado– LASID - PPGI/DI UFPB
É possível perceber na forma de onda os estímulos de entrada para o codificador aritmético na
correta seqüência de low, high e total respeitada as cadências que o processo exige, sem com isso
causar nenhum atraso. Os sinais do MIT-BIH com 65024 amostras de entrada produzem uma
quantidade grande de sinais na saída, e todos iguais à saída gera pelo modelo de alto nível em
JAVA.
4.9 - Forma de onda do codificador aritmético gerada no testbench.
89
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Uma vez finalizado o teste, a comparação é feita de forma automática entre a saída do modelo de
referencia em alto nível com a saída do modelo de baixo nível. Em todos os casos, o modelo sob
teste correspondeu integralmente ao modelo de referência.
4.2.3
Validação do Compressor com um modelo PPM
Para a validação do módulo do compressor PPM Binário, foi criado uma entidade de teste
tcompressor_ppm_arith_estrutural.vhd apresentado na Figura 4.10 para testar a descrição do
módulo codificador aritmético compressor_ppm_arith_estrutural.vhd.
Entidade de projeto para o Teste
Driver
Checker
Arquivos
de
entrada
Arquivos
de
saída
Entidade Sob Teste
4.10 - Testbench do compressor PPM binário com um modelo.
O modelo de referência em alto nível JAVA foi alimentado com os sinais já citados
anteriormente, a diferença agora é que o conjunto de testes gerado é na forma de streams de bits
na entrada e uma seqüência de inteiro na saída que é codificada em binário para gravação em
arquivos ou memória.
Alimentando a entidade de projeto para o teste tcompressor_ppm_arith_estrutural.vhd com os
mesmos sinais de entrada o driver da entidade de teste converte os dados colhidos do arquivo em
estímulos para a entidade sob teste, no caso compressor_ppm_arith_estrutural.vhd. À medida
90
Dissertação de Mestrado– LASID - PPGI/DI UFPB
que os estímulos vão produzindo resultados o checker vai verificando e armazenando a saída em
disco ao mesmo tempo em que os estímulos de reposta também são exibidos na tela em forma de
onda, apresentada na Figura 4.11. Como entrada temos o sinal bitIn em que recebe um stream de
bits. O processso de compressão e iniciado com o sinal ppmEnable indo para ‘1’ e encoderClose
indo para ‘0’. A medida em que o stream de bits é processado, os sinais agora internos low1_int,
high2_int e total3_int vão alimentando o codificador aritimético e assim obtendo a saida nos
sinais saída, ,saida2 esaida3 que quando ativos apresentam um pulso em saidaativa , saida2ativa
ou saida3ativa.
4.11 - Forma de onda do compressor PPM Binário gerada no testbench.
91
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Uma vez finalizado o teste, a comparação é feita de forma automática entre a saída do modelo de
referencia em alto nível com a saída do modelo de baixo nível. Em todos os casos, o modelo sob
teste correspondeu integralmente ao modelo de referência.
4.3
Síntese
A seguir, é mostrado o resultado da síntese de cada módulo e configuração do compressor
abordado no trabalho. As tabelas estão dividas por módulo componente, família, dispositivo e
quadro resumo exibido pelo Quartus II. Na Tabela 4.1 é mostrado a síntese do conversor AD em
várias famílias da Altera a fim de observar aspectos relacionados à alocação de espaço para o
projeto e comparar com os outros módulos do projeto.
4.1 – Síntese Conversor AD.
CONVERSOR AD
Família/
Resumo
Dispositivo
MAX
EPM240T100C3
92
Dissertação de Mestrado– LASID - PPGI/DI UFPB
FLEX10K
EPF10K10LC84-3
MAX7000B
EPM7256BTC100-5
MAX7000S
EPM 7128SLC84-7
93
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CICLONE
EP1C3T100C6
CICLONE II
EP2C5T144C6
STRATIX
EP1S10F484C5
94
Dissertação de Mestrado– LASID - PPGI/DI UFPB
STRATIX II
EP2S15F484C3
4.2 – Síntese do módulo PPM.
PPM
Família/
Resumo
Dispositivo
CICLONE
EP1C12Q240C6
95
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CICLONE II
EP2C20F256C6
Na tabela 4.2 podemos observar a implementação do módulo PPM na família Ciclone e Ciclone
II, dispositivo de baixo custo da Altera sendo um dos menores e mais baratos que permitem o
processamento de sinais.
4.3 – Síntese do módulo Codificador Aritmético.
CODIFICADOR ARITIMÉTICO
Família/
Resumo
Dispositivo
CICLONE II
EP2C50F484C6
96
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Na tabela 4.3 temos a implementação do codificador aritmético, que também coube num Ciclone
II apesar as sua lógica configurável e com uso de uma aritmética de inteiros com um range
elevado.
A Tabela 4.4 mostra a síntese do modelo proposto na Figura 3.19, em que obtemos um
compressor com um modelo PPM binário aliado ao codificador aritmético e testado no item
4.2.3.
4.4 – Síntese do módulo compressor com um modelo PPM.
COMPRESSOR COM UM PPM E
UM CODIFICADOR ARITIMÉTICO
Família/
Resumo
Dispositivo
CICLONE II
EP2C70F672C6
A Tabela 4.5 mostra a síntese do modelo proposto na Figura 3.15, item 3.7, em que obtemos um
compressor com doze modelos PPM binário aliado ao codificador aritmético. Os componentes
foram sintetizados em um único dispositivo EP2S180F1020C3 da família Stratix II da Altera.
97
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.5 – Síntese do Compressor com 12 modelos.
COMPRESSOR COM DOZE MODELOS PPM E
UM CODIFICADOR ARITIMÉTICO
Família/
Resumo
Dispositivo
STRATIX II
EP2S180F1020C3
A Tabela 4.6 contém como resultado a síntese do circuito completo (Controlador do Conversor,
Controlador USB e Compressor) em um Circuito Integrado FPGA; dispositivo EP2S180F1020C3
da família Stratix II, demonstrando assim exeqüibilidade da arquitetura proposta inicialmente e o
sucesso de cata etapa vencida , dentre elas o mapeamento das classes do código JAVA do PPM
binário em funções VHDL; a análise dos requisitos computacionais, envolvendo a descrição
informal do compressor e de suas funcionalidades; a definição da arquitetura do compressor;
especificação em VHDL dos blocos e sub-blocos componentes da arquitetura.
98
Dissertação de Mestrado– LASID - PPGI/DI UFPB
4.6 – Síntese do compressor com 12 modelos mais o conversor AD.
COMPRESSOR COM DOZE MODELOS PPM E
UM CODIFICADOR ARITIMÉTICO + CONVERSOR AD
Família/
Resumo
Dispositivo
STRATIX II
EP2S180F1020C3
99
Dissertação de Mestrado– LASID - PPGI/DI UFPB
CAPÍTULO 5
5 Conclusão
A transformação mundial vivenciada atualmente no setor de tecnologia acarretou uma crescente
demanda na produção de hardware e software para sistemas embarcados, arquiteturas dedicadas
ou mesmo sistemas eletrônicos de um modo geral, exigindo assim, que o tempo de projeto seja
cada vez mais curto.
Este trabalho apresentou uma proposta de uma arquitetura completa para aquisição e compressão
de sinais usados em holters. No método de compressão sugerido, os arquivos utilizavam código
Gray, decomposição em planos de bits e o algoritmo PPM com uso de codificador aritmético.
Os resultados indicam que a melhor compressão ocorre observando um contexto de tamanho
máximo igual a sete, resultando em uma RC de 2.46:1. Isso significa que o compressor proposto
foi capaz de reduzir arquivos a menos da metade do seu tamanho original, sem perda de
informação. Contudo, com a utilização de um contexto extremamente limitado, de tamanho
máximo um, se obtém uma RC = 2,38, muito próxima à máxima, com redução da ordem de 85
vezes nos requisitos de memória.
Com uma RC média de 2.38:1 para um K=1, o método proposto atinge RC próxima da RC do
compressor P2 + Huffman abordado por Batista et al. [9], sendo, porém, muito mais simples de
implementar por usar estruturas fixas e pouca memória, dispensando alocação dinâmica,
ordenamento e cálculos complexos.
O modelo PPM implementado neste trabalho, mesmo em FPGA e descrito em VHDL, possui
chaveamento de contexto em tempo de execução, fazendo o K variar do maior valor ao menor na
procura pelo contexto em memória. Possui ainda o K máximo configurável, bastando para isso
100
Dissertação de Mestrado– LASID - PPGI/DI UFPB
modificar a cláusula generic da descrição VHDL correspondente informando o novo K máximo;
possui mecanismo de escape implementado; outro diferencial é a renormalização dos contadores
em tempo de execução, pois quando os contadores chegam ao limite o modelo os reconfigura
automaticamente..Todos esses detalhes de implementação fazem com que este dispositivo seja
passível de reuso em outros projetos, necessitando apenas instanciar o componente já pronto e
testado.
De igual sorte o codificador aritmético, com uso apenas de aritmética de inteiros, sem uso de
aritmética flutuante, mantém a generalidade uma vez que possui sua precisão configurável,
podendo colocar o maior valor do range dos inteiros que a plataforma em questão suportar. Além
disso possui todo o código comentado o que permite uma boa manutenção e até um nível de
modularização por permitir uma eventual troca de alguma função sem que haja
comprometimento de qualquer outra parte do sistema.
Os resultados indicam ainda que um esquema de modelagem avançado produz um sistema
completo de aquisição e compressão eficaz que trazem uma série de benefícios adicionais,
podendo ser implementado em hardware inclusive com inovações ainda não abordadas.
Dentre as etapas superadas nesse trabalho estão: O mapeamento das classes do código JAVA do
PPM binário em funções VHDL; Análise dos requisitos computacionais, envolvendo a descrição
informal do compressor e de suas funcionalidades; Definição da arquitetura do compressor;
Especificação em VHDL dos blocos e sub-blocos componentes da arquitetura; Simulação e
síntese dos blocos e sub-blocos usando ferramental específica de CAD para FPGA; Síntese do
circuito completo (Controlador do Conversor, Controlador USB e Compressor) em Circuito
Integrado ou Circuitos Integrados FPGA; Implementação de protótipos que implementem partes
da arquitetura proposta para demonstrar sua exeqüibilidade;
Como trabalhos futuros pode se sugerir a substituição da divisão de inteiros necessária ao calculo
do range no codificador aritmético por uma função especifica previamente implementada com a
finalidade de aumentar a velocidade do sistema, uma vez que essa divisão mesmo que de inteiros
é o elemento limitador do sistema por ter uma precisão muito grande.
101
Dissertação de Mestrado– LASID - PPGI/DI UFPB
O compressor PPM binário com 12 modelos PPM em paralelo foi descrito em diagrama
esquemático do Quartus II, que devido ao uso dos módulos individuais já validados, podem ser
utilizados como componentes nesse ou em outros trabalhos sem qualquer esforço adicional.
Como sugestão poderia se implementar outro compressor com os módulos existentes assumindo
uma nova configuração onde características ainda não exploradas para a redução da surpresa do
sistema fossem atacadas.
Outro ponto a ser melhorado o espaço ocupado pelo sistema que pode ser diminuído com troca
das estruturas de repetição por subcircuitos que possam ser utilizados várias vezes dentro da
lógica do compressor implementado.
Neste trabalho, foram abordados assuntos dos mais diversos; integrando os ramos da medicina,
física, matemática e ciências da computação. Mais que o sistema de aquisição e compressão de
sinais de eletrocardiograma o estudo torna evidente que o uso do conhecimento adquirido ao
longo dos anos deve ser dirigido para o bem da sociedade com a aplicação de pesquisas
multidisciplinares juntando áreas, hoje isoladas, para a produção de novos equipamentos, técnicas
ou métodos.
Na área de computação, passamos por conceitos relacionados desde a compressão,
processamento de sinais até sistemas digitais onde o conceito de cores foi amplamente usado,
ressaltando sua importância no mercado mundial de semicondutores, devido a possibilidade de
reuso dos módulos projetados, testados e otimizados que permitem, que projetos cada vez mais
complexos sejam desenvolvidos em uma janela de tempo menor, time-to-market.
Foi possível entender a enorme dimensão especial que envolve o projeto de sistemas digitais e
assim o quanto de trabalho que ainda é preciso para auxiliar a comunidade desenvolvedora
devido as muitas ferramentas necessárias como simuladores, compiladores, montadores e pouco
disponibilizadas em software livre.
Desse modo, é possível afirmar que o sistema ora estudado, modelado e apresentado no presente,
atende as finalidades para as quais foi projetado.
102
Dissertação de Mestrado– LASID - PPGI/DI UFPB
6 Referências
1.
Husoy, J. H.; And Gjerde, T. (1996) “Computationally Efficient Sub-band Coding of ECG Sig-nals.” Medical
Engineering & Physics, v. 18, n. 2, p. 132-142.
2.
Womble, M. E.; Halliday, J. S.; Mitter, S. K.; Lancaster, M. C.; And Triebwasser, J. H. (1977) “Data
Compression for Storing and Transmitting ECG’s/VCG’s.” Proceedings of the IEEE, v. 65, n. 5, p. 702-706.
3.
Antoniol, G.; And Tonella, P. (1997) “EEG Data Compression Techniques.” IEEE Transactions on Biomedical
Engineering, v. 44, n. 2, p. 105-114..
4.
Batista, L. V.; Melcher, E. U. K.; And Carvalho, L. C. (2001) “Compression of ECG Signals by Optimized
Quantization of Discrete Cosine Transform Coefficients.” Medical Engineering & Physics, v. 23, n. 2, p. 127134.
5.
Jalaleddine, S. M. S; Hutchens, C. G.; Strattan, R. D.; And Coberly, W. A. (1990) “ECG Data Compression
Techniques - A Unified Approach.” IEEE Transactions on Biomedical Engineering, v. 37, n. 4, p. 329-343.
6.
Lee, H.; And Buckley, K. M. “ECG Data Compression Using Cut and Align Beats Ap-proach and 2-D
Transforms.” IEEE Transactions on Biomedical Engineering, v. 46, n. 5, p. 556-564, March 1999.
7.
Koski, A. (1997) “Lossless ECG Encoding.” Computer Methods and Programs in Biomedicine, v. 52, n. 1, p. 2333.
8.
Moody, G. B.; And Mark, R. G. (1988) MIT-BIH Arrhythmia Database Directory. Second edition, BMEC
TR010 (revised), Massachusetts Institute of Technology, Biomedical Engineering Center, and August.
9.
Batista, L.V.; Meira, M.M.; Patrício, F.Z.A.; Carvalho, L.C.; e lima, J.A.G. (2003) “Compressão sem Perdas de
Sinais Eletrocardiográficos” Workshop de Informática Médica.
10.
Bell, T., Cleary, J., Witten, I. (1984), “Data compression using adaptive coding and partial string matching”.
IEEE Transactions on Communications, v. 32, n. 4, pp. 396-402.
11.
Moffat, A. (1990), “Implementing the PPM data compression scheme”. IEEE Transactions on Communications,
v. 38, n.11, pp. 1917-1921.
12.
Shannon, C. E. (1948) “A Mathematical Theory of Communication.” Bell Syst. Tech. J., v. 27, p.379-423.
13.
ALTERA. MAX+PLUS II: Programmable Logic Development System & Software– Data Sheet v8.0. Altera
Corporation, 1998.
14.
Souza, A.R.C.; Marques; J. R. T.; Batista, L.V.; e lima, J.A.G. (2007) “Compressão Contextual sem Perdas de
Eletrocardiogramas utilizando Recursos Reduzidos de Memória” Congresso Latino Americano de Engenharia
Biomédica.
15.
16.
ANALOG DEVICES. AD574A User Manual.
BEZERRA, Cyro; LACERDA, Emmanuel. Implementação de um Controlador em FPGA para barramento USB.
2005. 93f. Trabalho de Conclusão de Curso (Conclusão do Curso de Ciências da Computação). Centro
Universitário de João Pessoa – UNIPÊ.
103
Dissertação de Mestrado– LASID - PPGI/DI UFPB
17.
D´AMORE, Roberto. VHDL: Descrição e Síntese de Circuitos Digitais. Rio de Janeiro: Ed. LTC, 2005. 276p.
18.
DEITEL, H.M.; DEITEL, P.J. Java: Como Programar. Porto Alegre: Ed. Bookman, 2003. 1386p.
19.
DLP. DLP-USB245M User Manual. Developer Design Ltd, 2002.
20.
ERCEGOVAC, M.; LANG, T.; MORENO, J.H. Introdução aos Sistemas Digitais. Porto Alegre: Ed. Bookman,
2000. 453p.
21.
FTDI. D2XX Programmer’s Guide. Future Technology Devices International Ltd, 2004.
22.
GILBERT, David. The JFreeChart Class Library Developer Guide. 2005. 564p.
23.
Linguagem de Descrição de Hardware. Disponível em:
<http://www.dee.ufcg.edu.br/~scaico/unipe/sd.htm/fpga1.htm>. Acesso em: 01 set. 2006.
24.
Lógica Programável e Dispositivos Lógicos Programáveis. Disponível em:
<http://www.dee.ufcg.edu.br/~scaico/unipe/sd.htm/fpga2.htm>. Acesso em: 01 set. 2006.
25.
PERRY, Douglas. VHDL: Programming by Example. New York: Ed. McGrawHill, 2002. 476p.
26.
SOMMERVILLE, Ian. Engenharia de Software. São Paulo: Ed. Pearson, 2003. 604p.
27.
TOCCI, Ronald J.; WIDMER, Neal S. Sistemas Digitais: Princípios e Aplicações. São Paulo: Ed. Prentice Hall,
2003. 776p.
28.
TORRES, Gabriel. Hardware: Curso Completo. Rio de Janeiro: Ed. Axcel Books, 2001. 1440p.
29.
VASCONCELOS, Laércio. Hardware Total. São Paulo: Ed. Makron Books, 2002. 1505p.
30.
ZELENOVSKY, Ricardo; MENDONÇA Alexandre. PC: Um Guia Prático de Hardware e Interfaceamento. Rio
de Janeiro: Ed. MZ Editora, 2002. 1031p.
31.
SBC (Sociedade Brasileira de Cardiologia). Diretriz de interpretação de eletrocardiograma de repouso. Arquivo
Brasileiro de Cardiologia, volume 80, (suplemento II), 2003.
32.
BARCELLOS, Gilberto Alt. ACHADOS Eletrocardiográficos na Gravidez Normal Revista da Sociedade de
Cardiologia do Rio Grande do Sul - Ano XIV nº 04 Jan/F Fev/ev/Mar/Abr 2005
33.
ROSA, Agostinho. Micro análise de alta resolução do electrocardiograma. Lisboa: Universidade Técnica de
Lisboa -Instituto Superior Técnico, 2003.
34.
GUYTON, A.C. & HALL, J.E. Tratado de Fisiologia Médica. 6ª edição, Rio de Janeiro Editora Guanabara,
1981.
35.
GUYTON, A.C. & HALL, J.E. Tratado de Fisiologia Médica. 10ª edição, McGraw-Hill Interamericana ,2001.
ISBN 970-10-3599-2
36.
LAMA T, Alexis. Einthoven: El hombre y su invento. Rev. méd. Chile, feb. 2004, vol.132, no.2, p.260-264.
ISSN 0034-9887.
37.
MACIEL, Rubens. Willem Einthoven. De Um Começo Árduo Ao Prêmio Nobel - Arquivos Brasileiros de
Cardiologia - http://publicacoes.cardiol.br/caminhos/015/default.asp, 1996
38.
http://nobelprize.org/nobel_prizes/medicine/laureates/1924/einthoven-bio.html - site da FUNDAÇÃO NOBEL:
104
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Acessos em: fevereiro de 2008.
39.
40.
WOLF, R., CAMACHO, A.A. y SOUZA, R.C.A. Computerized electrocardiography in dogs. Arq. Bras. Med.
Vet. Zootec. [online]. 2000, vol. 52, no. 6 [citado 2008-02-23], pp. 610-615. Disponible en:
<http://www.scielo.br/scielo.php?script=sci_arttext&pid=S0102-09352000000600010&lng=es&nrm=iso>. ISSN
0102-0935. doi: 10.1590/S0102-09352000000600010
RAMOS, Ângela Patrícia, SOUZA, Bolívar Saldanha. Eletrocardiograma: princípios, conceitos e aplicações.
Centro de Estudos de Fisiologia do Exercício, 2007
FUGANTI , Cláudio José. OLIVEIRA , Divina Seila de. RODRIGUES, Ricardo José. Curso de
Eletrocardiografia Básica - CCS/UEL – Universidade Estadual de Londrina
Disponible em:: < http://www3.solar.com.br/~roque/cursoeletrocardiogramainicio.htm>
.
42. POEL, JanKees van der. Compressão de Sinais de Eletrocardiograma. 1999. 164 f. Dissertação (Mestrado em
Engenharia Biomédica) - Universidade Federal da Paraíba, Coordenação de Aperfeiçoamento de Pessoal de
Nível Superior. Co-Orientador: Leonardo Vidal Batista
41.
43.
GUSSOW, Milton, Eletricidade Básica - McGraw-Hill-2a edição-1985.
44.
O'MALLEY, John, Análise de Circuitos , McGraw-Hill-2a edição-1994.
45.
Jornal Diagnósticos em Cardiologia - Edição 21ª - publicação trimestral do Instituto Cardios de ensino e
Pesquisa em Eletrocardiologia não Invasiva e MAPA - Av. Paulista, 509 1º andar 01311-910 São Paulo SP.
Coordenação Editorial: Dr. Ricardo J. Miglino, Flavia Torretta Martins, Redação: Dr. Ricardo J. Miglino, Flavia
Torretta Martins Produção Gráfica: TMDesigners Disponivel em:: <http://www.cardios.com.br/Jornais/jornal21/indice.htm>
46.
RUSSO, Rosaria. FADINI, Gianpaolo. L' interpretazione dell'elettrocardiogramma. Manuale rapido di
apprendimento, Presentazioni Sabino Ilíceto, Editore:Piccin-Nuova Libraria.
47.
UENISHI , Eliza Kaori. Enfermagem medico-cirurgica em unidade de terapia intensiva. 1º Edição, Editora:
Senac Sao Paulo, ISBN: 8585578181, 1994.
48.
SILVA, Daniella Dias Cavalcante da. Desenvolvimento de um IP Core de pré-processamento digital de sinais de
voz para aplicação em sistemas embutidos. Dissertação (Mestrado em Informática) UFCG, Campina Grande,
2006.92fs.: il.
49.
BARBIERO, Andréia Aparecida. AMBIENTE DE
EMBARCADOS, Universidade Federal do Paran´a,2006.
50.
Xilinx An Introduction to xilinx products 1999
Disponível em: http://bwrc.eecs.berkeley.edu/Research/Pico_Radio/Test_Bed/Hardware/Documentation/Xilinx/
intro.pdf
51.
PALMA, J. C.; Moraes, F.; Calazans, N. Métodos para desenvolvimento e distribuição de ip cores SRC'2001 Seminário de compoutacao Reconfigurável, p. S,2001.
52.
GAJSKI, Daniel D; WU, Allen C.-H; CHAIYAKUL, Viraphol; MORI, Shojiro; NUKIYAMA, Tom;
BRICAUD Pierre. “Essential Issues for IP Reuse” IEEE Jan. 2000.
53.
CARRO, L.; WAGNER, F. R. Sistemas Computacionais Embarcados. In: JAI'03 – XXII Jornadas de
Atualização em Informática, 2003, Campinas.
54.
PESSOA, Isaac Maia; Geração semi-automática de Testbenches para Circuitos Integrados Ditigais. Dissertação
(Mestrado em Informática) UFCG, Campina Grande, 2007.
SUPORTE
AO
PROJETO
DE
SISTEMAS
105
Dissertação de Mestrado– LASID - PPGI/DI UFPB
55.
DEHON, Andre. The Density Advantage of Configurable Computing. In: IEEE Computer. Vol. 33, No. 4. 2000.
56.
PONTE, D.F; MADEIRA, C.S; Aplicação Da Linguagem Descritiva De Hardware No Ensino De Circuitos
Digitais. I Congresso de Pesquisa e Inovação da Rede Norte Nordeste de Educação Tecnológica. Natal-RN 2006.
57.
Wikipédia, a enciclopédia livre.; VHDL - Disponível em:: < http://pt.wikipedia.org/wiki/VHDL>
58.
BATISTA, L.V; “Compresão de Sinais Eletrocardiógraficos Baseada na Transformada cosseno Discreta” 2002.
Tese (Doutorado em Ciências no domínio da Engenharia Elétrica) - Universidade Federal de Campina Grande,
Orientadores: Elmar Uwe Kurt Melcher e Luis Carlos Carvalho.
59.
HUFFMAN, D. A. “A Method for the Construction of Minimum Redundancy Codes.” Proceedings of the
Institute of Radio Engineers, n. 40, p. 1098-1101, 1996.
60.
CORMEN, T. H. et al. Algoritmos: Teoria e Prática. Rio de Janeiro: Campus, 2002.
61.
COUTINHO, Bruno Cunha, et al. “Atribuição de Autoria usando PPM” XXV Congresso da Sociedade
Brasileira de Compoutação: A universidade da Computação: um agente de inovação e conhecimento. Unisinos,
- São Leopoldo/RS
62.
ABRANTES, Sílvio A. "Apontamentos de Teoria da Informação" FEUP, Univerdisade do Proto Faculdade de
Engenharia - 2003.
63.
SAID, Amir; "Introduction to Arithmetic Coding - Theory and Practice". Imaging Systems Laboratory, HP
Laboratories Palo Alto, HPL-2004-76, 2004.
64.
ABRAMSON, Norman, “Information Theory and Coding”. McGraw-Hill, 1963. Hard Cover, Very Good, Very
Good. 201 pgs.
65.
RIS, Marcelo; “Compressão adaptativa usando codificação aritmética” 1996. Dissertação (Mestrado em
Matemática Aplicada) - Universidade de São Paulo.
66.
PENNEBAKER,W. B; MITCHELL , J. L; LANGDON, G. G. Jr; Arps , R. B; “An overview of the basic
prlnclples of the Q-Coder adaptive binary arithmetic coder” IBM 1. Res. Develop. Vol. 32 No. 6 November
1988.
67.
FRÄNTI, Pasi; "Image Compression", Lecture Notes, UNIVERSITY OF JOENSUU, Department of Computer
Science, 2002.
68.
http://dlpdesign.com/
69.
DLP Design; DLP-USB245M User Manual, Disponível em <http://www.dlpdesign.com>
70.
CARPENTER , Bob; “Arithmetic Coding and PPM” Disponível em:
<http://www.colloquial.com/ArithmeticCoding/javadoc/tutorial.html>
71.
CARPENTER , Bob; “Compression via Arithmetic Coding in Java.” Disponível em:
<http://www.colloquial.com/ArithmeticCoding >
72.
CHOONG, F; REAZ, M.B.I; CHIN, T. C; MOHD-YASIN, F. “Desing and Implementation of a Data
Compression Scheme: A Partial Matching Approach” Faculty of Engineering, Multimedia University 63100
Cyberjaya, Selangor, Malaysia.
106
Dissertação de Mestrado– LASID - PPGI/DI UFPB
73.
ZÚÑIGA-GRAJEDA, Virgilio; FEREGRINO-URIBE, Claudia. "Implementación en un FPGA del Modelo de
Compresión de Datos PPMC" Coordinación de Ciencias Computacionales, Instituto Nacional de Astrofísica,
Óptica y Electrónica, INAOE.Tonantzintla, Puebla México.
74.
BILGIN, A.; ZWEIG, G.; AND MARCELLIN, M. W. “Efficient Lossless Coding of Medical Ima-ge Volumes
Using Reversible Integer Wavelet Transforms.” Proc. of 1998 Data Compres-sion Conference, p. 428-437,
Snowbird, Utah, March 1998.
75.
http://www.americanheart.org
76.
http://www.acm.uiuc.edu/sigarch/projects/reconf/report_1.html
77.
http://www.starbridgesystems.com/
107
Dissertação de Mestrado– LASID - PPGI/DI UFPB
7 Glossário
•
ADC - Sigla em inglês para Conversor Analógico Digital.
•
API - Conjunto de rotinas e padrões estabelecidos por um software para utilização de suas
funcionalidades.
•
Arquitetura de software: especificação abstrata da estrutura dos elementos usados na
construção de sistemas, como estes elementos interagem, os padrões que guiam sua
composição e as diretrizes e princípios orientadores de seu projeto e evolução ao longo do
tempo;
•
BIT - Um dígito no sistema de numeração binário.
•
BYTE - Octeto formado pelo conjunto de 8 bits.
•
CAD - Nome dado a sistemas computacionais que facilitam no projeto de desenhos
técnicos.
•
CHIP - Abreviação da palavra microchip, que é a miniaturização de circuitos eletrônicos.
•
CLB - Blocos Lógicos Configuráveis contidos em um FPGA.
•
DLL - Biblioteca de Ligação Dinâmica largamente utilizada pelo sistema operacional
Windows que proporciona a redução do arquivo executável final.
•
ECG – Sigla que significa Eletrocardiograma.
•
FIFO - Estrutura de dados do tipo fila aonde os primeiros dados a chegarem são os
primeiros a saírem.
•
FPGA - Dispositivo semicondutor largamente utilizado para o processamento de
informações digiais.
•
FTDI - Fabricante do chip FT245BM da interface USB
•
HARDWARE - Elemento físico dos componentes do computador.
108
Dissertação de Mestrado– LASID - PPGI/DI UFPB
•
HOST - Computador ligado a uma rede ou que executa uma aplicação.
•
HOT PLUGGING - Recurso que permite conectar um dispositivo a um equipamento ativo
sem desligá-lo.
•
IEEE - Instituto de Engenheiros Eletricistas e Eletrônicos.
•
LASID - Laboratório de Sistemas Digitais.
•
LSB - Bit Menos Significativo.
•
MSB - Bit Mais Significativo.
•
PC - Abreviação de computador pessoal.
•
PLD - Sigla em inglês para Dispositivos Lógicos Programáveis.
•
PORTABILIDADE: permite que uma entidade de software opere em diferentes sistemas e
computação;
•
SOFTWARE - Programa de computador com toda a documentação associada e dados de
configuração necessários para o seu correto funcionamento.
•
USB - Barramento Serial Universal.
•
VHDL - Linguagem de descrição de hardware.
109
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Apêndice A - Testbench do PPM Binário
library IEEE;
use ieee.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
8
entity test_ppmen is
PORT ( low1, high2,total3 : OUT integer range 0 to 512;
9
arithClose : OUT STD_LOGIC; arithEnable : OUT STD_LOGIC
);
end;
10
architecture only of test_ppmen is
11
12 COMPONENT ppmen
13
PORT (
14
clk : IN STD_LOGIC;
15
ppmEnable : IN STD_LOGIC;
16
encoderClose : IN STD_LOGIC;
17
bitin : IN STD_LOGIC;
18
low1,high2,total3 : OUT INTEGER range 0 to 512;
19
arithClose : OUT STD_LOGIC;
20
arithEnable : OUT STD_LOGIC
21
);
22 END COMPONENT ;
23
24 SIGNAL clk : STD_LOGIC := '0';
25 SIGNAL ppmEnable : STD_LOGIC := '0';
26 SIGNAL encoderClose : STD_LOGIC := '0';
27 SIGNAL bitin : STD_LOGIC := '0';
28
29 begin
30
31 dut : ppmen
32
PORT MAP (
33
34
clk => clk,
35
ppmEnable => ppmEnable,
36
encoderClose => encoderClose,
37
bitin => bitin,
38
low1 => low1,
39
high2 => high2,
40
total3 => total3,
41
arithClose => arithClose,
42
arithEnable => arithEnable );
110
Dissertação de Mestrado– LASID - PPGI/DI UFPB
43
44 clock : PROCESS
45
begin
46
wait for 80 ns; clk <= not clk;
47 end PROCESS clock;
48
stimulus : PROCESS
begin
49 ppmEnable <='1';
50 encoderClose <='0';
51 bitin <='0';
52 wait for 140 ns; bitin <='1';
53 wait for 160 ns; bitin <='1';
54 wait for 160 ns; bitin <='1';
55 wait for 160 ns; bitin <='0';
56 wait for 160 ns; bitin <='1';
57 wait for 160 ns; bitin <='1';
58 wait for 160 ns; bitin <='1';
59 wait for 160 ns; bitin <='0';
60 wait for 160 ns; bitin <='1';
61 wait for 160 ns; bitin <='1';
62 wait for 160 ns; bitin <='1';
63 wait for 160 ns; bitin <='0';
64 wait for 160 ns; bitin <='1';
65 wait for 160 ns; bitin <='1';
66 wait for 160 ns; bitin <='1';
67 wait for 160 ns; bitin <='1';
68 wait for 160 ns; bitin <='0';
69 wait for 160 ns; bitin <='0';
70 wait for 160 ns; bitin <='0';
71 wait for 160 ns; bitin <='0';
72 wait for 160 ns; bitin <='1';
73 wait for 160 ns; bitin <='1';
74 wait for 160 ns; bitin <='0';
75 wait for 160 ns; bitin <='0';
76 wait for 160 ns; bitin <='1';
77 wait for 160 ns; bitin <='1';
78 wait for 160 ns; bitin <='1';
79 wait for 160 ns; bitin <='1';
80 wait for 160 ns; bitin <='0';
81 wait for 160 ns; bitin <='0';
82 wait for 160 ns; bitin <='0';
83 wait for 160 ns; bitin <='0';
84 wait for 160 ns; bitin <='0';
85 wait for 160 ns; bitin <='1';
86 wait for 160 ns; bitin <='1';
111
Dissertação de Mestrado– LASID - PPGI/DI UFPB
87
88
89
90
91
92
93
94
95
96
97
98
99
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
112
Dissertação de Mestrado– LASID - PPGI/DI UFPB
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='1';
wait for 160 ns; bitin <='0';
wait for 160 ns; bitin <='0';
100
wait for 160 ns; encoderClose <='1';
101
wait;
end PROCESS stimulus;
102
end only;
103
113
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Apêndice B - Testbench do Codificador Aritmético
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
library IEEE;
use ieee.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
entity test_arithen is
PORT ( saida : OUT std_logic_vector( 8 downto 1);
saida2 : OUT std_logic_vector( 8 downto 1);
saida3 : OUT std_logic_vector( 8 downto 1);
saidaAtiva : OUT STD_LOGIC;
saida2Ativa : OUT STD_LOGIC;
saida3Ativa : OUT STD_LOGIC
);-- BUFFER bit_vector(8 downto 1)
end;
architecture only of test_arithen is
COMPONENT arithen
PORT (
clk : IN STD_LOGIC;
arithEnable : IN STD_LOGIC;
arithClose : IN STD_LOGIC;
low1,high2,total3 : IN integer range 0 to 512;
saidaAtiva : OUT STD_LOGIC;
saida2Ativa : OUT STD_LOGIC;
saida3Ativa : OUT STD_LOGIC;
saida : OUT std_logic_vector( 8 downto 1);
saida2 : OUT std_logic_vector( 8 downto 1);
saida3 : OUT std_logic_vector( 8 downto 1)
);
END COMPONENT ;
SIGNAL clk : STD_LOGIC := '0';
SIGNAL arithEnable : STD_LOGIC := '1';
SIGNAL arithClose : STD_LOGIC := '0';
SIGNAL low1, high2, total3 : integer range 0 to 512 := 0;
begin
dut : arithen
PORT MAP (
clk => clk,
arithEnable => arithEnable,
arithClose => arithClose,
low1 => low1,
high2 => high2,
114
Dissertação de Mestrado– LASID - PPGI/DI UFPB
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
total3 => total3,
saidaAtiva => saidaAtiva,
saida2Ativa => saida2Ativa,
saida3Ativa => saida3Ativa,
saida => saida,
saida2 => saida2,
saida3 => saida3
);
clock : PROCESS
begin
wait for 190 ns; clk <= not clk;
end PROCESS clock;
stimulus : PROCESS
begin
arithEnable<='1';
low1 <=0; high2 <= 1; total3 <= 2;
wait for 220 ns; low1 <=1; high2 <= 2; total3 <= 2;
wait for 380 ns; low1 <=1; high2 <=3; total3 <=3;
wait for 380 ns; low1 <=1; high2 <=2; total3 <=2;
wait for 380 ns; low1 <=0; high2 <=1; total3 <=2;
wait for 380 ns; low1 <=1; high2 <=2; total3 <=2;
wait for 380 ns; low1 <=2; high2 <=3; total3 <=3;
wait for 380 ns; low1 <=2; high2 <=4; total3 <=4;
wait for 380 ns; low1 <=0; high2 <=2; total3 <=5;
wait for 380 ns; low1 <=1; high2 <=2; total3 <=2;
wait for 380 ns; low1 <=3; high2 <=6; total3 <=6;
wait for 380 ns; low1 <=3; high2 <=7; total3 <=7;
wait for 380 ns; low1 <=0; high2 <=3; total3 <=8;
wait for 380 ns; low1 <=1; high2 <=3; total3 <=3;
wait for 380 ns; low1 <=4; high2 <=9; total3 <=9;
wait for 380 ns; low1 <=4; high2 <=10; total3 <=10;
wait for 380 ns; low1 <=4; high2 <=11; total3 <=11;
wait for 380 ns; low1 <=0; high2 <=4; total3 <=12;
wait for 380 ns; low1 <=0; high2 <=1; total3 <=4;
wait for 380 ns; low1 <=0; high2 <=2; total3 <=5;
wait for 380 ns; low1 <=0; high2 <=3; total3 <=6;
wait for 380 ns; low1 <=4; high2 <=7; total3 <=7;
wait for 380 ns; low1 <=5; high2 <=13; total3 <=13;
wait for 380 ns; low1 <=0; high2 <=5; total3 <=14;
wait for 380 ns; low1 <=0; high2 <=4; total3 <=8;
wait for 380 ns; low1 <=5; high2 <=9; total3 <=9;
wait for 380 ns; low1 <=6; high2 <=15; total3 <=15;
wait for 380 ns; low1 <=6; high2 <=16; total3 <=16;
wait for 380 ns; low1 <=6; high2 <=17; total3 <=17;
wait for 380 ns; low1 <=0; high2 <=6; total3 <=18;
wait for 380 ns; low1 <=0; high2 <=5; total3 <=10;
115
Dissertação de Mestrado– LASID - PPGI/DI UFPB
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
wait for 380 ns; low1 <=0; high2 <=6; total3 <=11;
wait for 380 ns; low1 <=0; high2 <=7; total3 <=12;
wait for 380 ns; low1 <=0; high2 <=8; total3 <=13;
wait for 380 ns; low1 <=9; high2 <=14; total3 <=14;
wait for 380 ns; low1 <=7; high2 <=19; total3 <=19;
wait for 380 ns; low1 <=0; high2 <=7; total3 <=20;
wait for 380 ns; low1 <=9; high2 <=15; total3 <=15;
wait for 380 ns; low1 <=8; high2 <=21; total3 <=21;
wait for 380 ns; low1 <=8; high2 <=22; total3 <=22;
wait for 380 ns; low1 <=8; high2 <=23; total3 <=23;
wait for 380 ns; low1 <=0; high2 <=8; total3 <=24;
wait for 380 ns; low1 <=0; high2 <=9; total3 <=16;
wait for 380 ns; low1 <=0; high2 <=10; total3 <=17;
wait for 380 ns; low1 <=0; high2 <=11; total3 <=18;
wait for 380 ns; low1 <=12; high2 <=19; total3 <=19;
wait for 380 ns; low1 <=9; high2 <=25; total3 <=25;
wait for 380 ns; low1 <=9; high2 <=26; total3 <=26;
wait for 380 ns; low1 <=0; high2 <=9; total3 <=27;
wait for 380 ns; low1 <=12; high2 <=20; total3 <=20;
wait for 380 ns; low1 <=10; high2 <=28; total3 <=28;
wait for 380 ns; low1 <=10; high2 <=29; total3 <=29;
wait for 380 ns; low1 <=10; high2 <=30; total3 <=30;
wait for 380 ns; low1 <=0; high2 <=10; total3 <=31;
wait for 380 ns; low1 <=0; high2 <=12; total3 <=21;
wait for 380 ns; low1 <=0; high2 <=13; total3 <=22;
wait for 380 ns; low1 <=14; high2 <=23; total3 <=23;
wait for 380 ns; low1 <=0; high2 <=11; total3 <=32;
wait for 380 ns; low1 <=0; high2 <=14; total3 <=24;
wait for 380 ns; low1 <=15; high2 <=25; total3 <=25;
wait for 380 ns; low1 <=0; high2 <=12; total3 <=33;
wait for 380 ns; low1 <=15; high2 <=26; total3 <=26;
wait for 380 ns; low1 <=13; high2 <=34; total3 <=34;
wait for 380 ns; low1 <=13; high2 <=35; total3 <=35;
wait for 380 ns; low1 <=13; high2 <=36; total3 <=36;
wait for 380 ns; low1 <=0; high2 <=13; total3 <=37;
wait for 380 ns; low1 <=0; high2 <=15; total3 <=27;
wait for 380 ns; low1 <=16; high2 <=28; total3 <=28;
wait for 380 ns; low1 <=0; high2 <=14; total3 <=38;
wait for 380 ns; low1 <=16; high2 <=29; total3 <=29;
wait for 380 ns; low1 <=15; high2 <=39; total3 <=39;
wait for 380 ns; low1 <=0; high2 <=15; total3 <=40;
wait for 380 ns; low1 <=0; high2 <=16; total3 <=30;
wait for 380 ns; low1 <=17; high2 <=31; total3 <=31;
wait for 380 ns; low1 <=16; high2 <=41; total3 <=41;
wait for 380 ns; low1 <=16; high2 <=42; total3 <=42;
wait for 380 ns; low1 <=16; high2 <=43; total3 <=43;
116
Dissertação de Mestrado– LASID - PPGI/DI UFPB
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
wait for 380 ns; low1 <=0; high2 <=16; total3 <=44;
wait for 380 ns; low1 <=0; high2 <=17; total3 <=32;
wait for 380 ns; low1 <=18; high2 <=33; total3 <=33;
wait for 380 ns; low1 <=0; high2 <=17; total3 <=45;
wait for 380 ns; low1 <=0; high2 <=18; total3 <=34;
wait for 380 ns; low1 <=0; high2 <=19; total3 <=35;
wait for 380 ns; low1 <=20; high2 <=36; total3 <=36;
wait for 380 ns; low1 <=0; high2 <=18; total3 <=46;
wait for 380 ns; low1 <=20; high2 <=37; total3 <=37;
wait for 380 ns; low1 <=19; high2 <=47; total3 <=47;
wait for 380 ns; low1 <=19; high2 <=48; total3 <=48;
wait for 380 ns; low1 <=19; high2 <=49; total3 <=49;
wait for 380 ns; low1 <=0; high2 <=19; total3 <=50;
wait for 380 ns; low1 <=0; high2 <=20; total3 <=38;
wait for 380 ns; low1 <=0; high2 <=21; total3 <=39;
wait for 380 ns; low1 <=22; high2 <=40; total3 <=40;
wait for 380 ns; low1 <=20; high2 <=51; total3 <=51;
wait for 380 ns; low1 <=20; high2 <=52; total3 <=52;
wait for 380 ns; low1 <=20; high2 <=53; total3 <=53;
wait for 380 ns; low1 <=0; high2 <=20; total3 <=54;
wait for 380 ns; low1 <=22; high2 <=41; total3 <=41;
wait for 380 ns; low1 <=21; high2 <=55; total3 <=55;
wait for 380 ns; low1 <=21; high2 <=56; total3 <=56;
wait for 380 ns; low1 <=21; high2 <=57; total3 <=57;
wait for 380 ns; low1 <=0; high2 <=21; total3 <=58;
wait for 380 ns; low1 <=0; high2 <=22; total3 <=42;
wait for 380 ns; low1 <=0; high2 <=23; total3 <=43;
wait for 380 ns; low1 <=24; high2 <=44; total3 <=44;
wait for 380 ns; low1 <=0; high2 <=22; total3 <=59;
wait for 380 ns; low1 <=0; high2 <=24; total3 <=45;
wait for 380 ns; low1 <=25; high2 <=46; total3 <=46;
wait for 380 ns; low1 <=0; high2 <=23; total3 <=60;
wait for 380 ns; low1 <=25; high2 <=47; total3 <=47;
wait for 380 ns; low1 <=24; high2 <=61; total3 <=61;
wait for 380 ns; low1 <=24; high2 <=62; total3 <=62;
wait for 380 ns; low1 <=24; high2 <=63; total3 <=63;
wait for 380 ns; low1 <=0; high2 <=24; total3 <=64;
wait for 380 ns; low1 <=0; high2 <=25; total3 <=48;
wait for 380 ns; low1 <=0; high2 <=26; total3 <=49;
wait for 380 ns; low1 <=0; high2 <=27; total3 <=50;
wait for 380 ns; low1 <=28; high2 <=51; total3 <=51;
wait for 380 ns; low1 <=0; high2 <=25; total3 <=65;
wait for 380 ns; low1 <=0; high2 <=28; total3 <=52;
wait for 380 ns; low1 <=0; high2 <=29; total3 <=53;
wait for 380 ns; low1 <=30; high2 <=54; total3 <=54;
wait for 380 ns; low1 <=26; high2 <=66; total3 <=66;
117
Dissertação de Mestrado– LASID - PPGI/DI UFPB
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
wait for 380 ns; low1 <=26; high2 <=67; total3 <=67;
wait for 380 ns; low1 <=26; high2 <=68; total3 <=68;
wait for 380 ns; low1 <=0; high2 <=26; total3 <=69;
wait for 380 ns; low1 <=0; high2 <=30; total3 <=55;
wait for 380 ns; low1 <=0; high2 <=31; total3 <=56;
wait for 380 ns; low1 <=0; high2 <=32; total3 <=57;
wait for 380 ns; low1 <=33; high2 <=58; total3 <=58;
wait for 380 ns; low1 <=0; high2 <=27; total3 <=70;
wait for 380 ns; low1 <=0; high2 <=33; total3 <=59;
wait for 380 ns; low1 <=0; high2 <=34; total3 <=60;
wait for 380 ns; low1 <=35; high2 <=61; total3 <=61;
wait for 380 ns; low1 <=28; high2 <=71; total3 <=71;
wait for 380 ns; low1 <=28; high2 <=72; total3 <=72;
wait for 380 ns; low1 <=0; high2 <=28; total3 <=73;
wait for 380 ns; low1 <=35; high2 <=62; total3 <=62;
wait for 380 ns; low1 <=29; high2 <=74; total3 <=74;
wait for 380 ns; low1 <=29; high2 <=75; total3 <=75;
wait for 380 ns; low1 <=29; high2 <=76; total3 <=76;
wait for 380 ns; low1 <=0; high2 <=29; total3 <=77;
wait for 380 ns; low1 <=0; high2 <=35; total3 <=63;
wait for 380 ns; low1 <=36; high2 <=64; total3 <=64;
wait for 380 ns; low1 <=0; high2 <=30; total3 <=78;
wait for 380 ns; low1 <=36; high2 <=65; total3 <=65;
wait for 380 ns; low1 <=31; high2 <=79; total3 <=79;
wait for 380 ns; low1 <=31; high2 <=80; total3 <=80;
wait for 380 ns; low1 <=31; high2 <=81; total3 <=81;
wait for 380 ns; low1 <=0; high2 <=31; total3 <=82;
wait for 380 ns; low1 <=0; high2 <=36; total3 <=66;
wait for 380 ns; low1 <=0; high2 <=37; total3 <=67;
wait for 380 ns; low1 <=0; high2 <=38; total3 <=68;
wait for 380 ns; low1 <=0; high2 <=39; total3 <=69;
wait for 380 ns; low1 <=0; high2 <=40; total3 <=70;
wait for 380 ns; low1 <=0; high2 <=41; total3 <=71;
wait for 380 ns; low1 <=0; high2 <=42; total3 <=72;
wait for 380 ns; low1 <=43; high2 <=73; total3 <=73;
wait for 380 ns; low1 <=32; high2 <=83; total3 <=83;
wait for 380 ns; low1 <=32; high2 <=84; total3 <=84;
wait for 380 ns; low1 <=0; high2 <=32; total3 <=85;
wait for 380 ns; low1 <=43; high2 <=74; total3 <=74;
wait for 380 ns; low1 <=33; high2 <=86; total3 <=86;
wait for 380 ns; low1 <=33; high2 <=87; total3 <=87;
wait for 380 ns; low1 <=0; high2 <=33; total3 <=88;
wait for 380 ns; low1 <=43; high2 <=75; total3 <=75;
wait for 380 ns; low1 <=0; high2 <=34; total3 <=89;
wait for 380 ns; low1 <=0; high2 <=43; total3 <=76;
wait for 380 ns; low1 <=0; high2 <=44; total3 <=77;
118
Dissertação de Mestrado– LASID - PPGI/DI UFPB
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
wait for 380 ns; low1 <=45; high2 <=78; total3 <=78;
wait for 380 ns; low1 <=35; high2 <=90; total3 <=90;
wait for 380 ns; low1 <=35; high2 <=91; total3 <=91;
wait for 380 ns; low1 <=0; high2 <=35; total3 <=92;
wait for 380 ns; low1 <=45; high2 <=79; total3 <=79;
wait for 380 ns; low1 <=36; high2 <=93; total3 <=93;
wait for 380 ns; low1 <=36; high2 <=94; total3 <=94;
wait for 380 ns; low1 <=0; high2 <=36; total3 <=95;
wait for 380 ns; low1 <=0; high2 <=45; total3 <=80;
wait for 380 ns; low1 <=46; high2 <=81; total3 <=81;
wait for 380 ns; low1 <=37; high2 <=96; total3 <=96;
wait for 380 ns; low1 <=0; high2 <=37; total3 <=97;
wait for 380 ns; low1 <=46; high2 <=82; total3 <=82;
wait for 380 ns; low1 <=38; high2 <=98; total3 <=98;
wait for 380 ns; low1 <=38; high2 <=99; total3 <=99;
wait for 380 ns; low1 <=0; high2 <=38; total3 <=100;
wait for 380 ns; low1 <=46; high2 <=83; total3 <=83;
wait for 380 ns; low1 <=39; high2 <=101; total3 <=101;
wait for 380 ns; low1 <=39; high2 <=102; total3 <=102;
wait for 380 ns; low1 <=39; high2 <=103; total3 <=103;
wait for 380 ns; low1 <=0; high2 <=39; total3 <=104;
wait for 380 ns; low1 <=0; high2 <=46; total3 <=84;
wait for 380 ns; low1 <=0; high2 <=47; total3 <=85;
wait for 380 ns; low1 <=0; high2 <=48; total3 <=86;
wait for 380 ns; low1 <=49; high2 <=87; total3 <=87;
wait for 380 ns; low1 <=40; high2 <=105; total3 <=105;
wait for 380 ns; low1 <=40; high2 <=106; total3 <=106;
wait for 380 ns; low1 <=40; high2 <=107; total3 <=107;
wait for 380 ns; low1 <=0; high2 <=40; total3 <=108;
wait for 380 ns; low1 <=0; high2 <=49; total3 <=88;
wait for 380 ns; low1 <=0; high2 <=50; total3 <=89;
wait for 380 ns; low1 <=0; high2 <=51; total3 <=90;
wait for 380 ns; low1 <=0; high2 <=52; total3 <=91;
wait for 380 ns; low1 <=0; high2 <=53; total3 <=92;
wait for 380 ns; low1 <=54; high2 <=93; total3 <=93;
wait for 380 ns; low1 <=0; high2 <=41; total3 <=109;
wait for 380 ns; low1 <=54; high2 <=94; total3 <=94;
wait for 380 ns; low1 <=42; high2 <=110; total3 <=110;
wait for 380 ns; low1 <=42; high2 <=111; total3 <=111;
wait for 380 ns; low1 <=42; high2 <=112; total3 <=112;
wait for 380 ns; low1 <=0; high2 <=42; total3 <=113;
wait for 380 ns; low1 <=0; high2 <=54; total3 <=95;
wait for 380 ns; low1 <=0; high2 <=55; total3 <=96;
wait for 380 ns; low1 <=56; high2 <=97; total3 <=97;
wait for 380 ns; low1 <=0; high2 <=43; total3 <=114;
wait for 380 ns; low1 <=56; high2 <=98; total3 <=98;
119
Dissertação de Mestrado– LASID - PPGI/DI UFPB
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
wait for 380 ns; low1 <=44; high2 <=115; total3 <=115;
wait for 380 ns; low1 <=0; high2 <=44; total3 <=116;
wait for 380 ns; low1 <=56; high2 <=99; total3 <=99;
wait for 380 ns; low1 <=45; high2 <=117; total3 <=117;
wait for 380 ns; low1 <=45; high2 <=118; total3 <=118;
wait for 380 ns; low1 <=45; high2 <=119; total3 <=119;
wait for 380 ns; low1 <=0; high2 <=45; total3 <=120;
wait for 380 ns; low1 <=0; high2 <=56; total3 <=100;
wait for 380 ns; low1 <=0; high2 <=57; total3 <=101;
wait for 380 ns; low1 <=58; high2 <=102; total3 <=102;
wait for 380 ns; low1 <=46; high2 <=121; total3 <=121;
wait for 380 ns; low1 <=46; high2 <=122; total3 <=122;
wait for 380 ns; low1 <=46; high2 <=123; total3 <=123;
wait for 380 ns; low1 <=0; high2 <=46; total3 <=124;
wait for 380 ns; low1 <=58; high2 <=103; total3 <=103;
wait for 380 ns; low1 <=47; high2 <=125; total3 <=125;
wait for 380 ns; low1 <=47; high2 <=126; total3 <=126;
wait for 380 ns; low1 <=47; high2 <=127; total3 <=127;
wait for 380 ns; low1 <=0; high2 <=47; total3 <=128;
wait for 380 ns; low1 <=0; high2 <=58; total3 <=104;
wait for 380 ns; low1 <=59; high2 <=105; total3 <=105;
wait for 380 ns; low1 <=0; high2 <=48; total3 <=129;
wait for 380 ns; low1 <=59; high2 <=106; total3 <=106;
wait for 380 ns; low1 <=49; high2 <=130; total3 <=130;
wait for 380 ns; low1 <=49; high2 <=131; total3 <=131;
wait for 380 ns; low1 <=0; high2 <=49; total3 <=132;
wait for 380 ns; low1 <=59; high2 <=107; total3 <=107;
wait for 380 ns; low1 <=50; high2 <=133; total3 <=133;
wait for 380 ns; low1 <=50; high2 <=134; total3 <=134;
wait for 380 ns; low1 <=50; high2 <=135; total3 <=135;
wait for 380 ns; low1 <=0; high2 <=50; total3 <=136;
wait for 380 ns; low1 <=0; high2 <=59; total3 <=108;
wait for 380 ns; low1 <=60; high2 <=109; total3 <=109;
wait for 380 ns; low1 <=0; high2 <=51; total3 <=137;
wait for 380 ns; low1 <=0; high2 <=60; total3 <=110;
wait for 380 ns; low1 <=61; high2 <=111; total3 <=111;
wait for 380 ns; low1 <=52; high2 <=138; total3 <=138;
wait for 380 ns; low1 <=0; high2 <=52; total3 <=139;
wait for 380 ns; low1 <=61; high2 <=112; total3 <=112;
wait for 380 ns; low1 <=53; high2 <=140; total3 <=140;
wait for 380 ns; low1 <=53; high2 <=141; total3 <=141;
wait for 380 ns; low1 <=53; high2 <=142; total3 <=142;
wait for 380 ns; low1 <=0; high2 <=53; total3 <=143;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=113;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=114;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=115;
120
Dissertação de Mestrado– LASID - PPGI/DI UFPB
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
wait for 380 ns; low1 <=0; high2 <=64; total3 <=116;
wait for 380 ns; low1 <=65; high2 <=117; total3 <=117;
wait for 380 ns; low1 <=54; high2 <=144; total3 <=144;
wait for 380 ns; low1 <=0; high2 <=54; total3 <=145;
wait for 380 ns; low1 <=65; high2 <=118; total3 <=118;
wait for 380 ns; low1 <=55; high2 <=146; total3 <=146;
wait for 380 ns; low1 <=55; high2 <=147; total3 <=147;
wait for 380 ns; low1 <=55; high2 <=148; total3 <=148;
wait for 380 ns; low1 <=0; high2 <=55; total3 <=149;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=119;
wait for 380 ns; low1 <=66; high2 <=120; total3 <=120;
wait for 380 ns; low1 <=0; high2 <=56; total3 <=150;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=121;
wait for 380 ns; low1 <=67; high2 <=122; total3 <=122;
wait for 380 ns; low1 <=57; high2 <=151; total3 <=151;
wait for 380 ns; low1 <=0; high2 <=57; total3 <=152;
wait for 380 ns; low1 <=67; high2 <=123; total3 <=123;
wait for 380 ns; low1 <=58; high2 <=153; total3 <=153;
wait for 380 ns; low1 <=58; high2 <=154; total3 <=154;
wait for 380 ns; low1 <=58; high2 <=155; total3 <=155;
wait for 380 ns; low1 <=0; high2 <=58; total3 <=156;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=124;
wait for 380 ns; low1 <=68; high2 <=125; total3 <=125;
wait for 380 ns; low1 <=59; high2 <=157; total3 <=157;
wait for 380 ns; low1 <=59; high2 <=158; total3 <=158;
wait for 380 ns; low1 <=0; high2 <=59; total3 <=159;
wait for 380 ns; low1 <=68; high2 <=126; total3 <=126;
wait for 380 ns; low1 <=0; high2 <=60; total3 <=160;
wait for 380 ns; low1 <=68; high2 <=127; total3 <=127;
wait for 380 ns; low1 <=61; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=61; high2 <=162; total3 <=162;
wait for 380 ns; low1 <=61; high2 <=163; total3 <=163;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=164;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=128;
wait for 380 ns; low1 <=69; high2 <=129; total3 <=129;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=165;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=130;
wait for 380 ns; low1 <=70; high2 <=131; total3 <=131;
wait for 380 ns; low1 <=63; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=167;
wait for 380 ns; low1 <=70; high2 <=132; total3 <=132;
wait for 380 ns; low1 <=64; high2 <=168; total3 <=168;
wait for 380 ns; low1 <=64; high2 <=169; total3 <=169;
wait for 380 ns; low1 <=64; high2 <=170; total3 <=170;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=171;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=133;
121
Dissertação de Mestrado– LASID - PPGI/DI UFPB
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
wait for 380 ns; low1 <=0; high2 <=71; total3 <=134;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=135;
wait for 380 ns; low1 <=73; high2 <=136; total3 <=136;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=172;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=137;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=138;
wait for 380 ns; low1 <=75; high2 <=139; total3 <=139;
wait for 380 ns; low1 <=66; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=66; high2 <=174; total3 <=174;
wait for 380 ns; low1 <=66; high2 <=175; total3 <=175;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=176;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=140;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=141;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=142;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=143;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=144;
wait for 380 ns; low1 <=80; high2 <=145; total3 <=145;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=177;
wait for 380 ns; low1 <=80; high2 <=146; total3 <=146;
wait for 380 ns; low1 <=68; high2 <=178; total3 <=178;
wait for 380 ns; low1 <=68; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=68; high2 <=180; total3 <=180;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=181;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=147;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=148;
wait for 380 ns; low1 <=82; high2 <=149; total3 <=149;
wait for 380 ns; low1 <=69; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=183;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=150;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=151;
wait for 380 ns; low1 <=84; high2 <=152; total3 <=152;
wait for 380 ns; low1 <=70; high2 <=184; total3 <=184;
wait for 380 ns; low1 <=70; high2 <=185; total3 <=185;
wait for 380 ns; low1 <=70; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=187;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=153;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=154;
wait for 380 ns; low1 <=86; high2 <=155; total3 <=155;
wait for 380 ns; low1 <=71; high2 <=188; total3 <=188;
wait for 380 ns; low1 <=71; high2 <=189; total3 <=189;
wait for 380 ns; low1 <=0; high2 <=71; total3 <=190;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=156;
wait for 380 ns; low1 <=87; high2 <=157; total3 <=157;
wait for 380 ns; low1 <=72; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=72; high2 <=192; total3 <=192;
wait for 380 ns; low1 <=72; high2 <=193; total3 <=193;
122
Dissertação de Mestrado– LASID - PPGI/DI UFPB
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
wait for 380 ns; low1 <=0; high2 <=72; total3 <=194;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=158;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=159;
wait for 380 ns; low1 <=89; high2 <=160; total3 <=160;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=195;
wait for 380 ns; low1 <=89; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=196;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=162;
wait for 380 ns; low1 <=90; high2 <=163; total3 <=163;
wait for 380 ns; low1 <=75; high2 <=197; total3 <=197;
wait for 380 ns; low1 <=75; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=199;
wait for 380 ns; low1 <=90; high2 <=164; total3 <=164;
wait for 380 ns; low1 <=76; high2 <=200; total3 <=200;
wait for 380 ns; low1 <=76; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=76; high2 <=202; total3 <=202;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=203;
wait for 380 ns; low1 <=90; high2 <=165; total3 <=165;
wait for 380 ns; low1 <=77; high2 <=204; total3 <=204;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=205;
wait for 380 ns; low1 <=90; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=78; high2 <=206; total3 <=206;
wait for 380 ns; low1 <=78; high2 <=207; total3 <=207;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=208;
wait for 380 ns; low1 <=90; high2 <=167; total3 <=167;
wait for 380 ns; low1 <=79; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=79; high2 <=210; total3 <=210;
wait for 380 ns; low1 <=79; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=79; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=79; high2 <=213; total3 <=213;
wait for 380 ns; low1 <=79; high2 <=214; total3 <=214;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=215;
wait for 380 ns; low1 <=90; high2 <=168; total3 <=168;
wait for 380 ns; low1 <=80; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=80; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=218;
wait for 380 ns; low1 <=90; high2 <=169; total3 <=169;
wait for 380 ns; low1 <=81; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=81; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=81; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=222;
wait for 380 ns; low1 <=90; high2 <=170; total3 <=170;
wait for 380 ns; low1 <=82; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=224;
wait for 380 ns; low1 <=90; high2 <=171; total3 <=171;
wait for 380 ns; low1 <=83; high2 <=225; total3 <=225;
123
Dissertação de Mestrado– LASID - PPGI/DI UFPB
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
wait for 380 ns; low1 <=83; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=227;
wait for 380 ns; low1 <=90; high2 <=172; total3 <=172;
wait for 380 ns; low1 <=84; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=84; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=84; high2 <=230; total3 <=230;
wait for 380 ns; low1 <=84; high2 <=231; total3 <=231;
wait for 380 ns; low1 <=84; high2 <=232; total3 <=232;
wait for 380 ns; low1 <=84; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=234;
wait for 380 ns; low1 <=90; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=85; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=85; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=85; high2 <=237; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=174;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=175;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=176;
wait for 380 ns; low1 <=93; high2 <=177; total3 <=177;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=239;
wait for 380 ns; low1 <=93; high2 <=178; total3 <=178;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=240;
wait for 380 ns; low1 <=93; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=88; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=88; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=88; high2 <=243; total3 <=243;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=180;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=181;
wait for 380 ns; low1 <=95; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=89; high2 <=245; total3 <=245;
wait for 380 ns; low1 <=89; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=247;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=183;
wait for 380 ns; low1 <=96; high2 <=184; total3 <=184;
wait for 380 ns; low1 <=90; high2 <=248; total3 <=248;
wait for 380 ns; low1 <=90; high2 <=249; total3 <=249;
wait for 380 ns; low1 <=90; high2 <=250; total3 <=250;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=251;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=185;
wait for 380 ns; low1 <=97; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=252;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=187;
wait for 380 ns; low1 <=98; high2 <=188; total3 <=188;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=253;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=189;
124
Dissertação de Mestrado– LASID - PPGI/DI UFPB
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
wait for 380 ns; low1 <=99; high2 <=190; total3 <=190;
wait for 380 ns; low1 <=93; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=93; high2 <=255; total3 <=255;
wait for 380 ns; low1 <=93; high2 <=256; total3 <=256;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=257;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=191;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=192;
wait for 380 ns; low1 <=101; high2 <=193; total3 <=193;
wait for 380 ns; low1 <=94; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=259;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=194;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=195;
wait for 380 ns; low1 <=103; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=95; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=95; high2 <=261; total3 <=261;
wait for 380 ns; low1 <=95; high2 <=262; total3 <=262;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=263;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=197;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=198;
wait for 380 ns; low1 <=105; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=264;
wait for 380 ns; low1 <=105; high2 <=200; total3 <=200;
wait for 380 ns; low1 <=97; high2 <=265; total3 <=265;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=266;
wait for 380 ns; low1 <=105; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=98; high2 <=267; total3 <=267;
wait for 380 ns; low1 <=98; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=98; high2 <=269; total3 <=269;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=270;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=202;
wait for 380 ns; low1 <=106; high2 <=203; total3 <=203;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=271;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=204;
wait for 380 ns; low1 <=107; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=272;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=206;
wait for 380 ns; low1 <=108; high2 <=207; total3 <=207;
wait for 380 ns; low1 <=101; high2 <=273; total3 <=273;
wait for 380 ns; low1 <=101; high2 <=274; total3 <=274;
wait for 380 ns; low1 <=101; high2 <=275; total3 <=275;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=276;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=208;
wait for 380 ns; low1 <=109; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=277;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=210;
wait for 380 ns; low1 <=110; high2 <=211; total3 <=211;
125
Dissertação de Mestrado– LASID - PPGI/DI UFPB
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
wait for 380 ns; low1 <=0; high2 <=103; total3 <=278;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=212;
wait for 380 ns; low1 <=111; high2 <=213; total3 <=213;
wait for 380 ns; low1 <=104; high2 <=279; total3 <=279;
wait for 380 ns; low1 <=104; high2 <=280; total3 <=280;
wait for 380 ns; low1 <=104; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=282;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=214;
wait for 380 ns; low1 <=112; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=283;
wait for 380 ns; low1 <=112; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=106; high2 <=284; total3 <=284;
wait for 380 ns; low1 <=106; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=286;
wait for 380 ns; low1 <=112; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=107; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=107; high2 <=288; total3 <=288;
wait for 380 ns; low1 <=107; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=290;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=218;
wait for 380 ns; low1 <=113; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=291;
wait for 380 ns; low1 <=113; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=109; high2 <=292; total3 <=292;
wait for 380 ns; low1 <=109; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=294;
wait for 380 ns; low1 <=113; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=110; high2 <=295; total3 <=295;
wait for 380 ns; low1 <=110; high2 <=296; total3 <=296;
wait for 380 ns; low1 <=110; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=222;
wait for 380 ns; low1 <=114; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=111; high2 <=299; total3 <=299;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=300;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=224;
wait for 380 ns; low1 <=115; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=301;
wait for 380 ns; low1 <=115; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=113; high2 <=302; total3 <=302;
wait for 380 ns; low1 <=113; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=113; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=305;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=227;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=228;
wait for 380 ns; low1 <=0; high2 <=117; total3 <=229;
126
Dissertação de Mestrado– LASID - PPGI/DI UFPB
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
wait for 380 ns; low1 <=118; high2 <=230; total3 <=230;
wait for 380 ns; low1 <=114; high2 <=306; total3 <=306;
wait for 380 ns; low1 <=114; high2 <=307; total3 <=307;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=308;
wait for 380 ns; low1 <=118; high2 <=231; total3 <=231;
wait for 380 ns; low1 <=115; high2 <=309; total3 <=309;
wait for 380 ns; low1 <=115; high2 <=310; total3 <=310;
wait for 380 ns; low1 <=115; high2 <=311; total3 <=311;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=312;
wait for 380 ns; low1 <=0; high2 <=118; total3 <=232;
wait for 380 ns; low1 <=0; high2 <=119; total3 <=233;
wait for 380 ns; low1 <=120; high2 <=234; total3 <=234;
wait for 380 ns; low1 <=116; high2 <=313; total3 <=313;
wait for 380 ns; low1 <=116; high2 <=314; total3 <=314;
wait for 380 ns; low1 <=116; high2 <=315; total3 <=315;
wait for 380 ns; low1 <=0; high2 <=58; total3 <=158;
wait for 380 ns; low1 <=120; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=59; high2 <=159; total3 <=159;
wait for 380 ns; low1 <=59; high2 <=160; total3 <=160;
wait for 380 ns; low1 <=59; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=0; high2 <=59; total3 <=162;
wait for 380 ns; low1 <=0; high2 <=120; total3 <=236;
wait for 380 ns; low1 <=0; high2 <=121; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=122; total3 <=238;
wait for 380 ns; low1 <=123; high2 <=239; total3 <=239;
wait for 380 ns; low1 <=60; high2 <=163; total3 <=163;
wait for 380 ns; low1 <=60; high2 <=164; total3 <=164;
wait for 380 ns; low1 <=0; high2 <=60; total3 <=165;
wait for 380 ns; low1 <=123; high2 <=240; total3 <=240;
wait for 380 ns; low1 <=61; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=61; high2 <=167; total3 <=167;
wait for 380 ns; low1 <=61; high2 <=168; total3 <=168;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=169;
wait for 380 ns; low1 <=0; high2 <=123; total3 <=241;
wait for 380 ns; low1 <=0; high2 <=124; total3 <=242;
wait for 380 ns; low1 <=0; high2 <=125; total3 <=243;
wait for 380 ns; low1 <=126; high2 <=244; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=170;
wait for 380 ns; low1 <=126; high2 <=245; total3 <=245;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=171;
wait for 380 ns; low1 <=126; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=64; high2 <=172; total3 <=172;
wait for 380 ns; low1 <=64; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=174;
wait for 380 ns; low1 <=126; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=65; high2 <=175; total3 <=175;
127
Dissertação de Mestrado– LASID - PPGI/DI UFPB
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
wait for 380 ns; low1 <=65; high2 <=176; total3 <=176;
wait for 380 ns; low1 <=65; high2 <=177; total3 <=177;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=178;
wait for 380 ns; low1 <=0; high2 <=126; total3 <=248;
wait for 380 ns; low1 <=127; high2 <=249; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=179;
wait for 380 ns; low1 <=127; high2 <=250; total3 <=250;
wait for 380 ns; low1 <=67; high2 <=180; total3 <=180;
wait for 380 ns; low1 <=67; high2 <=181; total3 <=181;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=182;
wait for 380 ns; low1 <=127; high2 <=251; total3 <=251;
wait for 380 ns; low1 <=68; high2 <=183; total3 <=183;
wait for 380 ns; low1 <=68; high2 <=184; total3 <=184;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=185;
wait for 380 ns; low1 <=127; high2 <=252; total3 <=252;
wait for 380 ns; low1 <=69; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=69; high2 <=187; total3 <=187;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=188;
wait for 380 ns; low1 <=127; high2 <=253; total3 <=253;
wait for 380 ns; low1 <=70; high2 <=189; total3 <=189;
wait for 380 ns; low1 <=70; high2 <=190; total3 <=190;
wait for 380 ns; low1 <=70; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=127; total3 <=254;
wait for 380 ns; low1 <=0; high2 <=128; total3 <=255;
wait for 380 ns; low1 <=0; high2 <=129; total3 <=256;
wait for 380 ns; low1 <=0; high2 <=130; total3 <=257;
wait for 380 ns; low1 <=131; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=71; high2 <=193; total3 <=193;
wait for 380 ns; low1 <=0; high2 <=71; total3 <=194;
wait for 380 ns; low1 <=131; high2 <=259; total3 <=259;
wait for 380 ns; low1 <=72; high2 <=195; total3 <=195;
wait for 380 ns; low1 <=72; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=72; high2 <=197; total3 <=197;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=131; total3 <=260;
wait for 380 ns; low1 <=0; high2 <=132; total3 <=261;
wait for 380 ns; low1 <=133; high2 <=262; total3 <=262;
wait for 380 ns; low1 <=73; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=200;
wait for 380 ns; low1 <=133; high2 <=263; total3 <=263;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=201;
wait for 380 ns; low1 <=133; high2 <=264; total3 <=264;
wait for 380 ns; low1 <=75; high2 <=202; total3 <=202;
wait for 380 ns; low1 <=75; high2 <=203; total3 <=203;
wait for 380 ns; low1 <=75; high2 <=204; total3 <=204;
128
Dissertação de Mestrado– LASID - PPGI/DI UFPB
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
wait for 380 ns; low1 <=0; high2 <=75; total3 <=205;
wait for 380 ns; low1 <=0; high2 <=133; total3 <=265;
wait for 380 ns; low1 <=134; high2 <=266; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=206;
wait for 380 ns; low1 <=0; high2 <=134; total3 <=267;
wait for 380 ns; low1 <=0; high2 <=135; total3 <=268;
wait for 380 ns; low1 <=0; high2 <=136; total3 <=269;
wait for 380 ns; low1 <=0; high2 <=137; total3 <=270;
wait for 380 ns; low1 <=138; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=77; high2 <=207; total3 <=207;
wait for 380 ns; low1 <=77; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=77; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=210;
wait for 380 ns; low1 <=0; high2 <=138; total3 <=272;
wait for 380 ns; low1 <=139; high2 <=273; total3 <=273;
wait for 380 ns; low1 <=78; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=212;
wait for 380 ns; low1 <=0; high2 <=139; total3 <=274;
wait for 380 ns; low1 <=0; high2 <=140; total3 <=275;
wait for 380 ns; low1 <=0; high2 <=141; total3 <=276;
wait for 380 ns; low1 <=142; high2 <=277; total3 <=277;
wait for 380 ns; low1 <=79; high2 <=213; total3 <=213;
wait for 380 ns; low1 <=79; high2 <=214; total3 <=214;
wait for 380 ns; low1 <=79; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=216;
wait for 380 ns; low1 <=142; high2 <=278; total3 <=278;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=142; total3 <=279;
wait for 380 ns; low1 <=0; high2 <=143; total3 <=280;
wait for 380 ns; low1 <=0; high2 <=144; total3 <=281;
wait for 380 ns; low1 <=0; high2 <=145; total3 <=282;
wait for 380 ns; low1 <=0; high2 <=146; total3 <=283;
wait for 380 ns; low1 <=147; high2 <=284; total3 <=284;
wait for 380 ns; low1 <=81; high2 <=218; total3 <=218;
wait for 380 ns; low1 <=81; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=81; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=221;
wait for 380 ns; low1 <=147; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=222;
wait for 380 ns; low1 <=0; high2 <=147; total3 <=286;
wait for 380 ns; low1 <=0; high2 <=148; total3 <=287;
wait for 380 ns; low1 <=149; high2 <=288; total3 <=288;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=149; total3 <=289;
wait for 380 ns; low1 <=150; high2 <=290; total3 <=290;
wait for 380 ns; low1 <=84; high2 <=224; total3 <=224;
129
Dissertação de Mestrado– LASID - PPGI/DI UFPB
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
wait for 380 ns; low1 <=84; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=84; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=227;
wait for 380 ns; low1 <=150; high2 <=291; total3 <=291;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=228;
wait for 380 ns; low1 <=0; high2 <=150; total3 <=292;
wait for 380 ns; low1 <=151; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=229;
wait for 380 ns; low1 <=0; high2 <=151; total3 <=294;
wait for 380 ns; low1 <=0; high2 <=152; total3 <=295;
wait for 380 ns; low1 <=153; high2 <=296; total3 <=296;
wait for 380 ns; low1 <=87; high2 <=230; total3 <=230;
wait for 380 ns; low1 <=87; high2 <=231; total3 <=231;
wait for 380 ns; low1 <=87; high2 <=232; total3 <=232;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=233;
wait for 380 ns; low1 <=153; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=234;
wait for 380 ns; low1 <=0; high2 <=153; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=154; total3 <=299;
wait for 380 ns; low1 <=0; high2 <=155; total3 <=300;
wait for 380 ns; low1 <=0; high2 <=156; total3 <=301;
wait for 380 ns; low1 <=0; high2 <=157; total3 <=302;
wait for 380 ns; low1 <=158; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=89; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=89; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=89; high2 <=237; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=158; total3 <=304;
wait for 380 ns; low1 <=159; high2 <=305; total3 <=305;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=159; total3 <=306;
wait for 380 ns; low1 <=0; high2 <=160; total3 <=307;
wait for 380 ns; low1 <=161; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=240;
wait for 380 ns; low1 <=161; high2 <=309; total3 <=309;
wait for 380 ns; low1 <=92; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=92; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=92; high2 <=243; total3 <=243;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=161; total3 <=310;
wait for 380 ns; low1 <=0; high2 <=162; total3 <=311;
wait for 380 ns; low1 <=0; high2 <=163; total3 <=312;
wait for 380 ns; low1 <=164; high2 <=313; total3 <=313;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=245;
wait for 380 ns; low1 <=0; high2 <=164; total3 <=314;
wait for 380 ns; low1 <=0; high2 <=165; total3 <=315;
130
Dissertação de Mestrado– LASID - PPGI/DI UFPB
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
wait for 380 ns; low1 <=166; high2 <=316; total3 <=316;
wait for 380 ns; low1 <=94; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=94; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=94; high2 <=248; total3 <=248;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=166; total3 <=317;
wait for 380 ns; low1 <=0; high2 <=167; total3 <=318;
wait for 380 ns; low1 <=0; high2 <=168; total3 <=319;
wait for 380 ns; low1 <=0; high2 <=169; total3 <=320;
wait for 380 ns; low1 <=0; high2 <=170; total3 <=321;
wait for 380 ns; low1 <=0; high2 <=171; total3 <=322;
wait for 380 ns; low1 <=0; high2 <=172; total3 <=323;
wait for 380 ns; low1 <=173; high2 <=324; total3 <=324;
wait for 380 ns; low1 <=95; high2 <=250; total3 <=250;
wait for 380 ns; low1 <=95; high2 <=251; total3 <=251;
wait for 380 ns; low1 <=95; high2 <=252; total3 <=252;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=253;
wait for 380 ns; low1 <=0; high2 <=173; total3 <=325;
wait for 380 ns; low1 <=0; high2 <=174; total3 <=326;
wait for 380 ns; low1 <=0; high2 <=175; total3 <=327;
wait for 380 ns; low1 <=0; high2 <=176; total3 <=328;
wait for 380 ns; low1 <=0; high2 <=177; total3 <=329;
wait for 380 ns; low1 <=0; high2 <=178; total3 <=330;
wait for 380 ns; low1 <=0; high2 <=179; total3 <=331;
wait for 380 ns; low1 <=180; high2 <=332; total3 <=332;
wait for 380 ns; low1 <=96; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=96; high2 <=255; total3 <=255;
wait for 380 ns; low1 <=96; high2 <=256; total3 <=256;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=257;
wait for 380 ns; low1 <=0; high2 <=180; total3 <=333;
wait for 380 ns; low1 <=0; high2 <=181; total3 <=334;
wait for 380 ns; low1 <=0; high2 <=182; total3 <=335;
wait for 380 ns; low1 <=0; high2 <=183; total3 <=336;
wait for 380 ns; low1 <=0; high2 <=184; total3 <=337;
wait for 380 ns; low1 <=185; high2 <=338; total3 <=338;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=258;
wait for 380 ns; low1 <=185; high2 <=339; total3 <=339;
wait for 380 ns; low1 <=98; high2 <=259; total3 <=259;
wait for 380 ns; low1 <=98; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=261;
wait for 380 ns; low1 <=185; high2 <=340; total3 <=340;
wait for 380 ns; low1 <=99; high2 <=262; total3 <=262;
wait for 380 ns; low1 <=99; high2 <=263; total3 <=263;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=264;
wait for 380 ns; low1 <=185; high2 <=341; total3 <=341;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=265;
131
Dissertação de Mestrado– LASID - PPGI/DI UFPB
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
wait for 380 ns; low1 <=185; high2 <=342; total3 <=342;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=266;
wait for 380 ns; low1 <=185; high2 <=343; total3 <=343;
wait for 380 ns; low1 <=102; high2 <=267; total3 <=267;
wait for 380 ns; low1 <=102; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=269;
wait for 380 ns; low1 <=185; high2 <=344; total3 <=344;
wait for 380 ns; low1 <=103; high2 <=270; total3 <=270;
wait for 380 ns; low1 <=103; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=103; high2 <=272; total3 <=272;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=185; total3 <=345;
wait for 380 ns; low1 <=186; high2 <=346; total3 <=346;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=274;
wait for 380 ns; low1 <=186; high2 <=347; total3 <=347;
wait for 380 ns; low1 <=105; high2 <=275; total3 <=275;
wait for 380 ns; low1 <=105; high2 <=276; total3 <=276;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=277;
wait for 380 ns; low1 <=186; high2 <=348; total3 <=348;
wait for 380 ns; low1 <=106; high2 <=278; total3 <=278;
wait for 380 ns; low1 <=106; high2 <=279; total3 <=279;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=280;
wait for 380 ns; low1 <=186; high2 <=349; total3 <=349;
wait for 380 ns; low1 <=107; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=107; high2 <=282; total3 <=282;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=283;
wait for 380 ns; low1 <=186; high2 <=350; total3 <=350;
wait for 380 ns; low1 <=108; high2 <=284; total3 <=284;
wait for 380 ns; low1 <=108; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=108; high2 <=286; total3 <=286;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=287;
wait for 380 ns; low1 <=0; high2 <=186; total3 <=351;
wait for 380 ns; low1 <=0; high2 <=187; total3 <=352;
wait for 380 ns; low1 <=0; high2 <=188; total3 <=353;
wait for 380 ns; low1 <=0; high2 <=189; total3 <=354;
wait for 380 ns; low1 <=0; high2 <=190; total3 <=355;
wait for 380 ns; low1 <=0; high2 <=191; total3 <=356;
wait for 380 ns; low1 <=0; high2 <=192; total3 <=357;
wait for 380 ns; low1 <=193; high2 <=358; total3 <=358;
wait for 380 ns; low1 <=109; high2 <=288; total3 <=288;
wait for 380 ns; low1 <=109; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=109; high2 <=290; total3 <=290;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=291;
wait for 380 ns; low1 <=0; high2 <=193; total3 <=359;
wait for 380 ns; low1 <=0; high2 <=194; total3 <=360;
wait for 380 ns; low1 <=195; high2 <=361; total3 <=361;
132
Dissertação de Mestrado– LASID - PPGI/DI UFPB
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
wait for 380 ns; low1 <=0; high2 <=110; total3 <=292;
wait for 380 ns; low1 <=195; high2 <=362; total3 <=362;
wait for 380 ns; low1 <=111; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=294;
wait for 380 ns; low1 <=195; high2 <=363; total3 <=363;
wait for 380 ns; low1 <=112; high2 <=295; total3 <=295;
wait for 380 ns; low1 <=112; high2 <=296; total3 <=296;
wait for 380 ns; low1 <=112; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=195; total3 <=364;
wait for 380 ns; low1 <=0; high2 <=196; total3 <=365;
wait for 380 ns; low1 <=197; high2 <=366; total3 <=366;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=299;
wait for 380 ns; low1 <=197; high2 <=367; total3 <=367;
wait for 380 ns; low1 <=114; high2 <=300; total3 <=300;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=301;
wait for 380 ns; low1 <=197; high2 <=368; total3 <=368;
wait for 380 ns; low1 <=115; high2 <=302; total3 <=302;
wait for 380 ns; low1 <=115; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=115; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=305;
wait for 380 ns; low1 <=0; high2 <=197; total3 <=369;
wait for 380 ns; low1 <=198; high2 <=370; total3 <=370;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=306;
wait for 380 ns; low1 <=0; high2 <=198; total3 <=371;
wait for 380 ns; low1 <=0; high2 <=199; total3 <=372;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=186;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=187;
wait for 380 ns; low1 <=102; high2 <=188; total3 <=188;
wait for 380 ns; low1 <=117; high2 <=307; total3 <=307;
wait for 380 ns; low1 <=117; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=117; high2 <=309; total3 <=309;
wait for 380 ns; low1 <=0; high2 <=117; total3 <=310;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=189;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=190;
wait for 380 ns; low1 <=104; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=118; high2 <=311; total3 <=311;
wait for 380 ns; low1 <=118; high2 <=312; total3 <=312;
wait for 380 ns; low1 <=0; high2 <=118; total3 <=313;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=192;
wait for 380 ns; low1 <=105; high2 <=193; total3 <=193;
wait for 380 ns; low1 <=119; high2 <=314; total3 <=314;
wait for 380 ns; low1 <=119; high2 <=315; total3 <=315;
wait for 380 ns; low1 <=119; high2 <=316; total3 <=316;
wait for 380 ns; low1 <=0; high2 <=119; total3 <=317;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=194;
133
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
wait for 380 ns; low1 <=106; high2 <=195; total3 <=195;
wait for 380 ns; low1 <=0; high2 <=120; total3 <=318;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=196;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=197;
wait for 380 ns; low1 <=108; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=121; total3 <=319;
wait for 380 ns; low1 <=108; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=122; high2 <=320; total3 <=320;
wait for 380 ns; low1 <=122; high2 <=321; total3 <=321;
wait for 380 ns; low1 <=61; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=162;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=200;
wait for 380 ns; low1 <=109; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=163;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=202;
wait for 380 ns; low1 <=110; high2 <=203; total3 <=203;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=164;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=204;
wait for 380 ns; low1 <=111; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=64; high2 <=165; total3 <=165;
wait for 380 ns; low1 <=64; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=64; high2 <=167; total3 <=167;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=168;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=206;
wait for 380 ns; low1 <=112; high2 <=207; total3 <=207;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=169;
wait for 380 ns; low1 <=112; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=170;
wait for 380 ns; low1 <=112; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=171;
wait for 380 ns; low1 <=112; high2 <=210; total3 <=210;
wait for 380 ns; low1 <=68; high2 <=172; total3 <=172;
wait for 380 ns; low1 <=68; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=68; high2 <=174; total3 <=174;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=175;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=211;
wait for 380 ns; low1 <=113; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=176;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=214;
wait for 380 ns; low1 <=115; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=177;
wait for 380 ns; low1 <=115; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=71; high2 <=178; total3 <=178;
wait for 380 ns; low1 <=71; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=71; high2 <=180; total3 <=180;
134
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
wait for 380 ns; low1 <=0; high2 <=71; total3 <=181;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=217;
wait for 380 ns; low1 <=116; high2 <=218; total3 <=218;
wait for 380 ns; low1 <=72; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=183;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=219;
wait for 380 ns; low1 <=0; high2 <=117; total3 <=220;
wait for 380 ns; low1 <=0; high2 <=118; total3 <=221;
wait for 380 ns; low1 <=119; high2 <=222; total3 <=222;
wait for 380 ns; low1 <=73; high2 <=184; total3 <=184;
wait for 380 ns; low1 <=73; high2 <=185; total3 <=185;
wait for 380 ns; low1 <=73; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=187;
wait for 380 ns; low1 <=0; high2 <=119; total3 <=223;
wait for 380 ns; low1 <=120; high2 <=224; total3 <=224;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=188;
wait for 380 ns; low1 <=0; high2 <=120; total3 <=225;
wait for 380 ns; low1 <=0; high2 <=121; total3 <=226;
wait for 380 ns; low1 <=122; high2 <=227; total3 <=227;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=189;
wait for 380 ns; low1 <=122; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=76; high2 <=190; total3 <=190;
wait for 380 ns; low1 <=76; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=76; high2 <=192; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=193;
wait for 380 ns; low1 <=0; high2 <=122; total3 <=229;
wait for 380 ns; low1 <=0; high2 <=123; total3 <=230;
wait for 380 ns; low1 <=124; high2 <=231; total3 <=231;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=194;
wait for 380 ns; low1 <=124; high2 <=232; total3 <=232;
wait for 380 ns; low1 <=78; high2 <=195; total3 <=195;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=196;
wait for 380 ns; low1 <=124; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=79; high2 <=197; total3 <=197;
wait for 380 ns; low1 <=79; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=79; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=200;
wait for 380 ns; low1 <=0; high2 <=124; total3 <=234;
wait for 380 ns; low1 <=125; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=201;
wait for 380 ns; low1 <=125; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=202;
wait for 380 ns; low1 <=125; high2 <=237; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=203;
wait for 380 ns; low1 <=125; high2 <=238; total3 <=238;
wait for 380 ns; low1 <=83; high2 <=204; total3 <=204;
135
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
wait for 380 ns; low1 <=83; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=83; high2 <=206; total3 <=206;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=207;
wait for 380 ns; low1 <=0; high2 <=125; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=126; total3 <=240;
wait for 380 ns; low1 <=127; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=84; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=209;
wait for 380 ns; low1 <=127; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=210;
wait for 380 ns; low1 <=127; high2 <=243; total3 <=243;
wait for 380 ns; low1 <=86; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=86; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=213;
wait for 380 ns; low1 <=127; high2 <=244; total3 <=244;
wait for 380 ns; low1 <=87; high2 <=214; total3 <=214;
wait for 380 ns; low1 <=87; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=87; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=87; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=87; high2 <=218; total3 <=218;
wait for 380 ns; low1 <=87; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=220;
wait for 380 ns; low1 <=127; high2 <=245; total3 <=245;
wait for 380 ns; low1 <=88; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=88; high2 <=222; total3 <=222;
wait for 380 ns; low1 <=88; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=224;
wait for 380 ns; low1 <=0; high2 <=127; total3 <=246;
wait for 380 ns; low1 <=0; high2 <=128; total3 <=247;
wait for 380 ns; low1 <=0; high2 <=129; total3 <=248;
wait for 380 ns; low1 <=0; high2 <=130; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=131; total3 <=250;
wait for 380 ns; low1 <=0; high2 <=132; total3 <=251;
wait for 380 ns; low1 <=0; high2 <=133; total3 <=252;
wait for 380 ns; low1 <=134; high2 <=253; total3 <=253;
wait for 380 ns; low1 <=89; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=89; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=227;
wait for 380 ns; low1 <=134; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=90; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=90; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=90; high2 <=230; total3 <=230;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=231;
wait for 380 ns; low1 <=0; high2 <=134; total3 <=255;
wait for 380 ns; low1 <=135; high2 <=256; total3 <=256;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=232;
136
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
wait for 380 ns; low1 <=135; high2 <=257; total3 <=257;
wait for 380 ns; low1 <=92; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=92; high2 <=234; total3 <=234;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=235;
wait for 380 ns; low1 <=135; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=93; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=93; high2 <=237; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=135; total3 <=259;
wait for 380 ns; low1 <=136; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=94; high2 <=239; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=240;
wait for 380 ns; low1 <=136; high2 <=261; total3 <=261;
wait for 380 ns; low1 <=95; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=95; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=95; high2 <=243; total3 <=243;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=136; total3 <=262;
wait for 380 ns; low1 <=0; high2 <=137; total3 <=263;
wait for 380 ns; low1 <=0; high2 <=138; total3 <=264;
wait for 380 ns; low1 <=139; high2 <=265; total3 <=265;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=245;
wait for 380 ns; low1 <=0; high2 <=139; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=140; total3 <=267;
wait for 380 ns; low1 <=141; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=97; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=97; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=97; high2 <=248; total3 <=248;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=141; total3 <=269;
wait for 380 ns; low1 <=0; high2 <=142; total3 <=270;
wait for 380 ns; low1 <=143; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=250;
wait for 380 ns; low1 <=0; high2 <=143; total3 <=272;
wait for 380 ns; low1 <=144; high2 <=273; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=251;
wait for 380 ns; low1 <=144; high2 <=274; total3 <=274;
wait for 380 ns; low1 <=100; high2 <=252; total3 <=252;
wait for 380 ns; low1 <=100; high2 <=253; total3 <=253;
wait for 380 ns; low1 <=100; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=255;
wait for 380 ns; low1 <=0; high2 <=144; total3 <=275;
wait for 380 ns; low1 <=0; high2 <=145; total3 <=276;
wait for 380 ns; low1 <=146; high2 <=277; total3 <=277;
wait for 380 ns; low1 <=101; high2 <=256; total3 <=256;
wait for 380 ns; low1 <=101; high2 <=257; total3 <=257;
137
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
wait for 380 ns; low1 <=101; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=259;
wait for 380 ns; low1 <=146; high2 <=278; total3 <=278;
wait for 380 ns; low1 <=102; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=102; high2 <=261; total3 <=261;
wait for 380 ns; low1 <=102; high2 <=262; total3 <=262;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=263;
wait for 380 ns; low1 <=0; high2 <=146; total3 <=279;
wait for 380 ns; low1 <=0; high2 <=147; total3 <=280;
wait for 380 ns; low1 <=148; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=103; high2 <=264; total3 <=264;
wait for 380 ns; low1 <=103; high2 <=265; total3 <=265;
wait for 380 ns; low1 <=103; high2 <=266; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=267;
wait for 380 ns; low1 <=148; high2 <=282; total3 <=282;
wait for 380 ns; low1 <=104; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=104; high2 <=269; total3 <=269;
wait for 380 ns; low1 <=104; high2 <=270; total3 <=270;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=271;
wait for 380 ns; low1 <=0; high2 <=148; total3 <=283;
wait for 380 ns; low1 <=0; high2 <=149; total3 <=284;
wait for 380 ns; low1 <=150; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=105; high2 <=272; total3 <=272;
wait for 380 ns; low1 <=105; high2 <=273; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=274;
wait for 380 ns; low1 <=0; high2 <=150; total3 <=286;
wait for 380 ns; low1 <=151; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=106; high2 <=275; total3 <=275;
wait for 380 ns; low1 <=106; high2 <=276; total3 <=276;
wait for 380 ns; low1 <=106; high2 <=277; total3 <=277;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=278;
wait for 380 ns; low1 <=0; high2 <=151; total3 <=288;
wait for 380 ns; low1 <=152; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=279;
wait for 380 ns; low1 <=0; high2 <=152; total3 <=290;
wait for 380 ns; low1 <=0; high2 <=153; total3 <=291;
wait for 380 ns; low1 <=154; high2 <=292; total3 <=292;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=280;
wait for 380 ns; low1 <=154; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=109; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=109; high2 <=282; total3 <=282;
wait for 380 ns; low1 <=109; high2 <=283; total3 <=283;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=284;
wait for 380 ns; low1 <=0; high2 <=154; total3 <=294;
wait for 380 ns; low1 <=0; high2 <=155; total3 <=295;
wait for 380 ns; low1 <=156; high2 <=296; total3 <=296;
138
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
wait for 380 ns; low1 <=110; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=110; high2 <=286; total3 <=286;
wait for 380 ns; low1 <=110; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=288;
wait for 380 ns; low1 <=156; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=111; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=111; high2 <=290; total3 <=290;
wait for 380 ns; low1 <=111; high2 <=291; total3 <=291;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=292;
wait for 380 ns; low1 <=0; high2 <=156; total3 <=298;
wait for 380 ns; low1 <=157; high2 <=299; total3 <=299;
wait for 380 ns; low1 <=112; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=294;
wait for 380 ns; low1 <=0; high2 <=157; total3 <=300;
wait for 380 ns; low1 <=158; high2 <=301; total3 <=301;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=295;
wait for 380 ns; low1 <=158; high2 <=302; total3 <=302;
wait for 380 ns; low1 <=114; high2 <=296; total3 <=296;
wait for 380 ns; low1 <=114; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=114; high2 <=298; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=299;
wait for 380 ns; low1 <=0; high2 <=158; total3 <=303;
wait for 380 ns; low1 <=159; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=115; high2 <=300; total3 <=300;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=301;
wait for 380 ns; low1 <=159; high2 <=305; total3 <=305;
wait for 380 ns; low1 <=116; high2 <=302; total3 <=302;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=303;
wait for 380 ns; low1 <=159; high2 <=306; total3 <=306;
wait for 380 ns; low1 <=117; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=117; high2 <=305; total3 <=305;
wait for 380 ns; low1 <=117; high2 <=306; total3 <=306;
wait for 380 ns; low1 <=0; high2 <=117; total3 <=307;
wait for 380 ns; low1 <=0; high2 <=159; total3 <=307;
wait for 380 ns; low1 <=160; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=118; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=0; high2 <=118; total3 <=309;
wait for 380 ns; low1 <=0; high2 <=160; total3 <=309;
wait for 380 ns; low1 <=0; high2 <=161; total3 <=310;
wait for 380 ns; low1 <=0; high2 <=162; total3 <=311;
wait for 380 ns; low1 <=163; high2 <=312; total3 <=312;
wait for 380 ns; low1 <=119; high2 <=310; total3 <=310;
wait for 380 ns; low1 <=119; high2 <=311; total3 <=311;
wait for 380 ns; low1 <=119; high2 <=312; total3 <=312;
wait for 380 ns; low1 <=0; high2 <=119; total3 <=313;
wait for 380 ns; low1 <=0; high2 <=163; total3 <=313;
139
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
wait for 380 ns; low1 <=164; high2 <=314; total3 <=314;
wait for 380 ns; low1 <=0; high2 <=120; total3 <=314;
wait for 380 ns; low1 <=164; high2 <=315; total3 <=315;
wait for 380 ns; low1 <=0; high2 <=121; total3 <=315;
wait for 380 ns; low1 <=0; high2 <=164; total3 <=316;
wait for 380 ns; low1 <=0; high2 <=165; total3 <=317;
wait for 380 ns; low1 <=166; high2 <=318; total3 <=318;
wait for 380 ns; low1 <=122; high2 <=316; total3 <=316;
wait for 380 ns; low1 <=122; high2 <=317; total3 <=317;
wait for 380 ns; low1 <=122; high2 <=318; total3 <=318;
wait for 380 ns; low1 <=0; high2 <=122; total3 <=319;
wait for 380 ns; low1 <=0; high2 <=166; total3 <=319;
wait for 380 ns; low1 <=167; high2 <=320; total3 <=320;
wait for 380 ns; low1 <=0; high2 <=123; total3 <=320;
wait for 380 ns; low1 <=0; high2 <=167; total3 <=321;
wait for 380 ns; low1 <=0; high2 <=168; total3 <=322;
wait for 380 ns; low1 <=169; high2 <=323; total3 <=323;
wait for 380 ns; low1 <=0; high2 <=124; total3 <=321;
wait for 380 ns; low1 <=169; high2 <=324; total3 <=324;
wait for 380 ns; low1 <=125; high2 <=322; total3 <=322;
wait for 380 ns; low1 <=125; high2 <=323; total3 <=323;
wait for 380 ns; low1 <=125; high2 <=324; total3 <=324;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=162;
wait for 380 ns; low1 <=0; high2 <=169; total3 <=325;
wait for 380 ns; low1 <=0; high2 <=170; total3 <=326;
wait for 380 ns; low1 <=171; high2 <=327; total3 <=327;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=163;
wait for 380 ns; low1 <=0; high2 <=171; total3 <=328;
wait for 380 ns; low1 <=0; high2 <=172; total3 <=329;
wait for 380 ns; low1 <=0; high2 <=173; total3 <=330;
wait for 380 ns; low1 <=174; high2 <=331; total3 <=331;
wait for 380 ns; low1 <=64; high2 <=164; total3 <=164;
wait for 380 ns; low1 <=64; high2 <=165; total3 <=165;
wait for 380 ns; low1 <=64; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=167;
wait for 380 ns; low1 <=0; high2 <=174; total3 <=332;
wait for 380 ns; low1 <=0; high2 <=175; total3 <=333;
wait for 380 ns; low1 <=0; high2 <=176; total3 <=334;
wait for 380 ns; low1 <=177; high2 <=335; total3 <=335;
wait for 380 ns; low1 <=65; high2 <=168; total3 <=168;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=169;
wait for 380 ns; low1 <=0; high2 <=177; total3 <=336;
wait for 380 ns; low1 <=178; high2 <=337; total3 <=337;
wait for 380 ns; low1 <=66; high2 <=170; total3 <=170;
wait for 380 ns; low1 <=66; high2 <=171; total3 <=171;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=172;
140
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
wait for 380 ns; low1 <=178; high2 <=338; total3 <=338;
wait for 380 ns; low1 <=67; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=67; high2 <=174; total3 <=174;
wait for 380 ns; low1 <=67; high2 <=175; total3 <=175;
wait for 380 ns; low1 <=67; high2 <=176; total3 <=176;
wait for 380 ns; low1 <=67; high2 <=177; total3 <=177;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=178;
wait for 380 ns; low1 <=0; high2 <=178; total3 <=339;
wait for 380 ns; low1 <=179; high2 <=340; total3 <=340;
wait for 380 ns; low1 <=68; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=68; high2 <=180; total3 <=180;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=181;
wait for 380 ns; low1 <=179; high2 <=341; total3 <=341;
wait for 380 ns; low1 <=69; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=69; high2 <=183; total3 <=183;
wait for 380 ns; low1 <=69; high2 <=184; total3 <=184;
wait for 380 ns; low1 <=69; high2 <=185; total3 <=185;
wait for 380 ns; low1 <=69; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=69; high2 <=187; total3 <=187;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=188;
wait for 380 ns; low1 <=179; high2 <=342; total3 <=342;
wait for 380 ns; low1 <=70; high2 <=189; total3 <=189;
wait for 380 ns; low1 <=70; high2 <=190; total3 <=190;
wait for 380 ns; low1 <=70; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=179; total3 <=343;
wait for 380 ns; low1 <=0; high2 <=180; total3 <=344;
wait for 380 ns; low1 <=181; high2 <=345; total3 <=345;
wait for 380 ns; low1 <=0; high2 <=71; total3 <=193;
wait for 380 ns; low1 <=181; high2 <=346; total3 <=346;
wait for 380 ns; low1 <=72; high2 <=194; total3 <=194;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=195;
wait for 380 ns; low1 <=181; high2 <=347; total3 <=347;
wait for 380 ns; low1 <=73; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=73; high2 <=197; total3 <=197;
wait for 380 ns; low1 <=73; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=199;
wait for 380 ns; low1 <=0; high2 <=181; total3 <=348;
wait for 380 ns; low1 <=182; high2 <=349; total3 <=349;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=200;
wait for 380 ns; low1 <=182; high2 <=350; total3 <=350;
wait for 380 ns; low1 <=75; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=75; high2 <=202; total3 <=202;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=203;
wait for 380 ns; low1 <=182; high2 <=351; total3 <=351;
wait for 380 ns; low1 <=76; high2 <=204; total3 <=204;
141
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
wait for 380 ns; low1 <=76; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=76; high2 <=206; total3 <=206;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=207;
wait for 380 ns; low1 <=0; high2 <=182; total3 <=352;
wait for 380 ns; low1 <=183; high2 <=353; total3 <=353;
wait for 380 ns; low1 <=77; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=209;
wait for 380 ns; low1 <=183; high2 <=354; total3 <=354;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=210;
wait for 380 ns; low1 <=0; high2 <=183; total3 <=355;
wait for 380 ns; low1 <=184; high2 <=356; total3 <=356;
wait for 380 ns; low1 <=79; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=79; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=79; high2 <=213; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=214;
wait for 380 ns; low1 <=0; high2 <=184; total3 <=357;
wait for 380 ns; low1 <=185; high2 <=358; total3 <=358;
wait for 380 ns; low1 <=80; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=216;
wait for 380 ns; low1 <=185; high2 <=359; total3 <=359;
wait for 380 ns; low1 <=81; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=218;
wait for 380 ns; low1 <=185; high2 <=360; total3 <=360;
wait for 380 ns; low1 <=82; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=82; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=82; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=222;
wait for 380 ns; low1 <=0; high2 <=185; total3 <=361;
wait for 380 ns; low1 <=186; high2 <=362; total3 <=362;
wait for 380 ns; low1 <=83; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=224;
wait for 380 ns; low1 <=186; high2 <=363; total3 <=363;
wait for 380 ns; low1 <=84; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=226;
wait for 380 ns; low1 <=186; high2 <=364; total3 <=364;
wait for 380 ns; low1 <=85; high2 <=227; total3 <=227;
wait for 380 ns; low1 <=85; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=85; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=230;
wait for 380 ns; low1 <=186; high2 <=365; total3 <=365;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=231;
wait for 380 ns; low1 <=0; high2 <=186; total3 <=366;
wait for 380 ns; low1 <=0; high2 <=187; total3 <=367;
wait for 380 ns; low1 <=0; high2 <=188; total3 <=368;
wait for 380 ns; low1 <=189; high2 <=369; total3 <=369;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=232;
142
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
wait for 380 ns; low1 <=189; high2 <=370; total3 <=370;
wait for 380 ns; low1 <=88; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=88; high2 <=234; total3 <=234;
wait for 380 ns; low1 <=88; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=236;
wait for 380 ns; low1 <=189; high2 <=371; total3 <=371;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=189; total3 <=372;
wait for 380 ns; low1 <=0; high2 <=190; total3 <=373;
wait for 380 ns; low1 <=0; high2 <=191; total3 <=374;
wait for 380 ns; low1 <=192; high2 <=375; total3 <=375;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=238;
wait for 380 ns; low1 <=192; high2 <=376; total3 <=376;
wait for 380 ns; low1 <=91; high2 <=239; total3 <=239;
wait for 380 ns; low1 <=91; high2 <=240; total3 <=240;
wait for 380 ns; low1 <=91; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=242;
wait for 380 ns; low1 <=192; high2 <=377; total3 <=377;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=243;
wait for 380 ns; low1 <=192; high2 <=378; total3 <=378;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=192; total3 <=379;
wait for 380 ns; low1 <=0; high2 <=193; total3 <=380;
wait for 380 ns; low1 <=0; high2 <=194; total3 <=381;
wait for 380 ns; low1 <=195; high2 <=382; total3 <=382;
wait for 380 ns; low1 <=94; high2 <=245; total3 <=245;
wait for 380 ns; low1 <=94; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=94; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=248;
wait for 380 ns; low1 <=195; high2 <=383; total3 <=383;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=195; total3 <=384;
wait for 380 ns; low1 <=0; high2 <=196; total3 <=385;
wait for 380 ns; low1 <=0; high2 <=197; total3 <=386;
wait for 380 ns; low1 <=0; high2 <=198; total3 <=387;
wait for 380 ns; low1 <=0; high2 <=199; total3 <=388;
wait for 380 ns; low1 <=100; high2 <=194; total3 <=194;
wait for 380 ns; low1 <=96; high2 <=250; total3 <=250;
wait for 380 ns; low1 <=96; high2 <=251; total3 <=251;
wait for 380 ns; low1 <=96; high2 <=252; total3 <=252;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=253;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=195;
wait for 380 ns; low1 <=101; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=97; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=255;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=197;
143
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
wait for 380 ns; low1 <=102; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=256;
wait for 380 ns; low1 <=102; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=99; high2 <=257; total3 <=257;
wait for 380 ns; low1 <=99; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=99; high2 <=259; total3 <=259;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=260;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=200;
wait for 380 ns; low1 <=103; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=100; high2 <=261; total3 <=261;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=262;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=202;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=203;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=204;
wait for 380 ns; low1 <=106; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=101; high2 <=263; total3 <=263;
wait for 380 ns; low1 <=101; high2 <=264; total3 <=264;
wait for 380 ns; low1 <=101; high2 <=265; total3 <=265;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=206;
wait for 380 ns; low1 <=107; high2 <=207; total3 <=207;
wait for 380 ns; low1 <=102; high2 <=267; total3 <=267;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=268;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=208;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=209;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=210;
wait for 380 ns; low1 <=110; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=103; high2 <=269; total3 <=269;
wait for 380 ns; low1 <=103; high2 <=270; total3 <=270;
wait for 380 ns; low1 <=103; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=272;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=212;
wait for 380 ns; low1 <=111; high2 <=213; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=214;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=215;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=216;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=217;
wait for 380 ns; low1 <=115; high2 <=218; total3 <=218;
wait for 380 ns; low1 <=105; high2 <=274; total3 <=274;
wait for 380 ns; low1 <=105; high2 <=275; total3 <=275;
wait for 380 ns; low1 <=105; high2 <=276; total3 <=276;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=277;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=219;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=220;
wait for 380 ns; low1 <=0; high2 <=117; total3 <=221;
144
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
wait for 380 ns; low1 <=0; high2 <=118; total3 <=222;
wait for 380 ns; low1 <=119; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=106; high2 <=278; total3 <=278;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=279;
wait for 380 ns; low1 <=119; high2 <=224; total3 <=224;
wait for 380 ns; low1 <=107; high2 <=280; total3 <=280;
wait for 380 ns; low1 <=107; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=282;
wait for 380 ns; low1 <=119; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=108; high2 <=283; total3 <=283;
wait for 380 ns; low1 <=108; high2 <=284; total3 <=284;
wait for 380 ns; low1 <=108; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=108; high2 <=286; total3 <=286;
wait for 380 ns; low1 <=108; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=108; high2 <=288; total3 <=288;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=289;
wait for 380 ns; low1 <=119; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=109; high2 <=290; total3 <=290;
wait for 380 ns; low1 <=109; high2 <=291; total3 <=291;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=292;
wait for 380 ns; low1 <=119; high2 <=227; total3 <=227;
wait for 380 ns; low1 <=110; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=110; high2 <=294; total3 <=294;
wait for 380 ns; low1 <=110; high2 <=295; total3 <=295;
wait for 380 ns; low1 <=110; high2 <=296; total3 <=296;
wait for 380 ns; low1 <=110; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=110; high2 <=298; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=299;
wait for 380 ns; low1 <=119; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=111; high2 <=300; total3 <=300;
wait for 380 ns; low1 <=111; high2 <=301; total3 <=301;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=302;
wait for 380 ns; low1 <=119; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=112; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=112; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=112; high2 <=305; total3 <=305;
wait for 380 ns; low1 <=112; high2 <=306; total3 <=306;
wait for 380 ns; low1 <=112; high2 <=307; total3 <=307;
wait for 380 ns; low1 <=112; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=309;
wait for 380 ns; low1 <=119; high2 <=230; total3 <=230;
wait for 380 ns; low1 <=113; high2 <=310; total3 <=310;
wait for 380 ns; low1 <=113; high2 <=311; total3 <=311;
wait for 380 ns; low1 <=113; high2 <=312; total3 <=312;
wait for 380 ns; low1 <=0; high2 <=56; total3 <=156;
wait for 380 ns; low1 <=0; high2 <=119; total3 <=231;
145
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
wait for 380 ns; low1 <=0; high2 <=120; total3 <=232;
wait for 380 ns; low1 <=121; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=0; high2 <=57; total3 <=157;
wait for 380 ns; low1 <=0; high2 <=121; total3 <=234;
wait for 380 ns; low1 <=122; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=0; high2 <=58; total3 <=158;
wait for 380 ns; low1 <=122; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=59; high2 <=159; total3 <=159;
wait for 380 ns; low1 <=59; high2 <=160; total3 <=160;
wait for 380 ns; low1 <=59; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=0; high2 <=59; total3 <=162;
wait for 380 ns; low1 <=0; high2 <=122; total3 <=237;
wait for 380 ns; low1 <=123; high2 <=238; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=60; total3 <=163;
wait for 380 ns; low1 <=0; high2 <=123; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=124; total3 <=240;
wait for 380 ns; low1 <=125; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=164;
wait for 380 ns; low1 <=125; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=62; high2 <=165; total3 <=165;
wait for 380 ns; low1 <=62; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=62; high2 <=167; total3 <=167;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=168;
wait for 380 ns; low1 <=0; high2 <=125; total3 <=243;
wait for 380 ns; low1 <=126; high2 <=244; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=169;
wait for 380 ns; low1 <=0; high2 <=126; total3 <=245;
wait for 380 ns; low1 <=127; high2 <=246; total3 <=246;
wait for 380 ns; low1 <=64; high2 <=170; total3 <=170;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=171;
wait for 380 ns; low1 <=127; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=65; high2 <=172; total3 <=172;
wait for 380 ns; low1 <=65; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=65; high2 <=174; total3 <=174;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=175;
wait for 380 ns; low1 <=0; high2 <=127; total3 <=248;
wait for 380 ns; low1 <=128; high2 <=249; total3 <=249;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=176;
wait for 380 ns; low1 <=0; high2 <=128; total3 <=250;
wait for 380 ns; low1 <=0; high2 <=129; total3 <=251;
wait for 380 ns; low1 <=130; high2 <=252; total3 <=252;
wait for 380 ns; low1 <=0; high2 <=67; total3 <=177;
wait for 380 ns; low1 <=130; high2 <=253; total3 <=253;
wait for 380 ns; low1 <=68; high2 <=178; total3 <=178;
wait for 380 ns; low1 <=68; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=68; high2 <=180; total3 <=180;
146
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
wait for 380 ns; low1 <=0; high2 <=68; total3 <=181;
wait for 380 ns; low1 <=0; high2 <=130; total3 <=254;
wait for 380 ns; low1 <=131; high2 <=255; total3 <=255;
wait for 380 ns; low1 <=69; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=69; high2 <=183; total3 <=183;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=184;
wait for 380 ns; low1 <=0; high2 <=131; total3 <=256;
wait for 380 ns; low1 <=0; high2 <=132; total3 <=257;
wait for 380 ns; low1 <=133; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=70; high2 <=185; total3 <=185;
wait for 380 ns; low1 <=70; high2 <=186; total3 <=186;
wait for 380 ns; low1 <=70; high2 <=187; total3 <=187;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=188;
wait for 380 ns; low1 <=0; high2 <=133; total3 <=259;
wait for 380 ns; low1 <=134; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=71; high2 <=189; total3 <=189;
wait for 380 ns; low1 <=71; high2 <=190; total3 <=190;
wait for 380 ns; low1 <=71; high2 <=191; total3 <=191;
wait for 380 ns; low1 <=71; high2 <=192; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=71; total3 <=193;
wait for 380 ns; low1 <=134; high2 <=261; total3 <=261;
wait for 380 ns; low1 <=72; high2 <=194; total3 <=194;
wait for 380 ns; low1 <=72; high2 <=195; total3 <=195;
wait for 380 ns; low1 <=72; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=197;
wait for 380 ns; low1 <=0; high2 <=134; total3 <=262;
wait for 380 ns; low1 <=135; high2 <=263; total3 <=263;
wait for 380 ns; low1 <=73; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=73; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=73; high2 <=200; total3 <=200;
wait for 380 ns; low1 <=73; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=202;
wait for 380 ns; low1 <=135; high2 <=264; total3 <=264;
wait for 380 ns; low1 <=74; high2 <=203; total3 <=203;
wait for 380 ns; low1 <=74; high2 <=204; total3 <=204;
wait for 380 ns; low1 <=74; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=206;
wait for 380 ns; low1 <=135; high2 <=265; total3 <=265;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=207;
wait for 380 ns; low1 <=0; high2 <=135; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=136; total3 <=267;
wait for 380 ns; low1 <=137; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=76; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=209;
wait for 380 ns; low1 <=137; high2 <=269; total3 <=269;
wait for 380 ns; low1 <=77; high2 <=210; total3 <=210;
147
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
wait for 380 ns; low1 <=77; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=77; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=137; total3 <=270;
wait for 380 ns; low1 <=138; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=78; high2 <=214; total3 <=214;
wait for 380 ns; low1 <=78; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=78; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=78; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=218;
wait for 380 ns; low1 <=138; high2 <=272; total3 <=272;
wait for 380 ns; low1 <=79; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=79; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=79; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=222;
wait for 380 ns; low1 <=0; high2 <=138; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=139; total3 <=274;
wait for 380 ns; low1 <=140; high2 <=275; total3 <=275;
wait for 380 ns; low1 <=80; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=80; high2 <=224; total3 <=224;
wait for 380 ns; low1 <=80; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=226;
wait for 380 ns; low1 <=140; high2 <=276; total3 <=276;
wait for 380 ns; low1 <=81; high2 <=227; total3 <=227;
wait for 380 ns; low1 <=81; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=81; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=230;
wait for 380 ns; low1 <=0; high2 <=140; total3 <=277;
wait for 380 ns; low1 <=0; high2 <=141; total3 <=278;
wait for 380 ns; low1 <=142; high2 <=279; total3 <=279;
wait for 380 ns; low1 <=82; high2 <=231; total3 <=231;
wait for 380 ns; low1 <=82; high2 <=232; total3 <=232;
wait for 380 ns; low1 <=82; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=234;
wait for 380 ns; low1 <=142; high2 <=280; total3 <=280;
wait for 380 ns; low1 <=83; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=83; high2 <=236; total3 <=236;
wait for 380 ns; low1 <=83; high2 <=237; total3 <=237;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=142; total3 <=281;
wait for 380 ns; low1 <=143; high2 <=282; total3 <=282;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=143; total3 <=283;
wait for 380 ns; low1 <=144; high2 <=284; total3 <=284;
wait for 380 ns; low1 <=85; high2 <=240; total3 <=240;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=241;
148
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
wait for 380 ns; low1 <=144; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=86; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=86; high2 <=243; total3 <=243;
wait for 380 ns; low1 <=86; high2 <=244; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=245;
wait for 380 ns; low1 <=0; high2 <=144; total3 <=286;
wait for 380 ns; low1 <=145; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=246;
wait for 380 ns; low1 <=0; high2 <=145; total3 <=288;
wait for 380 ns; low1 <=146; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=88; high2 <=247; total3 <=247;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=248;
wait for 380 ns; low1 <=146; high2 <=290; total3 <=290;
wait for 380 ns; low1 <=89; high2 <=249; total3 <=249;
wait for 380 ns; low1 <=89; high2 <=250; total3 <=250;
wait for 380 ns; low1 <=89; high2 <=251; total3 <=251;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=252;
wait for 380 ns; low1 <=0; high2 <=146; total3 <=291;
wait for 380 ns; low1 <=0; high2 <=147; total3 <=292;
wait for 380 ns; low1 <=148; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=253;
wait for 380 ns; low1 <=148; high2 <=294; total3 <=294;
wait for 380 ns; low1 <=91; high2 <=254; total3 <=254;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=255;
wait for 380 ns; low1 <=148; high2 <=295; total3 <=295;
wait for 380 ns; low1 <=92; high2 <=256; total3 <=256;
wait for 380 ns; low1 <=92; high2 <=257; total3 <=257;
wait for 380 ns; low1 <=92; high2 <=258; total3 <=258;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=259;
wait for 380 ns; low1 <=0; high2 <=148; total3 <=296;
wait for 380 ns; low1 <=149; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=93; high2 <=260; total3 <=260;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=261;
wait for 380 ns; low1 <=0; high2 <=149; total3 <=298;
wait for 380 ns; low1 <=0; high2 <=150; total3 <=299;
wait for 380 ns; low1 <=0; high2 <=151; total3 <=300;
wait for 380 ns; low1 <=152; high2 <=301; total3 <=301;
wait for 380 ns; low1 <=94; high2 <=262; total3 <=262;
wait for 380 ns; low1 <=94; high2 <=263; total3 <=263;
wait for 380 ns; low1 <=94; high2 <=264; total3 <=264;
wait for 380 ns; low1 <=0; high2 <=94; total3 <=265;
wait for 380 ns; low1 <=0; high2 <=152; total3 <=302;
wait for 380 ns; low1 <=153; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=0; high2 <=95; total3 <=266;
wait for 380 ns; low1 <=0; high2 <=153; total3 <=304;
wait for 380 ns; low1 <=0; high2 <=154; total3 <=305;
149
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
wait for 380 ns; low1 <=0; high2 <=155; total3 <=306;
wait for 380 ns; low1 <=0; high2 <=156; total3 <=307;
wait for 380 ns; low1 <=157; high2 <=308; total3 <=308;
wait for 380 ns; low1 <=96; high2 <=267; total3 <=267;
wait for 380 ns; low1 <=96; high2 <=268; total3 <=268;
wait for 380 ns; low1 <=96; high2 <=269; total3 <=269;
wait for 380 ns; low1 <=0; high2 <=96; total3 <=270;
wait for 380 ns; low1 <=0; high2 <=157; total3 <=309;
wait for 380 ns; low1 <=0; high2 <=158; total3 <=310;
wait for 380 ns; low1 <=0; high2 <=159; total3 <=311;
wait for 380 ns; low1 <=0; high2 <=160; total3 <=312;
wait for 380 ns; low1 <=0; high2 <=161; total3 <=313;
wait for 380 ns; low1 <=0; high2 <=162; total3 <=314;
wait for 380 ns; low1 <=0; high2 <=163; total3 <=315;
wait for 380 ns; low1 <=164; high2 <=316; total3 <=316;
wait for 380 ns; low1 <=97; high2 <=271; total3 <=271;
wait for 380 ns; low1 <=97; high2 <=272; total3 <=272;
wait for 380 ns; low1 <=97; high2 <=273; total3 <=273;
wait for 380 ns; low1 <=0; high2 <=97; total3 <=274;
wait for 380 ns; low1 <=0; high2 <=164; total3 <=317;
wait for 380 ns; low1 <=0; high2 <=165; total3 <=318;
wait for 380 ns; low1 <=166; high2 <=319; total3 <=319;
wait for 380 ns; low1 <=0; high2 <=98; total3 <=275;
wait for 380 ns; low1 <=0; high2 <=166; total3 <=320;
wait for 380 ns; low1 <=0; high2 <=167; total3 <=321;
wait for 380 ns; low1 <=0; high2 <=168; total3 <=322;
wait for 380 ns; low1 <=169; high2 <=323; total3 <=323;
wait for 380 ns; low1 <=99; high2 <=276; total3 <=276;
wait for 380 ns; low1 <=99; high2 <=277; total3 <=277;
wait for 380 ns; low1 <=99; high2 <=278; total3 <=278;
wait for 380 ns; low1 <=0; high2 <=99; total3 <=279;
wait for 380 ns; low1 <=0; high2 <=169; total3 <=324;
wait for 380 ns; low1 <=0; high2 <=170; total3 <=325;
wait for 380 ns; low1 <=171; high2 <=326; total3 <=326;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=280;
wait for 380 ns; low1 <=0; high2 <=171; total3 <=327;
wait for 380 ns; low1 <=0; high2 <=172; total3 <=328;
wait for 380 ns; low1 <=0; high2 <=173; total3 <=329;
wait for 380 ns; low1 <=174; high2 <=330; total3 <=330;
wait for 380 ns; low1 <=101; high2 <=281; total3 <=281;
wait for 380 ns; low1 <=101; high2 <=282; total3 <=282;
wait for 380 ns; low1 <=101; high2 <=283; total3 <=283;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=284;
wait for 380 ns; low1 <=0; high2 <=174; total3 <=331;
wait for 380 ns; low1 <=0; high2 <=175; total3 <=332;
wait for 380 ns; low1 <=176; high2 <=333; total3 <=333;
150
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
wait for 380 ns; low1 <=102; high2 <=285; total3 <=285;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=286;
wait for 380 ns; low1 <=0; high2 <=176; total3 <=334;
wait for 380 ns; low1 <=0; high2 <=177; total3 <=335;
wait for 380 ns; low1 <=178; high2 <=336; total3 <=336;
wait for 380 ns; low1 <=103; high2 <=287; total3 <=287;
wait for 380 ns; low1 <=103; high2 <=288; total3 <=288;
wait for 380 ns; low1 <=103; high2 <=289; total3 <=289;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=290;
wait for 380 ns; low1 <=0; high2 <=178; total3 <=337;
wait for 380 ns; low1 <=179; high2 <=338; total3 <=338;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=291;
wait for 380 ns; low1 <=179; high2 <=339; total3 <=339;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=292;
wait for 380 ns; low1 <=0; high2 <=179; total3 <=340;
wait for 380 ns; low1 <=0; high2 <=180; total3 <=341;
wait for 380 ns; low1 <=181; high2 <=342; total3 <=342;
wait for 380 ns; low1 <=106; high2 <=293; total3 <=293;
wait for 380 ns; low1 <=106; high2 <=294; total3 <=294;
wait for 380 ns; low1 <=106; high2 <=295; total3 <=295;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=296;
wait for 380 ns; low1 <=0; high2 <=181; total3 <=343;
wait for 380 ns; low1 <=182; high2 <=344; total3 <=344;
wait for 380 ns; low1 <=107; high2 <=297; total3 <=297;
wait for 380 ns; low1 <=107; high2 <=298; total3 <=298;
wait for 380 ns; low1 <=107; high2 <=299; total3 <=299;
wait for 380 ns; low1 <=107; high2 <=300; total3 <=300;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=301;
wait for 380 ns; low1 <=182; high2 <=345; total3 <=345;
wait for 380 ns; low1 <=108; high2 <=302; total3 <=302;
wait for 380 ns; low1 <=108; high2 <=303; total3 <=303;
wait for 380 ns; low1 <=108; high2 <=304; total3 <=304;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=305;
wait for 380 ns; low1 <=182; high2 <=346; total3 <=346;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=306;
wait for 380 ns; low1 <=0; high2 <=182; total3 <=347;
wait for 380 ns; low1 <=183; high2 <=348; total3 <=348;
wait for 380 ns; low1 <=110; high2 <=307; total3 <=307;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=308;
wait for 380 ns; low1 <=0; high2 <=183; total3 <=349;
wait for 380 ns; low1 <=184; high2 <=350; total3 <=350;
wait for 380 ns; low1 <=111; high2 <=309; total3 <=309;
wait for 380 ns; low1 <=111; high2 <=310; total3 <=310;
wait for 380 ns; low1 <=55; high2 <=155; total3 <=155;
wait for 380 ns; low1 <=0; high2 <=55; total3 <=156;
wait for 380 ns; low1 <=184; high2 <=351; total3 <=351;
151
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
wait for 380 ns; low1 <=0; high2 <=56; total3 <=157;
wait for 380 ns; low1 <=0; high2 <=184; total3 <=352;
wait for 380 ns; low1 <=0; high2 <=185; total3 <=353;
wait for 380 ns; low1 <=186; high2 <=354; total3 <=354;
wait for 380 ns; low1 <=0; high2 <=57; total3 <=158;
wait for 380 ns; low1 <=0; high2 <=186; total3 <=355;
wait for 380 ns; low1 <=187; high2 <=356; total3 <=356;
wait for 380 ns; low1 <=58; high2 <=159; total3 <=159;
wait for 380 ns; low1 <=58; high2 <=160; total3 <=160;
wait for 380 ns; low1 <=58; high2 <=161; total3 <=161;
wait for 380 ns; low1 <=0; high2 <=58; total3 <=162;
wait for 380 ns; low1 <=187; high2 <=357; total3 <=357;
wait for 380 ns; low1 <=0; high2 <=59; total3 <=163;
wait for 380 ns; low1 <=0; high2 <=187; total3 <=358;
wait for 380 ns; low1 <=0; high2 <=188; total3 <=359;
wait for 380 ns; low1 <=189; high2 <=360; total3 <=360;
wait for 380 ns; low1 <=0; high2 <=60; total3 <=164;
wait for 380 ns; low1 <=0; high2 <=189; total3 <=361;
wait for 380 ns; low1 <=190; high2 <=362; total3 <=362;
wait for 380 ns; low1 <=61; high2 <=165; total3 <=165;
wait for 380 ns; low1 <=61; high2 <=166; total3 <=166;
wait for 380 ns; low1 <=61; high2 <=167; total3 <=167;
wait for 380 ns; low1 <=0; high2 <=61; total3 <=168;
wait for 380 ns; low1 <=0; high2 <=190; total3 <=363;
wait for 380 ns; low1 <=191; high2 <=364; total3 <=364;
wait for 380 ns; low1 <=62; high2 <=169; total3 <=169;
wait for 380 ns; low1 <=0; high2 <=62; total3 <=170;
wait for 380 ns; low1 <=191; high2 <=365; total3 <=365;
wait for 380 ns; low1 <=63; high2 <=171; total3 <=171;
wait for 380 ns; low1 <=0; high2 <=63; total3 <=172;
wait for 380 ns; low1 <=191; high2 <=366; total3 <=366;
wait for 380 ns; low1 <=64; high2 <=173; total3 <=173;
wait for 380 ns; low1 <=64; high2 <=174; total3 <=174;
wait for 380 ns; low1 <=64; high2 <=175; total3 <=175;
wait for 380 ns; low1 <=0; high2 <=64; total3 <=176;
wait for 380 ns; low1 <=0; high2 <=191; total3 <=367;
wait for 380 ns; low1 <=192; high2 <=368; total3 <=368;
wait for 380 ns; low1 <=65; high2 <=177; total3 <=177;
wait for 380 ns; low1 <=0; high2 <=65; total3 <=178;
wait for 380 ns; low1 <=192; high2 <=369; total3 <=369;
wait for 380 ns; low1 <=66; high2 <=179; total3 <=179;
wait for 380 ns; low1 <=0; high2 <=66; total3 <=180;
wait for 380 ns; low1 <=192; high2 <=370; total3 <=370;
wait for 380 ns; low1 <=67; high2 <=181; total3 <=181;
wait for 380 ns; low1 <=67; high2 <=182; total3 <=182;
wait for 380 ns; low1 <=67; high2 <=183; total3 <=183;
152
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
wait for 380 ns; low1 <=0; high2 <=67; total3 <=184;
wait for 380 ns; low1 <=0; high2 <=192; total3 <=371;
wait for 380 ns; low1 <=193; high2 <=372; total3 <=372;
wait for 380 ns; low1 <=68; high2 <=185; total3 <=185;
wait for 380 ns; low1 <=0; high2 <=68; total3 <=186;
wait for 380 ns; low1 <=0; high2 <=193; total3 <=373;
wait for 380 ns; low1 <=0; high2 <=194; total3 <=374;
wait for 380 ns; low1 <=0; high2 <=195; total3 <=375;
wait for 380 ns; low1 <=196; high2 <=376; total3 <=376;
wait for 380 ns; low1 <=69; high2 <=187; total3 <=187;
wait for 380 ns; low1 <=69; high2 <=188; total3 <=188;
wait for 380 ns; low1 <=69; high2 <=189; total3 <=189;
wait for 380 ns; low1 <=0; high2 <=69; total3 <=190;
wait for 380 ns; low1 <=0; high2 <=196; total3 <=377;
wait for 380 ns; low1 <=197; high2 <=378; total3 <=378;
wait for 380 ns; low1 <=0; high2 <=70; total3 <=191;
wait for 380 ns; low1 <=0; high2 <=197; total3 <=379;
wait for 380 ns; low1 <=198; high2 <=380; total3 <=380;
wait for 380 ns; low1 <=71; high2 <=192; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=71; total3 <=193;
wait for 380 ns; low1 <=198; high2 <=381; total3 <=381;
wait for 380 ns; low1 <=72; high2 <=194; total3 <=194;
wait for 380 ns; low1 <=72; high2 <=195; total3 <=195;
wait for 380 ns; low1 <=72; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=0; high2 <=72; total3 <=197;
wait for 380 ns; low1 <=0; high2 <=198; total3 <=382;
wait for 380 ns; low1 <=199; high2 <=383; total3 <=383;
wait for 380 ns; low1 <=0; high2 <=73; total3 <=198;
wait for 380 ns; low1 <=0; high2 <=199; total3 <=384;
wait for 380 ns; low1 <=100; high2 <=192; total3 <=192;
wait for 380 ns; low1 <=0; high2 <=74; total3 <=199;
wait for 380 ns; low1 <=0; high2 <=100; total3 <=193;
wait for 380 ns; low1 <=101; high2 <=194; total3 <=194;
wait for 380 ns; low1 <=75; high2 <=200; total3 <=200;
wait for 380 ns; low1 <=75; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=75; high2 <=202; total3 <=202;
wait for 380 ns; low1 <=0; high2 <=75; total3 <=203;
wait for 380 ns; low1 <=0; high2 <=101; total3 <=195;
wait for 380 ns; low1 <=102; high2 <=196; total3 <=196;
wait for 380 ns; low1 <=0; high2 <=76; total3 <=204;
wait for 380 ns; low1 <=0; high2 <=102; total3 <=197;
wait for 380 ns; low1 <=103; high2 <=198; total3 <=198;
wait for 380 ns; low1 <=77; high2 <=205; total3 <=205;
wait for 380 ns; low1 <=0; high2 <=77; total3 <=206;
wait for 380 ns; low1 <=103; high2 <=199; total3 <=199;
wait for 380 ns; low1 <=78; high2 <=207; total3 <=207;
153
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
wait for 380 ns; low1 <=78; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=78; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=0; high2 <=78; total3 <=210;
wait for 380 ns; low1 <=0; high2 <=103; total3 <=200;
wait for 380 ns; low1 <=104; high2 <=201; total3 <=201;
wait for 380 ns; low1 <=79; high2 <=211; total3 <=211;
wait for 380 ns; low1 <=0; high2 <=79; total3 <=212;
wait for 380 ns; low1 <=104; high2 <=202; total3 <=202;
wait for 380 ns; low1 <=0; high2 <=80; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=104; total3 <=203;
wait for 380 ns; low1 <=105; high2 <=204; total3 <=204;
wait for 380 ns; low1 <=81; high2 <=214; total3 <=214;
wait for 380 ns; low1 <=81; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=81; high2 <=216; total3 <=216;
wait for 380 ns; low1 <=0; high2 <=81; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=105; total3 <=205;
wait for 380 ns; low1 <=106; high2 <=206; total3 <=206;
wait for 380 ns; low1 <=0; high2 <=82; total3 <=218;
wait for 380 ns; low1 <=0; high2 <=106; total3 <=207;
wait for 380 ns; low1 <=107; high2 <=208; total3 <=208;
wait for 380 ns; low1 <=83; high2 <=219; total3 <=219;
wait for 380 ns; low1 <=0; high2 <=83; total3 <=220;
wait for 380 ns; low1 <=107; high2 <=209; total3 <=209;
wait for 380 ns; low1 <=84; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=84; high2 <=222; total3 <=222;
wait for 380 ns; low1 <=84; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=84; total3 <=224;
wait for 380 ns; low1 <=0; high2 <=107; total3 <=210;
wait for 380 ns; low1 <=0; high2 <=108; total3 <=211;
wait for 380 ns; low1 <=109; high2 <=212; total3 <=212;
wait for 380 ns; low1 <=85; high2 <=225; total3 <=225;
wait for 380 ns; low1 <=0; high2 <=85; total3 <=226;
wait for 380 ns; low1 <=0; high2 <=109; total3 <=213;
wait for 380 ns; low1 <=0; high2 <=110; total3 <=214;
wait for 380 ns; low1 <=111; high2 <=215; total3 <=215;
wait for 380 ns; low1 <=86; high2 <=227; total3 <=227;
wait for 380 ns; low1 <=86; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=86; high2 <=229; total3 <=229;
wait for 380 ns; low1 <=0; high2 <=86; total3 <=230;
wait for 380 ns; low1 <=0; high2 <=111; total3 <=216;
wait for 380 ns; low1 <=112; high2 <=217; total3 <=217;
wait for 380 ns; low1 <=0; high2 <=87; total3 <=231;
wait for 380 ns; low1 <=0; high2 <=112; total3 <=218;
wait for 380 ns; low1 <=0; high2 <=113; total3 <=219;
wait for 380 ns; low1 <=114; high2 <=220; total3 <=220;
wait for 380 ns; low1 <=0; high2 <=88; total3 <=232;
154
Dissertação de Mestrado– LASID - PPGI/DI UFPB
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
wait for 380 ns; low1 <=114; high2 <=221; total3 <=221;
wait for 380 ns; low1 <=89; high2 <=233; total3 <=233;
wait for 380 ns; low1 <=89; high2 <=234; total3 <=234;
wait for 380 ns; low1 <=89; high2 <=235; total3 <=235;
wait for 380 ns; low1 <=0; high2 <=89; total3 <=236;
wait for 380 ns; low1 <=0; high2 <=114; total3 <=222;
wait for 380 ns; low1 <=115; high2 <=223; total3 <=223;
wait for 380 ns; low1 <=0; high2 <=90; total3 <=237;
wait for 380 ns; low1 <=115; high2 <=224; total3 <=224;
wait for 380 ns; low1 <=91; high2 <=238; total3 <=238;
wait for 380 ns; low1 <=0; high2 <=91; total3 <=239;
wait for 380 ns; low1 <=0; high2 <=115; total3 <=225;
wait for 380 ns; low1 <=116; high2 <=226; total3 <=226;
wait for 380 ns; low1 <=92; high2 <=240; total3 <=240;
wait for 380 ns; low1 <=92; high2 <=241; total3 <=241;
wait for 380 ns; low1 <=92; high2 <=242; total3 <=242;
wait for 380 ns; low1 <=0; high2 <=92; total3 <=243;
wait for 380 ns; low1 <=0; high2 <=116; total3 <=227;
wait for 380 ns; low1 <=117; high2 <=228; total3 <=228;
wait for 380 ns; low1 <=93; high2 <=244; total3 <=244;
wait for 380 ns; low1 <=0; high2 <=93; total3 <=245;
wait for 380 ns; arithClose <='1';
wait for 1390 ns; arithEnable <='0';
wait;
end PROCESS stimulus;
end only;
2018
155
Dissertação de Mestrado– LASID - PPGI/DI UFPB
Apêndice C - Testbench Compressor PPM Binário e Cód.Aritmético
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
library IEEE;
use ieee.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use ieee.std_logic_unsigned.all;
USE STD.TEXTIO.ALL;-- versao VHDL-1993
entity tBcompressor_ppm_arith_estrutural is
PORT (
saidaAtiva : buffer std_logic;
saida2Ativa : buffer std_logic;
saida3Ativa : buffer std_logic;
saida : buffer std_logic_vector(8 downto 1);
saida2 : buffer std_logic_vector(8 downto 1);
saida3 : buffer std_logic_vector(8 downto 1);
--dado2 : inout std_logic_vector(8 downto 1);
--dd : out character;
dado : OUT CHARACTER
);
end;
architecture only of tBcompressor_ppm_arith_estrutural is
COMPONENT compressor_ppm_arith_estrutural
PORT (
clk
: IN STD_LOGIC;
ppmEnable : IN STD_LOGIC;
encoderClose : IN STD_LOGIC;
bitin : IN STD_LOGIC;
saidaAtiva : buffer std_logic;
saida2Ativa : buffer std_logic;
saida3Ativa : buffer std_logic;
saida : buffer std_logic_vector( 8 downto 1);
saida2 : buffer std_logic_vector( 8 downto 1);
saida3 : buffer std_logic_vector( 8 downto 1)
);
END COMPONENT ;
FILE arq_wr_rd : TEXT;
FILE arq_wr_rd_s : TEXT;
SIGNAL clk : STD_LOGIC := '0';
SIGNAL ppmEnable : STD_LOGIC := '0';
SIGNAL encoderClose : STD_LOGIC := '0';
SIGNAL bitin : STD_LOGIC := '0';
--signal saida2_int : std_logic_vector(8 downto 1):="00000000";
156
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2063 begin
2064
2065 dut : compressor_ppm_arith_estrutural
2066
PORT MAP (
2067
2068
clk => clk,
2069
ppmEnable => ppmEnable,
2070
encoderClose => encoderClose,
2071
bitin => bitin,
2072
saidaAtiva => saidaAtiva,
2073
saida2Ativa => saida2Ativa,
2074
saida3Ativa => saida3Ativa,
2075
saida => saida,
2076
saida2 => saida2,
2077
saida3 => saida3
2078
);
2079
2080
2081 clock : PROCESS
2082
VARIABLE linhaWR
: LINE;
-- objeto tipo LINE para armazenar texto
2083
--VARIABLE leitura_okWR : BOOLEAN := TRUE; -- verificacao do procedimento
READ
2084
VARIABLE valorWR
: CHARACTER;
-- dado recuperado no arquivo
2085
VARIABLE TESTE : INTEGER;
2086
begin
2087
FILE_OPEN(arq_wr_rd_s, "dado_s1.txt",Append_Mode);
2088
2089
wait for 80 ns; clk <= not clk;
2090
if (saidaAtiva ='1') then
2091
2092
TESTE := conv_integer(saida);
2093
WRITE(linhaWR, TESTE );
2094
WRITELINE (arq_wr_rd_s, linhaWR);
2095
--se teve saida sencundaria do writebittrue or false no mesmo ciclo de clock
2096
if (saida2Ativa='1') then
2097
TESTE := conv_integer(saida2);
2098
WRITE(linhaWR, TESTE );
2099
WRITELINE (arq_wr_rd_s, linhaWR);
2100
end if; --saida2Ativa
2101
2102
if (saida3Ativa='1') then
2103
TESTE := conv_integer(saida3);
2104
WRITE(linhaWR, TESTE );
2105
WRITELINE (arq_wr_rd_s, linhaWR);
2106
end if; --saida2Ativa
2107
157
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
--FOR i IN 8 DOWNTO 1 LOOP
-- if (saida(i)='0') then
-- valorWR := '0';
-- WRITE(linhaWR, valorWR );
--elsif (saida(i)='1') then
-- valorWR := '1';
-- WRITE(linhaWR, valorWR );
--end if;
--END LOOP;
--WRITELINE (arq_wr_rd_s, linhaWR);
--dd <= 'X';--else dd <= 'y';
end if;
FILE_CLOSE(arq_wr_rd_s);
end PROCESS clock;
stimulus : PROCESS
VARIABLE linha : LINE;
-- objeto tipo LINE para armazenar texto
VARIABLE leitura_ok : BOOLEAN := TRUE; -- verificacao do procedimento READ
VARIABLE valor
: CHARACTER;
begin
ppmEnable <='1';
encoderClose <='0';
FILE_OPEN(arq_wr_rd, "dado_e1.txt",Read_Mode);
READLINE (arq_wr_rd, linha);
-- leitura de uma linha
WHILE leitura_ok LOOP
READ (linha, valor, leitura_ok); -- leitura dos dados de uma linha
dado <= valor;
--dado2 <= saida;
if (valor = '0') then
bitin <='0';
elsif (valor = '1') then
bitin <='1';
elsif (valor = 'f') then
--bitin <='1';
wait for 160 ns;encoderClose <='1';
exit;
end if;
WAIT FOR 160 ns;
158
Dissertação de Mestrado– LASID - PPGI/DI UFPB
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
-- dado2 <= saida;-- temporizacao para mostra "dado" no simulador
END LOOP;
wait for 260 ns; ppmEnable<='0'; --arithEnable<='0';
wait;
FILE_CLOSE(arq_wr_rd);
end PROCESS stimulus;
escreve:process
begin
wait;
END PROCESS escreve;
end only;
159
Dissertação de Mestrado– LASID - PPGI/DI UFPB
160