simulador interativo de eletrÔnica digital pedro...

SIMULADOR INTERATIVO DE ELETRÔNICA DIGITAL

Pedro Guimarães Del Rei

Projeto de Graduação apresentado ao Curso de

Engenharia Eletrônica e de Computação da Escola

Politécnica, Universidade Federal do Rio de

Janeiro, como parte dos requisitos necessários à

obtenção do título de Engenheiro.

Orientador: José Arthur da Rocha

Rio de Janeiro

Junho de 2018

iii

Del Rei, Pedro Guimarães

Simulador Interativo de Eletrônica Digital/ Pedro

Guimarães Del Rei. – Rio de Janeiro: UFRJ/ Escola

Politécnica, 2018.

X, 53: il.; 29,7 cm.


Projeto de Graduação - UFRJ/Escola Politécnica/

Curso de Engenharia Eletrônica e de Computação, 2018

Referências Bibliográficas: p. 59.

1. Eletrônica Digital 2. Simulador Educativo.

3. Orientação a Objeto. I. Arthur da Rocha, José. II.

Universidade Federal do Rio de Janeiro, Escola

Politécnica, Curso de Engenharia Eletrônica e de

Computação. III. Simulador Interativo de Eletrônica

Digital.

v

AGRADECIMENTO

Dedico este trabalho aos meus mestres pela paciência e aos meus pais por sempre

acreditarem em mim.

vi

Resumo do Projeto de Graduação apresentado à Escola Politécnica/UFRJ como parte

dos requisitos necessários para a obtenção do grau de Engenheiro Eletrônico e de

Computação.

Simulador Interativo de Eletrônica Digital


Junho/2018


Curso: Engenharia Eletrônica e de Computação

Este é o projeto de graduação da UFRJ consiste em um simulador de eletrônica digital,

onde o usuário pode montar circuitos em cima de uma protoboard e criar circuitos

adicionais, conforme desejar.

Focou-se em criar um sistema com uma curva de aprendizado simples, investindo em

uma interface simples e intuitiva, visualmente semelhante ao laboratório de eletrônica

digital.

O sistema simula qualquer circuito montado, desde que não haja realimentações,

portanto é possível criar qualquer circuito integrado combinacional que o usuário

desejar.

O simulador conseguiu calcular corretamente todos os circuitos montados, obteve

tempos de resposta satisfatórios e mostrou-se capaz de substituir simuladores utilizados

para fins acadêmicos.

Palavras-chave: eletrônica digital, circuito, simulador, software.

vii

Abstract of Undergraduate Project presented to POLI/UFRJ as a partial fulfillment of the

requirements for the degree of Engineer.

DIGITAL ELECTRONIC INTERACTIVE SIMULATOR


Junho/2018

Advisor: José Arthur da Rocha

Course: Electronic and Computer Engineering

This project consists in a digital electronics simulator, where the user can mount circuits

in one or more protoboards and create additional integrate circuits as he or she wishes.

The focus was in creating a system with a simple learning curve, making efforts on

creating a simple and intuitive interface, visually like the digital electronics lab.

The simulator was able to calculate correctly all the circuits tested, had a satisfactory

response time and was able to replace all the simulators used for academic purposes.

Key-words: digital electronics, circuit, simulator, software.

viii

Sumário

1 Introdução 1

1.1 – Tema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 - Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.3 - Desenvolvimento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.4 - Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 Os Componentes 3

2.1 - A Fonte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2 - A Protoboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.3 - O Fio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2.4 - Circuitos Integrados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.4.1 - Circuitos Combinacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.4.1.1 - AND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.4.1.2 - NAND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.4.1.3 - OR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.4.1.4 - NOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2.4.1.5 - NOT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4.1.6 - XOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.4.1.7 - Multiplexador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2.4.1.8 - Demultiplexador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

2.4.1.9 - Decodificador Binário - Decimal . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2.4.1.10 - Decodificador Hexa - Display 7 Segmentos . . . . . . . . . . . . . . . . 12

ix

2.4.1.11 - Componente Fictício - Decimal para BCD . . . . . . . . . . . . . . . . . 14

2.4.2 - Circuitos Sequenciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.4.2.1 - Flip-flop Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.4.2.2 - Flip-flop J-K . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.5 - LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

2.6 - Display de 7 Segmentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.7 - Componente Fictício - Display de 7 Segmentos com 4 Entradas . . . . . . . . . . . . . 18

2.8 - Resistor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.9 - Label . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

3 Ampliando a Lista de Componentes 20

3.1 – Nome do Arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

3.2 – O Conteúdo do Arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.2.1 – Atributos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.2.1.1 – Nome . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3.2.1.2 – ConnectorsName . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

3.2.1.3 – Tabela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

3.3 – Criando um Arquivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4 O Sistema 26

4.1 - A Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

x

4.1.1 - A Lista de Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

4.1.2 - O Console . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

4.1.3 - A Área de Trabalho . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.1.4 - A Ponta de Prova . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

4.1.5 - O Painel de Cores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.2 - A Montagem de Circuito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.3 - O Encapsulamento de Circuitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.3.1 - Primeira Etapa: Entradas e Saídas do Circuito . . . . . . . . . . . . . . . . . . . . . . 33

4.3.2 - Segunda Etapa: Pinagem do CI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.4 - Arquivos Salvos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5 Desenvolvimento 35

5.1 – Representação dos Componentes e Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.2 – Montagem de Circuitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5.2.1 – Seleção . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

5.2.2 – Posicionamento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

5.2.3 - Conexão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5.3 – Cálculo de Circuitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5.3.1 – Coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

5.3.2 – Cálculo de Estados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5.3.2.1 – Componentes Combinacionais . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

5.3.2.2 – Componentes Sequenciais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

xi

5.3.2.3 – Demais Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

5.3.2 – Estados Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

5.3.2 – Tabela Verdade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

5.4 – Utilizando a Unity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.4.1 – Orientação a Objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

5.4.2 – MonoBehaviour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.4.3 – BoxColliders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.4.4 – GameObjects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.5 – Classes e Heranças dos Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.6 – Composição dos Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5.6.1 – Protoboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5.6.2 – Demais Componentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

6 Testes Realizados 50

6.1 – Testes Implícitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

6.2 - Testes de Stress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

6.2.1 - Primeiro Teste de Stress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.2.2 - Segundo Teste de Stress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.2.3 - Terceiro Teste de Stress . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.3 - Testes Lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

6.3.1 - Teste da Década . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

6.3.2 - Teste do Mux 2:1 Encapsulado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

xii

7 Conclusões 56

7.1 - Aprendizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

7.2 - Trabalhos Futuros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

Bibliografia 57

A Manual do Usuário 58

xiii

SIGLAS

BCF - Binary-coded decimal

CI - Circuito Integrado

FFP - Flip-flop

JSON - JavaScript Object Notation

LED - Light Emitting Diode

LSB – Least Significant Bit (Bit menos significativo)

MSB – Most Significant Bit (Bit mais significativo)

TTL - Transistor-Transistor Logic

UFRJ - Universidade Federal do Rio de Janeiro

V – Volts

1

Capítulo 1

Introdução

1.1 – Tema

O projeto consiste em um sistema que simula um laboratório de eletrônica

digital, onde o usuário pode montar circuitos projetados em tempo real para condições

ideais.

1.2 – Objetivo

O objetivo do projeto é construir um sistema simples, intuitivo e de rápido

aprendizado, que auxilie o aluno durante o aprendizado de eletrônica digital.

1.3 – Desenvolvimento

A primeira etapa do projeto foi a definição do seu escopo.

A etapa seguinte foi a definição dos componentes que seriam implementados no

sistema, da interface e usabilidade do sistema.

Entende-se por componente tudo aquilo que participa da montagem de um

circuito, seja a placa onde os chips serão interconectados, os fios, que interligam pontos

distintos da placa, os circuitos integrados ou os LEDs, utilizados para identificar

rapidamente o estado de um ponto da placa.

Já a interface e usabilidade do sistema, definem as informações exibidas para o

usuário e sua simplicidade e facilidade de uso.

Definidos os componentes, foram feitos os seus desenhos e iniciou-se a fase de

implementação. Foram implementados componentes e a comunicação entre eles, e

depois a interface do usuário.

2

Após a implementação veio a fase de testes e ajuste fino, onde foram feitas

melhoras de desempenho do sistema e, como consequência a revisão do escopo inicial.

1.4 – Descrição

No capítulo 2 serão listados e descritos todos os componentes implementados no

sistema;

O capítulo 3 mostra como é possível expandir a lista de componentes

apresentados no capítulo anterior;

O capítulo 4 apresenta a interface de usuário e introduz as funcionalidades e

possibilidades do software;

O capítulo 5 explica, de maneira um pouco mais detalhada, o desenvolvimento

do sistema e as ferramentas usadas para o mesmo;

O capítulo 6 mostra testes realizados para avaliar o desempenho do sistema;

O capítulo 7 conclui o trabalho, apresentando aprendizados e trabalhos futuros.

3

Capítulo 2

Os Componentes

É definido como componente tudo aquilo que pode ser utilizado na montagem

de um circuito. Neste capítulo será feita uma apresentação de cada um dos componentes

inicialmente implementados no sistema, que podem ser encontrados e selecionados

utilizando a lista de componentes ou o console, ambos apresentados no terceiro

capítulo.

2.1 – A Fonte

A fonte é responsável por fornecer energia ao circuito. Pode ser ligada/desligada

utilizando o seu botão vermelho. Ela possui 2 saídas (terra, ou GND, e +VCC) e sua

tensão está fixa em 5v, uma vez que esta é a tensão utilizada em circuitos digitais em

geral e em todos os componentes do sistema. Os botões de regulagem e sua saída

esquerda (-VCC) isentam-se de funcionalidade, existindo apenas para trazer fidelidade à

imagem da fonte, uma vez que suas funções não se fazem necessárias neste projeto.

Figura 2.1 – A fonte.

4

2.2 – A Protoboard

A protoboard ou matriz de conexões é uma placa contendo furos interligados por

material condutor conforme mostrado em amarelo na Figura 2.2.

Suas entradas superiores (amarela, vermelha e verde) são chamadas de Bornes e

servem tanto para fios com terminação do tipo banana ou fios comuns. São nessas

entradas que são conectados os fios que saem da fonte de alimentação.

Figura 2.2 – Conexão dos furos da protoboard.

2.3 – O Fio

O fio conecta duas entradas da protoboard e/ou da fonte, fazendo com que os

dois pontos tenham a mesma tensão. No projeto foram implementados dois tipos de fios

diferentes: os fios chamados de banana - que são cabos mais grossos utilizados para

conectar nas entradas da fonte e nos bornes da protoboard - e os fios comuns, utilizados

para conectar as demais entradas da protoboard. A cor do fio pode ser alterada pelo

usuário.

5

2.4 – Circuitos Integrados

Circuitos Integrados se dividem em 2 categorias: circuitos combinacionais e

circuitos sequenciais. Para ambos os casos foram escolhidos CIs da família TTL -

devido à sua ainda grande utilização nos laboratórios educacionais e no mercado – de

maneira aleatória (não há nenhuma razão especial pelo qual os CIs foram selecionados

além do fato de serem da família TTL), focando em suas características lógicas

(pinagem), e não em suas características eletrônicas (como o tempo de resposta, tensões

e correntes).

A seleção dos componentes inicialmente presentes neste trabalho tenta

contemplar todos os circuitos essenciais para uma montagem.

2.4.1 – Circuitos Combinacionais

Circuitos combinacionais são aqueles que em qualquer instante de tempo, o

nível lógico da saída do circuito depende apenas da combinação dos níveis lógicos

presentes nas entradas, não possuindo memória.

2.4.1.1 – AND

A função lógica AND (ou E em português) é uma operação lógica que gera nível

lógico 1 em sua saída quando todas as entradas estão também em nível lógico 1. Sua

tabela verdade para duas entradas é indicada na Tabela 2.1.

Tabela 2.1 – Tabela verdade da operação lógica AND para duas entradas

Entrada 0 Entrada 1 Saída

0 0 0

0 1 0

1 0 0

1 1 1

6

Foi escolhido o CI DM7408 Quad 2-Input AND Gates, que possui 4 portas

lógicas AND de duas entradas e 14 pinos com a pinagem conforme indicada na Figura

2.3.

Figura 2.3 – Pinagem do AND 7408.

Fonte: Manual TTL [4].

2.4.1.2 – NAND

NAND (ou Não-E) pode ser obtido colocando uma porta AND e uma porta NOT

em cascata. Ela tem o nível lógico 1 na saída se tiver nível lógico 0 em pelo menos uma

das entradas. Sua tabela verdade é exatamente a oposta da tabela verdade do AND.

Tabela 2.2 – Tabela verdade da operação lógica NAND para duas entradas


0 0 1

0 1 1

1 0 1

1 1 0

Para este CI foi escolhido o DM7400 Quad 2-Input NAND Gates que possui 4

portas lógicas NAND e com a pinagem conforme indicada na Figura 2.4.

Figura 2.4 – Pinagem do NAND 7400.


7

2.4.1.3 – OR

OR (ou OU) é uma função lógica básica que tem nível lógico 1 em sua saída se

pelo menos uma das entradas estiver com nível lógico 1. Para duas entradas, sua tabela

verdade é conforme a Tabela 2.3.

Tabela 2.3 – Tabela verdade da operação lógica OR para duas entradas


0 0 0

0 1 1

1 0 1

1 1 1

Para este CI foi escolhido o DM74LS32 Quad 2-Input OR Gate, que possui 4

portas lógicas OR e com a pinagem conforme indicada na Figura 2.5.

Figura 2.5 – Pinagem do OR 7432.


2.4.1.4 – NOR

NOR (ou Não-OU) pode ser obtido ao conectar um OR e um NOT em cascata.

Sua tabela verdade a complementar à do OU.

Tabela 2.4 – Tabela verdade da operação lógica NOR para duas entradas


0 0 1

0 1 0

1 0 0

1 1 0

8

Foi escolhido o 74HC02 Quad 2 Input NOR Gate, que possui 4 portas lógicas

NOR com a pinagem indicada pela Figura 2.6.

Figura 2.6 – Pinagem do NOR 7402.


2.4.1.5 – NOT

NOT (ou Não ou Inversor) é uma operação de uma entrada e uma saída que tem

em sua saída sempre em nível lógico oposto do nível lógico da entrada.

Tabela 2.5 – Tabela verdade da operação lógica NOT

Entrada Saída

0 1

0 0

Foi escolhido o DM7404 Hex Inverting Gates, que possui 6 portas lógicas NOT

ligadas conforme indicado na Figura 2.7.

Figura 2.7 – Pinagem do NOT 7404.


2.4.1.6 – XOR

XOR (ou OU exclusivo) é a operação cuja saída tem nível lógico 1 (H – HIGH)

quando o nível lógico de suas entradas é diferente. A tabela verdade de um XOR com

duas entradas é conforme a Tabela 2.6.

9

Tabela 2.6 – Tabela verdade de um XOR com duas entradas


0 0 0

0 1 1

1 0 1

1 1 0

Foi escolhido o DM7486 Quad 2-Input Exclusive-OR Gate, que possui 4 portas

lógicas XOR ligadas conforme indicado na Figura 2.8.

Figura 2.8 – Pinagem do XOR 7486.


2.4.1.7 – Multiplexador

O multiplexador ou MUX pode ser chamado também de seletor de dados. Ele

possui diversas entradas codificadas, uma saída e um seletor (composto por um ou mais

pinos do CI). O valor do código binário presente no seletor indica qual a entrada que

terá seu valor replicado na saída. Por exemplo, no caso de um MUX 4 para 1 (4

entradas, 2 linhas seletoras e 1 saída), a tabela verdade segue de maneira indicada na

Tabela 2.7a.

Tabela 2.7a – Tabela verdade do MUX 4:1

Seletor0 Seletor1 Saída

0 0 Entrada 0

0 1 Entrada 1

1 0 Entrada 2

1 1 Entrada 3

10

Foi implementado o CI DM74150 com 16 entradas, 4 linhas seletoras e 1 saída

com sua pinagem indicada na Figura 2.9. Note que o pino denominado de Strobe nada

mais é do que o Enable, ou seja, o pino que habilita o CI (em nível lógico 0).

Figura 2.9 – Pinagem do CI DM74150.

Fonte: Farchild [5].

É importante observar que sua saída tem o nível lógico ativo baixo (L – low

level). Para melhor entendimento do funcionamento dos componentes, é possível

consultar a Tabela 2.7b

Tabela 2.7b – Tabela verdade do CI DM74150.


11

2.4.1.8 – Demultiplexador

O demultiplexador ou DEMUX possui diversas saídas e um seletor (composto

por um ou mais pinos do CI). Ele funciona de forma complementar ao multiplexador,

ou seja: o seletor define em qual saída terá nível lógico 0 enquanto todas as demais terão

nível lógico 1.

Foi implementado o DM74154 4-Line to 16-Line que possui 16 saídas e 4

entradas seletoras. Para seu funcionamento, ambas as entradas G1 e G2 deverão estar

em nível lógico 0, conforme mostrado na Tabela 2.8.

Figura 2.10 – Pinagem do DM74154.


Tabela 2.8 – Tabela verdade do DM74154.


12

2.4.1.9 – Decodificador Binário - Decimal

Os decodificadores são responsáveis por converter um sinal codificado em um

sinal com formato “legível” - como o decimal, por exemplo. O decodificador

implementado foi o DM7442A BCD to Decimal Decoder que transforma o sinal no

formato binário em um sinal decimal. Sua tabela verdade e pinagem estão presentes na

Figura 2.11 e na Tabela 2.9 respectivamente.

Figura 2.11 – Pinagem do DM7442A.


Tabela 2.9 – Tabela verdade do DM7442A.


2.4.1.10 – Decodificador BCD - Display 7 Segmentos

Esse componente converte um sinal binário para um sinal próprio para ser

utilizado em um display de 7 segmentos (descrito em 2.6).

13

Foi escolhido o CI DM9368 7-Segment Decoder, com 4 entradas, um Latch

Enable, uma entrada RBI (Ripple Blanking Input) e uma entrada RBO (Ripple Blanking

Output). Sua pinagem é conforme a Figura 2.12.

Figura 2.12 – Pinagem do TTL9368.


O pino Latch Enable, quando ativo (nível lógico 0), faz com que o decodificador

funcione normalmente, com o valor das saídas definido pelo valor das entradas. Caso

ele esteja inativo (nível lógico 1), as saídas do CI serão correspondentes ao último valor

aplicado nas entradas com a entrada Latch Enable ativa.

A entrada RBI zera as saídas (estado lógico indefinido) caso esteja ativa

enquanto as demais entradas estiverem em estado lógico 0. Neste caso, a saída RBO

estará em nível lógico 0 (para todas as outras possibilidades, a saída RBO estará em

estado lógico 1).

Essa entrada pode ser utilizada para ocultar zeros à esquerda. Para isso, deve-se

conectar a saída RBO do dígito à esquerda na entrada RBI do dígito anterior (menos

significativo) e assim sucessivamente, com a exceção do LSB, que mantém o RBI em

estado lógico 1, e do MSB, que deve ficar com o RBI aterrado.

A tabela verdade do DM9368 está indicada na Tabela 2.10.

14



2.4.1.11 – Componente Fictício – Decimal para BCD

Foi criado ainda um Codificador de Decimal para BCD fictício, definindo-se sua

pinagem e tabela verdade.

O codificador de decimal para BCD criado, tem a tabela verdade contraposta em

relação ao decodificador BCD para decimal DM7442A, conforme informado na Tabela

2.11 enquanto a pinagem permanece idêntica à do decodificador, presente na Figura

2.12.

15

Tabela 2.11 – Tabela verdade do Codificador Decimal - BCD.

2.4.2 – Circuitos Sequenciais

Um circuito sequencial é composto por um circuito combinacional e elementos

de memória. Os elementos de memória são circuitos capazes de armazenar informação

codificada em binário. Desta forma, fica evidente que as saídas de um circuito

sequencial dependem não apenas das entradas, mas também do estado atual,

armazenado nos elementos de memória. [1]

2.4.2.1 – Flip-flop Data

O flip-flop Data ou flip-flop D tem uma entrada de clock, uma entrada D - ou

data - e uma saída Q. O valor lógico da saída será igual ao valor da entrada D quando

houver uma ativação (positiva ou negativa, variando de componente para componente)

do clock.

O componente implementado foi o DM7474 Dual Positive-Edge-Triggered D-

Type Flip-Flops with Preset, Clear and Complementary Outputs que possui 2 flip-flops

16

tipo D, cada um com uma entrada preset, uma entrada clear e uma saída complementar,

ou seja, uma saída com o valor invertido em relação à saída comum.

Este CI é “Positive-Edge-Triggered” ou seja, é ativado com transições positivas

do clock.

Conforme indicado na Tabela 2.12, o estado onde o preset (PR) e clear (CLR)

estão no nível lógico 0 (L - low) é instável e não deve ser utilizado.

Figura 2.13 – Pinagem do DM7474.




2.4.2.2 – Flip-flop J-K

O flip-flop J-K possui as entradas J e K que controlam o valor da saída conforme

a Tabela 2.13, onde Q0 indica que o estado da saída permanece o mesmo e Q0’ indica

que o estado comuta, ou seja: inverte.

17

Tabela 2.13 – Tabela verdade do FFP J-K

J K Saída

0 0 Q0

0 1 0

1 0 1

1 1 Q0’

O FFP implementado foi o DM74LS73A Dual Negative-Edge-Triggered Master Slave

J-K Flip-Flops with Clear and Complementary Outputs, que possui 2 flip-flops J-K com

entrada clear e saída complementar. Este flip-flop é “Negative-EdgeTriggered”, ou seja:

é ativado com transições negativas do clock. Sua pinagem e tabela verdade são

conforme a Figura 2.14.

Figura 2.14 – Pinagem (à esquerda) e tabela verdade (à direita) do DM74LS73.


2.5 – LED

LED é um dispositivo semicondutor que emite luz quando polarizado

corretamente. Em um laboratório, ele serve para indicar rapidamente nível lógico de um

ponto de interesse da protoboard. Sua cor pode ser alterada pelo usuário.

Foram implementados dois tipos diferentes de LED: o real e o ideal. O LED

ideal acenderá sempre que houver uma diferença de 5v entre seus terminais,

independente do seu posicionamento, enquanto o LED real deve ser polarizado

diretamente e ter uma diferença de potencial entre o anodo e o catodo positiva, abaixo

de 5 volts para poder funcionar corretamente, caso contrário ele queimará.

18

2.6 – Display de 7 Segmentos

Os Displays de 7 segmentos são utilizados para comunicação em painéis. Ele

possui 7 pinos para os segmentos e mais um para o ponto decimal, totalizando 8 pinos

(Seu nome ainda é display de 7 segmentos apesar do ponto decimal).

Foram implementados os displays com catodo e com anodo comum, sendo os

segmentos do primeiro ativados em estado lógico 1 e os do segundo em estado lógico 0.

Figura 2.15 – Pinagem dos displays com anodo comum (à esquerda) e catodo comum (à direita)

O decodificador hexadecimal para display de 7 segmentos pode ser utilizado em

série com um Display de 7 Segmentos com catodo comum de maneira a facilitar a sua

implementação. Para tal, basta ligar as saídas do decodificador às respectivas entradas

do display.

2.7 – Componente Fictício – Display de 7 Segmentos com 4 Entradas

O display de 7 segmentos com 4 entradas funciona como um display de 7

segmentos onde, ao invés de haver 1 entrada para cada segmento, há 4 entradas que

representam o valor binário que será exibido (em hexadecimal) no display. Sua saída é

indicada no display e vai de 0 (0, em decimal) a F (15, em decimal).

Sua pinagem está indicada na Figura 2.16.

19

Figura 2.16 – Pinagem do Display de 7 segmentos com 4 entradas.

2.8 – Resistor

O resistor é um componente que converte energia elétrica em energia térmica e

oferecem uma resistência à passagem de corrente elétrica, causando uma queda de

tensão entre seus dois terminais. Em eletrônica digital, sua função é de condicionar o

sinal para o correto funcionamento de alguns componentes – no caso desse sistema, o

LED real. Sua função no sistema é puramente educacional, portanto foi implementado

somente o resistor de 1kΩ.

Figura 2.17 – O resistor

2.9 – Label

O label é um componente criado para facilitar a identificação de pontos de

interesse no circuito. Com ele é possível nomear linhas e identificar entradas específicas

da protoboard.

Figura 2.18 – O Label

20

Capítulo 3

Ampliando a Lista de Componentes

O usuário pode, ainda, expandir a lista apresentada no capítulo anterior,

adicionando componentes de criação própria ou de terceiros. Os componentes

adicionais devem ficar na pasta “CustomCI”, separados em arquivos de texto com a

extensão json.

Para criar um componente novo, o conteúdo do seu arquivo deve seguir um modelo

predefinido, explicado neste capítulo.

3.1 – Nome do Arquivo

O nome do arquivo será o nome que aparecerá na listagem de componentes.

Portanto, um arquivo como o da Figura 3.1 aparecerá na listagem conforme a Figura

3.2.

Figura 3.1 – Arquivo contendo um componente adicional.

Figura 3.2 – CI adicional na listagem de componentes.

21

3.2 – O Conteúdo do Arquivo

O conteúdo do arquivo deverá ser iniciado pelo caractere ““ e terminar com

“”. Entre esses caracteres, ele deve conter 3 atributos específicos.

3.2.1 – Atributos

De maneira sucinta, os atributos são campos com nome e valor que, no software,

serão convertidos em atributos de uma classe. Eles não precisam estar ordenados, mas o

formato de cada um deve ser seguido de maneira estrita.

O nome do atributo sempre vem primeiro e entre aspas, seguido de dois pontos

(“:”) e o seu valor. Os atributos são separados por vírgula e o usuário pode também

separá-los por quebra de linha (ou “enter”), para facilitar a visualização de seu

conteúdo.

3.2.1.1 – Nome

O primeiro atributo é o “nome”. Ele indica qual o nome que será exibido

quando a ponta de prova apontar para este componente. O usuário pode colocar um

nome diferente do nome do arquivo, caso desejar. Seu valor deve estar entre aspas,

conforme o exemplo mostrado na Figura 3.3a.

Figura 3.3a – Atributo nome e seu valor.

Figura 3.3b – Conteúdo exibido pela ponta de prova.

22

3.2.1.2 – ConnectorsName

O segundo atributo chama-se “connectorsName”. É importante ressaltar que o

nome dos atributos deve ser escrito exatamente conforme mostrado, sem espaços ou

caixa alta diferente, ou o sistema não o reconhecerá e, portanto, não será capaz de

importar o componente para o sistema.

O valor desse atributo é um vetor, iniciado por “[“ e terminado com “]”, onde

cada índice é separado por vírgula e escrito entre aspas. Cada componente desse vetor

possui um conector do CI importado, ordenado conforme sua pinagem.

A contagem da pinagem nesse caso não segue a contagem tradicional

(começando no pino superior esquerdo e terminando no pino superior direito), mas é

conforme indicada na Figura 3.4.

Figura 3.4 – Contagem da pinagem dos CIs pelo sistema.

Antes do nome de cada pino, deve-se adicionar também um texto indicativo,

composto pela letra “X” ou a letra “Y” - indicando que esse pino é uma entrada ou uma

saída respectivamente - e seu índice. O índice indicará a posição desse pino na tabela

verdade, conforme indicado na Tabela 3.1.

23

Tabela 3.1 – Relação entre índices das entradas e saídas e os seus posicionamentos na tabela verdade.

Tabela Verdade

Índice das Entradas Índice Índice das Saídas

. . . 3 2 1 0 0 1 2 3 . . .

Valor das Entradas Valor das Saídas

. . . 0 0 0 0 0 Y0 Y16 Y32 Y47 . . .

. . . 0 0 0 1 1 Y1 Y17 Y33 Y48 . . .

. . . 0 0 1 0 2 Y2 Y18 Y34 Y49 . . .

. . . 0 0 1 1 3 Y3 Y19 Y35 Y50 . . .

. . . 0 1 0 0 4 Y4 Y20 Y36 Y51 . . .

. . . 0 1 0 1 5 Y5 Y21 Y37 Y52 . . .

. . . 0 1 1 0 6 Y6 Y22 Y38 Y53 . . .

. . . 0 1 1 1 7 Y7 Y23 Y39 Y54 . . .

. . . 1 0 0 0 8 Y8 Y24 Y40 Y55 . . .

. . . 1 0 0 1 9 Y9 Y25 Y41 Y56 . . .

. . . 1 0 1 0 10 Y10 Y26 Y42 Y57 . . .

. . . 1 0 1 1 11 Y11 Y27 Y43 Y58 . . .

. . . 1 1 0 0 12 Y12 Y28 Y44 Y59 . . .

. . . 1 1 0 1 13 Y13 Y29 Y45 Y60 . . .

. . . 1 1 1 0 14 Y14 Y30 Y46 Y61 . . .

. . . 1 1 1 1 15 Y15 Y31 Y47 Y62 . . .

Caso o pino seja uma entrada, seu índice indicará sua posição (0 sendo o LSB e

N sendo o MSB) no valor binário do índice (linha) da tabela verdade, enquanto para

uma saída, o índice indicará sua posição (coluna) da tabela verdade. O índice, neste

último caso, é contado da esquerda para a direita, enquanto que, para as entradas, a

contagem é feita da esquerda para a direita, conforme mostra a tabela.

O texto indicativo não é aplicado para os pinos VCC e GND. Estes pinos são

obrigatórios para todos os CIs. Caso contrário, o componente não poderá ser ativado.

Segue, na Figura 3.5, um exemplo do atributo “connectorsName” para um CI

com duas entradas e uma saída.

Figura 3.5 – Vetor com o valor do atributo “connectorsName”.

24

3.2.1.3 – Tabela

O último atributo é chamado de “tabela” e também é um vetor, portanto deve ser

iniciado com “[“ e finalizado com “]”. Nele está presente a tabela verdade do

componente, sendo cada índice (separado por vírgula e entre aspas) contendo uma

coluna da tabela verdade, com nível lógico alto (H) representado pelo número um (1),

nível lógico baixo (L) representado pelo número um negativo (-1) e o nível lógico

indefinido representado pelo número zero (0).

O ponto final (“.”) contido em cada índice separa cada coluna da tabela verdade

e acontece nos casos em que há mais de uma saída. O índice da coluna, portanto, se

refere ao índice da saída (a primeira coluna, ou coluna 0 se refere aos valores da

primeira saída, ou a saída Y0).

Portanto, para uma tabela verdade como a da Tabela 3.2, esse atributo deve ser

preenchido conforme a Figura 3.6.

Tabela 3.2 – Tabela verdade de um componente adicional.

Y0 Y1 Y2

H L L

H H H

L H H

Figura 3.6 – O atributo “tabela” para um componente com a tabela verdade da Tabela 2.15.

3.3 – Criando um Arquivo

Para esclarecer o processo de criação de um componente, como exemplo criou-

se um AND com duas entradas e duas saídas complementares, com a pinagem conforme

a Figura 3.7 e a Tabela verdade conforme a Tabela 3.3.

25

Figura 3.7 – Pinagem de um AND de duas entradas e saídas complementares.

Tabela 3.3 – Tabela verdade de um AND de duas entradas e duas saídas complementares.

Y0 !Y0

L H

L H

L H

H L

O conteúdo de seu arquivo deverá ser, portanto, conforme a Figura 3.8.

Figura 3.8 – Conteúdo do arquivo de um AND de saídas complementares.

Analisando cada atributo do arquivo, temos:

Nome: Independente do nome do CI na listagem, este atributo auxilia na

identificação do componente ao utilizar a ponta de prova neste.

ConnetorsName: A e B são entradas, uma vez que tem “X0” e “X1”

escritos antes de seus nomes, enquanto Y0 e !Y0 são as saídas.

Tabela: Em todos os índices, o primeiro valor (anterior ao ponto) é

referente à saída Y0 e o segundo à saída !Y0, uma vez que a primeira

possui o índice 0 e a segunda, o índice 1 (Y0Y0 e Y1!Y0).

Ao finalizar a criação do arquivo, este deve ser colocado na pasta “CustomCI” e

o sistema reconhecerá o componente na próxima vez que for inicializado.

26

Capítulo 4

O Sistema

4.1 – A Interface

A interface do sistema com o usuário é composta pela área de trabalho, lista de

componentes e console.

Figura 4.1 – A listagem de componentes (à direita) e o console (na parte inferior).

4.1.1 – A Lista de Componentes

A lista de componentes se encontra ao lado esquerdo da tela e é nela que o

usuário encontra todos os componentes implementados no sistema (com exceção do fio,

da label e da fonte).

O usuário pode selecionar o componente desejado clicando em seu nome na

listagem ou pode ainda buscar por um componente digitando seu nome na parte superior

da listagem.

27

Figura 4.2 – A lista de componentes.

4.1.2 – O Console

O console permite que o usuário execute alguns comandos específicos. Nele, é

possível:

Selecionar componente;

Salvar/Carregar arquivo;

Encapsular circuito;

Reiniciar;

Alterar cor;

Listar cores/componentes disponíveis;

Alterar a cor da área de trabalho.

O console pode ser ocultado a qualquer momento pelo usuário para ter uma

visão mais limpa da área de trabalho (ao iniciar o sistema, o console estará

inativo).

Figura 4.3 – O console.

28

4.1.3 – A Área de Trabalho

A área de trabalho é o espaço onde o usuário pode realizar a montagem de

circuitos. Ao selecionar uma protoboard, ele pode posiciona-la em qualquer lugar livre

da área de trabalho (a fonte está presente na área de trabalho).

4.1.4 – A Ponta de Prova

A ponta de prova pode ser utilizada durante a montagem de circuitos para

informar o estado lógico de uma entrada específica da protoboard, conforme indicado

na Figura 4.4.

Figura 4.4 – A ponta de prova.

Ao apontar para um chip, a ponta de prova traz também informações adicionais

a seu respeito, como o seu nome, Datasheet e o estado de cada uma de suas entradas

(Figura 4.5).

Figura 4.5 – A ponta de prova ao apontar para um chip.

29

4.1.5 – O Painel de Cores

LEDs, fios e labels podem ter suas cores alteradas utilizando o console ou então

o painel de cores.

Para utilizar o painel de cores, basta selecionar um componente e selecionar a

cor desejada.

Figura 4.6 – O painel de cores.

4.2 – A Montagem de Circuito

Para montar um circuito o usuário deve inicialmente selecionar pelo menos uma

protoboard (pela lista ou console) e posiciona-la(s) na área de trabalho. É importante

ressaltar que o número de protoboards utilizáveis é ilimitado.

Figura 4.7 – Tela com a protoboard posicionada na área de trabalho.

30

Após posicionar a protoboard, o usuário pode selecionar qualquer componente

na listagem e conectá-lo a ela, desde que os furos selecionados estejam livres. O

contorno branco em volta do furo indica que a entrada selecionada da protoboard está

livre para ser conectada.

Figura 4.8 – O contorno branco indicando os furos disponíveis.

Figura 4.9 – Componente conectado à protoboard

É possível, ainda, conectar linhas distintas de uma ou mais protoboards

utilizando os fios. Eles não estão presentes na listagem de componentes. Ao invés disso,

é possível ligá-los à protoboard simplesmente selecionando 2 entradas diferentes.

A conexão pode ser feita de maneira livre desde que não haja realimentações,

uma vez que estes casos estão fora do escopo do projeto, e não serão calculados

corretamente.

31

Figura 4.10 – Um fio ligando os dois pinos do CI conectado.

Caso os dois pontos conectados pelo fio tenham suas tensões definidas, e

diferentes, ocorrerá a queima deste fio, conforme mostrado na Figura 4.11. O fio

queimado não funcionará mais, ou seja, não conectará mais dois pontos da protoboard, e

deverá ser removido do circuito.

Figura 4.11 – Fio queimado.

Caso o fio conecte duas saídas de CIs diferentes, o usuário será informado pelo

console que fez uma conexão incorreta e que deve refazer a conexão corretamente

(Figura 4.12).

Figura 4.12 – Aviso indicando conexão incorreta.

É possível obter informações adicionais a respeito do circuito montado,

utilizando-se a ponta de prova. Esta, mostra o estado de qualquer entrada da protoboard

e informações adicionais dos componentes conectados na protoboard.

32

Caso desejado, a visualização do circuito ainda pode ser melhorada nomeando

linhas da protoboard, por meio das labels.

Figura 4.13 – Labels (roxa e verde) auxiliando na visualização do circuito.

Para que o circuito funcione, é necessário ligar a fonte e conecta-la à protoboard,

para que esta seja energizada.

Figura 4.14 – A fonte ligada (indicada pelo display aceso) e conectada à protoboard.

4.3 – O Encapsulamento de Circuitos

É possível, ainda, encapsular um circuito combinacional em um novo CI,

aumentando o número de componentes disponíveis para a montagem de circuitos.

33

Antes de realizar o encapsulamento o usuário deve ter um circuito montado,

desligar a fonte e quaisquer fios conectados a ela.

4.3.1 – Primeira Etapa: Entradas e Saídas do Circuito

Com o circuito montado, a fonte desligada e desconectada da protoboard, o

usuário pode dar início ao encapsulamento utilizando o comando “gerar” no console (O

comando é explicado no manual do usuário, presente no apêndice.

A primeira etapa do encapsulamento consiste na identificação das entradas e

saídas. O usuário deve seguir as orientações fornecidas na interface e selecionar em

quais furos da protoboard se encontram as entradas e saídas. Elas são identificadas por

labels vermelhas (no caso das entradas) ou azuis (no caso das saídas).

Figura 4.15 – As entradas (labels vermelhas) e saídas (labels azuis) identificadas no circuito

montado.

As entradas e saídas podem ter seus nomes redefinidos pelo usuário para auxiliar

na visualização de seu Datasheet (Figura 4.16).

34

Figura 4.16 – As entradas e saídas do circuito podem ser renomeadas.

4.3.2 – Segunda Etapa: Pinagem do CI

Com as entradas e saídas identificadas, o usuário pode avançar para a segunda e

última etapa do encapsulamento.

Nesta etapa, o usuário informa a pinagem desejada para o novo CI arrastando as

entradas (X0, X1, ...), as saídas (Y0, Y1, ...) e as entradas de ativação do CI (VCC e GND)

até os pinos desejados.

Figura 4.17 – Tela de pinagem do CI novo.

O usuário também pode visualizar os mintermos do circuito montado em sua

forma canônica (completa) durante esta etapa, para auxiliá-lo.

Figura 4.18 – Mintermos do circuito montado.

35

Ao finalizar esta etapa e consequentemente o encapsulamento, o circuito

montado será salvo e o usuário retornará para a tela inicial, onde poderá encontrar o

novo CI na lista de componentes.

4.4 – Arquivos Salvos

As informações a respeito dos CIs encapsulados, assim como os arquivos

incluídos pelo usuário, são salvas em um arquivo com formato json disponível na pasta

CustomCI e podem ser editados e removidos conforme o usuário desejar.

Capítulo 5

Desenvolvimento

O desenvolvimento do sistema foi feito em cima da Unity – um motor (engine)

de jogos proprietário e uma IDE, que possui bibliotecas e ferramentas (mencionados

neste capítulo) que auxiliam no desenvolvimento de jogos e demais softwares.

Definido o escopo do projeto, foram estabelecidas as principais etapas para o seu

desenvolvimento, a primeira sendo a representação (visual e lógica) dos componentes e

da interface no sistema, seguida da montagem e cálculo de circuitos e, por fim, a

exibição dos resultados por meio de uma interface simples.

5.1 – Representação dos Componentes e Interface

Optou-se por utilizar desenhos para representar visualmente os componentes e a

interface no sistema dando a este um tom mais amigável e uma aparência mais próxima

de a de um jogo e não de um sistema acadêmico.

36

Para tal, foi utilizado o Piskel – um software para criação desenhos pixelados –

por ser gratuito e open source. O conhecimento prévio do autor também foi um fator

determinante para a escolha.

O software fornece algumas ferramentas como camadas, palheta de cores e

algumas teclas de atalho que facilitam a criação de desenhos e o tornam mais vantajoso

do que o Paint (software de criação de desenhos da Microsoft).

Quanto à representação lógica, resolveu-se tomar proveito da semelhança

comportamental dos CIs e optar por uma linguagem de programação com orientação a

objeto.

O principal conceito da orientação de objetos é o de herança, onde – de maneira

sucinta – uma classe B, se herdada da classe A, tem acesso a alguns métodos presentes

na primeira, fazendo com que não seja necessário reescrever partes do código.

5.2 – Montagem de Circuitos

Neste trabalho, definiu-se montagem de circuitos a interconexão de

componentes por meio da protoboard. A montagem deve seguir o seguinte fluxo

Seleção

Posicionamento

Conexão

A seguir será explicado cada uma dessas etapas e como foram implementadas no

projeto.

5.2.1 – Seleção

A seleção é a etapa onde o usuário escolhe o componente que utilizará. Para isso

ele deve procurar o componente na listagem de componentes e selecioná-lo (clique com

o botão esquerdo do mouse).

Os componentes da lista de componentes estão em uma lista de ListItem. Esta

classe possui como atributos o nome do componente, palavras-chave e o objeto que será

instanciado ao selecioná-lo.

37

Para listar também os componentes adicionados pelo usuário (pertencentes a

pasta CustomCI), um método é invocado ao iniciar o sistema, onde é feita uma

varredura na pasta e cada arquivo de extensão json é convertido para um ListItem.

Ao selecionar um componente, o componente é instanciado na área de trabalho e

o usuário pode posicioná-lo.

Figura 5.1 – A inclusão dos componentes adicionais na listagem.

5.2.2 – Posicionamento

Selecionado o componente, o posicionamento é a etapa onde o usuário deve

escolher onde ele será conectado. Para uma maior precisão, o componente desconectado

segue a posição do mouse nesta etapa.

Para acompanhar o mouse, a atualização da posição do componente é feita no

método Update. Este método, fornecido pela classe MonoBehaviour (classe base de

qualquer script da Unity) é executado a cada frame.

38

O método Update é um método não implementado, onde seu comportamento é

descrito pelo desenvolvedor ao implementá-lo. No caso mostrado na Figura 5.2, o

método foi implementado com o objetivo de atualizar a posição do componente não

conectado à cada frame.

Figura 5.2 – O método Update sendo utilizado pela classe ComponentBehaviour.

Para verificar o posicionamento correto do componente, foi colocado um

BoxCollider em cada conector e cada entrada da protoboard.

Figura 5.3 – Os BoxColliders dos conectores de um CI.

BoxColliders são componentes da Unity e servem para marcar delimitações.

Toda vez que um BoxCollider sobrepõe ou deixa de sobrepor um outro, os métodos

OnTriggerStay2D e OnTriggerExit2D são invocados respectivamente. Ambos os

métodos são da classe MonoBehaviour e, assim como o método Update, não são

implementados por padrão.

No sistema, quando um BoxCollider de um conector é sobreposto com algum

outro, ele invoca o método OnTriggerStay2D, que foi implementado (conforme

indicado pela figura 5.4) para verificar se o BoxCollider que o sobrepôs é de um slot da

39

protoboard. Caso seja, o método SelectSlot é invocado, este método salva o slot para

caso o usuário deseje conectar o componente.

Figura 5.4 – Os métodos OnTriggerStay2D e OnTriggerExit2D.

Pelos motivos citados acima, todos os componentes são herdeiros da classe

MonoBehaviour.

5.2.3 – Conexão

Ao tentar conectar um componente, efetua-se uma checagem para certificação

de que todos os conectores deste estejam posicionados corretamente acima de uma

entrada da protoboard. Feito isso, cada um de seus conectores deve se conectar com um

slot e consequentemente com uma linha da protoboard.

Para que a conexão com a protoboard funcione corretamente, foram criadas as

classes RowBehaviour e SlotBehaviour, que representam as linhas e os slots da

protoboard respectivamente.

Toda vez que uma alteração é feita no circuito, as informações seguem o fluxo

mostrado na figura Figura 5.5.

Figura 5.5 – Fluxo de informações.

Ao conectar ou remover um componente da protoboard, o método

ConnectDisconnect, é invocado em cada um dos conectores (ConnectorBehaviour) e a

40

informação de cada conector é passado para o respectivo slot conectado

(SlotBehaviour), que passa para sua respectiva linha (RowBehaviour).

A linha adiciona/remove o conector em uma lista de conectores conectados

(connectedConnectors) e em seguida recalcula-se o seu novo estado.

Figura 5.6 – O método ConnectDisconnect da classe RowBehaviour.

5.3 – Cálculo de Circuitos

Para que o sistema consiga simular circuitos em tempo real, o cálculo deve ser

feito a cada alteração, seja esta uma conexão ou uma remoção de um componente da

protoboard ou ao desligar ou ligar a fonte.

Ao se alterar um circuito, todas as linhas afetadas varrem a lista de conectores

conectados em busca de um conector que seja uma saída (ou output). Ao encontrá-la, a

linha define seu estado como sendo o mesmo deste conector (caso ela não encontre, o

seu estado será indefinido) e em seguida varre a lista de conectores e, para cada um

41

destes (com a exceção do output), invoca o método SetState de cada conector. Cada um

informa o seu componente de que houve uma alteração no circuito e caso algum estado

tenha sido alterado, o componente toma as devidas providências.

Figura 5.7 – Fluxo de comunicação entre componentes e a protoboard.

5.3.1 – Coroutines

O cálculo do circuito é feito em cascata, onde uma alteração em uma linha pode

alterar o estado da linha seguinte e assim sucessivamente até chegar no final do circuito.

Por isso, estes cálculos podem ser bastante demorados e afetarem o desempenho do

sistema. Para melhorar a performance, foram utilizadas Coroutines.

Coroutines possibilitam que os métodos possam ser interrompidos e retomados

após um determinado período. Isso faz com que operações demoradas não atrapalhem o

desempenho do sistema.

Os métodos ConnectDisconnect de todas as classes são Coroutines. Portanto ao

conectar um componente, visualmente ele é conectado, mas logicamente a conexão é

parcelada nos frames seguintes, fazendo com que o sistema não trave enquanto calcula

os estados resultantes ao fazer uma conexão.

Uma conexão em cascata como o da Figura 5.8 causa uma reação em cascata

onde cada linha atualiza o estado do fio que atualiza o estado da linha seguinte e assim

42

adiante. Sem o uso da Coroutine seria impossível calcular os estados resultantes e

mostrar visualmente a conexão sem um atraso perceptível.

Figura 5.8 – Conexão em cascata na protoboard.

Na Figura 5.9 é possível ver a interrupção do método por um frame em “yield

return null”, antes de propagar a conexão para o slot.

Figura 5.9 – Um pedaço do método ConnectDisconnect em ConnectorBehaviour.

5.3.2 – Cálculo de Estados

Definida a comunicação entre os componentes e a protoboard, resta definir o

cálculo dos estados em si.

43

5.3.2.1 – Componentes Combinacionais

A classe LogicGate foi criada para representar as operações lógicas

combinacionais (simples ou complexas). Dentre seus atributos estão suas entradas,

saídas e tabela verdade. Em cada CI são instanciados diversos objetos dessa classe e é

feita a atribuição de seus atributos de acordo com a sua pinagem e operações lógicas.

Toda vez que é feita uma alteração no circuito, os componentes afetados

invocam o método Operate em cada LogicGate de cada conector afetado. Neste método

é feita a consulta da tabela verdade e os estados das saídas são devidamente setados.

Figura 5.10 – O construtor da classe LogicGate.

5.3.2.2 – Componentes Sequenciais

Componentes sequenciais não trabalham com tabela verdade, portanto seu

comportamento não é comum aos combinacionais.

Para estes casos foi criado a classe FlipFlop (os únicos componentes sequenciais

desse projeto são flipflops), que substituem o LogicGate. No ponto de vista do

componente, seu funcionamento é o mesmo: O método Operate é invocado, que seta o

valor das saídas, porém a forma de calcular os estados funciona de maneira diferente.

44

Ao invés de consultar a tabela verdade, o seu comportamento foi todo

programado, checando o valor das entradas (J e K ou D e o Clock) e setando o valor das

saídas com base no valor do Clock e do estado anterior.

Figura 5.11 – Cálculo do estado seguinte para o Flip-flop J-K.

5.3.2.3 – Demais Componentes

Foram criadas classes próprias para os demais componentes, baseado no

comportamento de cada um destes.

Entre alguns exemplos estão o LED, que acende, apaga ou queima baseado no

estado de suas entradas e o Display, que muda a cor de seus segmentos.

5.3.3 – Estados Lógicos

Como o sistema trabalha apenas com situações ideais, não é preciso representar

os estados com valores inteiros ou decimais (representando as tensões), porém não é

possível representá-los utilizando variáveis binárias (booleanas), pois além dos estados

lógicos 1 (High) e 0 (Low), existe ainda o estado “indefinido” (quando não há uma

tensão definida). Portanto, foi utilizada a classe DBBool para representar os estados

lógicos, que possui 3 estados: True (High), False (Low) e Null (Indefinido).

45

5.3.4 – Tabela Verdade

A tabela verdade é representada por um array de N linhas por M colunas. M é o

número de saídas daquela porta lógica enquanto N é o número de combinações de

estados lógicos possíveis para todas as entradas da porta lógica, ou seja, para uma porta

lógica de duas entradas e uma saída (um AND, por exemplo), sua tabela verdade terá

uma coluna (uma saída) e quatro linhas representando os valores binários 0 0, 0 1, 1 0 e

1 1 nas entradas.

A tabela 5.1 mostra a tabela verdade para um AND de duas entradas e uma

saída.

Tabela 5.1 – Array contendo a tabela verdade do AND com duas entradas.

Linha Val. Binário Array

I X1 X0 Y0

0 0 0 0

1 0 1 0

2 1 0 0

3 1 1 1

A tabela verdade é consultada em LogicGate toda vez em que o método Operate

é invocado. A consulta funciona da seguinte maneira:

A lista de entradas é varrida na ordem que ela foi instanciada e, para cada

entrada, é verificado o seu estado lógico.

A cada verificação de estado lógico é adicionado um digito “1” (caso

esse estado seja verdadeiro) ou um digito “0” (caso esse estado seja

falso) à esquerda de uma string chamada binaryVal.

Caso alguma das entradas tenha o estado indefinido, a consulta é

interrompida e o estado indefinido (NULL) é forçado na(s) saída(s).

Ao final da verificação, a string binaryVal representará o valor binário

presente na(s) entrada(s). Este valor é convertido para decimal e esse

valor será o índice da linha em que será consultada na tabela verdade.

O estado de cada saída será forçado com o valor presente no índice ij da

tabela verdade, onde i (linha) é o índice da linha, calculado anteriormente

e j é o índice da saída na lista de saídas.

46

Figura 5.12 – A consulta da tabela verdade.

5.4 – Utilizando a Unity

A Unity é um framework utilizado no desenvolvimento de jogos, que possui

uma licença gratuita – com algumas restrições [2].

Apesar de ser utilizada para o desenvolvimento de jogos, ela não está restrita

somente a eles. A Unity pode ser utilizada para outras aplicações e protótipos em geral

pois possui ferramentas que auxiliam o desenvolvimento, tornando-o rápido e robusto.

Algumas vantagens da Unity foram mencionadas anteriormente e aqui serão

reunidas todas as principais vantagens desta ferramenta.

5.4.1 – Orientação a Objeto

A Unity utiliza a linguagem de programação C#, uma linguagem orientada a

objeto criada pela Microsoft. Isso supre a necessidade do uso da orientação a objeto, que

auxilia na organização, estruturação do projeto e agilizar o seu desenvolvimento. A

orientação a objetos foi utilizada para reaproveitar comportamentos comuns,

principalmente dos componentes (seleção, posicionamento e conexão), além de

estruturar e organizar o código.

47

5.4.2 – MonoBehaviour

MonoBehaviour é a classe base de todos os scripts da Unity. Vários métodos

desta foram utilizados no projeto. Dentre eles, os mencionados anteriormente: Update,

OnTriggerEnter2D e OnTriggerExit2D. Além desses o método Start foi muito utilizado

para inicializar variáveis. Este método é executado uma vez quando o sistema é

inicializado.

5.4.3 – BoxColliders

BoxColliders são componentes delimitadores que resolvem o problema de

posicionamento de componentes.

Eles são utilizados em todos os componentes, conectores e slots da protoboard e

servem também para evitar que um componente seja conectado em cima de outro,

mesmo estando posicionado corretamente acima dos slots da protoboard.

5.4.4 – GameObjects

GameObjects são o conceito mais importante dentro da Unity. Tudo do sistema

é composto de GameObjects, que a princípio são abstratos, contendo apenas posição,

largura e rotação (nos eixos X, Y e Z).

Aos GameObjects podem ser atribuídos componentes da Unity e é dessa

maneira que eles vão tomando “forma”. Para cada componente, por exemplo, foram

atribuídos uma imagem, um BoxCollider e um script. A Figura 5.13 mostra o

GameObject da Fonte.

Figura 5.13 – Componentes atribuídos ao GameObject da fonte.

48

GameObjects possibilitam ainda realizar uma espécie de herança múltipla

(quando uma classe herda de uma ou mais classes), o que não seria permitido em C# ao

se atribuir mais de um script a ele.

5.5 – Classes e Heranças dos Componentes

Como foi mencionado anteriormente, todos os componentes e a protoboard são

herdeiros da classe ComponentBehaviour devido ao seu comportamento comum durante

a seleção, o posicionamento e a conexão.

A protoboard é representada pela classe ProtoboardBehaviour, enquanto os

componentes, caso sejam CIs (AND, NAND, OR, NOR, NOT, XOR, MUX, ETC), vêm

de classes herdeiras de CIBehaviour, que por sua vez herda de ComponentBehaviour.

A classe CIBehaviour tem como característica principal a verificação de

ativação, que ocorre caso os pinos VCC e GND tenham as suas devidas tensões.

Os componentes sequenciais são representados na classe FFPBehaviour, que

contemplam as diferenças dos sequenciais para os combinacionais.

Todos os demais componentes têm suas classes herdadas diretamente de

ComponentBehaviour, como o fio (FioBehaviour), o LED (LedBehaviour), a label

(LabelBehaviour) e o resistor (ResistorBehaviour).

A Figura 5.14 mostra a árvore de classes dos componentes.

Figura 5.14 – Árvore de classes dos componentes.

49

5.6 – Composição dos Componentes

Nas seções acima foram descritas as ferramentas utilizadas no desenvolvimento

do sistema. Nesta seção será mostrado a construção dos componentes presentes neste.

5.6.1 – Protoboard

A protoboard, assim como todos os outros componentes foram criados a partir

de um GameObject. Nele, foi adicionado o componente chamado SpriteRender,

responsável por exibir sua imagem, que no caso será a imagem da protoboard. Além do

SpriteRender, foi adicionada a classe ProtoboardBehaviour e um BoxCollider.

Para cada linha e cada slot foram criados GameObjects com as classes

RowBehaviour e SlotBehaviour respectivamente. Em cada slot foi adicionado também

um BoxCollider para lidar com o posicionamento dos chips.

5.6.2 – Demais Componentes

Os demais componentes foram criados a partir de um GameObject com um

SpriteRender que exibe a sua imagem, o script da sua classe (ResistorBehaviour ou

LedBehaviour para o caso de um resistor ou um LED respectivamente, por exemplo) e,

para cada conector foi criado um GameObject com um BoxCollider e a classe

ConectorBehaviour.

50

Capítulo 6

Testes Realizados

Foram feitos três tipos de teste para verificar o desempenho do sistema.

Primeiro foram feitos testes implícitos, examinando o tempo de resposta de

alguns componentes implementados no sistema.

O segundo teste foi o teste de stress, onde foi testada a velocidade de resposta do

sistema.

Já o terceiro e último teste foi o teste lógico, onde foi validado se os circuitos

montados e encapsulados tinham o comportamento lógico esperado.

6.1 – Testes Implícitos

Para os testes implícitos, foi testado os tempos de resposta do TTL7408,

TTL74151 e do TTL7473. Para tal, o código foi adaptado de forma a calcular o tempo

decorrido do momento em que é conectado o fio ligando as entradas dos CIs até a

alteração de estado na saída dos mesmos.

Os resultados são satisfatórios, conforme é mostrado na Figura 6.1.

Figura 6.1 – Tempos de resposta do TTL7408 (cima), TTL74151 (meio) e TTL7473 (baixo).

6.2 – Testes de Stress

O teste de stress foi feito de três maneiras diferentes: Na primeira, foi medido o

tempo de resposta da protoboard para uma variação encadeada de estados.

51

Já no segundo teste de stress foi medido o tempo de carregamento de um

circuito com vários componentes.

O terceiro e último teste consistiu no cálculo de tempo levado para encapsular

um circuito com 10 entradas e 10 saídas.

6.2.1 – Primeiro Teste de Stress

Para medir o tempo de resposta da protoboard, o código foi modificado para

calcular o tempo exato levado desde o momento em que o usuário conecta um fio

(indicado pelo círculo amarelo na Figura 6.2) na protoboard até o tempo que o LED leva

para acender.

O circuito montado foi o circuito da Figura 6.2, onde os CIs rosas são o MUX

TTL74151, o CI preto é o AND TTL7408, o CI verde é o OR TTL7432 e o CI azul é o

NOT 7404. Todas as portas destes CIs foram interligadas com o objetivo de encadear o

maior número de operações lógicas. O tempo de resposta, conforme esperado, foi baixo

(0.03701973 segundos) conforme indicado na Figura 6.3.

Figura 6.2 – Circuito montado para o primeiro teste de stress.

Figura 6.3 – Tempo de resposta para a transição de estado no circuito da Figura 6.2.

52

6.2.2 – Segundo Teste de Stress

Para o segundo teste de stress, mediu-se o tempo exato desde a inserção do

comando de carregar até o final do carregamento do circuito. O circuito utilizado foi o

mesmo do primeiro teste (Figura 6.2). O resultado satisfez as expectativas (0.7031422

segundos), conforme indicado na Figura 6.4

Figura 6.4 – Tempo de resposta para o carregamento do circuito da Figura 6.2.

6.2.3 – Terceiro Teste de Stress

Para o terceiro teste de stress foi medida a duração do encapsulamento de um

circuito de 10 entradas e 10 saídas. Como o gargalo está no cálculo da tabela verdade

resultante, este foi o parâmetro utilizado para a medição deste teste.

O circuito escolhido foi o mesmo dos testes anteriores e as saídas e entradas

foram escolhidas de maneira aleatória. O resultado, mais uma vez, foi satisfatório,

conforme indica a Figura 6.5

Figura 6.5 – Tempo de resposta para o cálculo de uma tabela verdade com 10 entradas e 10

saídas.

6.3 – Testes Lógicos

Os testes lógicos foram feitos com o propósito de confirmar a coerência no

cálculo dos circuitos. Foram montados e testados 2 circuitos: Década e o MUX 2:1

encapsulado.

53

6.3.1 – Teste da década

A década nada mais é do que um contador que, ao chegar na 10, é reiniciado.

Para montar a década, foram utilizados 2 chips contendo 2 FFPs J-K cada e um NAND

conectados da maneira mostrada na Figura 6.6. Para validar a contagem, foram

utilizados LEDs, conforme mostra a Figura 6.7, onde os CIs roxos são os J-K TTL7473

e o CI vermelho, o NAND TTL7400. Os bits são identificados por LEDs (do MSB ao

LSB) marrom, cinza, amarelo e verde.

Figura 6.6 – Conexões entre FFPs J-K e a porta lógica NAND, formando uma década.

Figura 6.7 – Década montada na protoboard.

54

Os resultados foram satisfatórios: A década conta corretamente, porém,

exibe o número 10 (1010 em binário) rapidamente antes de retornar para o zero. Isso

acontece, pois, as mudanças de estado são calculadas em tempo real e a mudança de

estado só chega ao NAND depois de chegar nos Flip-Flops. O tempo de duração do

número 10 é o tempo em que a transição de estado demora para chegar no NAND, que

não é a mesma dos Flip-Flops.

6.3.2 – Teste do Mux 2:1 Encapsulado

O Mux 2:1 é um multiplexador com 2 entradas, 1 seletor e uma saída. Para

realizar esse teste, foi montado e encapsulado um mux, utilizando duas portas lógicas

AND, uma porta lógica NOT e uma porta OR, ligadas conforme mostra a Figura 6.8.

Figura 6.8 – Conexões entre portas lógicas formando um MUX 2:1.

O circuito montado funcionou corretamente, conforme o esperado. Em seguida,

ele foi encapsulado e testado novamente. O CI novo funcionou corretamente, conforme

o esperado, mostrado na Figura 6.10.

55

Figura 6.9 – MUX 2:1 montado na protoboard, onde o CI laranja é o AND TTL7408, o CI

amarelo é o NOT TTL7404 e o azul, o OR TTL7432.

Figura 6.10 – A pinagem do MUX encapsulado (acima) e o seu funcionamento (abaixo).

56

Capítulo 7

Conclusões

Apesar do planejamento ter sofrido modificações constantes, foi possível

gerenciar e adaptar o projeto corretamente. O uso de uma linguagem orientada a objetos

e da Unity ajudou a criar um sistema robusto e bem organizado.

Ao realizar os testes, pode-se ver que o software contempla todas as funções

importantes de um simulador e consegue substituir os softwares utilizados em aula.

Além disso é perceptível sua simplicidade e a facilidade de utilização do sistema pelo

usuário – consequência de uma interface limpa e visualmente semelhante ao laboratório.

7.1 – Aprendizados

O maior aprendizado adquirido neste projeto foi o de gerenciamento. A

definição do escopo do projeto e o gerenciamento do tempo foram grandes aliados,

norteando o desenvolvimento deste. Assim foi possível balancear qualidade e

quantidade, de maneira a cumprir o projeto no prazo, mas ainda assim cumprindo seu

escopo definido inicialmente.

7.2 – Trabalhos Futuros

Para o futuro, há inteção de se desenvolver o projeto fora da Unity – utilizada

neste caso com o intuito de agilizar o seu desenvolvimento -, para otimizá-lo e,

possivelmente, transformá-lo em uma aplicação WEB.

A próxima versão do projeto deve incluir o encapsulamento de circuitos

sequenciais e simulação de realimentações, além de elementos que tornem a simulação

mais próxima da aplicação real, como a implementação de tempo de resposta.

57

Bibliografia

[1] TOCCI, Ronald J, WIDMER, Neal S., MOSS, Gregory L., Sistemas Digitais:

Princípios e Aplicações. 11a ed. São Paulo: Pearson, 2011, pp 101.

[2] GÜNTZEL, José L., NASCIMENTO, Francisco A. Introdução aos Sistemas

Digitais. V.2001/1 Cap. 4 Pag. 1. (acesso em 05 de Março de 2018) Disponível em:

https://www.inf.ufsc.br/~j.guntzel/isd/isd4.pdf

[4] Instruments, TEXAS, The TTL Data Book, Disponível em:

http://www.novaims.unl.pt/docentes/vlobo/escola_naval/SistemasDigitais/TTL_Lo

gic_databook_TexasInstruments.pdf

[5] Farchild, Disponível em: https://www.fairchildsemi.com/datasheets/74/

https://www.inf.ufsc.br/~j.guntzel/isd/isd4.pdf

http://www.novaims.unl.pt/docentes/vlobo/escola_naval/SistemasDigitais/TTL_Logic_databook_TexasInstruments.pdf

http://www.novaims.unl.pt/docentes/vlobo/escola_naval/SistemasDigitais/TTL_Logic_databook_TexasInstruments.pdf

58

Apêndice A

Manual do Usuário

A.1 – Iniciando o Sistema

O sistema não precisa ser instalado. Para inicia-lo, basta executar o arquivo

“Simulador.exe”.

Ao executar o arquivo, o usuário terá de escolher uma entre as resoluções

disponíveis. Deve-se escolher a resolução 1024 x 768 (a opção “Windowed” é

opcional).

Figura A.1 – Tela de escolha de resolução.

Caso a listagem de componentes esteja vazia, deve-se certificar que as pastas

“CustomCi” e “Saves” estão presentes em Simulador_Data/Resources.

59

A.2 – Utilização do Sistema

A.2.1 – Listagem de Componentes

Para selecionar um componente da listagem, basta clicar em seu nome com o

botão esquerdo do mouse. Caso o usuário não encontre o componente na lista, ele pode

rolar a lista para cima e para baixo com o scroll do mouse ou então utilizar o campo de

texto presente em sua parte superior para filtrar seus componentes.

Um componente pode ser filtrado digitando seu nome ou qualquer palavra chave

que o inclua (TTL, Custom, AND, NAND, OR, NOR, NOT etc.).

A.2.2 – Console

O console encontra-se inicialmente oculto. Para exibi-lo/oculta-lo, basta apertar

a tecla “Enter” do teclado. Para executar um comando, basta digita-lo no campo de

texto e apertar “Enter” para envia-lo. Caso o comando esteja incorreto, o console

exibirá uma mensagem indicando o mesmo.

Todos os comandos têm uma versão em português e uma em inglês. Abaixo

serão explicados todos os comandos e a forma correta de utiliza-los:

Ajuda (Help): Lista todos os comandos disponíveis ao usuário;

Reiniciar (Reset): Reinicia o programa. Caso o circuito da área de

trabalho não esteja salvo, o progresso será perdido;

Salvar (Save) / Carregar (Load) + <Nome do arquivo>: Salva/Carrega

o circuito com o nome indicado. Este nome deve ser único (O circuito

não será salvo se já houver outro arquivo salvo com o mesmo nome);

Deletar (Delete) + <Nome do circuito>: Deleta o circuito com o nome

indicado. Caso haja um CI encapsulado com este nome, ele também será

deletado e o programa reiniciado;

Listar (List) componentes (components): Lista todos os componentes

presentes na lista de componentes e a label;

Listar (List) cores (colors): Lista todas as cores (em inglês e português)

disponíveis para serem utilizadas no comando de setar cor;

Setar (Set) + <cor>: Seta a cor padrão dos LEDs, fios e labels;

60

Selecionar (Select) + <componente>: Seleciona o componente. Caso

este componente for uma label, o comando deve ter mais um argumento,

sendo este o nome de identificação da label;

Gerar (Generate) + <nome do novo CI>: Inicia o processo de

encapsulamento de circuitos. O nome do CI deve ser único, não havendo

nenhum outro CI criado ou circuito salvo com o mesmo nome;

Sair (Exit): Sai da aplicação.

A.2.3 – Utilizando a Área de Trabalho

A área de trabalho é onde o usuário pode montar o circuito. Para isso, ele deve

primeiro selecionar pelo menos uma protoboard (por meio da lista ou console) e

posiciona-la em qualquer lugar da área de trabalho com o botão esquerdo do mouse.

Para conectar qualquer outro componente na protoboard, deve-se primeiro

posiciona-lo corretamente, com todos os seus conectores acima de pinos livres da nela

(indicados pelo contorno branco como na figura A.2). Posicionado o componente

corretamente, o usuário pode conecta-lo, assim como a protoboard, pressionando o

botão esquerdo do mouse.

Para desconectar um componente para reposiciona-lo ou remove-lo, basta clicar

nele com o botão esquerdo do mouse. A seleção de um componente pode ser cancelada

e o componente removido com a tecla “Esc” do teclado.

Figura A.2 – Posicionamento correto (dir.) e incorreto (esq.) do chip na protoboard.

61

Caso uma saída do chip seja conectada em uma linha com uma tensão já

definida, o usuário será informado de que fez uma conexão incorreta pelo console e

caso a conexão não seja consertada, o sistema poderá calcular o circuito incorretamente.

Para selecionar um fio, o usuário deve clicar nas duas entradas da protoboard (ou

da fonte). Existem dois tipos de fio, o fio “Banana” que serve para conectar na fonte e

nos bornes da protoboard e o fio “Comum” utilizado para as demais entradas da

protoboard. O tipo de fio é selecionado automaticamente assim que o usuário seleciona

a primeira entrada.

Para alterar a cor de um fio/LED/label, utiliza-se o painel de cores. Clicando

com o botão direito do mouse em qualquer um desses componentes, o painel se abrirá e

o usuário pode escolher a cor desejada.

Para utilizar a ponta de prova, basta pressionar a tecla “Alt” esquerda do teclado

e apontar o mouse no componente / entrada que deseja obter informações.

A.2.4 – Encapsulamento de Componentes

O encapsulamento se inicia assim que o usuário desliga a fonte e qualquer

conexão entre esta e a protoboard e digita o comando no console. O usuário pode

indicar as entradas e saídas do circuito pressionando a tecla “X” (para entradas) ou “Y”

(para saídas) e clicando na entrada desejada da protoboard. A entrada/saída será então

identificada por uma label vermelha (entrada) ou azul (saída). Para remover a

entrada/saída selecionada, basta clicar na flag com o botão esquerdo do mouse.

As entradas e saídas podem ser renomeadas para facilitar a visualização do

datasheet do CI novo. Para isso, basta clicar com o botão direito do mouse na label que

deseja alterar o nome e um painel será exibido com uma caixa de texto contendo o nome

atual da label. O texto pode ser modificado por um outro texto único com até 3

caracteres. A alteração é confirmada com a tecla “Enter” do teclado.

Selecionando todas as entradas e saídas do circuito, o usuário deve pressionar

“Enter” para avançar para a etapa de pinagem do CI. Neste momento, o circuito é

simulado para todas as entradas e saídas possíveis para gerar a sua tabela verdade

resultante. Caso durante essa simulação um componente seja queimado, o

encapsulamento é cancelado e o usuário retorna para a tela de montagem de circuito

sem o componente queimado.

62

Caso não haja nenhum problema durante a simulação do circuito, a etapa de

pinagem se inicia. O usuário deve selecionar uma das entradas/saídas/VCC/GND e

posicionar no pino desejado arrastando com o botão direito do mouse o seu nome e o

soltando em cima do “Slot” referente ao pino.

Figura A.3 – VCC e X1 posicionados nos slots dos pinos 1 e 5 do CI novo.

Após definir a pinagem, o usuário finaliza o processo de encapsulamento

pressionando mais uma vez a tecla “Enter”. O circuito montado e o CI novo são então

salvos e o programa reiniciado com o CI novo na listagem de componentes.

A.2.5 – Arquivos Salvos e Adição de Componentes

A pasta CustomCI contém os componentes adicionados pelo usuário. As

informações destes componentes são guardadas em arquivos de texto de extensão json e

cujo o conteúdo é conforme a Figura A.4.

O usuário pode incluir CIs ao sistema adicionando novos arquivos na pasta. É

possível criar um arquivo json utilizando qualquer editor de texto, mas é preferível

editores simples como o notepad, de maneira a evitar caracteres especiais, não

visualizados pelo usuário, mas muitas vezes visualizados pelo sistema.

Para a criação do conteúdo do arquivo, o usuário deve seguir cuidadosamente o

modelo do arquivo, explicado abaixo.

Figura A.4 – Arquivo JSON de um CI encapsulado.

63

A primeira linha contém o nome do CI (Importante: o nome do arquivo deve

ser igual ao nome do CI também).

A segunda linha indica a pinagem do CI, onde a contagem ocorre conforme a

Figura A.5. Ao nome das entradas e saídas foi adicionado os caracteres “X +

<índice>” (no caso das entradas) e “Y + <índice>” (no caso das saídas),

indicando se são entradas ou saídas e a sua ordem na tabela verdade. No

exemplo da Figura A.5, vê-se que a primeira coluna da tabela verdade então

se refere à saída “Y0Q” e a segunda coluna à saída “Y1Q”. As entradas

VCC e GND são obrigatórias ou o CI não ficará ativo.

A ultima linha contém a tabela verdade do CI, onde cada índice contem o

valor de cada saída separado por “.”. O valor “-1” indica o valor lógico 0 (L

– LOW), o valor “1” indica o valor lógico 1 (H – HIGH) e o valor “0” indica

o valor lógico “NULL” ou indefinido.

O CI do arquivo da Figura A.4 ficaria então com a pinagem da Figura A.5 e a

tabela verdade da Tabela A.

Figura A.5 – Pinagem do CI da Figura A.4.

Tabela A.1 – Tabela verdade do CI da Figura A.4.

Entradas Saídas

B A !Q Q

0 0 0 0

0 1 0 1

1 0 1 0

1 1 1 1

64

O arquivo deve ser salvo como “<Nome do Componente>.json” e colocado na

pasta correta (CustomCI). O sistema reconhecerá o componente assim que for

inicializado.

Caso o componente não funcione de maneira esperada, deve-se rever o seu

conteúdo para se certificar de que este está correto.

simulador interativo de eletrÔnica digital pedro...

Documents