Universidade Federal do Amazonas

Instituto de Computação
ICC060 – Sistemas Lógicos (SL) – 2018/2
Prof. Leandro Galvão

Atividade Prática 01 – Representação de Números Binários

em Arduino

OBJETIVOS:
• Avaliar respostas de um sistema computacional, usando a base binária.
• Praticar conversão de números da base decimal para a base binária, e vice-versa.
• Ganhar familiaridade com a placa Arduino e a IDE Arduino.

MATERIAIS:
• 01 placa Arduino Uno
• 08 resistores de 330 Ω
• 08 leds difusos
• 09 fios jumper macho-macho
• 01 protoboard

ATENÇÃO:
• Primeiro, monte os circuitos indicados. DEPOIS, conecte o Arduino à porta USB do compu-
tador.
• Não inverta os terminais do LED ao encaixá-lo na protoboard.

Experimento 1: LED pisca-pisca

Para ganhar familiaridade com o Arduino, vamos fazer o experimento “LED pisca-pisca”, mais co-
nhecido como blink. Nele, programaremos o Arduino para acender e apagar um LED (diodo emissor
de luz), causando o efeito pisca-pisca. Todo experimento com Arduino é composto por:

1. Um circuito eletrônico, como o da Figura 1, que você deve montar. Consulte o Apêndice,
no final deste Roteiro, caso você não tenha familiaridade com componentes eletrônicos, como
LEDs, resistores e protoboards.

2. Um sketch ou programa, como o Código 1, que você deve carregar no Arduino. Todos os códi-
gos Arduino utilizados em cada Atividade Prática de Sistemas Lógicos estão disponibilizados
no Colabweb.

1
 TAREFA
1. Conecte um LED e um resistor à protoboard, e depois conecte esta ao Arduino, como ilustrado
na Figura 1. Lembre-se: o terminal curto do LED deve ser conectado no sentido do GND
(terra) do Arduino.

2. Conecte o cabo USB do Arduino ao computador.

3. Abra a IDE Arduino.

4. Abra o Código 1. Você pode usar a versão disponível no Colabweb ou a versão padrão disponí-
vel pelo menu Arquivo -> Exemplos -> Basics -> Blink.

5. Navegue pelo menu Ferramentas -> Porta e verifique se a porta usada pelo Arduino está
corretamente selecionada,

6. Transfira o código para o Arduino, usando o menu Sketch -> Carregar.

7. Verifique o que acontece com o LED.

8. Varie o valor da função delay(), nas linhas 10 e 12, e recarregue o programa no Arduino. Por
exemplo, use os valores 2000 e 500. O que acontece?

9. Escreva na Folha de Respostas outros valores de tempo que você usou para o LED permanecer
aceso (HIGH) e permanecer apagado (LOW).

Figura 1: Circuito a ser montado para o experimento do LED pisca-pisca (Blink).

Código 1: Código Arduino para a experiência do LED pisca-pisca (Blink).

1 / * a funcao ’setup ’ eh executada apenas uma vez * /

2 void setup () {
3 / * ajusta o pino 13 como uma saida * /
4 pinMode (13, OUTPUT);
5 }
6
7 / * a funcao ’loop ’ eh executada indefinidamente * /
8 void loop () {

2
 9 digitalWrite (13, HIGH); /* liga o LED , jogando tensao ALTA (HIGH) * /
10 delay (1000); /* espera 1 segundo * /
11 digitalWrite (13, LOW); /* desliga o LED , jogando tensao BAIXA (LOW) * /
12 delay (1000); /* espera 1 segundo * /
13 }

Entendendo o código do LED pisca-pisca

Se você já conhece o Arduino, pode pular a explicação abaixo e ir direto à Atividade 2.
Todo programa Arduino deve especificar obrigatoriamente as seguintes funções [3]:

• setup: descreve os comandos que devem ser executados durante a inicialização do programa,
apenas uma única vez.

• loop: contém os comandos que devem ser repetidos continuamente, em um laço de duração
infinita.

A palavra-chave void (vazio) indica que as funções setup e loop não retornam nenhum valor à
função que as chamar. A função pinMode(X, <modo>) (linha 4) indica como o pino X do Arduino
será utilizado:

• se servirá como saída (output) de sinal do Arduino para o circuito; ou

• se servirá como entrada (input) de sinal do circuito para o Arduino.

Por fim, a função digitalWrite(X, <tensão>) (linhas 9 e 11) aplica um nível de tensão ao pino
X indicado: tensão alta (high) ou tensão baixa (low). O LED da Figura 1 está conectado com o termi-
nal curto ligado ao GND (terra) e o terminal comprido ligado ao pino 13 do Arduino. Dessa forma,
quando aplicamos uma tensão alta ao pino 13, cria-se uma diferença de potencial, fazendo o LED
acender. Por outro lado, quando aplicamos uma tensão baixa ao pino 13, não há diferença de poten-
cial entre os terminais do LED, que por isso fica apagado.

Experimento 2: Acendendo LEDs em sequência

Objetivo: acender uma sequência de oito LEDs, um por vez, e em seguida desligá-los, um por vez,
na mesma ordem em que foram ligados.

Código 2: Acendimento de LEDs em sequência.

1 byte numPins = 8; / * qtde de leds * /

2 byte pins [] = {5, 6, 7, 8, 9, 10, 11, 12}; / * pinos conectados aos leds * /
3 int delayTime = 150; / * tempo de delay * /
4
5 void setup () {
6 / * Configura todos os pinos de led como OUTPUT * /
7 for (byte i = 0; i < numPins; i++) {
8 pinMode(pins[i], OUTPUT);
9 }
10 }
11
12 void loop () {
13 / * Liga cada led em sequencia * /
14 for (byte i = 0; i < numPins; i++) {

3
15 digitalWrite(pins[i], HIGH);
16 delay(delayTime);
17 }
18
19 / * Desliga cada led em sequencia * /
20 for (byte i = 0; i < numPins; i++) {
21 digitalWrite(pins[i], LOW);
22 delay(delayTime);
23 }
24 }

Figura 2: Circuito a ser montado para acender e apagar oito LEDs em sequência.

TAREFA
1. Monte o circuito ilustrado na Figura 2. Certifique-se de usar os pinos 5 a 12 do Arduino, pois o
Código 2 faz referência a eles na linha 2.

2. Na IDE Arduino, abra o Código 2.

3. Transfira o código para o Arduino, usando o menu Sketch -> Carregar.

4. Verifique o padrão de acendimento e apagamento dos LEDs.

4
 5. Modifique os laços for no interior da função loop(), bem como o valor da variável delayTime
na linha 3, de modo a obter outros padrões de acendimento dos LEDs.
6. Em especial, modifique a função loop() para acender sequencialmente os LEDs conectados aos
pinos 5 a 12 e apagá-los na ordem inversa. Ou seja, o último LED a acender deve ser o primeiro
a apagar. Mostre o resultado ao instrutor.
7. Escreva na Folha de Respostas o código modificado da função loop(). Não escreva código de
outras funções!

ATENÇÃO:
• O tipo byte representa apenas valores não negativos, ou seja, valores entre 0 e 255. Portanto,
o comando byte i = 0 - 1 não atribui o valor −1 à variável i. Ao somarmos um valor
com −1, na verdade estamos ordenando que o Arduino devolva o valor anterior segundo a
sequência de valores possíveis. Assim, o valor anterior a 0 é 255, e não −1. Isso acontece
porque em espaços limitados de memória, a reta numérica funciona de forma circular.

Experimento 3: Imprimindo a representação binária nos LEDs

Neste experimento, utilize o mesmo circuito anterior. O Código 3 exibe nos LEDs a representação
binária do número informado na linha 1. Por exemplo, o número (186)10 , armazenado na variável
num, corresponde a (10111010)2 .
Código 3: Acende os LEDs de acordo com a representação binária da variável num.

1 byte num = 186; /* valor a imprimir = 0b10111010 * /

2 byte v[8]; /* Vetor auxiliar * /
3 byte numPins = 8; /* numero de leds * /
4 byte pins [] = {12, 11, 10, 9, 8, 7, 6, 5}; /* pinos conectados aos leds * /
5 int delayTime = 150; /* tempo de delay * /
6
7 void setup () {
8 / * Armazena bits do numero ’num ’ no vetor ’v’ * /
9 for (byte i = 0; i < numPins; i++) {
10 v[i] = num >> (numPins - 1);
11 num = num << 1;
12 }
13
14 / * Configura todos os pinos de led como OUTPUT * /
15 for (byte i = 0; i < numPins; i++)
16 pinMode(pins[i], OUTPUT);
17 }
18
19 void loop () {
20 / * acende ou apaga os leds conforme bits do vetor * /
21 for (byte i = 0; i < numPins; i++) {
22 if (v[i] == 1)
23 digitalWrite (pins[i], HIGH);
24 else
25 digitalWrite (pins[i], LOW);
26 }
27 }

5
Como funciona? Lembre-se que o Arduino é um sistema computacional. Por isso, todas as infor-
mações manipuladas por ele estão representadas em binário. Dessa forma, a variável num já está
armazenada em binário na memória do Arduino. Logo, é redundante e desnecessário converter para
a base binária um valor que já está na própria base binária.

Como imprimir a sequência de bits do valor de entrada? Como mostra a Figura 3, se deslocarmos
o conjunto de dígitos em sete posições para a direita, o MSB do número original será levado para a ex-
tremidade direita. Dessa forma, o valor obtido será o próprio valor do MSB (zero ou um), permitindo
sua impressão com 8 bits. Este procedimento é realizado pela linha 10 do Código 3.
Para imprimir os demais bits, repetimos o mesmo procedimento acima. Antes, porém, é ne-
cessário deslocar o bit de interesse, ou seja, aquele que desejamos imprimir, para a posição mais
significativa. Isso é feito pela linha 11, que, a cada iteração, desloca a sequência de bits de num uma
posição à direita. Note que esse comando altera o valor original de num, que é perdido ao final da
execução do laço for.

Figura 3: Representação gráfica dos procedimentos executados pelas linhas 10 e 11 do Código 3.

TAREFA
1. Na IDE Arduino, abra o Código 3.

2. Transfira o programa para o Arduino, usando o menu Sketch -> Carregar.

3. Verifique se o padrão de LEDs acesos e apagados corresponde ao padrão de bits correspondente

a 186. Note que você pode estar vendo o circuito de cabeça para baixo.

4. Qual o valor em binário dos números indicados na Folha de Respostas? Modifique a linha 1
do Código 3 e pinte os quadrados correspondentes aos LEDs que acendem.

Experimento 4: Trabalhando com o Monitor Serial

O Código 3 não é prático quando se deseja testar várias entradas diferentes, pois exige que o pro-
grama seja recarregado a todo momento no Arduino. Para contornar essa dificuldade, vamos usar o
Monitor Serial, representado pelo ícone de uma lupa no canto superior direito da IDE Arduino.

6
 Código 4: Acende os LEDs correspondentes à representação binária de um número inserido pelo
Monitor Serial.

1 byte numBits = 8; / * Qte. de bits a imprimir * /

2 byte pins [] = {5, 6, 7, 8, 9, 10, 11, 12}; / * pinos conectados aos leds * /
3 int delayTime = 500; / * tempo de delay * /
4
5 byte v[] = {1, 1, 1, 1, 1, 1, 1, 1}; / * Vetor de bits * /
6
7 byte byteRead; / * Numero a ser convertido * /
8 String incomingBytes ; / * Caracteres lidos no terminal * /
9
10 void setup () {
11 Serial.begin (9600);
12
13 / * Configura todos os pinos de led como OUTPUT * /
14 for (byte i = 0; i < numBits; i++) {
15 pinMode(pins[i], OUTPUT);
16 }
17
18 / * Mensagem inicial * /
19 Serial.println("Digite um numero de 0 a 255:");
20 }
21
22 void loop () {
23 / * Verifica se caracteres foram digitados no computador e enviados ao Arduino
*/
24 if (Serial.available ()) {
25
26 / * Le nova string do teclado , convertendo -a em inteiro * /
27 incomingBytes = Serial.readString ();
28 Serial.println( incomingBytes );
29 byteRead = incomingBytes .toInt ();
30
31 / * Eco do valor digitado * /
32 Serial.println("Voce digitou:");
33
34 Serial.print("DEC: ");
35 Serial.println(byteRead , DEC);
36
37 Serial.print("HEX: ");
38 Serial.println(byteRead , HEX);
39
40 Serial.print("BIN: ");
41 Serial.println(byteRead , BIN);
42
43 Serial.println("");
44
45 / * Armazena bits do numero ’byteRead ’ no vetor ’v’ * /
46 for (byte i = 0; i < numBits; i++) {
47 v[i] = byteRead >> (numBits - 1);
48 byteRead = byteRead << 1;
49 }
50
51 / * Mensagem para proximo loop * /
52 Serial.println("Digite um numero de 0 a 255:");
53 }
54
55 / * Acende ou apaga os LEDs correspondentes ao padrao de bits * /

7
56 for (byte i = 0; i < numBits; i++) {
57 if (v[i] == 1)
58 digitalWrite (pins[i], HIGH);
59 else
60 digitalWrite (pins[i], LOW);
61 }
62 }

TAREFA
1. Na IDE Arduino, abra o Código 4.

2. Transfira o programa para o Arduino, usando o menu Sketch -> Carregar.

3. Qual o valor em binário dos números indicados na Folha de Respostas? Insira os valores no
Monitor Serial; verifique a sequência de acendimento dos LEDs; e pinte os quadrados corres-
pondentes aos LEDs que acendem.

Experimento 5: Overflow
Overflow é uma condição em que um espaço de memória não é suficientemente grande para repre-
sentar um valor [1]. Ou seja, se um espaço de memória tem n bits de tamanho, então ele só pode
representar números naturais contidos no intervalo fechado entre 0 a 2n − 1. Valores maiores ou
iguais a 2n não podem ser representados.
Como analogia, considere um marcador de quilometragem de um carro com apenas três posições.
Se esse carro percorreu 1.234 km, então o marcador registrará 234. Dessa forma, observando apenas
o mostrador, não é possível afirmar se o carro percorreu apenas 234 km, ou 1.234 km, ou 666.234 km.

TAREFA

1. Continue a Atividade anterior, desta vez usando valores maiores ou iguais a 256 (= 28 ).

2. Responda às perguntas constantes na Folha de Respostas.

Referências
[1] Carvalho, L. S. G. Apostila de ICC060 Sistemas Lógicos, 0.6 ed. Universidade Federal do Amazo-
nas, 2017.

[2] Geddes, M. Manual de projetos do Arduino: 25 projetos práticos para começar. Novatec, 2017.

[3] Monk, S. Programação com Arduino: começando com Sketches. Bookman, Porto Alegre, 2013. Série
Tekne.

[4] Platt, C. Eletrônica para Makers: Um manual prático para o novo entusiasta de eletrônica. Novatec,
2016.

8
Apêndice – Componentes eletrônicos

Protoboard
Protoboard, ou matriz de contatos, é uma placa de plástico com furos igualmente espaçados para
encaixar componentes eletrônicos. Ela serve como base para construir protótipos de circuitos eletrô-
nicos. Por dentro da placa, existem condutores que fazem conexões ao longo das fileiras de furos [4].
Em inglês, o nome correto da protoboard é breadboard.
A Figura 4 ilustra um pedaço de uma protoboard. Já a Figura 5 ilustra como os furos da proto-
board estão interconectados internamente, formando trilhas. Componentes encaixados nos furos de
uma mesma trilha estarão interligados.

Figura 4: Visão superior de uma protoboard, ou matriz de contatos.

Figura 5: Interconexão interna dos furos de uma protoboard, formando trilhas horizontais (A e D),
usadas como barramento de alimentação, e trilhas verticais (B e C), usadas como área de trabalho
para encaixe dos componentes desejados.

Como mostra a Figura 5, as trilhas horizontais (A e D) são usadas para fornecer alimentação para
o circuito. Por convenção, a trilha azul deve ser conectada ao polo negativo da fonte de alimentação
(GND), e a trilha vermelha ao polo positivo (Vcc).
Note que a trilha azul do barramento A é independente da trilha azul do barramento D. Ou seja, se
o GND for conectado em A, então ele não será aplicado em D, a não ser que você interconecte essas
trilhas usando um fio jumper. Da mesma forma, as trilhas verticais em B também são independentes
das trilhas verticais em C, ainda que estejam alinhadas.

Fios jumper
Fios jumper servem para conectar furos da protoboard entre si ou a equipamentos externos, como
o Arduino. Por convenção, utilizam-se fios de cor preta (e não os azuis) para conexões ao nível

9
de tensão terra (GND) e fios de cor vermelha para conexões à tensão positiva (Vcc). As outras cores
podem ser usadas livremente. Somente nos filmes de Hollywood a cor dos fios tem algum significado
para desarmar (ou detonar) uma bomba.

LED
LED (light emitting diode, diodo emissor de luz) é um componente eletrônico que emite luz quando
uma corrente elétrica circula por ele. A intensidade da luz é proporcional à corrente que passa por
ele.
Para que uma corrente elétrica circule por um circuito, em especial por um LED, é necessário que
haja uma diferença de tensão entre os terminais. Se os dois terminais de um LED forem conectados
a uma mesma trilha da protoboard, a tensão aplicada entre eles também será a mesma, e por isso
nenhuma corrente elétrica circulará entre os terminais.
O LED deve ser sempre conectado em série com um resistor, cujo papel é limitar a corrente que
circula pelo LED, evitando que ele queime. Na prática, o LED não queima automaticamente pela
falta de um resistor, mas sua vida útil é reduzida.

Como funciona um LED? O LED é um componente polarizado, ou seja, só funciona se a corrente

passar em um determinado sentido. Se a corrente tentar circular no sentido contrário, ela é barrada
pelas propriedades físicas do LED, que não acenderá.

• Na base circular do LED há um corte, chamado chanfro. O terminal

alinhado ao chanfro deve ser conectado na direção do polo negativo
da fonte de alimentação (GND). Esse terminal, chamado de catodo, é o
mais curto entre os dois, quando sai da fábrica. Por isso, se você tomar
um LED usado, oriente-se pelo chanfro, pois alguém pode ter cortado
os terminais de forma invertida.

• O outro terminal do LED, o anodo, deve ser conectado orientado ao

polo positivo da fonte de alimentação (Vcc).

Resistores
Resistores restringem a quantidade de corrente elétrica que pode fluir através de um circuito, a fim
de evitar sobrecarga nos componentes [2]. Como ilustra a Figura 6, eles se parecem com cilindros
com faixas coloridas e um fio em cada ponta.
O valor nominal do resistor é indicado pelo código de cores. A unidade de medida é ohms, cujo
símbolo é Ω. Na maior parte dos experimentos em Sistemas Lógicos, usaremos resistores de 330 Ω,
indicado pelas faixas laranja (3), laranja (3) e marrom (×101 ).

Figura 6: Exemplo de um resistor.

10