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
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.
Orientador: José Arthur da Rocha
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.

iii
iv
 AGRADECIMENTO

Dedico este trabalho aos meus mestres pela paciência e aos meus pais por sempre
acreditarem em mim.

v
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

Pedro Guimarães Del Rei

Junho/2018

Orientador: José Arthur da Rocha

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.

vi
Abstract of Undergraduate Project presented to POLI/UFRJ as a partial fulfillment of the
requirements for the degree of Engineer.

DIGITAL ELECTRONIC INTERACTIVE SIMULATOR

Pedro Guimarães Del Rei

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.

vii
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

viii
 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

ix
 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

x
 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

xi
7 Conclusões 56

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

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

Bibliografia 57

A Manual do Usuário 58

xii
 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

xiii
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.

1
 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.

2
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.

3
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.

4
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

5
 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
Entrada 0 Entrada 1 Saída
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.

Fonte: Manual TTL [4].

6
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

Entrada 0 Entrada 1 Saída
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.

Fonte: Manual TTL [4].

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
Entrada 0 Entrada 1 Saída
0 0 1
0 1 0
1 0 0
1 1 0

7
 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.

Fonte: Manual TTL [4].

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.

Fonte: Manual TTL [4].

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.

8
 Tabela 2.6 – Tabela verdade de um XOR com duas entradas
Entrada 0 Entrada 1 Saída
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.

Fonte: Manual TTL [4].

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

9
 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.

Fonte: Farchild [5].

10
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.

Fonte: Manual TTL [4].

Tabela 2.8 – Tabela verdade do DM74154.

Fonte: Farchild [5].

11
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.

Fonte: Manual TTL [4].

Tabela 2.9 – Tabela verdade do DM7442A.

Fonte: Farchild [5].

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).

12
 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.

Fonte: Farchild [5].

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.

13
 Tabela 2.10 – Tabela verdade do DM9368.
Fonte: Farchild [5].

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.

14
 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

15
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.

Fonte: Manual TTL [4].

Tabela 2.12 – Tabela verdade do DM7474.

Fonte: Farchild [5].

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.

16
 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.

Fonte: Manual TTL [4].

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á.

17
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.

18
 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

19
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.

20
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.

21
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.

22
 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”.

23
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.

24
 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.

25
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.

26
 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.

27
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.

28
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.

29
 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.

30
 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.

31
 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.
32
 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).

33
 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.

34
 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.

35
 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.

36
 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.

37
 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

38
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

39
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

40
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

41
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.

42
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.

43
 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).

44
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 00 0
1 01 0
2 10 0
3 11 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.

45
 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.

46
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.

47
 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.

48
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.

49
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.

50
 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.

51
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.

52
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.

53
 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.

54
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).

55
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.

56
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/

57
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.

58
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;

59
  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.

60
 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.

61
 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.

62
  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

63
 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.

64