BIBLIOTECA DE SIMULAÇÃO DE CIRCUITOS DIGITAIS PARA ARDUINO

(1)

UNIVERSIDADE FEDERAL RURAL DO SEMI-ÁRIDO PRÓ-REITORIA DE GRADUAÇÃO

CENTRO MULTIDISCIPLINAR DE PAU DOS FERROS – CMPF CURSO BACHARELADO EM CIÊNCIA E TECNOLOGIA

ROBSON THIAGO BATISTA REGO

BIBLIOTECA DE SIMULAÇÃO DE CIRCUITOS DIGITAIS PARA ARDUINO

PAU DOS FERROS 2018

(2)

Trabalho de Conclusão de Curso apresentado a Universidade Federal Rural do Semi-Árido – UFERSA, Campus Pau dos Ferros, para obtenção do título de Bacharel em Ciência e Tecnologia.

Orientador: Prof. Dr. Rodrigo Soares Semente

PAU DOS FERROS 2018

(3)

obra é de inteira responsabilidade do (a) autor (a), sendo o mesmo, passível de sanções administrativas ou penais, caso sejam infringidas as leis que regulamentam a Propriedade Intelectual, respectivamente, Patentes: Lei n° 9.279/1996 e Direitos Autorais: Lei n° 9.610/1998. O conteúdo desta obra tomar-se-á de domínio público após a data de defesa e homologação da sua respectiva ata. A mesma poderá servir de base literária para novas pesquisas, desde que a obra e seu (a) respectivo (a) autor (a) sejam devidamente citados e mencionados os seus créditos bibliográficos.

O serviço de Geração Automática de Ficha Catalográfica para Trabalhos de Conclusão de Curso (TCC´s) foi desenvolvido pelo Instituto de Ciências Matemáticas e de Computação da Universidade de São Paulo (USP) e gentilmente cedido para o Sistema de Bibliotecas da Universidade Federal Rural do Semi-Árido (SISBI-UFERSA), sendo customizado pela Superintendência de Tecnologia da Informação e Comunicação (SUTIC) sob orientação dos bibliotecários da instituição para ser adaptado às necessidades dos alunos dos Cursos de Graduação e Programas de Pós-Graduação da Universidade.

(4)

Trabalho de Conclusão de Curso apresentado a Universidade Federal Rural do Semi-Árido – UFERSA, Campus Pau dos Ferros, para obtenção do título de Bacharel em Ciência e Tecnologia.

Defendido em: 18 / 04 / 2018.

(5)

Aos meus pais, Rosano Rego Gonçalves e Betânia Maria Moreira Batista Gonçalves, por estarem ao meu lado e lutarem por educar e apoiarem seus filhos nas horas mais precisas.

(6)

A toda minha família, por estarem ao meu lado nos momentos difíceis e por fazerem companhia.

A todos meus amigos, pois a amizade é uma das coisas que me proporciona alegria.

A meus colegas que se tornaram amigos durante todo o ciclo acadêmico, e que demostraram companheirismo.

Ao meu orientador Dr. Rodrigo Soares Semente, por me ajudar a elaboração deste trabalho.

A todos os docentes, onde tive a oportunidade de receber um pouco dos conhecimentos deles.

(7)

“A vida é como andar de bicicleta. Para manter o equilíbrio é preciso se manter em movimento”.

(8)

A álgebra booleana é um dos principais elementos para construção de um circuito digital, tal que, disciplinas que abordam o tema tem ausência de aulas práticas por muitas vezes a falta de recursos. A plataforma Arduino pode ser uma alternativa de aulas práticas, por ser de baixo custo e por conter pinos de entrada e saída digital que é suficiente para a manipulação da álgebra booleana. Com a utilização desta plataforma, é possível desenvolver biblioteca de funções, através de programação, que representam elementos da disciplina de Circuitos Digitais, como portas lógicas e flip-flops, dando a liberdade ao usuário utilizar essas ferramentas para elaborar o que necessita. Com entradas e saídas lógicas representadas por push-buttons e LEDs, respectivamente, torna as aulas mais dinâmicas. Desta forma é possível utilizar a biblioteca desenvolvida para diversas aplicações como circuitos combinacionais, sequenciais, contadores, registradores de deslocamento entre outros.

(9)

Boolean algebra is one of the main elements for the construction of a digital circuit, such that disciplines that approach the subject have absence of practical classes for many times the lack of resources. The Arduino platform can be an alternative to practical classes, because it is inexpensive and contains pins of digital input and output that is sufficient for the manipulation of Boolean algebra. With the use of this platform, it is possible to develop library of functions, through programming, that represent elements of the discipline of Digital Circuits, such as logic gates and flip-flops, giving the user the freedom to use these tools to elaborate what they need. With logic inputs and outputs represented by push-buttons and LEDs, respectively, it makes classes more dynamic. In this way it is possible to use the library developed for various applications such as combinational circuits, sequential, counters, shift registers, among others.

(10)

Figura 1 – Placa Arduino Uno …...………….………...16

Figura 2 – Designação de tensão típica de um sistema digital...………....…… 18

Figura 3 – Portas lógicas implementadas de forma discreta...………... 18

Figura 4 – Porta lógica OR ………...……...19

Figura 5 – Porta lógica AND...………...……...20

Figura 6 – Porta lógica NOT …...………...21

Figura 7 – Porta lógica NOR ……....………... 21

Figura 8 – Porta lógica NAND ………...…………...22

Figura 9 – Porta lógica XOR...…...…...23

Figura 10 – Porta lógica XNOR ……...…………...23

Figura 11 – Lacth com portas NAND...……...…..24

Figura 12 – Lacth com portas NOR ………...…………...25

Figura 13 – Representação do Flip-flop S-R disparado na borda de subida...25

Figura 14 – Representação do Flip-flop J-K disparado na borda de subida...26

Figura 15 – Representação do Flip-flop D...27

Figura 16 – Representação do Flip-flop T...27

Figura 17 – Flip-flop J-K disparado na borda de descida com entradas assíncronas...28

Figura 18 – Testes do trabalho…...….………...30

Figura 19 – Ilustração do trabalho …...………….………...31

Figura 20 – Circuito interno do Flip-flop S-R...41

Figura 21 – Circuito interno do Flip-flop J-K...42

Figura 22 – Circuito Combinacional …...….………...45

Figura 23 – Registrador de Deslocamento...…………...46

Figura 24 – Contador Assíncrono …...………….…………....…………...47

Figura 25 – Contador Síncrono …...….………...49

(11)

Tabela 1 – Especificações Técnicas do Arduino Uno...17 Tabela 2 – Componentes utilizados para testes...…...30

(12)

FF Flip-flop

LED Light emitting diode (diodo emissor de luz)

PWM Pulse width modulation (modulação de largura de pulso) LSB Least significant bit (bit menos significativo)

(13)

1 INTRODUÇÃO ... 13

1.1 OBJETIVOS ... 14

1.1.1 Objetivo Geral ... 14

1.1.2 Objetivos Específicos... 14

1.2 ESTRUTURAÇÃO DOS CAPÍTULOS ... 14

2 REFERENCIAL TEÓRICO ... 15 2.1 ARDUINO ... 15 2.1.1 Arduino Uno ... 16 2.2 CIRCUITOS DIGITAIS ... 17 2.2.1 Portas/funções lógicas ... 19 2.2.1.1 Porta OR ... 19 2.2.1.2 Porta AND ... 20 2.2.1.3 Porta NOT ... 20 2.2.1.4 Porta NOR ... 21 2.2.1.5 Porta NAND ... 22 2.2.1.6 Porta XOR ... 22 2.2.1.7 Porta XNOR ... 23 2.2.2 Latch e Flip-Flops... 23

2.2.2.1 Latch com portas NAND ... 24

2.2.2.2 Latch com portas NOR ... 24

2.2.2.3 Flip-flop S-R ... 25

2.2.2.4 Flip-flop J-K ... 26

2.2.2.5 Flip-flop D ... 26

2.2.2.6 Flip-flop T ... 27

2.2.2.7 Flip-flop J-K com entradas assíncronas... 27

3 DESENVOLVIMENTO E TESTES ... 29

3.1 PROGRAMAÇÃO ... 30

3.1.1 Funções das Portas Lógicas ... 32

3.1.1.1 Operação OR ... 33

3.1.1.2 Operação AND ... 34

3.1.1.3 Operação NOT ... 35

(14)

3.1.1.6 Operação XOR ... 36

3.1.1.7 Operação XNOR... 37

3.1.2 Funções dos Latchs e Flip-flops ... 37

3.1.2.1 Latch NAND ... 38 3.1.2.2 Latch NOR ... 38 3.1.2.3 Clock ... 39 3.1.2.4 Flip-flop S-R ... 40 3.1.2.5 Flip-flop J-K ... 41 3.1.2.6 Flip-flop D ... 42 3.1.2.7 Flip-flop T ... 43

3.1.2.8 Flip-flop J-K com entradas assíncronas... 43

3.2 TESTES ... 45 3.2.1 Circuitos Combinacionais ... 45 3.2.2 Registradores de Deslocamento ... 46 3.2.3 Contadores Assíncronos ... 47 3.2.4 Contadores Síncronos ... 49 4 CONSIDERAÇÕES FINAIS ... 52 4.1 TRABALHOS FUTUROS ... 52 5 REFERÊNCIAS BIBLIOGRÁFICAS ... 53 APÊNDICE ... 55

(15)

1 INTRODUÇÃO

As técnicas de circuitos digitais têm sido aplicadas em diversas áreas da tecnologia. Porém a área da computação digital é sem duvida a mais influenciadora, e a mais ampla. Tudo que um computador pode fazer o humano também, mas o computador faz em velocidades e precisões muito maiores, isso tudo é devido sua manipulação de dados e operações aritmética de forma binária, com 0s e 1s (TOCCI; WIDMER; MOSS, 2011).

A disciplina de Circuitos Digitais necessita aulas práticas para melhor entendimento do aluno, mas os equipamentos didáticos referentes à disciplina não são acessíveis para muitos, pois tem chances de queima ou estrago com a utilização de pessoas inexperientes, já que são sensíveis. A limitação da infraestrutura de laboratórios da instituição de ensino e seus recursos limitados torna difícil a aquisição equipamentos inviabilizando a utilização deste recurso de suma importância para o entendimento da disciplina. Com isso, uma das possibilidades que os alunos tem para aplicar os conhecimentos teóricos é através de softwares de simulação de circuitos digitais. Apesar destes softwares reduzirem um pouco a distância entre a teoria e a prática, estes não permitem o contato físico com os componentes da área.

Kits didáticos são algumas alternativas para as aulas práticas de circuitos digitais, porém fica inviável devido seu alto custo no mercado, alguns exemplos são:

O Módulo MPL-D10A, fabricado pela empresa Zilocchi Materiais Didáticos, é um equipamento desenvolvido para o auxílio das aulas práticas de laboratório de eletrônica digital, utiliza dispositivos lógicos programáveis para implementação das funções lógicas, tendo seu custo de R$ 1.250,00. Outro kit didático é o módulo 8410, fabricado pela Datapool Eletrônica, é idealizado para aplicações básicas de eletrônica digital utilizando circuitos integrados TTL para implementação das funções lógicas do equipamento. Com um protoboard acoplado, tem gerador de clock, detector de níveis lógicos, entre outras funcionalidades, seu preço no mercado é de R$ 2.611,40. (TEOFILO, 2015)

O trabalho de Teofilo (2015) criou um kit didático com o custo benefício melhor do que os kits encontrados no mercado, com diversas funcionalidades para a disciplina de Circuitos Digitais, seu custo foi de R$ 750,00.

Já o Arduino Uno, por ser uma plataforma open source existem diversos criadores da plataforma, o custo de uma criada pela a própria empresa fundadora é de U$ 22,00. Porém fabricantes locais fornecem com o custo em média de R$ 25,00. Existem kits com componentes eletrônicos bases com custo médio de R$ 80,00. Com isso, o custo benefício para auxilio didático é favorecido pelo Arduino.

(16)

Uma alternativa para sanar esta lacuna, seria o uso da plataforma arduino. O Arduino é um microcontrolador que a partir de suas entradas, permite aos usuários manipular componentes eletrônicos como resistores, LEDs, capacitores, push-buttons, sensores, entre outros. Por ser uma plataforma de prototipagem têm grandes vantagens para auxilio didático, pois o mesmo pode ser utilizado para diversas aplicações. Uma dessas aplicações seria a utilização para desenvolver meios práticos para a disciplina de circuitos digitais, o qual é o enfoque deste trabalho.

1.1 OBJETIVOS 1.1.1 Objetivo Geral

 Auxiliar a disciplina de Circuitos Digitais simulando uma plataforma física de desenvolvimento e testes de circuitos digitais utilizando o Arduino Uno.

1.1.2 Objetivos Específicos

 Desenvolver código/biblioteca que permitirá ao usuário projetar e testar circuitos digitais.

 Desenvolver exemplos de práticas utilizando os códigos criados. 1.2 ESTRUTURAÇÃO DOS CAPÍTULOS

No capítulo 2, apresentará informações sobre a plataforma Arduino e enfatizando a placa utilizada, o Arduino Uno. Também discutirá sobre circuitos digitais e seus componentes, portas lógicas e flip-flops. No terceiro capítulo está todo o desenvolvimento do trabalho, o desenvolvimento da biblioteca e suas aplicações, portas lógicas, flip-flops, contadores, entre outros. E por último, o capítulo 4 que apresenta as considerações finais do trabalho.

(17)

2 REFERENCIAL TEÓRICO

Neste capítulo apresentará as referências principais do trabalho, tais como, a plataforma Arduino enfatizando a placa Arduino Uno e sobre circuitos digitais e seus componentes.

2.1 ARDUINO

As placas Arduino são capazes de receber sinais externos como entrada por meio de sensores, microfones, botões, e transformá-los em saídas, como acender um LED e/ou ativando um motor. Isso tudo é capaz devido ao microcontrolador e sua linguagem de programação, Wiring, que é semelhante à linguagem C/C++ (ARDUINO, 2018a).

Essa plataforma eletrônica open source de baixo custo com várias utilidades nasceu na Itália como uma ferramenta fácil de prototipagem rápida, e ao longo dos anos, o Arduino tem sido o cérebro de milhares de projetos, desde objetos comuns até instrumentos científicos (ARDUINO, 2018a).

Quando aplicada para auxilio didático, estimula a curiosidade do discente para se aprofundar nas diversas possibilidades que a plataforma pode oferecer aumentando o interesse de inventar. A mesma é utilizada para fins didáticos em diversas atividades, como o projeto realizado por Perez et al (2013), que através da oferta de cursos de eletrônica, programação em Arduino e robótica móvel em escola de nível médio estadual buscou estimular o interesse dos alunos pela área de engenharia.

Com sua utilização, foram promovidas aulas experimentais de física moderna no ensino médio, já que as escolas não apresentavam laboratórios apropriados para tal aula prática, pois tinha ausência de equipamentos mais sofisticados e de alto custo, com isso a plataforma Arduino foi capaz de auxiliar e substituir estes equipamentos. (SILVEIRA e GIRARDI, 2017). E também foi usada como reforço na disciplina de sistemas embarcados (JAMIESON, 2010).

A placa Arduino possibilita diversas maneiras de ensino pedagógico, como nas áreas de matemática, música, eletrônica, robótica e automação, não fica limitada somente na área de informática. E para as universidades é auxiliadora nos cursos de computação, engenharia (CAVALCANTE, 2014).

O Arduino tem diversas funções na disciplina de Circuitos Digitais, uma grande variedade de exemplos práticos de baixa dificuldade, como criar um sensor de passagem e proximidade, operações lógicas, alarmes por temperatura entre outros, utilizando componentes simples, mas de alta aprendizagem (LABORATORIO DE GARAGEM, 2017).

(18)

Esta plataforma têm diversas funcionalidades, por ter pinos de entradas e saídas digitais e por ser programável, pode-se auxiliar a disciplina com representações de lógicas combinacionais e sequenciais. Auxiliada por um computador e componentes eletrônicos básicos, esta plataforma é uma opção de baixo custo para aulas práticas.

Dentre as diversas placas de Arduino disponíveis no mercado, a mais utilizada é a do Arduino Uno. Pelo seu custo e ser a mais utilizada, esta foi escolhida para desenvolver o projeto. A seguir, será apresentado uma breve descrição do Arduino Uno.

2.1.1 Arduino Uno

Existem diversas variações da plataforma Arduino, uns mais sofisticados com mais tecnologia e outros mais simples com menos pinos digitais, menos memória. A necessidade do projeto é que determina o Arduino ideal, por exemplo, o Arduino Mega 2560 contém 54 pinos digitais, é uma ótima escolha para projetos que necessitam de muitos sensores e atuadores. Já o Arduino Uno é o clássico e mais popular dentre as demais plataformas, contém menos pinos digitais e é ótimo para iniciantes e projetos simples. O Arduino Zero e o Arduino 101 são melhorias da placa clássica (ARDUINO, 2018b).

O Arduino Uno, como apresentado na Figura 1, é uma placa com um microcontrolador ATmega328P, possuindo 14 pinos de entrada/saída digital, 6 entradas analógicas, uma conexão USB, um conector de energia, entre outros componentes (ARDUINO, 2018b).

Figura 1 - Placa Arduino Uno

(19)

Na Figura 1, pode-se visualizar o microcontrolador, destacado pelo número 1, os pinos de entrada/saída discriminando pelo número 2, a região destacada pelo número 3 consiste nas entradas analógicas, a conexão USB, responsável pela comunicação entre o software e hardware, é destacada no número 4 e na região representada pelo número 5 tem-se a conexão para entrada de alimentação da placa. A Tabela 1 apresenta os detalhes técnicos adicionais do Arduino Uno.

Tabela 1 - Especificações Técnicas do Arduino Uno

Atributos Valores

Microcontrolador ATmega328P

Tensão operacional 5 V

Tensão de entrada (recomendado) 7-12 V

Tensão de entrada (limite) 6-20 V

Pinos Digital I/O 14 (dos quais 6 fornecem saída PWM)

Pinos de entrada Analógica 6

CC por pino de I/O 20 mA

CC para o pino de 3,3 V 50 mA

Memória Flash 32 KB (ATmega328P) dos quais 0,5 KB é usados pelo bootloader

SRAM 2 KB (ATmega328P) EEPROM 1 KB (ATmega328P) Velocidade do Clock 16 MHz Comprimento 68,6 mm Largura 53,4 mm Peso 25 g Fonte: ARDUINO (2018b) 2.2 CIRCUITOS DIGITAIS

São circuitos eletrônicos projetados para receber tensões como entrada que são processadas de forma lógica binária, e geram tensões como saídas (TOCCI; WIDMER; MOSS, 2011).

Em 1854, um matemático chamado George Boole escreveu uma investigação das leis do pensamento, em que descrevia o modo que as decisões do cotidiano eram tomadas em verdadeiras ou falsas. Este método é conhecido hoje como lógica booleana, e o sistema que

(20)

emprega essas decisões são chamados de álgebra booleana (TOCCI; WIDMER; MOSS, 2011).

A álgebra booleana é um modo de expressar a relação entre as entradas e saídas de um circuito lógico, onde geralmente as entradas são tensões que variam de 0 a 5 V. O valor booleano 0 pode ser representado por qualquer tensão no intervalo de 0 a 0,8 V, e o valor booleano 1 é representado no intervalo de 2 a 5 V. Tensões entre 0,8 e 2 V são indefinidas, não deveriam ocorrer em circunstâncias normais. Como mostra na Figura 2 (TOCCI; WIDMER; MOSS, 2011).

Figura 2 – Designação de tensão típica de um sistema digital

Fonte: TOCCI; WIDMER; MOSS (2011)

A álgebra booleana tem, de fato, apenas três operações básicas: OR (OU), AND (E) e NOT (NÃO). Ela está presente nos circuitos digitais são denominadas de portas lógicas, que podem ser construídas a partir de diodos, transistores e resistores interconectados de modo que a saída do circuito seja o resultado de uma operação lógica realizada sobre as entradas. A Figura 3 mostra um exemplo (TOCCI; WIDMER; MOSS, 2011).

Figura 3 – Portas lógicas implementadas de forma discreta

(21)

2.2.1 Portas/funções lógicas

As portas lógicas são a base para construção de circuitos digitais, pois são componentes fundamentais para o desenvolvimento de circuitos digitais, também conhecidos como circuitos combinacionais, pois sua saída depende somente da combinação das entradas externas. A implementação dessas portas, pode ser feita somente com chaves. No Arduino consegue representar essas portas lógicas de maneira fácil com apenas dois botões (ou mais) que serão as entradas, um LED que será a saída e três resistores e, um algoritmo para que o microcontrolador possa processar e executar o que o usuário deseje. (FRITZEN, 2016)

2.2.1.1 Porta OR

A operação OR (OU) em circuitos digitais só ocorre quando tem duas ou mais entradas, onde a saída dependerá das entradas. Essa operação é representada pelo o símbolo ‘+’ na álgebra booleana, mas não representa a adição como na álgebra convencional. Em caso de termos duas entradas (A e B) na porta lógica OR, teremos expressão booleana,

x = A + B (1)

Onde lê “x é igual a A ou B”. A saída (x) é igual a 0 (nível baixo) somente se ambas entradas forem iguais a 0, se pelo menos uma das entradas for igual a 1 (nível alto) ou ambas iguais a 1, a saída será 1. A tabela-verdade da função OR está presente na Figura 4(a). Esta operação é semelhante à adição da álgebra convencional, porém não satisfaz quando as duas entradas forem iguais a 1, pois na álgebra booleana 1+1=1. Na Figura 4(b) é apresentado o símbolo para representação da porta lógica OR.

Figura 4 – Porta lógica OR

(22)

2.2.1.2 Porta AND

A operação AND (E) é a segunda operação booleana básica que precisa de duas ou mais entradas para que gere uma saída, e na álgebra booleana é representada por ‘∙’, podendo ser equivalente à multiplicação da álgebra convencional, a Figura 5(a) mostra as possíveis combinações entre duas entradas e sua saída gerada. A expressão é dada para duas entradas como,

x = A ∙ B (2)

Onde lê “x é igual a A e B”, e como já foi dito, a saída (x) só é nível alto quando todas as entradas forem também, caso contrário, a saída é igual a 0. A Figura 5(b), está representado o símbolo da porta AND nos diagramas de circuitos digitais.

Figura 5 – Porta lógica AND

2.2.1.3 Porta NOT

A operação NOT (NÃO) ou Inversa é uma operação realizada somente com uma entrada, diferente das operações anteriores, a expressão pode ser escrita como,

x = Ᾱ ou x = ‘A (3)

A barra em cima da entrada ou o apóstrofo (‘) indica a inversão da variável, onde se lê “x é igual a A negado” ou “x é igual ao complemento de A”. Como na álgebra booleana as variáveis só podem assumir o valor de 0 ou 1, o resultado da operação NOT será o oposto da entrada, ou seja, quando A=0 a saída será x=1 e quando A=1 a saída será x=0, como mostra a tabela-verdade (Figura 6(a)). E na Figura 6(b) vê-se o símbolo que representa a operação NOT nos diagramas de circuitos digitais/lógicos.

(23)

Figura 6 – Porta lógica NOT

2.2.1.4 Porta NOR

A operação NOR (NÃO-OU) é uma combinação das operações básicas OR e NOT. A porta NOR é muito utilizada em circuitos lógicos, sua expressão é dada por,

x=𝐴 + 𝐵̅̅̅̅̅̅̅̅ (4)

Onde é simplesmente a união da porta OR seguida da porta NOT, a tabela-verdade (Figura 7(c)) mostra as possíveis saídas com duas entradas, será o complemento das saídas da porta OR. Na Figura 7(a), o símbolo da porta NOR usado nos diagramas está representado. Na verdade, essa representação é a simplificação da combinação de duas portas lógicas (OR e NOT) Figura 7(b).

Figura 7 – Porta lógica NOR

(24)

2.2.1.5 Porta NAND

Como a operação anterior, a operação NAND (NÃO-E) é uma combinação de duas portas básicas (AND e NOT), e é bastante utilizada em circuitos lógicos, sua expressão é escrita na álgebra booleana é igual à operação AND, porém negada,

x=𝐴 ∙ 𝐵̅̅̅̅̅̅ (5)

A Figura 8(c) mostra todas as possíveis saídas com duas entradas, que consequentemente será a inversão da operação AND. Na Figura 8(a) representa o símbolo da porta NAND usado nos diagramas, que na verdade é a simplificação da combinação de duas portas lógicas (AND e NOT), Figura 8(b).

Figura 8 – Porta lógica NAND

2.2.1.6 Porta XOR

A operação OU-EXCLUSIVO (XOR) é um circuito especial, sua expressão booleana é dada como:

x=𝐴̅ ∙ 𝐵 + 𝐴 ∙ 𝐵̅ (6)

Esta expressão diz que, o valor da saída somente irá ser nível alto se as entradas forem de valores opostos, como mostra a tabela-verdade, na Figura 9(b). Na Figura 9(a) representa como a porta XOR é vista nos diagramas de circuitos digitais, e que sua expressão booleana geralmente é expressa por x=𝐴 ⊕ 𝐵.

(25)

Figura 9 – Porta lógica XOR

2.2.1.7 Porta XNOR

Esta operação também é um circuito especial, conhecida por NÃO-OU-EXCLUSIVO (COINCIDÊNCIA) ou simplesmente pela a sigla XNOR, sua expressão booleana é dada por:

x=𝐴 ∙ 𝐵̅̅̅̅̅̅ + 𝐴 ∙ 𝐵 (7) Ou seja, a saída só assume valor lógico 1 quando as entradas tem o mesmo nível lógico, A=B=1 ou A=B=0, como mostra a Figura 10(b). A operação XNOR é o complemento da operação XOR. A Figura 10(a) ilustra sua representação, e que geralmente é expressa por x=𝐴 ⊙ 𝐵.

Figura 10 – Porta lógica XNOR

2.2.2 Latch e Flip-Flops

Os circuitos lógicos citados até agora são circuitos combinacionais, pois o nível lógico da saída em qualquer instante de tempo só depende das entradas naquele mesmo instante. Nenhuma entrada anterior vai afetar as entradas atuais, visto que circuitos combinacionais não possuem memória. O elemento de memória mais importante é o flip-flop (FF) que é composto por portas lógicas (TOCCI; WIDMER; MOSS, 2011).

(26)

Portas lógicas por si só não armazena informações, porém nos latchs são portas lógicas realimentadas, ou seja, conectam-se as saídas das portas de volta as entradas de portas apropriadas. Os latchs têm duas saídas, a saída normal 𝑄 e a saída invertida 𝑄̅. Sempre o latch está relacionado com sua saída normal (𝑄). O flip-flop é uma particularidade do latch, pois são latchs sincronizados pelo um sinal de clock (TOCCI; WIDMER; MOSS, 2011).

2.2.2.1 Latch com portas NAND

O latch com portas NAND é composto por duas portas NAND interligadas entre si de modo cruzado (Figura 11(a)), a saída da porta 1 esta conectada na entrada da porta 2, e vice-versa. Neste latch existem dois tipos de entradas, a SET e RESET, normalmente estão em repouso quando ambas estão em nível alto (1). A Figura 11(a) apresenta a tabela-verdade com as possíveis entradas e saídas (TOCCI; WIDMER; MOSS, 2011).

Figura 11 – Latch com portas NAND

Fonte TOCCI; WIDMER; MOSS (2011)

Para “setar” este latch, precisa-se colocar a entrada SET em nível baixo, e RESET em nível alto, e para “resetar” o oposto, caso SET=RESET=0, a saída será invalida, pois 𝑄 e 𝑄̅ não pode assumir os mesmo valores.

2.2.2.2 Latch com portas NOR

O latch com portas NOR é composto por duas portas NOR, análogo ao latch com portas NAND (Figura 12(a)). Diferente do latch anterior, este fica em repouso quando SET=RESET=0, consequentemente será “setado” (Q=1) quando SET=1, e “resetado” quando RESET=1. Como mostra a tabela-verdade (Figura 12(b)), as entradas serão inválidas quando

(27)

SET=RESET=1, pois 𝑄 e 𝑄̅ não pode assumir os mesmo valores (TOCCI; WIDMER; MOSS, 2011).

Figura 12 – Latch com portas NOR

2.2.2.3 Flip-flop S-R

O Flip-flop S-R é um flip-flop síncrono, ou seja, os momentos exatos para que a saída possa mudar de estado são determinados por um sinal de clock. Os latchs (flip-flop sem clock) citados anteriormente são assíncronos, pois as saídas podem mudar no mesmo instante de tempo que as entradas também mudarem. Resumindo, o FF S-R é um latch com portas NOR com uma entrada de sinal de clock. (TOCCI; WIDMER; MOSS, 2011)

Na Figura 13(b), mostra a tabela-verdade do flip-flop S-R, em que o clock é representado pela a sigla CLK, e seta para cima (↑) representa que o FF é acionado na borda de subida do sinal do clock, porém os flip-flops também podem ser disparados com a borda de descida (↓). Na Figura 13(a), pode-se visualizar a representação do flip-flop S-R com disparo na borda de subida.

Figura 13 - Representação do Flip-flop S-R disparado na borda de subida.

(28)

2.2.2.4 Flip-flop J-K

Este flip-flop é similar ao flip-flop S-R, as mesmas condições das entradas geram as mesmas saídas, exceto quando J=K=1, pois no FF S-R quando as entradas são iguais a 1 gera uma saída ambígua, e no FF J-K a saída Q muda para seu estado lógico oposto no instante da borda de subida/descida, esta operação de comutação é bastante utilizada em todos os tipos de contadores. Em resumo o flip-flop J-K faz tudo que o flip-flop S-R pode fazer, além de comutar a saída (TOCCI; WIDMER; MOSS, 2011).

Na Figura 14(b) mostra as possíveis entradas do FF J-K e suas respectivas saídas, no exemplo, foi utilizado o FF acionado na borda de subida representado por (↑), conforme visto na Figura 14(a), mas existem FF acionado na borda de descida do sinal de clock no qual são representados pela a seta para baixo (↓).

Figura 14 - Representação do Flip-flop J-K disparado na borda de subida

2.2.2.5 Flip-flop D

Ao contrário dos flip-flops S-R e J-K, o flip-flop D tem apenas uma entrada (D). Seu funcionamento é bem simples, quando D=1, Q será nível alto e quando D=0, Q será nível baixo, ou seja, a saída terá o mesmo valor da entrada. O FF irá armazenar o valor da entrada na próxima borda de subida/descida do clock. (TOCCI; WIDMER; MOSS, 2011)

Na Figura 15(c), pode-se ver a tabela-verdade do FF D acionado na borda de subida. Na Figura 15(a) mostra a implementação do FF D a partir de um FF J-K, a entrada D é diretamente ligada com a entrada J e seu complemento na entrada K, essa implementação pode-se ser feita também no FF S-R que terá o mesmo resultado.

(29)

Figura 15 - Representação do Flip-flop D

2.2.2.6 Flip-flop T

O flip-flop T também tem apenas uma entrada (T), quando a entrada está em nível baixo, o valor da saída não mudará, irá ser igual à saída anterior, e quando T=1, a saída irá comutar na próxima borda de subida/descida do clock (Figura 16(c)). (VERTULO, 2015)

Este flip-flop é uma variação do flip-flop J-K, a entrada T é ligada diretamente na entrada J e K (Figura 16(a)), com isso, o FF T assumirá os resultados do FF J-K quando J=K=1 e J=K=0.

Figura 16 - Representação do Flip-flop T

Fonte: adaptado de TOCCI; WIDMER; MOSS (2011)

2.2.2.7 Flip-flop J-K com entradas assíncronas

As entradas dos flip-flops ditas até agora são entradas síncronas, ou seja, seus valores têm efeitos à saída quando sincronizada com a entrada do clock. As entradas assíncronas operam independente da entrada de clock. Tais entradas podem colocar o FF em valores 1 ou 0 em qualquer instante, independente de qualquer entrada assíncrona, essas entradas são conhecidas como PRESET (𝑃𝑅𝐸̅̅̅̅̅̅), que conduzira o FF a ter valores Q=1 , e CLEAR (𝐶𝐿𝑅̅̅̅̅̅̅), que conduzira o Q=0. Estas entradas geralmente são ativas em níveis baixos, a Figura 17(b)

(30)

representa as possíveis combinações de entradas e suas respectivas saídas, este flip-flop também foi desenvolvido no trabalho para algumas aplicações como contadores. Na Figura 17(a), tem-se a representação do flip-flop J-K com entradas assíncronas e disparado na borda de descida (TOCCI; WIDMER; MOSS, 2011).

Figura 17 – Flip-flop J-K disparado na borda de descida com entradas assíncronas

(31)

3 DESENVOLVIMENTO E TESTES

Inicialmente, foi estudada a plataforma para analisar as possíveis funções que poderiam ser relacionadas com a disciplina. Foi escolhido o Arduino Uno para realização do trabalho devido ser o mais popular, clássico e com o melhor custo benefício para a realizar o suporte didático para a disciplina de Circuitos Digitais. Suas 14 portas de entrada e saída digital é suficiente para a maioria das práticas com álgebra booleana

Para melhores estudos da plataforma, foi utilizado o aplicativo on-line Tinkercad (que uma das suas funções é simular o Arduino Uno) no início do trabalho para poder estabelecer quantos componentes iriam ser utilizados, como resistores, LEDs, push-buttons.

Logo após foi analisado o plano de curso da disciplina, precisamente o plano de curso da disciplina Circuitos Digitais ofertado pelo curso Bacharelado em Ciência e Tecnologia da UFERSA Câmpus Pau dos Ferros, e estudado os assuntos que poderiam ser auxiliados pelo Arduino. Com isso, o assunto base da disciplina, portas lógicas, é a base para construção de circuitos digitais e, que as mesmas podem ser representadas facilmente com a plataforma. Assim, utilizando a linguagem de programação do Arduino, que é semelhante à linguagem C/C++ e, que também é estudada no mesmo curso, é um excelente apoio.

Finalmente foram desenvolvidas funções na linguagem de programação do Arduino que pudessem simular as portas lógicas. Como na linguagem de programação existem operadores básicos booleanos representados por ‘&&’ (AND), ‘||’ (OR) e ‘!’(NOT), não houve muitas dificuldades, com isso, foram elaboradas as demais operações booleanas e os flip-flops. Em seguida, foram construídas algumas aplicações com os flip-flops, como contadores síncronos e assíncronos e deslocamentos de bits.

Como os circuitos digitais necessitam de entradas para gerarem saídas, foram utilizados push-buttons para representarem as entradas, que quando forem pressionados estarão representando o valor lógico 1, e quando estiverem no estado de repouso estarão representando o valor lógico 0. Todo o circuito digital será substituído pela a programação seguindo a mesma lógica de um circuito real. E por fim as saídas serão representadas por LEDs, que quando estiverem apagados indicaram valores lógicos 0, e quando acessos representaram o valor 1.

Os testes foram feitos no laboratório de Eletrônica e Automação (LeAut) da UFERSA Câmpus Pau dos Ferros utilizando os componentes disponíveis, tais como: protoboard, LED, resistores, push-buttons e fios conforme visualizado na Figura 18. A Tabela 2, tem-se a representação da quantidade de componentes utilizados no desenvolvimento do trabalho.

(32)

Figura 18 – Testes do trabalho

Fonte: Autor (2018)

Tabela 2 – Componentes utilizados para testes

Componentes Quantidades Arduino Uno 1 Protoboard 1 Resistor (100 Ohm) 4 LEDs 4 Push-button 4 Fios 18 Fonte: Autor (2018) 3.1 PROGRAMAÇÃO

Após a montagem do circuito no protoboard, são necessárias as especificações de cada pino digital do Arduino, assim foi atribuído o número de cada pino digital utilizando o comando #define que atribuirá uma constante que indica sua função respectivamente e o valor do período do clock em milissegundos na constante CLK (pode ser alterado), presente no Apêndice.

(33)

Constantes “porta-i” indicam em quais pinos digitais estão conectados os push-buttons e as constantes “ledout-i” indicam onde estão conectados os LEDs. Foi considerado que o push-button mais à esquerda será conectado ao pino digital 2, consequentemente será representado pela a constante “porta1”, e o push-button mais â direita será representado pela a constante “porta4”. E os LEDs, que o mais a direita (verde) foi considerado como o “ledout1” e o mais a esquerda como “ledout4” que consequentemente está conectado no pino digital 10. Na Figura 19estão ilustradas as conexões da Figura 18, para melhor compreensão.

Figura 19 – Ilustração do trabalho

Fonte: adaptado de Tinkercad (2018)

Na função void setup() foram especificados as entradas e saídas utilizando a função pinMode(): pinMode(ledout1, OUTPUT); pinMode(ledout2, OUTPUT); pinMode(ledout3, OUTPUT); pinMode(ledout4, OUTPUT); pinMode(porta1, INPUT_PULLUP); pinMode(porta2, INPUT_PULLUP);

(34)

pinMode(porta3, INPUT_PULLUP); pinMode(porta4, INPUT_PULLUP);

Os LEDs foram indicados como saídas (OUTPUT) e os push-buttons como entradas (INPUT_PULLUP). Para simplificar o circuito foi adotado o método de “input_pullup” para os push-buttons, este método possibilita a redução de componentes como fios e resistores para implementar o push-button no Arduino, porém, quando o push-button está em repouso, ele assumirá o valor “HIGH” (nível alto) e pressionado será “LOW” (nível baixo), isto é o oposto do que foi dito. Para consertar este erro, foi invertido o valor lógico na leitura dos push-buttons.

Na função void loop() do Arduino, é onde vai ocorrer todo processo lógico da programação. A leitura das entradas foi feita através da função digitalRead():

A=!digitalRead(porta1); B=!digitalRead(porta2); C=!digitalRead(porta3); D=!digitalRead(porta4);

Houve a declaração das variáveis A, B, C e D do tipo inteiro para armazenamento dos valores lidos dos push-buttons respectivamente. Nota-se que as variáveis recebem o complemento do valor lido da função digitalRead() devido o ‘!’, para consertar o erro mencionado. Com isso, as variáveis A, B, C e D serão atribuídas valor lógico HIGH quando os push-buttons mantiverem pressionados respectivamente e valor LOW quando estiverem em repouso.

3.1.1 Funções das Portas Lógicas

Com as entradas e saídas declaradas, foram criadas funções para representarem as funções lógicas da álgebra booleana. Para que as portas lógicas tivessem uma quantidade de entradas variadas, sem haver um valor fixo, foi preciso a inclusão da biblioteca “stdarg.h” da linguagem C.

(35)

3.1.1.1 Operação OR

A operação OR representada no Arduino ficou no seguinte formato: Código 01 – Função OR

int OR(int quant,...){ int saida=0,i; va_list ent;

va_start(ent,quant); for(i=0;i<quant;i++){

int entrada = va_arg(ent,int); saida=(saida || entrada);

}

va_end(ent); return(saida); }

É uma função do tipo inteiro, porém só retornará valores lógicos (0 ou 1), todo o trabalho poderia trabalhar somente com variáveis do tipo booleana, mas a biblioteca “stdarg.h” não trata com esse tipo de variável.

O primeiro parâmetro “int quant” será o valor da quantidade de entradas que a operação receberá.

Como o teorema booleano do OR diz que: qualquer entrada ou 0 = qualquer entrada (x + 0 = x) (TOCCI; WIDMER; MOSS, 2011), assim a variável de saída “int saida=0” incialmente.

A variável do tipo “va_list” e as funções “va_start()” e “va_end()” estão inclusas na biblioteca citada. Em resumo o laço de repetição “for” irá repetir quant-vezes (quantidade de entradas) e em cada repetição irá armazenar o valor da próxima entrada na variável “int entrada” e em seguida será executada a operação “saida || entrada” e armazenar na variável “saida”, como a operação OR (||) é associativa, pode-se acumular deste modo. Por fim a função retornará a variável “saida” com o valor final da operação.

A chamada desta função na função void loop() do programa ficará:

saida=OR(3,A,B,C);

(36)

Ao declarar uma variável tipo inteiro para armazenar o valor da função OR (int saida), pode-se chamar a função com os parâmetros mostrados, 3 (devido ter 3 entradas) e as variáveis A, B e C que representam os push-buttons. A função digitalWrite() é que acenderá ou apagará o LED (ledout1 no exemplo) para representação da saída, apagado representará valor lógico 0 e aceso 1. Consequentemente, o valor da variável “saida=0” irá apagar o LED e se “saida=1” irá acender.

3.1.1.2 Operação AND

A operação AND representada no Arduino ficou no seguinte formato: Código 02 – Função AND

int AND(int quant,...){ int saida=1,i; va_list ent;

int entrada = va_arg(ent,int); saida=(saida && entrada);

}

O corpo da função é semelhante à operação OR mostrada, o que diferenciará é que a operação AND tem o teorema booleano que diz: qualquer entrada e 1 = qualquer entrada (x ∙ 1 = x) (TOCCI; WIDMER; MOSS, 2011), assim a variável de saída “int saida=1” incialmente. E será atribuída à variável de saída da função a operação “saida && entrada”.

A chamada desta função na função void loop() do programa ficará:

saida=AND(4,A,B,C,D); digitalWrite(ledout1,saida);

Análogo o que já foi dito, este exemplo demonstra a operação AND recebendo 4 entradas, e o LED (ledout1) exibirá o valor da saída devido ao digitalWrite(). Neste exemplo o LED só acenderá se os quatros push-buttons mantiverem pressionados.

(37)

3.1.1.3 Operação NOT

Está operação é bem simples de ser representada, pode-se usar a função criada: Código 03 – Função NOT

int NOT(int entrada){ return(!entrada); }

Ou simplesmente adicionar o símbolo ‘!’ antes da variável booleana, pois a linguagem de programação C permite isto, exemplo no void loop():

saida=NOT(A); ou saida=!A;

digitalWrite(ledout1,saida);

O LED (ledout1) acenderá se o push-button tiver em repouso, e apagará se estiver pressionado.

3.1.1.4 Operação NOR

A operação NOR representada no Arduino ficou no seguinte formato: Código 04 – Função NOR

int NOR(int quant,...){ int saida=0,i; va_list ent;

int entrada = va_arg(ent,int); saida=(saida || entrada); }

va_end(ent); return(!saida); }

Similar à operação OR, porém retornará o complemento da saída da operação OR. Seu exemplo no corpo da função void loop() será similar:

(38)

saida=NOR(4,A,B,C,D); digitalWrite(ledout1,saida);

3.1.1.5 Operação NAND

A operação NAND representada no Arduino ficou no seguinte formato: Código 05 – Função NAND

int NAND(int quant,...){ int saida=1,i; va_list ent;

int entrada = va_arg(ent,int); saida=(saida && entrada);

}

Similar à operação AND, porém retornará o complemento da saída da operação AND. Seu exemplo no corpo da função void loop() será similar:

saida=NAND(4,A,B,C,D); digitalWrite(ledout1,saida);

3.1.1.6 Operação XOR

A operação XOR ficou representada no seguinte formato: Código 06 – Função XOR

int XOR(int ent1,int ent2){ return (ent1 ^ ent2); }

A função é bem simples devida que na linguagem C existe um operador que representa o XOR, o operador é o ‘^’, foi considerado que a função receberá uma quantidade fixa de

(39)

parâmetros, que será somente dois parâmetros. Assim a função retornará o resultado da operação.

3.1.1.7 Operação XNOR

A operação XNOR ficou representada no seguinte formato: Código 07 – Função XNOR

int XNOR(int ent1,int ent2){ return !(ent1 ^ ent2); }

Análogo à função XOR, esta função também terá dois parâmetros como entradas e, como o XNOR é o complemento do XOR, então retornará a operação ou-exclusivo negado. Seu exemplo no corpo da função void loop() ficará:

saida=XNOR(A,B);

3.1.2 Funções dos Latchs e Flip-flops

Como os Latchs e FFs geram duas saídas, foi criada uma estratégia para que as funções retornassem os dois valores de saídas, com isso a estratégia utilizada foi criar um struct (registro) que contém dois valores tipo inteiro, 𝑄 e 𝑄̅.

Código 08 – Registro do Flip-flop typedef struct ff Flip_Flop; struct ff{

int Q; int Q_; };

O registro será indicado como “Flip_Flop” e a saída que será representada por ‘Q’ e seu complemento por ‘Q_’. Para

Para utilizar um Latch ou FF, precisa-se declarar um variável tipo Flip_Flop e atribuir valores zeros para que não aconteça erro:

Flip_Flop FF1={0,0};

(40)

3.1.2.1 Latch NAND

Como mostra a Figura 11(a) o latch NAND é composto por duas portas lógicas NAND, com isso foi criado uma função contendo as funções da operação NAND já citadas, assim:

Código 09 – Função Latch NAND

Flip_Flop latch_NAND(int set, int reset,Flip_Flop flip){ flip.Q=NAND(2,set,flip.Q_);

flip.Q_=NAND(2,reset,flip.Q); return flip;

}

Os parâmetros são as entradas comuns do latch, o SET como primeiro parâmetro, o RESET como segundo, e o terceiro é o próprio registro do FF, pois ele será alterado e será o retorno da função com saídas modificadas. Após declarar uma variável do tipo Flip_Flop, esta função em void loop() ficará:

FF1= latch_NAND (A,B,FF1); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

A entrada ‘A’ representar o SET, e a ‘B’ o RESET, como a função é do tipo Flip_Flop, a variável declarada anteriormente receberá a função, o ideal é que após a execução da mesma, em seguida seja executado o comando de representar as saídas (digitalWrite();) como já foi mencionado.

3.1.2.2 Latch NOR

O latch NOR foi representado com o mesmo procedimento, seguindo a base de sua representação, composto por duas portas NOR, sua função ficou:

Código 10.1 – Função Latch NOR

Flip_Flop latch_NOR(int set, int reset,Flip_Flop flip){ flip.Q=NOR(2,reset,flip.Q_);

flip.Q_=NOR(2,set,flip.Q); return flip;

(41)

Com a mesma ordem de parâmetros da função “latch_NAND”, e será similar sua representação no void loop();:

FF1= latch_NOR (A,B,FF1); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

Foi criado outra alternativa de função, com base na tabela-verdade, onde usam comandos de condições para gerar as saídas:

Código 10.2 – Função Latch NOR

Flip_Flop latch_NOR (int set,int reset,Flip_Flop flip){ if(!set && reset){

flip.Q=LOW;

flip.Q_=HIGH;

}else if(set && !reset){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(set && reset){

flip.Q=LOW;

flip.Q_=LOW;

}

return flip; }

Esta alternativa contém os mesmo parâmetros e a mesma saída, porém não é formada com portas lógicas.

3.1.2.3 Clock

O clock foi representado por uma variável do tipo inteiro, “int clock=0” que inicialmente foi declarado e atribuído o valor zero, e para representar o sinal como todo, foi declarada outra variável e atribuída o valor zero, “int tempo=0”. O sinal de clock no void loop() ficou:

(42)

Código 11 – Representação do Clock delay(10); tempo+=10; if(tempo>CLK){ tempo=0; } if(tempo==CLK/2){ clock=1; }else{ clock=0; }

Inicialmente, a linguagem de programação do Arduino tem uma função delay() que pausa sua execução em um determinado tempo em milissegundos, no exemplo foi pausado 10 milissegundos, logo após a variável tempo será incrementado de 10, consequentemente, estará acumulando o tempo da pausa, em seguida, terá um comando de condição, caso o tempo seja maior que a constante CLK (o tempo do período do clock em milissegundos) ele será zerado. Se o tempo for igual à metade do período, o clock será atribuído de 1, se não, 0, isso representará a borda de descida ou subida quando clock=1.

3.1.2.4 Flip-flop S-R

O FF S-R foi representado com portas lógicas, mas diferente das funções anteriores, os FFs precisam de um parâmetro a mais, que será o clock, e foi elaborado conforme a Figura 20. Assim:

Código 12 – Função Flip-flop S-R

Flip_Flop FF_SR(int S,int R,Flip_Flop flip,int clock){ flip.Q=NAND(2,NAND(2,S,clock),flip.Q_); flip.Q_=NAND(2,NAND(2,R,clock),flip.Q); return flip;

(43)

Figura 20 – Circuito interno do Flip-flop S-R

A função retornará a saída de acordo com as entradas que foram mostradas na tabela-verdade. Pode-se representar com comando de repetições como foi citado, porém o código fica menor representado somente com a combinação de portas lógicas. A função será chamada como:

FF1= FF_SR (A,B,FF1,clock); digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

Quando o clock=1 representará a borda de subida ou descida, assim irá satisfazer a tabela-verdade.

3.1.2.5 Flip-flop J-K

A função do FF J-K foi construída similar à função “FF_SR” com as funções das portas lógicas, e com seus parâmetros com entradas respectivamente, e foi desenvolvida como apresenta na Figura 21, com isso terá:

Código 13 – Função Flip-flop J-K

Flip_Flop FF_JK (int J,int K,Flip_Flop flip,int clock){ int a=NAND(3,J,flip.Q_,clock);

int b=NAND(3,K,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_);

(44)

flip.Q_=NAND(2,b,flip.Q); return flip;

}

Figura 21 – Circuito interno do Flip-flop J-K

3.1.2.6 Flip-flop D

Esta função terá o mesmo corpo da função do Flip-flop J-K, porem com apenas uma entrada síncrona:

Código 14 – Função Flip-flop D

Flip_Flop FF_D(int D,Flip_Flop flip,int clock){ int a=NAND(3,D,flip.Q_,clock); int b=NAND(3,!D,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_); flip.Q_=NAND(2,b,flip.Q); return flip; }

(45)

3.1.2.7 Flip-flop T

Análogo ao FF D, terá somente uma entrada síncrona, e a mesma quantidade de parâmetros, sendo o primeiro a entrada “T”.

Código 15.1 – Função Flip-flop T

Flip_Flop FF_T(int T,Flip_Flop flip,int clock){ int a=NAND(3,T,flip.Q_,clock); int b=NAND(3,T,flip.Q,clock); flip.Q=NAND(2,a,flip.Q_); flip.Q_=NAND(2,b,flip.Q); return flip; }

Como já foi dito, o valor da entrada “T” equivale à entrada “J” e “K” simultâneo em um FF J-K. O FF T também pode ser representado por comandos de condições, e ficará bem simples:

Código 15.2 – Função Flip-flop T

Flip_Flop FF_T(int T,Flip_Flop flip,int clock){ if(clock==1){ if(T==1){ flip.Q_=flip.Q; flip.Q=!flip.Q; } } return flip; }

E como todos os FFs citados, sua representação no void loop() é: FF1= FF_T(A,FF1,clock);

digitalWrite(ledout1,FF1.Q); digitalWrite(ledout2,FF1.Q_);

3.1.2.8 Flip-flop J-K com entradas assíncronas

Como FFs com entradas assíncronas têm mais entradas do que o normal, consequentemente têm mais parâmetros. Foram adicionados mais dois parâmetros para

(46)

representações das entradas CLEAR e PRESET e o corpo da função foi representado por comandos de condições.

Código 16 – Função Flip-flop J-K com entradas assincronas

Flip_Flop FF_JKassincrono(int J,int K,int CLR,int PRE,Flip_Flop flip,int clock){ if(CLR==1 && PRE==1){

if(clock==1){ if(!J && K){

flip.Q=LOW;

flip.Q_=HIGH;

}else if(J && !K){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(J && K){

flip.Q=!flip.Q;

flip.Q_=!flip.Q_;

}

}else if(CLR==1 && PRE==0){

flip.Q=HIGH;

flip.Q_=LOW;

}else if(CLR==0 && PRE==1){

flip.Q=LOW; flip.Q_=HIGH; }else{ flip.Q=LOW; flip.Q_=LOW; } return flip; }

O primeiro comando de condição irá verificar se as entradas assíncronas são iguais a 1, com isso o flip-flop comportará como síncrono, se não vai mudar os valores de saída sem verificar o valor do clock. Sua “chamada” no corpo da função void loop() ficou:

(47)

FF1=FF_JKassincrono(A,B,!C,!D,FF1,clock); digitalWrite(ledout1,FF1.Q);

digitalWrite(ledout2,FF1.Q_);

Como as entradas assíncronas são ativas em nível baixo, ficou mais viável usar o complemento dos valores dos push-buttons referentes às mesmas, ‘!C’ para o CLR e ‘!D’ para o PRE.

3.2 TESTES

Com as funções básicas já representadas, portas lógicas e flip-flops, é possível realizar diversas aplicações, como montar um circuito combinacional com inúmeras portas lógicas e construção de contadores com os FFs.

3.2.1 Circuitos Combinacionais

Um circuito combinacional é um conjunto de portas lógicas que a saída vai depender do modo que elas estejam agrupadas, um exemplo de circuito combinacional:

Figura 22 – Circuito Combinacional

Este circuito (Figura 22) pode ser expresso utilizando as funções das operações lógicas como:

Código 17.1 – Representação do Circuito combinacional x=(𝐴 + 𝐵) ∙ (𝐵̅ + 𝐶) saida=AND(2,OR(2,A,B),OR(2,!B,C));

Para melhor entendimento pode-se declarar duas variáveis ‘X’ e ‘Y’ para receber os valores das portas OR:

(48)

Código 17.2 – Representação do Circuito combinacional x=(𝐴 + 𝐵) ∙ (𝐵̅ + 𝐶) X=OR(2,A,B); Y=OR(2,!B,C); saida=AND(2,X,Y); digitalWrite(ledout1,saida); 3.2.2 Registradores de Deslocamento

Um registrador de deslocamento é um conjunto de FFs agrupados de forma que o valor de armazenamento de um seja deslocado para o FF seguinte em cada pulso de clock. Este tipo de agrupamento é feito com flip-flops J-K ou simplesmente D. Na Figura 23 está mostrado um registrador de deslocamento com FFs J-K, onde o primeiro FF vai transferir sua informação para o próximo, e o segundo para o terceiro e, assim sucessivamente, até que a cada pulso de clock o 𝑋3 irá transferir seu valor para 𝑋2 e 𝑋2 transferirá seu valor para 𝑋1

antes de assumir o valor de 𝑋₃, desta forma o valor lógico do primeiro FF será transferido para os demais a cada pulso de clock. (TOCCI; WIDMER; MOSS, 2011)

Figura 23 – Registrador de Deslocamento

Esta aplicação foi representada da seguinte forma no Arduino:

Código 18 – Representação de uma Registrador de Deslocamento com 4 bits FF4=FF_D(FF3.Q,FF4,clock);

digitalWrite(ledout4,FF4.Q); FF3=FF_D(FF2.Q,FF3,clock); digitalWrite(ledout3,FF3.Q); FF2=FF_D(FF1.Q,FF2,clock);

(49)

digitalWrite(ledout2,FF2.Q); FF1=FF_D(A,FF1,clock); digitalWrite(ledout1,FF1.Q);

Foram utilizadas as funções do Flip-flop D, e foi declarado quatro variáveis do tipo Flip_Flop para representar cada um, o FF1 representou o primeiro flip-flop e o FF4 o último, desta forma, o FF1 receberá o primeiro valor, que será dado pela a entrada A. As saídas de cada flip-flop é representada pelos os “ledout-i”, desta forma a cada sinal de clock o “ledout1” passará seu valor lógico para o “ledout2”, que no próximo sinal de clock o “ledout2” passará para o “ledout3” e assim sucessivamente. Para exemplificar foram utilizados quatros FFs, consequentemente quatro LEDs, porém no Arduno Uno é possível realizar um deslocamento com 13 LEDs, pois uma porta digital deve ser reservada para a primeira entrada.

3.2.3 Contadores Assíncronos

O contador assíncrono tem a função de contar em forma binária. É construído a partir de flip-flops J-K ou T de modo que todos os FFs tenham suas entradas síncronas iguais a 1, ou seja, J=K=1 ou para o FF T, T=1. E a entrada do sinal de clock será o valor da saída Q do flip-flop anterior, como mostra a Figura 24. O tempo de incremento da contagem é denominado pelo o período do clock, o FF que recebe o sinal do clock representa o bit menos significativo (LSB). (TOCCI; WIDMER; MOSS, 2011)

Figura 24 – Contador Assíncrono

Como a entrada do clock do FF é ativado com o valor do anterior, na transição de Q=1 para Q=0, pois é ativado na borda de descida, foi implementado na programação da seguinte forma:

(50)

Código 19 – Sinal de clock com a saída do FF anterior if(!FF1.Q && q_ant1){

clock2=1; }else{

clock2=0; }

q_ant1=FF1.Q;

Precisam-se declarar duas variáveis do tipo inteiro (para cada FF) para representar este sistema, a “q_ant1” guardará o valor anterior da saída do FF anterior, e “clock2” representará a borda de descida quando “clock2=1”, isso acontece quando o valor da saída do FF anterior (FF1.Q) é igual a 0, e o valor anterior desta saída for igual a 1. Com isso, um contador assíncrono com quatro FF T que contará de 0000 a 1111 (0 a 15) ficará:

Código 20 – Representação de um Contador Assíncrono FF1=FF_T(1,FF1,clock);

digitalWrite(ledout1,FF1.Q); if(!FF1.Q && q_ant1){ clock2=1; }else{ clock2=0; } q_ant1=FF1.Q; FF2=FF_T(1,FF2,clock2); digitalWrite(ledout2,FF2.Q); if(!FF2.Q && q_ant2){ clock3=1; }else{ clock3=0; } q_ant2=FF2.Q; FF3=FF_T(1,FF3,clock3); digitalWrite(ledout3,FF3.Q); if(!FF3.Q && q_ant3){

(51)

clock4=1; }else{ clock4=0; } q_ant3=FF3.Q; FF4=FF_T(1,FF4,clock4); digitalWrite(ledout4,FF4.Q);

O FF1 será o bit menos significativo e o FF4 o mais significativo. O “clock-i” representará a borda de descida para ativar o “FF-i”.

3.2.4 Contadores Síncronos

O contador síncrono também tem a função de contar e composto por flip-flops J-K ou T, porém todos os FFs são sincronizados com um único sinal de clock, e também são compostos por portas AND (Figura 25). As entradas síncronas do primeiro FF (á direita) são iguais a 1, e os demais FF tem como entrada o resultado da operação AND das saídas dos FFs anteriores. (TOCCI; WIDMER; MOSS, 2011)

Figura 25 – Contador Síncrono

(52)

Código 21 – Representação de um Contador Síncrono FF4=FF_T(AND(3,FF1.Q,FF2.Q,FF3.Q),FF4,clock); digitalWrite(ledout4,FF4.Q); FF3=FF_T(AND(2,FF1.Q,FF2.Q),FF3,clock); digitalWrite(ledout3,FF3.Q); FF2=FF_T(FF1.Q,FF2,clock); digitalWrite(ledout2,FF2.Q); FF1=FF_T(1,FF1,clock); digitalWrite(ledout1,FF1.Q);

Onde o FF1 e o “ledout1” representam o bit menos significativo e o FF4 e “ledout4” o mais significativo. Contadores têm sua contagem limitada pela a quantidade de flip-flops, suas contagens binarias vão de 0 até 2𝑁− 1, onde N é a quantidade de FFs.

Para limitar a contagem de um contador síncrono pode-se utilizar FFs com entradas assíncronas para determinar um intervalo fixo de contagem, como mostra a Figura 26, por exemplo, a contagem é realizada no intervalo de 0 a 9 em binário. Contadores com intervalo fixo de contagem também podem ser construídos com contadores assíncronos.

Figura 26 – Contador Síncrono 0 a 9

Desta forma foi representado com funções do FF J-K assíncrono, e a variável para zerar todos os FFs foi declarada como “assinc”, assim temos que:

(53)

Código 22 – Representação de um Contador Síncrono de contagem 0 a 9 assinc=NAND(2,FF2.Q,FF4.Q); FF4=FF_JKassincrono(AND(3,FF1.Q,FF2.Q,FF3.Q),AND(3,FF1.Q,FF2.Q,FF3.Q),assinc,1,F F4,clock); digitalWrite(ledout4,FF4.Q); FF3=FF_JKassincrono(AND(2,FF1.Q,FF2.Q),AND(2,FF1.Q,FF2.Q),assinc,1,FF3,clock); digitalWrite(ledout3,FF3.Q); FF2=FF_JKassincrono(FF1.Q,FF1.Q,assinc,1,FF2,clock); digitalWrite(ledout2,FF2.Q); FF1=FF_JKassincrono(1,1,assinc,1,FF1,clock); digitalWrite(ledout1,FF1.Q);

(54)

4 CONSIDERAÇÕES FINAIS

Neste trabalho exemplificou algumas formas de incluir experimentos práticos da disciplina Circuitos Digitais utilizando a plataforma Arduino Uno. Foram utilizados 8 pinos de entrada e saída digital para a realização dos testes das funções desenvolvidas, sendo que, a biblioteca de funções não é limitada pelas combinações possíveis de entrada e saída, e para projetos mais elaborados pode ser que precisam usar os 14 pinos possíveis. De forma prática o Arduino possibilita a representação de conceitos básicos de circuitos digitais, como as operações booleanas, e com isso sua utilização tem uma grande variação de possibilidades, podendo construir flip-flops, contadores, multiplexadores, elaboração de projetos, por exemplo. Também a manipulação de componentes eletrônicos possibilita o usuário uma base de conhecimento de circuitos. Uma forma hibrida por unir circuito e simulação, o Arduino é um grande auxiliador para a disciplina.

4.1 TRABALHOS FUTUROS

Uma das possíveis melhorias que podem ser feitas no trabalho:  Melhorar a representação do sinal do clock.

 Criar uma interface gráfica para melhor manipulação do usuário.  Acoplar uma plataforma de entradas e saídas já existentes.

(55)

5 REFERÊNCIAS BIBLIOGRÁFICAS

ARDUINO. What is Arduino?. 2018. Disponível em:

<www.arduino.cc/en/Guide/Introduction#>. Acesso em: 10 dez. 2017.

_________. Arduino Uno Rev3. 2018. Disponível em: <https://store.arduino.cc/usa/arduino-uno-rev3>. Acesso em: 27 fev. 2018.

CARCHEDI, Luiz Carlos Carchedi. Comportamento Temporal de Circuitos Digitais Utilizando o Logisim. Trabalho de Conclusão de Curso. Universidade Federal de Juiz de Fora - UFJF, Juiz de Fora – MG, 2016.

CAVALCANTE, M. M. et al. A Plataforma Arduino para fins didáticos: Estudo de caso com recolhimento de dados a partir do PLX-DAQ. In: XXXIV CONGRESSO DA SOCIEDADE BRASILEIRA DE COMPUTAÇÃO, 2014, Brasília. CSBC 2014. Brasília, 2014, p. 1687-1696.

FRITZEN, Clovis. Implementando portas lógicas no Arduino. 2016. Disponível em: <http://fritzenlab.com.br/2016/10/implementando-portas-logicas-arduino/>. Acesso em: 14 dez. 2017.

JAMIESON, P. Arduino for teaching embedded systems. Are computer scientists and engineering educators missing the boat?. Proc. FECS, pp. 289-294, 2010.

LABORATORIO DE GARAGEM. Experimentos Básicos. 2017. Disponível em: <http://arduino.labdegaragem.com/Guia_preview/basicos.html>. Acesso em: 14 dez. 2017.

PEREZ, Anderson L. F. et al. Uso da Plataforma Arduino para o Ensino e o Aprendizado de Robótica. In: INTERNATIONAL CONFERENCE ON INTERACTIVE COMPUTER AIDED BLENDED LEARNING, 2013, Florianópolis. Conferência da ICBL2013. Florianópolis, 2013, p. 230-232.

SILVEIRA, S; GIRARDI, M. Desenvolvimento de um kit experimental com Arduino para o ensino de Física Moderna no Ensino Médio. Revista Brasileira de Ensino de Física, São Paulo, v. 39, n. 4, e4502, 2017.

(56)

TEOFILO, Francisco Lindolfo. Kit Didático para a prática de Circuitos Digitais. Trabalho de Conclusão de Curso. Universidade Federal Rural do Semi Árido - UFERSA, Pau dos Ferros – RN, 2015.

TINKERCAD. Tinkercad. 2018. Disponível em: <https://www.tinkercad.com/>. Acesso em: 01 abr. 2018.

TOCCI, R. J; WIDMER, N. S; MOSS, G. L. Sistemas Digitais: princípios e aplicações. 11. ed. São Paulo: Pearson Prentice Hall, 2011.

VERTULO, Rodrigo C. Tipos de Flip Flops – Flip Flop tipo T. 2015. Disponível em: <http://labdeeletronica.com.br/tipos-de-flip-flops-flip-flop-tipo-t/>. Acesso em: 02 abr. 2018.

(57)

APÊNDICE A – Código criado para representação de circuitos digitais //BIBLIOTECA DE SIMULAÇÃO DE CIRCUITOS DIGITAIS PARA ARDUINO //TRABALHO DE CONCLUSAO DE CURSO

//AUTOR: ROBSON THIAGO BATISTA REGO

#define porta1 2 #define porta2 3 #define porta3 4 #define porta4 5 #define ledout1 13 #define ledout2 12 #define ledout3 11 #define ledout4 10 #define CLK 2000

//biblioteca para funçoes com paramentros variaveis #include <stdarg.h>

//FF

typedef struct ff Flip_Flop; struct ff{ int Q; int Q_; }; //--- //PORTAS LOGICAS

int AND(int quant,...){ int saida=1,i;

va_list ent;

(58)

saida=(saida && entrada); }

int OR(int quant,...){ int saida=0,i; va_list ent;

int NOT(int entrada){ return(!entrada); }

int NAND(int quant,...){ int saida=1,i;

va_list ent;

int entrada = va_arg(ent,int); saida=(saida && entrada); }

(59)

int NOR(int quant,...){ int saida=0,i;

va_list ent;

int XOR(int ent1,int ent2){ return (ent1 ^ ent2); }

int XNOR(int ent1,int ent2){ return !(ent1 ^ ent2); }

//--- //latch NAND real

Flip_Flop latch_NAND(int set, int reset,Flip_Flop flip){ flip.Q=NAND(2,set,flip.Q_);

flip.Q_=NAND(2,reset,flip.Q); return flip;

}

//latch NOR real

Flip_Flop latch_NOR(int set, int reset,Flip_Flop flip){ flip.Q=NOR(2,reset,flip.Q_);

flip.Q_=NOR(2,set,flip.Q); return flip;

(60)

//latch NOR teorico

Flip_Flop latch_NORteorico(int set,int reset,Flip_Flop flip){ if(!set && reset){// 0 1

flip.Q=LOW; flip.Q_=HIGH;

}else if(set && !reset){// 1 0 flip.Q=HIGH;

flip.Q_=LOW;

}else if(set && reset){// 1 1 flip.Q=LOW; flip.Q_=LOW; } return flip; } //Flip-flop S-R teorico

Flip_Flop FF_SRteorico(int S,int R,Flip_Flop flip,int clock){ if(clock==1){

if(!S && R){// 0 1 flip.Q=LOW; flip.Q_=HIGH;

}else if(S && !R){// 1 0 flip.Q=HIGH;

flip.Q_=LOW;

}else if(S && R){// 1 1 flip.Q=LOW; flip.Q_=LOW; } } return flip; } //Flip-flop S-R REAL