O Arduino Descomplicado e Divertido

 Como o Arduino funciona;

 Instalação do software;
 Teste da placa;
 Códigos C/C+;
 Experiências
Com LED.
http://loja.burgoseletronica.net
www.lojaburgoseletronica.com.br
www.esquemafacil.com.br
www.livrotec.com

Dedicatória
Dedico este trabalho a todos os meus familiares, colaboradores e principalmente aos meus
alunos que são a razão principal pela qual trabalho ensinando esta profissão maravilhosa.
Muito obrigado a todos e vamos seguindo em frente.
Bibliografia
Todo o texto contido neste curso é de minha inteira autoria e responsabilidade. Algumas fotos e
códigos foram retirados da internet porém todos estes modificados por nós da Burgoseletronica
Ltda para adequar-se ao curso. Segue abaixo alguns sites interessantes para quem quer obter
códigos, apender mais coisas, comprar acessórios e até simular o funcionamento de Arduino:
www.arduino.cc
www.labdegaragem.com.br
www.oarduino.com
http://123d.circuits.io
www.comofazerascoisas.com.br
http://alexmartins.net
www.modkit.com
http://arduinobymyself.blogspot.com.br
http://www.arduinoecia.com.br

LISTA DE MATERIAL PARA O VOL.1
 1 Placa de Arduino UNO;

 1 Protoboard de 830 pinos;
 1 Conjunto de fios jumpers para as ligações;
 1 Fonte chaveada de 9 ou 12 V x 0,5 ou 1 A
 6 Resistores de 100 Ω x ¼ W;
 2 Resistores de 10 KΩ x ¼ W;
 1 Resistor de 22 KΩ x ¼ W;
 1 Potenciômetro de 20 KΩ;
 1 Resistor LDR (fotorresistor) de 5 ou 10 mm
 7 Leds vermelhos difusos de 5 mm;
 4 Leds amarelos difusos de 5 mm;
 2 Leds verdes difusos de 5 mm;
 1 Led tricolor RGB de 5 mm e 4 terminais;
 2 Microchaves de toque;
LISTA DE MATERIAL VOL.1 E VOL.2
 1 Placa de Arduino UNO;

 1 Protoboard de 830 pinos;
 1 Conjunto de fios jumpers para as ligações;
 1 Fonte chaveada de 9 ou 12 V x 0,5 ou 1 A
 1 Porta Pilhas para 4 pilhas AA;
 4 Pilhas AA;
 2 Resistores de 10 KΩ x ¼ W;
 1 Potenciômetro de 20 KΩ;
 1 Resistor LDR (fotorresistor) de 5 ou 10 mm
 1 Capacitor eletrolítico de 47 µF x 16 V;
 7 Leds vermelhos difuso de 5 mm;
 4 Leds amarelos difuso de 5 mm;
 2 Leds verdes difuso de 5 mm;
 1 Led tricolor RGB de 5 mm e 4 terminais;
 1 Diodo 1N4007;
 2 Transistores TIP41;
 2 Transistores TIP42;
 2 Microchaves de toque;
 1 Mini alto falante “buzzer” de 5 V;
 1 Motor DC de 6 V;
 1 Display de leds de 7 segmentos e catodo comum;
 1 Display LCD 16 x 2 com backlight;

COMPONENTES PARA O VOL.1
COMPONENTES PARA OS VOL.1 E 2

ÍNDICE
I. Introdução ______________________________________________________________01
II. O Arduino ______________________________________________________________01
III. Testando a placa de Arduino do curso ________________________________________03
IV. Trabalhando com o Arduino – Montagem de experiências ________________________07
1. Experiência nº 1 – Pisca-pisca simples _______________________________________07
2. Experiência nº 2 – Pisca-pisca duplo _________________________________________11
3. Experiência nº 3 – Botão liga-desliga _________________________________________13
4. Experiência nº 4 – Semáforo brasileiro _______________________________________15
5. Experiência nº 5 – Semáforo duplo sincronizado ________________________________17
6. Experiência nº 6 – Porta lógica NÃO (NOT) e os resistores “pull up” “pull down” _______19
7. Experiência nº 7 – Portas lógicas com Arduino _________________________________22
8. Experiência nº 8 – Led de brilho variável (PWM) do Arduino ______________________25
9. Experiência nº 9 – Controle de brilho do led ___________________________________27
10. Experiência nº 10 – Led tricolor com brilhos e cores variáveis _____________________31
11. Experiência nº 11 – Semáforo com botão acionador _____________________________34
12. Experiência nº 12 – Sequencial com 4 leds ____________________________________37
13. Experiência nº 13 – Sequencial com 10 leds ___________________________________39
14. Experiência nº 14 – Sequencial com 10 leds controlado manualmente _______________41
15. Experiência nº 15 – Comparador de tensão e fotocélula com Arduino _______________43
16. Experiência nº 16 – Efeito de chama de fogueira com leds ________________________45
17. Experiência nº 17 – Led tricolor RGB com controle serial através do PC _____________47
18. Experiência nº 18 – Sensor de luz com 3 leds __________________________________51
19. Experiência nº 19 – Pisca-pisca controlado por potenciômetro e luz _________________53
20. Experiência nº 20 – Dado eletrônico _________________________________________55

O ARDUINO DESCOMPLICADO E DIVERTIDO

Por Luis Carlos Burgos
www.burgoseletronica.net
I. INTRODUÇÃO
Neste curso que ora iniciamos ensinaremos ao aluno, seja ele técnico ou hobbista na área da
eletrônica, como funciona e como programar o Arduino através de experiências que serão
feitas ao longo do curso. O curso é formado por este livro, vídeo aula e o material didático que
o aluno receberá para acompanhá-lo e desenvolver bem rápido seu aprendizado. Portanto
prestem bastante atenção ao curso que vocês verão como é bem fácil trabalhar com Arduino.
II. O ARDUINO
Arduino é um “hardware” (circuito eletrônico) cujo principal componente é um circuito integrado

(chip ou CI) microcontrolador da família ATMEL. Microcontroladores são CIs que podemos
programá-los para realizar as funções que queremos. Há diversos tipos de microcontroladores
na eletrônica, porém o Arduino tem algumas vantagens sobre os demais principalmente nos
quesitos preço (é relativamente barato perto dos demais) e na facilidade de programação. Ele
usa a linguagem C/C++. O Arduino surgiu na Itália em 2005 e hoje é bastante usado nos meios
da eletrônica digital especialmente no ramo da robótica. Veja abaixo na figura 1 o Arduino
UNO que usaremos durante este curso e seus componentes principais explicados a seguir:
Figura 1 - Arduino Uno
Arduino Descomplicado e Divertido Luis Carlos Burgos

Página 1

CI Microcontrolador - Ou simplesmente CI micro, é o componente principal do Arduino. Este
modelo UNO usa um ATMEGA328P, processador de 8 bits, ou seja, troca informações 8 bits (0
e 1) por vez, possui 32 Kb de memória interna (que para o tamanho dos arquivos dos
programas que ele pode trabalhar dá e sobra) e funciona com um clock de 16 MHz através de
um cristal ligado em seus pinos. No caso deste nosso Arduino o CI micro é do tipo
convencional ou TH (through hole) e soquetado, porém muitos Arduinos usam o CI micro do
tipo SMD (montagem em superfície);
Entrada USB - Faz a comunicação do Arduino com um computador PC ou notebook;
Entrada DC - Permite a ligação do Arduino numa alimentação por fonte externa entre 8 e 12
VDC quando ele não está conectado ao computador ou notebook;
CI USB para serial - Pequeno CI SMD da ATMEL MEGA16U2 que converte os dados seriais
universais (USB) para dados seriais comuns (sistema mais antigo de comunicação serial).
Desta forma o Arduino pode receber dados via porta USB, muito usada há vários anos.
Cristal de 16 MHz - É o clock (sinal de sincronismo) do CI micro. Desta forma o CI pode
processar 16 milhões de informações por vez, ou seja, 2 (bit 0 ou bit 1) elevado à 8ª potência
(como já explicado 8 bits por vez);
Entradas/saídas digitais e PWM - Aqui os dados digitais saem ou entram do/no Arduino
dependendo da configuração do projeto. Os que têm o símbolo “~” podem ser usados também
como saídas de PWM (onda quadrada ou modulação por largura de pulso);
Comunicação serial - Estes dois terminais permitem ao Arduino trocar dados seriais com
outro dispositivo ou circuito externo;
Entradas analógicas - Permitem a ligação de componentes ou dispositivos analógicos como,
por exemplo, um potenciômetro;
Alimentação - Daí sai tensões para alimentar circuitos ou componentes ligados no Arduino.
Temos aí tensões de 5 V, 3,3 V, Vin (a mesma tensão do conector entrada DC caso o Arduino
esteja alimentado por uma fonte externa) e os terras ligados nos mesmos pontos (GND);
CI regulador de tensão - Caso o Arduino esteja alimentado com uma fonte externa, este CI
vai transformar esta tensão em 5 V estabilizados e destes também serão obtidos os 3,3 V para
alimentar todo o circuito da placa;
Botão RESET - Usado para reiniciar o micro em caso de alguma falha no funcionamento;
Led liga/desliga - Fica aceso quando a placa está alimentada;
Leds de comunicação - Acende quando a placa está recebendo dados do computador ou
notebook;
Led de teste - Vai ligado no pino 13 do Arduino para fazer um teste rápido de funcionamento
da placa que normalmente consiste de piscadas quando ela está funcionando. Há um código
do qual falaremos mais adiante que podemos gravar no Arduino para que este led pisque,
testando assim o funcionamento do micro.
Existem diversos tipos de Arduinos no mercado cada um com um micro e quantidade diferente
de entradas/saídas adequando-se aos milhares de projetos envolvendo este hardware. Porém
conforme já explicado para o desenvolvimento de nosso curso usaremos o Arduino UNO (um
em italiano) por ser o mais simples de trabalhar e também bastante didático. Os demais usam
o mesmo conceito do modelo UNO.

Página 2

III. TESTANDO A PLACA ARDUINO DO CURSO
Antes de iniciarmos as experiências para o aprendizado é necessário instalar o software e

testar o funcionamento da placa do Arduino a ser usado no curso.
1. - Instalação do software
O software ou programa do Arduino é uma interface com ambiente de desenvolvimento, sendo
chamada de IDE (Interface Development Environment) em inglês. É com este programa que
gravaremos as instruções no Arduino. Ele também permite a escrita do código diretamente na
interface. Para obtenção gratuita do software vá ao endereço http://www.arduino.cc/
Após entrar no site do fabricante, vá à aba “Download”:
E dentro você encontrará duas versões a 1.0.5 (estável) e a 1.5.7 (beta), porém você pode usar
qualquer uma das duas para nosso Arduino UNO. Pode ser que quando estiver estudando este
curso já hajam versões mais atualizadas que estas. Daí você vai clicar e baixar a versão
correspondente ao seu sistema operacional (Windows, MAC ou Linux), como abaixo vemos
para a opção Windows (serve para XP, 7 e 8 sem problemas):
Agora esperamos baixar o programa e para instalá-lo é bem simples bastando um clique duplo
e se seu PC usa o Windows 7 ou 8 clique com o botão direito do mouse sobre o instalador do
programa e no menu que abre escolha “Executar como administrador”. Daí é só concordar com
os termos e dar o “next” para começar a instalar o software.

Página 3

E na próxima tela clicar em “Install” e esperar a conclusão da instalação que pode demorar um
pouco mais ou menos dependendo da velocidade de seu PC ou laptop. Para a instalação do
programa não é necessário que o Arduino esteja conectado ao PC ou laptop. Após completar a
instalação clique em “Close” e o programa já está instalado em seu PC ou laptop e pronto para
usar. Se ao ligar pela primeira vez a placa do Arduino no PC e a instalação do driver falhar e
precisar instalar o driver manualmente veja o procedimento no apêndice no final deste livro.
2. - Configuração do software e teste da placa Aruino

Abra o programa, vá ao menu Ferramentas, opção Placa e verifique se está selecionado o
Arduino UNO. Se não estiver basta clicar e selecionar:

Página 4

Aproveite e vá também ao mesmo menu Ferramentas e opção Porta veja se aparece “COM1”,
desta forma o programa já está pronto para uso.
Agora conecte a placa Arduino UNO no seu PC ou laptop através do cabo USB que
acompanha a placa. Pode plugar em qualquer porta USB do PC ou laptop. Não é necessário
instalar mais nada, a placa e “plug and play” (conecta e funciona). O led liga/desliga (verde)
deverá acender caso contrário a placa não está funcionando. Se o led acende, abra o
programa vá ao menu “Arquivo” opção “Exemplos”, “01. Basics”, “Blink”:
Vai aparecer uma tela com um código de um pisca-pisca, mas não se preocupe com este
código por enquanto. Clique no botão “Verificar” para o programa compilar e testar o código. Se
no final aparecer “Compilação terminada”, o código está correto e se aparecer “Erro
compilando” em laranja, o código está com algum erro que deve ser corrigido:

Página 5

Agora clique no botão “Carregar” para enviar o código à placa Arduino. Espere alguns
segundos e depois de terminado o processo de transferência de dados deverá aparecer a
palavra “Carregado” na parte inferior do programa como visto a seguir. Agora verifique na placa
que o led de teste (laranja) deverá estar piscando num sequência de 1 segundo. Se isto
acontecer, a placa do Arduino está funcionando perfeitamente.
Se aparecer uma mensagem em laranja após o carregamento, indica que houve um erro na
transferência de dados para o Arduino. Isto geralmente ocorre quando há um defeito na placa
do Arduino que não está se comunicando com o PC/laptop. Neste caso devemos substituir esta
placa. Veja abaixo:

Página 6

IV. TRABALHANDO COM O ARDUINO - MONTAGEM DE EXPERIÊNCIAS
A partir deste tópico, depois de testado, aprenderemos a usar o Arduino através da montagem
de algumas experiências usando o material do curso. Também falaremos um pouco a respeito
da programação que ele usa, porém de uma forma mais simples, até porque encontramos
milhares de códigos na internet para usar o Arduino nas mais variadas funções em vários
ramos da eletrônica. Não nos aprofundaremos muito no quesito códigos de operação, porém
noções básicas sim para que o aluno possa escrever alguns mais simples e pegar alguns mais
complexos pela internet e modifica-los de acordo com sua necessidade.
Observação - A palavra Arduino é patenteada, porém o circuito eletrônico e os códigos em
linguagem C não são de modo que qualquer pessoa ou empresa pode criar um Arduino (com
outro nome), programar ou modificar os códigos para adequar-se às suas necessidades.
1. Experiência nº 1 - Pisca-pisca simples
Lista de materiais
- Placa de Arduino UNO

- Protoboard de 830 pinos
- 1 Resistor de 100 Ω (marrom-preto-marrom)
- 1 Led vermelho de 5 mm
- Fios para as ligações
Procedimento
Monte o circuito como indicado abaixo usando o Arduino e a protoboard. Os desenhos foram
feitos num software chamado Fritzing (http://fritzing.org).
Na página a seguir temos o esquema elétrico do circuito que também foi elaborado no Fritzing.
No desenho só aparece uma parte da protoboard que é onde vamos usar para montar nosso
primeiro circuito deste curso.

Página 7

Após a montagem do circuito ao ligarmos o Arduino no PC ou alimentá-lo com uma fonte

externa, o led não acenderá porque não há nenhum programa gravado no CI micro da placa
que o faça controlar o led. A seguir vamos gravar um código no CI para que o pisca funcione. O
código a ser gravado está abaixo dentro de uma caixa de texto:
// Experiência 1 ‐ Pisca pisca simples

int ledPin = 10; // variável inteira LedPin (poderia ter outro nome) ligado no pino 10
void setup() { // esta função roda só uma vez cada vez que o circuito é ligado
pinMode(ledPin, OUTPUT); // indica que o led no pino 10 é para saída de dados
}
void loop() { // esta função roda continuamente enquanto o circuito está ligado
digitalWrite(ledPin, HIGH); // O pino 10 onde está o led passa para nível alto (acende)
delay(1000); // Espera de 1000 milissegundos ou 1 segundo
digitalWrite(ledPin, LOW); // O pino 10 onde está o led passa para nível baixo (apaga)
}
Agora você abre o programa do Arduino (IDE), Vai ao menu “Arquivo” opção “Novo” e digita lá
o código acima. Ou se quiser para facilitar o trabalho, seleciona todo o texto copia e cola. Após
clica no botão “Verificar” para testar o código e estando correto clica em “Carregar” para
mandar o código para o Arduíno. Após o carregamento completo devemos ver o led piscar à
velocidade de uma piscada a cada segundo. Se isto ocorrer, seu circuito funcionou
perfeitamente. Todos os códigos usados por todas as experiências deste curso além de
estarem neste livro também mandamos separadamente como arquivos txt (para blocos de
notas) numa pasta separada. Assim você pode usá-los ou modifica-los da forma que quiser. Na
página a seguir mostramos uma figura com o código acima escrito no IDE do Arduino.

Página 8

Como podemos observar o código escrito na sketch (rascunho) do programa será gravado no
Arduino para que ele execute a função indicada.
Noções sobre o código C do Arduino
1.1 - Código x Comentários - Como observamos dentro do programa do Arduino ao colocar o

código da nossa experiência, as frases que aparecem na cor cinza precedidos por duas barras
“//” são comentários sobre cada linha ou parte do código. Comentários são opcionais, mas
importantes por duas razões: indicar as funções das partes do código e no caso de códigos
complexos para que quem esteja programando não se perca. As palavras em outras cores
(preto, laranja, azul) fazem parte do código em si. O Arduino só interpreta o código, não
importa a quantidade de comentários inseridos nele. Comentários também podem começar
com “/*” (sem aspas) e terminar com “*/” (sem aspas). Exemplo: /* este é um circuito do
Arduino */
1.2 - Idioma - As funções do código devem ser escritas obrigatoriamente em inglês,
diferenciando maiúsculas de minúsculas (a linguagem C interpreta estas diferenças). As
variáveis (os componentes do circuito) podem estar em outro idioma. Veja na página a seguir:

Página 9

int ledPin = 10; - A palavra abreviada int (“interage” ou inteiro) deve ser mantida como está. A
palavra ledPin é o led do circuito (variável) e pode ser substituída por qualquer outra palavra
por exemplo “led” ou ledvermelho (não pode haver espaços entre as palavras). Porém se você
substituir a palavra ledPin por ledvermelho, por exemplo, na primeira linha do código, terá que
fazer esta substituição em todas as linhas do código que usam a palavra ledPin.
1.3 - Ponto e vírgula (;) - Cada linha de código representando uma função deve terminar em
ponto e vírgula para o programa não acusar erro de código.
1.4 - Funções SETUP e LOOP - A programação do Arduino sempre tem estas duas funções
onde a primeira roda uma vez quando ligamos o circuito para identificar os parâmetros do
mesmo (variáveis, pinagem) e a segunda roda todos os demais códigos indefinidamente até
que o circuito seja desligado. Em resumo SETUP indica o que tem no circuito e LOOP faz o
circuito funcionar.
Mudança no código e comportamento da experiência 1

No código para este circuito há duas linhas de comando chamadas delay(1000). A de cima
indica o tempo em ms que o led fica aceso (HIGH) e a de baixo indica o tempo que o led fica
apagado (LOW). Substitua os dois números no código por 500 (pode ser no próprio programa),
carregue o arquivo para o Arduino e veja que agora o led pisca a cada 0,5 s (2 vezes por
segundo). Tente diminuir para 100 e veja o led piscar 10 vezes por segundo ou mude para
2000 e veja o led piscar uma vez a cada 2 s. Tente outros valores se quiser.
Simplificação do código da experiência 1

Podemos simplificar mais o código a ser aplicado ao Arduino retirando a variável e indicando
apenas o número do pino no lugar dela. Veja abaixo:
int ledPin = 10; // variável inteira LedPin (poderia ter outro nome) ligado no pino 10
pinMode(ledPin, OUTPUT); // indica que o led no pino 10 é para saída de dados
}
digitalWrite(ledPin, HIGH); // O pino 10 onde está o led passa para nível alto (acende)
digitalWrite(ledPin, LOW); // O pino 10 onde está o led passa para nível baixo (apaga)
} // Podemos usar este código para nosso pisca de 1 segundo
pinMode(10, OUTPUT); // indica que o pino 10 é para saída de dados
}
digitalWrite(10, HIGH); // O pino 10 onde está o led passa para nível alto (acende)
digitalWrite(10, LOW); // O pino 10 onde está o led passa para nível baixo (apaga)
} // Ou podemos usar este aqui que dá o mesmo resultado
Arduino Descomplicado e Divertido Página Luis Carlos Burgos

10

2. Experiência nº 2 - Pisca-pisca duplo
Lista de materiais

- 2 Resistores de 100 Ω (marrom-preto-marrom)
- 1 Led verde de 5 mm
Procedimento
Monte o circuito como indicado abaixo usando o Arduino e a protoboard:

11

Insira o seguinte código no programa do Arduino:
// Experiência 2 ‐ Pisca pisca duplo

int ledverm = 10; // led vermelho no pino 10
int ledverd = 9; // led verde no pino 9

void setup() {
pinMode(ledverm, OUTPUT); // pino 10 do led vermelho como saída
pinMode(ledverd, OUTPUT); // pino 9 do led verde como saída
}

void loop() {
digitalWrite(ledverm, HIGH); // pino 10 vai a nível alto e acende o led vermelho
digitalWrite(ledverd, LOW); // pino 9 vai a nível baixo e apaga o led verde
delay(1000); // espera 1 seg
digitalWrite(ledverm, LOW); // pino 10 vai a nível baixo e apaga o led vermelho
digitalWrite(ledverd, HIGH); // pino 9 vai a nível alto e acende o led verde
}
Ao carregar este código para a placa os dois leds piscarão alternadamente à frequência de 1
piscada por segundo. Se quiser modificar a velocidade das piscadas basta alterar o valor da
linha delay(1000) para aumentar ou diminuir o tempo conforme já explicado. Nesta experiência
se quiser você também pode usar um código mais simples como indicado abaixo:
// Experiência 2 ‐ Pisca pisca duplo

void setup() {
pinMode(10, OUTPUT); // pino 10 como saída
pinMode(9, OUTPUT); // pino 9 como saída
}

void loop() {
digitalWrite(10, HIGH); // pino 10 vai a nível alto e acende o led vermelho
digitalWrite(9, LOW); // pino 9 vai a nível baixo e apaga o led verde
digitalWrite(10, LOW); // pino 10 vai a nível baixo e apaga o led vermelho
digitalWrite(9, HIGH); // pino 9 vai a nível alto e acende o led verde
}
Observe que cada função no código começa com uma chave “{” e termina com outra
chave “}”.

12

3. Experiência nº 3 - Botão liga/desliga
Lista de materiais

- 1 Resistor de 220 Ω (vermelho-vermelho-marrom)
- 1 Microchave de toque
Procedimento
Monte o circuito como indicado abaixo usando o Arduino e a protoboard:

13

// Experiência 3 ‐ Botão liga/desliga

int led = 7; // led no pino 7
int botao = 6; // botão no pino 6
int estadobotao = 0; //Estado inicial do botão (0 = aberto ou desligado)

void setup() {
pinMode(led, OUTPUT); // pino 7 do led como saída
pinMode(botao, INPUT); // pino 6 do botão como entrada
}
void loop() {
estadobotao = digitalRead(botao); // leitura de que estado (aberto ou fechado) está o botão
if (estadobotao == HIGH) { // Se o botão está igual a nível alto (ligado)
digitalWrite(led, HIGH); // pino 7 vai a nível alto e acende o led
} else { // senão
digitalWrite(led, LOW); // pino 7 vai a nível baixo e apaga o led
}
}
Ao carregar o código você observará que o led fica apagado e acende a cada toque na tecla.
Se quiser inverter o processo, ou seja, deixar o led aceso a apagá-lo com um toque na tecla
basta modificar no código (led, HIGH) para (led, LOW) e vice-versa.
Este código do botão liga/desliga também pode ser simplificado como indicado abaixo:
// Experiência 3 ‐ Botão liga/desliga

void setup() {
pinMode(7, OUTPUT); // pino 7 do led como saída
pinMode(6, INPUT); // pino 6 do botão como entrada
}
void loop() {
digitalRead(6); // leitura do estado do pino 6
if (6 == HIGH) { // Se o pino 6 está em nível alto (botão ligado)
digitalWrite(7, HIGH); // pino 7 vai a nível alto e acende o led
} else { // senão
digitalWrite(7, LOW); // pino 7 vai a nível baixo e apaga o led
}
}
Observe que excluímos as variáveis do código deixando apenas os números dos pinos do
Arduino onde serão ligados o led e a microchave.

14

4. Experiência nº 4 - Semáforo Brasileiro
Lista de materiais

- 1 Led amarelo de 5 mm
Procedimento
Monte o circuito como indicado abaixo usando o Arduino e a protoboard.

15

// Experiência 4 ‐ Semáforo Brasileiro

int luzvermelha = 10; // led representando a luz vermelha no pino 10
int luzamarela = 9; // led representando a luz amarela no pino 9
int luzverde = 8; // led representando a luz verde no pino 8

void setup() {
pinMode(luzvermelha, OUTPUT); // led ligado no pino 10 como saída
pinMode(luzamarela, OUTPUT); // led ligado no pino 9 como saída
pinMode(luzverde, OUTPUT); // led ligado no pino 8 como saída
}
void loop() {
digitalWrite(luzvermelha, HIGH); // acende o led vermelho (PARE)
digitalWrite(luzamarela, LOW); // led amarelo apagado
digitalWrite(luzverde, LOW); // led verde apagado
delay(5000); // espera 5 segundos
digitalWrite(luzvermelha, LOW); // led vermelho apagado
digitalWrite(luzamarela, LOW); // led amarelo apagado
digitalWrite(luzverde, HIGH); // acende o led verde (SIGA)
digitalWrite(luzvermelha, LOW); // led vermelho apagado
digitalWrite(luzamarela, HIGH); // acende o led amarelo (ATENÇÃO)
digitalWrite(luzverde, LOW); // led verde apagado

}
Ao carregar este código você observará como funciona um semáforo no qual os leds
representam suas luzes. Inicialmente o led vermelho acende, ficando 5 segundos neste estado
enquanto os demais permanecem apagados. Após este tempo o led vermelho apaga enquanto
o verde acende e permanece assim por 5 segundos. Após o tempo o amarelo acende e fica 2
segundos aceso antes de acender de volta o vermelho e assim o ciclo se repete como nos
semáforos reais (porém a diferença é que estes operam por mais segundos que o de nossa
experiência).
Este código também pode ser simplificado retirando-se as variáveis “int” antes do “void setup”
e substituindo-se as palavras “luzvermelha, luzamarela e luzverde” pelos respectivos
números “10, 9 e 8”. Veja por exemplo uma parte do código modificado abaixo:
pinMode(10, OUTPUT); // led ligado no pino 10 como saída
}
void loop() {
digitalWrite(10, HIGH);

16

5. Experiência nº 5 - Semáforo duplo sincronizado
Lista de materiais

- 2 Leds vermelhos de 5 mm
- 2 Leds amarelos de 5 mm
- 2 Leds verdes de 5 mm
Procedimento

17

Coloque o seguinte código no programa do Arduino:
// Experiência 5 ‐ Semáforo duplo sincronizado
int luzvermelha1 = 10; // led vermelho do semáforo nº 1
int luzamarela1 = 9; // led amarelo do semáforo nº 1
int luzverde1 = 8; // led verde do semáforo nº 1
int luzvermelha2 = 7; // led vermelho do semáforo nº 2
int luzamarela2 = 6; // led amarelo do semáforo nº 2
int luzverde2 = 5; // led verde do semáforo nº 2
void setup() {
pinMode(luzvermelha1, OUTPUT);
pinMode(luzamarela1, OUTPUT);
pinMode(luzverde1, OUTPUT); // define os pinos dos leds como saída
pinMode(luzvermelha2, OUTPUT);
pinMode(luzamarela2, OUTPUT);
pinMode(luzverde2, OUTPUT);
}
void loop() {
digitalWrite(luzvermelha1, HIGH); //acende o vermelho do semáforo 1 (PARE)
digitalWrite(luzamarela1, LOW);
digitalWrite(luzverde1, LOW);
digitalWrite(luzvermelha2, LOW);
digitalWrite(luzverde2, HIGH); //acende o verde do semáforo 2 (SIGA)
delay(5000); //espera 5 segundos
digitalWrite(luzvermelha1, HIGH); //mantém o vermelho aceso no semáforo 1 (PARE)
digitalWrite(luzamarela2, HIGH); //acende o amarelo do semáforo 2 (ATENÇÃO)
digitalWrite(luzverde1, HIGH); //acende o verde do semáforo 1 (SIGA)
digitalWrite(luzvermelha2, HIGH); //acende o vermelho do semáforo 2 (PARE)
digitalWrite(luzamarela1, HIGH); //acende o amarelo do semáforo 1 (ATENÇÃO)
digitalWrite(luzvermelha2, HIGH); //mantém o vermelho aceso no semáforo 2 (PARE)
}
Quando o semáforo 1 está no vermelho, o 2 está no verde (como num cruzamento entre duas
ruas ou avenidas). Quando o 1 passa para verde, o 2 passa para vermelho ao mesmo tempo e
entre estas fases temos o amarelo para cada semáforo.

18

6. Experiência nº 6 - Porta lógica NOT (NÃO) e os resistores pull up / pull down
Lista de materiais

- 1 Resistor de 22 K (vermelho-vermelho-laranja)
Procedimento

19

// Experiência 6 ‐ Porta lógica NOT (NÃO)


void setup() {
pinMode(botao, INPUT); // pino 9 do botão como entrada
}
void loop() {
boolean botaoState = digitalRead(botao); // leitura do estado do botão
boolean ledState; // Estado do led ligado ao pino 10
ledState = !botaoState ; // Estado do botão Invertido (!) em relação ao led (função NOT)
digitalWrite(led, ledState); // pino 10 vai a nível baixo ou alto de acordo com o botão
}
Neste circuito o pino 9 do Arduino é mantido constantemente em nível alto (5 V) através do

resistor de “pull up” R2 de 22 K. Nesta condição a saída vai a nível baixo e apaga o led. Ao
apertarmos a tecla, o pino 9 vai a nível baixo, a saída passa a nível alto e o led acende. Em
eletrônica digital esta função inversora chama-se NÂO ou NOT (em inglês).
Resistores “pull up” e “pull down”
Veja no exemplo abaixo um resistor para cada tipo de finalidade:
Resistores “pull up” mantém um pino do CI sempre a nível alto porque vai ligado à linha de
+B do circuito. Tal resistor é de alguns KΩ e mantém a estabilidade de funcionamento de um
circuito digital. No Arduino podemos acrescentar o resistor fora ou usar o que ele já tem interno
usando um comando para habilitá-lo. A chave CH1 quando pressiona leva o pino ao nível
baixo. Sem apertar a chave o pino fica sempre em nível alto. Em algumas de nossas
experiências usaremos o resistor “pull up” que o Arduino já tem interno.
Resistores “pull down” mantém o pino do CI ligado ao terra através de um resistor de

centenas de Ω ou alguns KΩ. Assim o pino fica normalmente em nível baixo. Ao pressionarmos
a chave CH1 o pino vai a nível alto. No caso do Arduino não há o “pull down” interno.

20

Usando o resistor “pull up” interno ao CI micro do Arduino para a experiência 6
Podemos simplificar os projetos com portas lógicas usando o resistor interno do Arduino. Assim
o circuito nº 6 fica como indicado abaixo e apenas devemos acrescentar a palavra PULLUP na
linha de código pinMode(botao, INPUT);. Fica assim: pinMode(botao, INPUT_PULLUP);

// Experiência 6 ‐ Porta lógica NOT (NÃO) com o resistor pull up interno


void setup() {
pinMode(botao, INPUT_PULLUP); // pino 9 do botão como entrada com pull up interno
}
void loop() {
boolean botaoState = digitalRead(botao); // leitura do estado do botão
ledState = !botaoState ; // Estado do botão Invertido (!) em relação ao led (função NOT)
digitalWrite(led, ledState); // pino 10 vai a nível baixo ou alto de acordo com o botão
}
Como podemos observar o código é praticamente o mesmo do experimento anterior só

acrescentando a palavra PULLUP para habilitar o resistor “pull up” interno e desta forma
diminuir a quantidade de componentes externos ao Arduino. Faça o teste de funcionamento
desta porta NOT usando os dois códigos. Você verá que no primeiro código ao retirar o resistor
pull up de 22 K do circuito, o pino 9 do Arduino passa a nível baixo e a saída a nível alto
acendendo o led. No segundo código, mesmo retirando o resistor externo de 22 K o pino
continua em nível alto (pull up interno) e a saída continua baixa mantendo o led apagado.

21

7. Experiência nº 7 - Portas lógicas com Arduino
Lista de materiais

- 2 Microchaves de toque
Procedimento

22

Nesta experiência estudaremos o funcionamento de 6 portas lógicas usando o mesmo circuito
e praticamente o mesmo código porém com pequenas alterações para cada tipo de porta.
Também usamos os resistores “pull up” internos do CI micro ao invés de colocarmos na
protoboard. Veja abaixo o código a ser usado no Arduino para este circuito:
// Experiência 7 ‐ Portas lógicas com Arduino

int botao1 = 5; // botão 1 no pino 5
int botao2 = 4; // botão 2 no pino 4

void setup() {
pinMode(botao1, INPUT_PULLUP); // pino 5 do botão1 como entrada
pinMode(botao2, INPUT_PULLUP); // pino 4 do botão2 como entrada
}
void loop() {
boolean botao1State = digitalRead(botao1); // leitura do estado do botão1
boolean botao2State = digitalRead(botao2); // leitura do estado do botão2
ledState = (botao1State & botao2State); // Saída depende do estado botão 1 e 2
digitalWrite(led, ledState); // pino 6 segue a tabela da verdade ‐ porta E (AND)
}

/* Para a mudança do tipo de porta mudamos apenas a linha de comando:
ledState = (botao1State & botao2State); para porta E (AND);
ledState = !(botao1State & botao2State); para porta NE (NAND);
ledState = (botao1State | botao2State); para porta OU (OR);
ledState = !(botao1State | botao2State); para porta NOU (NOR);
ledState = (botao1State ^ botao2State); para porta OU exclusiva (XOR);
ledState = !(botao1State ^ botao2State); para porta NOU exclusiva (XNOR);
*/
Como podemos observar no comentário abaixo do código, mudando apenas a linha de

comando ledState = (botao1State & botao2State); de acordo como indicado no próprio comentário
mudamos o tipo de porta lógica que o circuito passa a funcionar. Ao ligarmos o circuito e
carregarmos o código nele os dois pinos onde estão ligadas as chaves já ficam em nível alto
devido aos resistores “pull up” dentro do CI. Ao pressionarmos cada chave colocamos o seu
pino correspondente em nível baixo.
Porta E (AND) - Veja a tabela da verdade dela abaixo:
Botão 1 Botão 2 LED

Ligado (nível 1) Ligado (nível 1) Aceso (nível 1)
Ligado (nível 1) Desligado (nível 0) Apagado (nível 0)
Desligado (nível 0) Ligado (nível 1) Apagado (nível 0)
Desligado (nível 0) Desligado (nível 0) Apagado (nível 0)

23

Porta NE (NAND) - Veja a tabela da verdade dela abaixo:

Ligado (nível 1) Ligado (nível 1) Apagado (nível 0)
Ligado (nível 1) Desligado (nível 0) Aceso (nível 1)
Desligado (nível 0) Ligado (nível 1) Aceso (nível 1)
Desligado (nível 0) Desligado (nível 0) Aceso (nível 1)
Porta OU (OR) - Veja a tabela da verdade dela abaixo:

Porta NOU (NOR) - Veja a tabela da verdade dela abaixo:

Porta OU Exclusiva (XOR) - Veja a tabela da verdade dela abaixo:

Porta NOU Exclusiva (XNOR) - Veja a tabela da verdade dela abaixo:

ledState = (botao1State & botao2State); para porta E (AND);
ledState = !(botao1State & botao2State); para porta NE (NAND);
ledState = (botao1State | botao2State); para porta OU (OR);
ledState = !(botao1State | botao2State); para porta NOU (NOR);
ledState = (botao1State ^ botao2State); para porta OU exclusiva (XOR);
ledState = !(botao1State ^ botao2State); para porta NOU exclusiva (XNOR);


24

8. Experiência nº 8 - Led de brilho variável (PWM do Arduino)
Lista de materiais

Procedimento


25

// Experiência 8 ‐ Led de brilho variável (PWM do Arduino)

int led = 11; // Led ligado no pino 11 (PWM)
int valor = 0; // Valor inicial do led (apagado)
void setup()
{ // Aqui não temos nada para configurar
}
void loop()
{
for(valor = 0; valor <= 255; valor += 5) // aumenta o nível de brilho 5 passos por vez
{
analogWrite(led, valor); // aumenta o brilho entre 0 e 255
delay(50); // 50 milissegundos para visualizar entre um nível de brilho e outro
}
for(valor = 255; valor >= 0; valor ‐= 5) // diminui o nível de brilho 5 passos por vez
{
analogWrite(led, valor); // diminui o brilho entre 255 e 0
delay(50); // 50 milissegundos para visualizar entre um nível de brilho e outro
}
}
Nesta experiência estamos usando um dos pinos do Arduino com a função PWM (“Pulse Width
Modulation” ou modulação por largura de pulso). Os pinos com esta função vêm marcados com
o nome PWM ou com o símbolo “~”. Os pinos do Arduino são digitais onde a tensão pode
atingir dois níveis: baixo ou “0” (0 V) e alto ou “1” (5 V). Porém alguns pinos além de
trabalharem digitalmente com dois níveis também podem trabalhar como se fossem
analógicos. Para isto eles emulam (imitam) uma variação de tensão analógica através de
pulsos digitais chamados PWM. O PWM é uma onda quadrada de frequência fixa (no Arduino é
cerca de 500 Hz), mas cujos pulsos podem variar de largura. Para o pino fornecer tensão
menor os pulsos são mais finos (mais tempo em nível baixo que alto). Para fornecer tensão
maior os pulsos são mais grossos (mais tempo em nível alto que baixo). Veja abaixo:
O PWM é estreitado e alargado em 256 passos entre o zero e 255. Cada passo o sinal terá
certa largura e oferecerá uma tensão no pino 11 (em nosso caso) entre 0 e 5 V. Assim o led
aumentará e diminuirá o brilho. Entre um nível e outro há um tempo que pode ser alterado no
comando delay(50); Tente mudar este valor e veja a velocidade da variação de brilho. Mudando
o valor += 5 e valor ‐= 5 fazemos o brilho variar quantos passos por vez quisermos. Tente.

26

9. Experiência nº 9 - Controle de brilho do led
Lista de materiais

- 1 Potenciômetro de 20 K
Procedimento

27

//Experiência 9 ‐ Controle de brilho do led

int pinoled = 9; // Pino do led ‐PWM
int pinopot = 0; // Entrada analógica ligada ao centro do potenciômetro
int valorpot = 0; // Valor inicial do potenciômetro, entre 0 e 1023
int brilho = 0; // Valor inicial de brilho do led entre 0 e 255

void setup()
{
pinMode(pinoled, OUTPUT); // pino do led como saída
pinMode(pinopot, INPUT); // pino do potenciômetro como entrada
}

void loop()
{
valorpot = analogRead(pinopot); // leitura do valor analógico do potenciômetro
brilho = map(valorpot, 0, 1023, 0, 255); /*Converte o valor do potenciômetro entre 0 e 1023
para um valor PWM entre 0 e 255 para o brilho do led*/
analogWrite(pinoled, brilho); // Envia o valor de brilho para o led entre 0 e 255
}
Neste código podemos observar um valor inicial para o potenciômetro (este vai de 0 a 1023) e
outro para o led (conforme vimos na experiência anterior o PWM que sai do CI para controlar o
brilho do led vai de 0 a 255). A linha de comando brilho = map(valorpot, 0, 1023, 0, 255); possui à
esquerda os valores inicial e final do potenciômetro e à direita os valores inicial e final do brilho
do led. Mudando os valores 0, 255 podemos definir como será o brilho inicial e final do led em
todo o giro do potenciômetro. Mudando os valores 0 e 1023 (à esquerda) definimos qual fração
do giro do potenciômetro o brilho vai do mínimo ao máximo e ao continuar o giro o brilho vai de
mínimo ao máximo novamente. Para controle uniforme do brilho os valores devem estar como
no código.
Uso do monitor de porta serial no Arduino
O programa do Arduino tem no canto superior direito um ícone para ativar um monitor de
estado que podemos usar para verificar o comportamento dos dados nos pinos entradas e
saídas da experiência realizada. Veja abaixo o local do ícone citado:

28

Para habilitar o funcionamento do monitor em nossa experiência 9 colocaremos o comando
Serial.begin(9600); dentro do void setup () em qualquer lugar e os comandos: Serial.print(“Valor do
potenciometro:”); Serial.print(valorpot); Serial.print(“= Brilho do led:”); Serial.println(brilho); em
qualquer lugar do void loop () e desta forma o código ficaria assim:
//Experiência 9 ‐ Controle de brilho do led com o monitor serial

int pinoled = 9; // Pino do led ‐PWM
int pinopot = 0; // Entrada analógica ligada ao centro do potenciômetro
int valorpot = 0; // Valor inicial do potenciômetro, entre 0 e 1023
int brilho = 0; // Valor inicial de brilho do led entre 0 e 255

void setup()
{
Serial.begin(9600); // inicia a porta serial COM3 do monitor
pinMode(pinoled, OUTPUT); // pino do led como saída
pinMode(pinopot, INPUT); // pino do potenciômetro como entrada
}

void loop()
{
valorpot = analogRead(pinopot); // leitura do valor analógico do potenciômetro
brilho = map(valorpot, 0, 1023, 0, 255); /*Converte o valor do potenciômetro entre 0 e 1023
para um valor PWM entre 0 e 255 para o brilho do led*/
analogWrite(pinoled, brilho); // Envia o valor de brilho para o led entre 0 e 255
Serial.print(“Valor do potenciometro :”); // imprime no monitor o que está entre aspas
Serial.print(valorpot); // imprime o valor atual do potenciômetro no monitor
Serial.print(“ = Brilho do led:”); // imprime no monitor o que está entre aspas
Serial.println(brilho); //imprime o valor do brilho atual do led no monitor
}
Após o carregamento do código você abre primeiro verifica se a porta COM3 está selecionada
no programa do Arduino como mostrado abaixo:

29

Após isso abra o monitor serial conforme mostrado abaixo e você verá à medida que gira o
potenciômetro os valores que ele vai atingindo e os valores de brilho do led:
Observações importantes:
- O que vai escrito dentro dos parênteses e aspas das duas linhas de comando:
Serial.print(“Valor do potenciometro:”);
Serial.print(“= Brilho do led:”);
Vai aparecer na tela do monitor como podemos observar. Podemos escrever qualquer coisa aí,
porém escreva dados que tem a ver com o circuito para facilitar a leitura pelo monitor;
- Você pode copiar e colar o código para o programa do Arduino como nas outras experiências,
mas corrija as aspas destas duas linhas de comandos: (“Valor do potenciometro:”); (“= Brilho do
led:”); com o teclado do PC (refaça estas aspas) de tal modo que estes dois códigos apareçam
na cor azul no programa. Senão o código não funcionará.
- A linha de código Serial.println(brilho); usa a letra “L” (ele) minúscula após a palavra print.

30

10. Experiência nº 10 - Led tricolor RGB com brilhos e cores variáveis
Lista de materiais

- 3 Resistores de 220 Ω (vermelho-vermelho-marrom)
- 1 Led tricolor RGB de 5 mm e 4 terminais
Procedimento

31

// Experiência 10 ‐ Led RGB tricolor com brilho e cores variáveis

int ledvermelho = 11; // Led ligado no pino 11 (PWM)
int ledverde = 10; // Led ligado no pino 10 (PWM)
int ledazul = 9; // Led ligado no pino 9 (PWM)
int valor = 0; // Valor inicial dos leds (apagados)

void setup()
{
} // Aqui não temos nada para configurar

void loop()
{
{analogWrite(ledazul, valor); // aumenta o brilho do AZUL
delay(50);} // 50 milissegundos para visualizar entre um nível de brilho e outro
{analogWrite(ledazul, valor); // diminui o brilho do AZUL
delay(50); } // 50 milissegundos para visualizar entre um nível de brilho e outro

{analogWrite(ledazul, valor); // aumenta o brilho do azul e vermelho (ROXO)
analogWrite(ledvermelho, valor);
{analogWrite(ledazul, valor); // diminui o brilho do azul e vermelho (ROXO)

{analogWrite(ledvermelho, valor); // aumenta o brilho do VERMELHO
{analogWrite(ledvermelho, valor); // diminui o brilho do VERMELHO

/*Código continua na próxima página*/

O código continua na próxima página e você observará que ao carrega-lo para o Arduino o led
ficará alternado entre as cores azul, roxa, vermelho, amarelo, verde, ciano e branco, sempre
aumentando e diminuindo o brilho para cada uma delas.

32

Continuação do código:
{analogWrite(ledverde, valor); // aumenta o brilho do verde e vermelho (AMARELO)
{analogWrite(ledverde, valor); // diminui o brilho do verde e vermelho (AMARELO)

{analogWrite(ledverde, valor); // aumenta o brilho do VERDE
{analogWrite(ledverde, valor); // diminui o brilho do VERDE

{analogWrite(ledazul, valor); // aumenta o brilho do azul e verde (CIANO)
analogWrite(ledverde, valor);
{analogWrite(ledazul, valor); // diminui o brilho do azul e verde (CIANO)
analogWrite(ledverde, valor);

{analogWrite(ledverde, valor); // aumenta o brilho dos três leds (BRANCO)
analogWrite(ledazul, valor);
{analogWrite(ledverde, valor); // diminui o brilho dos três leds (BRANCO)
analogWrite(ledazul, valor);

}

Como podemos observar o código é o mesmo da experiência 8 com mais linhas de código para
controlarmos o brilho dos leds individualmente formando as três primárias (RGB), de dois em
dois formando as secundárias (ciano, amarelo e roxo) e os três ao mesmo tempo formando o
branco. Veja o resultado ao alimentar o circuito e mandar o código ao Arduino.

33

11. Experiência nº 11 - Semáforo com botão acionador
Lista de materiais

- 2 Led verdes de 5 mm
- 1 microchave de toque
Procedimento

34

// Experiência 11 ‐ Semáforo com botão acionador

int carroR = 12; // Led vermelho semáforo dos carros
int carroY = 11; // Led amarelo semáforo dos carros
int carroG = 10; // Led verde semáforo dos carros
int pedR = 8; // Led vermelho semáforo dos pedestres
int pedG = 9; // Led verde semáforo dos pedestres
int botao = 4; // Botão de acionamento pelos pedestres
int tempoatravessar = 7000; //Tempo para os pedestres atravessarem
unsigned long changeTime; // Tempo decorrido deste que o botão foi acionado

void setup() {
pinMode(carroR, OUTPUT);
pinMode(carroY, OUTPUT);
pinMode(carroG, OUTPUT); // Pinos dos leds como saídas
pinMode(pedR, OUTPUT);
pinMode(pedG, OUTPUT);
pinMode(botao, INPUT_PULLUP); // Botão como entrada usando os resistores “pull up”
digitalWrite(carroG, HIGH); // Condição normal do semáforo dos carros (verde aceso)
digitalWrite(pedR, HIGH); // Condição normal do semáforo dos pedestres (vermelho aceso)
}

void loop() {
int estado = digitalRead(botao); // Lê o estado do botão
if (estado == LOW && (millis() ‐ changeTime) > 5000) { /* Verifica o acionamento do botão e se
passaram 5 segundos desde o último acionamento*/
delay(5000); // após o pedestre apertar o botão, o semáforo aguarda 5 segundos
changeLights (); // Semáforo muda as luzes
}
}
void changeLights() {
digitalWrite(carroG, LOW); // Semáforo dos carros apaga o verde
digitalWrite(carroY, HIGH); // Semáforo dos carros acende o amarelo
delay(2000); // Espera 2 segundos
digitalWrite(carroY, LOW); // Semáforo dos carros apaga o amarelo
digitalWrite(carroR, HIGH); // Semáforo dos carros acende o vermelho
delay(1000); // Espera 1 segundo por segurança

digitalWrite(pedR, LOW); // Semáforo de pedestres apaga o vermelho
digitalWrite(pedG, HIGH); // Semáforo de pedestres acende o verde
delay(tempoatravessar); // Espera o tempo dos pedestres passarem (7 seg definidos acima)
digitalWrite(pedG, LOW); // Semáforo de pedestres apaga o verde

/* Código continua na próxima página */

35

/* Continuação do código*/

for (int x=0; x<10; x++) { // Inicia a função pisca‐pisca para o vermelho de pedestres

digitalWrite(pedR, HIGH); // Semáforo de pedestres acende o vermelho
delay(250); // Espera 0,25 segundos
digitalWrite(pedR, LOW); // Semáforo de pedestres apaga o vermelho
}
digitalWrite(pedR, HIGH); // Semáforo de pedestres acende e mantém o vermelho
digitalWrite(carroR, LOW); // Semáforo dos carros apaga o vermelho
digitalWrite(carroG, HIGH); // Semáforo dos carros acende e mantém o verde

changeTime = millis(); // Inicia novamente o loop do semáforo
}
Ao carregar o código no programa do Arduino observamos que o led verde do semáforo de

carros e o vermelho do semáforo de pedestres ficam acesos até que a tecla seja apetada. Ao
apertar a tecla, após 5 segundos o semáforo muda de estado várias vezes até voltar à
condição inicial como já explicado.
Observação - Mesmo que alguma experiência deste curso tenha seu código escrito em duas
partes por não caber todo numa folha só (como é o caso desta), você pode copiar e colar no
programa do Arduino em duas partes uma em cima da outra, que funciona normalmente.
Alguns símbolos que já estão aparecendo em algum de nossos códigos
== (igual a)
!= (não igual a ou diferente de)
< (menor que)
> (maior que)
<= (menor ou igual a)
>= (maior ou igual a)
x++ (eleva o valor de x em 1 unidade. É o mesmo que x = x+1)
Tipos de dados e o espaço ocupado na memória interna do CI micro do Arduino
Quando um comando ou um código é escrito para o Arduino executar ele possui diversas
linhas. Várias destas linhas tem indicado o tipo de dado que o comando é e desta forma qual o
espaço que vai ocupar na memória RAM do Arduino. Conforme vimos cada tipo de Arduino
possui um tipo de CI micro e consequentemente uma capacidade de armazenamento diferente.
No modelo UNO que usamos neste curso o CI tem uma capacidade de 32 Kbytes o que é
bastante uma vez que os códigos de uma forma geral que usamos são muito menores não
chegando nem perto deste valor total de armazenamento. Na página seguinte temos uma
tabela dos tipos de dados, espaço ocupado e o intervalo de valores que eles podem assumir.

36

TIPOS DE DADOS MEMÓRIA USADA INTERVALO NUMÉRICO
boolean 1 byte 0 a 1 (alto ou baixo)
byte 1 byte 0 a 255
char 1 byte -128 a 127
unsigned char 1 byte 0 a 255
int 2 bytes -32.768 a 32.767
unsigned int 2 bytes 0 a 65.535
word 2 bytes 0 a 65.535
long 4 bytes -2.147.483.648 a 2.147.483.647
unsigned long 4 bytes 0 a 4.294.967.295
float 4 bytes -3,4028235E+38 a 3,4028235E+38
double 4 bytes -3,4028235E+38 a 3,4028235E+38
string 1 byte + x Sequência de caracteres
array 1 byte + x Coleção e variáveis (arranjo)
12. Experiência nº 12 - Sequencial com 4 leds
Lista de materiais

Procedimento
Na página seguinte temos o esquema elétrico e o código. Ao gravar o código observe como os
leds acendem e apagam em sequencia num sentido e no outro. A velocidade depende de um
dado colocado no código.

37

//Experiência 12 ‐ Sequencial com 4 leds
byte pinosLEDs [] = {9, 10, 11, 12}; //arranjo com os pinos ligados aos leds
int atrasoLEDs(100); // Tempo entre apagar um led e acender o seguinte (0,1 segundo)
int sentido = 1; // Sentido para correr os leds (direita ou esquerda)
int LEDatual = 0; // led atual da sequencia
unsigned long mudaTempo;

void setup() {
for (int x=0; x<4; x++) {
pinMode(pinosLEDs[x], OUTPUT); } // Estabelece os pinos dos leds como saídas
mudaTempo = millis();
}
void loop() {
if ((millis() ‐ mudaTempo) > atrasoLEDs) { // Verifica se já passou o tempo de atraso dos leds
mudaLED(); // Muda o estado dos leds
}
}
void mudaLED() {
for (int x=0; x<4; x++) {
digitalWrite(pinosLEDs[x], LOW); //Apaga todos os leds
}
digitalWrite(pinosLEDs[LEDatual], HIGH); // Acende o led atual
LEDatual += sentido; // Cria a sequencia para os leds
if(LEDatual == 3) {sentido = ‐1;} // muda o sentido quando chega no final da carreira
if(LEDatual == 0) {sentido = 1;} // muda o sentido quando chega no final da carreira
}

38

13. Experiência nº 13 - Sequencial com 10 leds
Lista de materiais

Procedimento

39

//Experiência 13 ‐ Sequencial com 10 leds
byte pinosLEDs [] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; //arranjo com os pinos ligados aos leds
int atrasoLEDs(50); // Tempo entre apagar um led e acender o seguinte (50 milissegundos)

void setup() {
for (int x=0; x<10; x++) { // Aqui colocamos a quantidade de leds do sequencial
}
void loop() {
}
}
void mudaLED() {
for (int x=0; x<10; x++) {
}
}
Observe que é praticamente o mesmo código do circuito anterior onde fizemos pequenas
alterações. Ao carregar para o Arduino, os leds acendem e apagam em sequencia bem rápido
indo e voltando. Ao mudar o valor da linha int atrasoLEDs(50); fazemos a sequencia andar mais
rápido ou devagar. Experimente outros números, mas lembrando de que o valor está em
milissegundos. A linha for (int x=0; x<10; x++) { deve ser modificada para a quantidade de leds
que temos na sequencia. Neste caso temos 10. Se tiver menos coloque a quantidade certa. Já
na linha de comando if(LEDatual == 9) {sentido = ‐1;} você coloca a quantidade de leds da
sequencia menos 1. Como tem 10 leds colocamos o número 9. Se tiver 4 leds, coloca 3 e
assim por diante. A contagem dos pinos para o circuito digital não é de 1 a 10 e sim de 0 a 9.
Agora neste mesmo circuito vamos acrescentar um potenciômetro para controlar a velocidade
dos leds e esta será nossa próxima experiência.

40

14. Experiência nº 14 - Sequencial com 10 leds controlado manualmente
Lista de materiais

Procedimento

41

//Experiência 14 ‐ Sequencial com 10 leds controlado manualmente

byte pinosLEDs [] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12}; //arranjo com os pinos ligados aos leds
int atrasoLEDs; // Tempo entre apagar um led e acender o seguinte
int potenc = 3; // pino analógico onde vai o potenciômetro

void setup() {
for (int x=0; x<10; x++) { // Aqui colocamos a quantidade de leds do sequencial
}

void loop() {
atrasoLEDs = analogRead(potenc); // Lê o valor do potenciômetro para o atraso dos LEDs
}
}

void mudaLED() {
for (int x=0; x<10; x++) {
}
}
Ao carregar o programa verificamos que os leds acendem e apagam em sequencia como na

experiência anterior, porém nesta podemos controlar a velocidade com que isto ocorre através
de um potenciômetro. Para que o potenciômetro pudesse ser acrescentado no circuito anterior
retiramos o valor em int atrasoLEDs; acrescentamos a linha int potenc = 3; antes do void setup ()
e a leitura do potenciômetro na linha: atrasoLEDs = analogRead(potenc); devido ao potenciômetro
ser um componente analógico e usamos a entrada analógica 3 para ele mas poderíamos ter
usado qualquer outra.

42

15. Experiência nº 15 - Comparador de tensão e fotocélula com Arduíno
Lista de materiais

- 1 Resistor de 220 Ω (vermelho-vermelho-marrom)
- 2 Resistores de 10 K (marrom-preto-laranja)
- 1 Fotorresistor (LDR) de 5 ou 10 mm
Procedimento

43

//Experiência 15 ‐ Arduino como comparador de tensão e fotocélula

int led = 9; // Pino do led
int V1 = 1; // Entrada analógica para a tensão V1 (divisor formado por R2 e R3/LDR)
int V2 = 2; // Entrada analógica para a tensão V2 (potenciômetro)
int valorV1 = 0; // Valor inicial da tensão V1
int valorV2 = 0; // Valor inicial da tensão V2
void setup() {
pinMode(led, OUTPUT); // Pino do led como saída
pinMode(V1, INPUT); // Pino da tensão analógica V1 como entrada
pinMode(V2, INPUT); // Pino da tensão analógica V2 como entrada
}
void loop() {
valorV1 = analogRead(V1); // Leitura analógica do valor da tensão V1
valorV2 = analogRead(V2); // Leitura analógica do valor da tensão V2
if(valorV2 > valorV1) { // Se a tensão V2 é maior que V1
digitalWrite(led, HIGH); // O led acende
}else{ // Senão
digitalWrite(led, LOW); // O led apaga
}
}
Neste circuito comparamos duas tensões (V1 e V2) nas entradas analógicas do Arduino e se
uma delas é maior que a outra (neste caso V2 maior que V1 definida pelo código acima), a
saída vai a nível alto acendendo o led. Funciona como um amplificador operacional
comparador e tais circuitos são muito úteis na eletrônica.
Fotocélula
Para fazer a fotocélula basta trocar R3 pelo LDR. Não precisa mexer em mais nada no circuito
nem no código. Veja como fica o circuito na protoboard usando o LDR:
Coloque o circuito no escuro e gire devagar o potenciômetro até que o led acenda. Quando for
para um ambiente claro o led apaga. Assim você calibrou o circuito para o nível de escuro
desejado para que o led acenda. Pode ser mais ou menos escuro de acordo com o ajuste.

44

16. Experiência nº 16 - Efeito de fogueira com leds
Lista de materiais

Procedimento

45

// Experiência nº 16 ‐ Efeito fogueira

int led1 = 11;
int led2 = 10;
int led3 = 9; // Pinos dos leds (o led 3 é o vermelho)
int led4 = 6;
int led5 = 5;

void setup() {
pinMode(led1, OUTPUT);
pinMode(led3, OUTPUT); // Pinos dos leds como saídas
}

void loop() {
analogWrite(led1, random(120)+136); // cada pino do led assume valores PWM aleatórios
analogWrite(led2, random(120)+136); //entre 0 e 119 (120 passos total) e se soma a 136 passos
analogWrite(led3, random(120)+136); //para chegar no brilho máximo. Isto dá o efeito de
analogWrite(led4, random(120)+136); //brilho variável como o de uma chama
analogWrite(led5, random(120)+136);
delay(random(100)); // Espera um tempo aleatório entre 0 e 100 ms e recomeça o efeito
}
Ao carregar o programa na IDE do Arduino observamos os leds variarem o brilho

constantemente como se fossem uma chama de fogueira. Nesta experiência organizamos os
leds de modo que o vemelho fique ao centro rodeado pelos amarelos para dar um efeito
interessante de fogo. Se fizer isso com um led só (no caso apenas uma linha de código) dá o
efeito de uma chama de vela. Aqui apareceram os comandos “random” que significa aleatório,
em inglês. Conforme vimos alguns pinos do Arduino tem saída PWM usados nesta experiência.
Tais pinos produzem uma onda quadrada com larguras diferentes de pulsos produzindo
tensões diferentes analógicas para alimentar o dispositivo ligado neles (neste caso os leds). Há
256 diferentes passos para a tensão PWM e consequentemente valores de tensão analógica
entre 0 e 5 V. Com os comandos random(120)+136 fazemos os primeiros 120 passos do PWM
oferecerem uma tensão aleatória somada aos demais 136 passos para o led. Assim cada led
recebe uma tensão fixa de 2,66 V (136 passos) somada a outra que vai de 0 a 2,34 V (120
passos) aleatoriamente. Em resumo cada led recebe uma tensão aleatória entre 2,66 a 5 V
dando o efeito de chama de fogueira. O tempo que a tensão do led passa de um valor ao outro
também é aleatório entre 0 e 100 milissegundos definido pelo comando delay(random(100)).

46

17. Experiência nº 17 - Led tricolor RGB com controle serial através do PC
Lista de materiais

- 1 Led tricolor RGB de 5 mm e 4 terminais
Monte o circuito abaixo (é o mesmo da experiência 10) com o Arduino e a protoboard

47

// Experiência nº 17 – Led tricolor RGB com controle serial através do PC

char buffer[18]; // Define um arranjo de caracteres com 18 letras
int vermelho, verde, azul; // Cores dos leds da experiência
int Vermelho = 11;
int Verde = 10; // Define os pinos do led RGB usado no circuito
int Azul = 9;

void setup() {
Serial.begin(9600); // Inicia a comunicação serial com o PC a 9600 caracteres por segundo
Serial.flush(); // Limpa a linha para o próximo grupo de caracteres
pinMode(Vermelho, OUTPUT);
pinMode(Verde, OUTPUT); // Define os pinos do led RGB como saída
pinMode(Azul, OUTPUT);
}

void loop() {
if (Serial.available() > 0) { // Se os dados são enviados pela linha serial
int index=0; // Define um inteiro (index) com o valor “0”
delay(100); // Aguarda 100 milissegundos para encher o buffer com os dados
int numChar = Serial.available(); // Dados seriais que acabaram de chegar
if (numChar>15) { // Se tais dados tiverem mais de 15 caracteres
numChar=15; // Define como máximo de 15 caracteres por linha
}
while (numChar‐‐) { // Subtrai 1 do número de caracteres enquanto este não for zero
buffer[index++] = Serial.read(); // Soma 1 ao inteiro e define como valor lido de caracteres
}
splitString(buffer); // Lê os dados do buffer e o separa por linhas de acordo como comando
}
}

void splitString(char* data) { // Separa os caracteres por comandos (ex: R do G e do B)
Serial.print("Data entered: "); // Mostra no PC os dados digitados na linha de comandos
Serial.println(data); // Mostra no PC os dados já organizados por linhas
char* parameter; // Declara os parâmetros dos caracteres
parameter = strtok (data, " ,"); // Caracteres que representam espaços e vírgulas
while (parameter != NULL) { // Enquanto o conteúdo de caracteres não estiver vazio
setLED(parameter); // Ajusta os parâmetros dos leds
parameter = strtok (NULL, " ,"); // Limpa os buffers
}

/* Código continua na próxima página*/

48

/* Continuação do código */

for (int x=0; x<16; x++) { // Repete a próxima linha 16 vezes
buffer[x]='\0'; // Esvazia o buffer
}
Serial.flush(); // Limpa novamente a linha para o próximo grupo de caracteres
}

void setLED(char* data) { // Função ajuste dos leds
if ((data[0] == 'r') || (data[0] == 'R')) { // Se for digitado “R” ou “r”
int Ans = strtol(data+1, NULL, 10); //Define Ans como número após “R” ou “r”
Ans = constrain(Ans,0,255); // Define Ans entre 0 e 255
analogWrite(Vermelho, Ans); //Escreve o valor Ans no pino do led vermelho
Serial.print("Vermelho esta em: "); // Mostra “Vermelho esta em” no monitor do Arduino
Serial.println(Ans); // Mostra o valor do led vermelho
}
if ((data[0] == 'g') || (data[0] == 'G')) { // Se for digitado “G” ou “g”
int Ans = strtol(data+1, NULL, 10); //Define Ans como número após “G” ou “g”
analogWrite(Verde, Ans); //Escreve o valor Ans no pino do led verde
Serial.print("Verde esta em: "); // Mostra “Verde esta em” no monitor do Arduino
Serial.println(Ans); // Mostra o valor do led verde
}
if ((data[0] == 'b') || (data[0] == 'B')) { // Se for digitado “B” ou “b”
int Ans = strtol(data+1, NULL, 10); //Define Ans como número após “B” ou “b”
analogWrite(Azul, Ans); //Escreve o valor Ans no pino do led azul
Serial.print("Azul esta em: "); // Mostra “Azul esta em” no monitor do Arduino
Serial.println(Ans); // Mostra o valor do led azul
}
}
Este circuito é bastante interessante porque com ele você poderá controlar o brilho e a cor do
led RGB apenas digitando no monitor do IDE do Arduino. A primeira coisa a fazer é carregar o
código no programa do Arduino. Inicialmente o led não acenderá nenhuma cor. Então você
abre o monitor da IDE do Arduino como mostrado abaixo:

49

Daí você digita r255, g255, b255 no campo menor e pode ser em maiúsculas, minúsculas, com
ou sem espaço. Desta forma cada cor terá seu brilho máximo e o led RGB acenderá branco ao
teclar ENTER. Veja abaixo:
Para apagar todas as cores basta digitar r0, g0, b0 ou simplesmente r, g, b conforme podemos
ver abaixo:
Assim podemos obter muitas (mais de 16 milhões) de cores intermediárias digitando valores
diferentes para rgb, como por exemplo, se digitar r255, b120 obtemos um violeta bem suave,
r100, g100 dá amarelo, r180, g100 dá laranja, r150, g150, b100 dá um verde suave. Vá
experimentando valores diferentes e veja o resultado no led RGB.

50

18. Experiência nº 18 - Sensor de luz com três leds
Lista de materiais

- 1 Resistor de 10 K (marrom-preto-laranja)
Monte o circuito abaixo com o Arduino e a protoboard:

51

// Experiência nº 18 – Sensor de luz controlado por três leds

int ldr = 3; // Identifica o pino analógico onde está ligado o LDR
int valorldr = 0; // Valor inicial do LDR
int ledvm = 7; // Pino do led vermelho
int ledam = 6; // Pino do led amarelo
int ledvd = 5; // Pino do led verde

void setup() {
pinMode(ledvm, OUTPUT);
pinMode(ledam, OUTPUT); // Define os pinos dos leds como saídas
pinMode(ledvd, OUTPUT);

}
void loop() {
valorldr = analogRead(ldr); // Lê o valor analógico do LDR (luz incidente sobre ele)
if(valorldr < 750) { // Se o valor está abaixo de 750 (condição escuro)
apagaosleds(); // Apaga os demais leds
digitalWrite(ledvm, HIGH); // E acende o led vermelho
}
if(valorldr >= 750 && valorldr <= 800) { // Se o valor está entre 750 e 800 (penumbra)
digitalWrite(ledam, HIGH); // E acende o led amarelo
}
if(valorldr > 800) { // Se o valor está acima de 800 (condição claro)
digitalWrite(ledvd, HIGH); // E acende o led verde
}
delay(50); // Espera 50 milissegundos
}

void apagaosleds() { // Função usada para apagar todos os leds
digitalWrite(ledvm, LOW);
digitalWrite(ledam, LOW); // Apaga os leds não usados naquela condição de luz
digitalWrite(ledvd, LOW);
}
Ao copiar o código para a IDE do Arduino, verificamos que dependendo do nível de luz sobre o
sensor (LDR) vai acender um dos três leds, sendo que para ambiente escuro (cobrindo o ldr,
por exemplo) acende o vermelho, meia luz (jogando uma sombra) acende o amarelo e para
ambiente iluminado acende o verde.

52

19. Experiência nº 19 - Pisca pisca controlado por potenciômetro e luz
Lista de materiais


53

// Experiência nº 19 – Pisca pisca controlado por potenciômetro e luz

int led1 = 6; // Pino do led verde
int led2 = 5; // Pino do led vermelho
int ldr = 3; // Pino do LDR (3 analógico)
int pot = 2; // Pino do potenciômetro (2 analógico)
int valorpot = 0; // Valor inicial do potenciômetro
int valorldr = 0; // Valor inicial do LDR
int brilho = 0; // Brilho inicial dos leds

void setup() {
pinMode(led1, OUTPUT); // Pino do led verde como saída
pinMode(led2, OUTPUT); // Pino do led vermelho como saída
pinMode(ldr, INPUT); // Pino do LDR como entrada
pinMode(pot, INPUT); // Pino do potenciômetro como entrada

}
void loop() {
valorpot = analogRead(pot); // Leitura do valor do potenciômetro
valorldr = analogRead(ldr); // Leitura do valor do LDR
brilho = map(valorldr, 0, 1023, 0, 255); // Converte o valor do LDR para valor aos leds
analogWrite(led1, brilho); // Acende o led verde com brilho de acordo com o LDR
analogWrite(led2, 0); // Apaga o led vermelho
delay(valorpot); // Espera o tempo definido pelo potenciômetro
analogWrite(led1, 0); // Apaga o led verde
analogWrite(led2, brilho); // Acende o led vermelho com brilho de acordo com o LDR
delay(valorpot); // Espera o tempo definido pelo potenciômetro

}
A seguir carregamos o programa para a IDE do Arduino e podemos ver que os dois leds
piscam alternadamente conforme outra experiência que fizemos neste curso, porém agora o
ritmo das piscadas e o brilho dos leds são controlados pelo potenciômetro e pelo LDR. O LDR
ligado ao pino 2 capta a luz do ambiente e sua resistência depende dela. Quando o ambiente
está mais escuro, a resistência do LDR é maior e a tensão no pino A3 aumenta fazendo o
Arduino mandar maior tensão para os pinos 5 e 6 (PWM). Desta forma os leds brilham mais
forte. Se a luz do ambiente for mais forte a resistência do LDR diminui e os leds brilham mais
fraco. O potenciômetro fornece uma tensão ao pino A2 e dependendo dela os leds piscam mais
rápido ou mais devagar. Resumindo o LDR controla o brilho e o potenciômetro controla a
velocidade do pisca.

54

20. Experiência nº 20 - Dado eletrônico
Lista de materiais

- 1 Microchave de toque

55

// Experiência nº 20 – Dado eletrônico

int leds[7] = {6, 7, 8, 9, 10, 11, 12}; // Pinos dos leds do led A ao led F

int formatodado[7][7] = { // Aqui damos um formato de dado ao arranjo dos leds na placa
/* Para seu arranjo de leds funcionar legal na placa recomendo que, para a maneira que os leds
estão ligados e indicados por letras, distribua a matriz abaixo da maneira colocada aqui */

// Leds: {A, B, C, D, E, F, G}
{0, 0, 0, 1, 0, 0, 0}, // Mostra o 1
{0, 0, 1, 0, 0, 0, 1}, // Mostra o 2
{0, 0, 1, 1, 0, 0, 1}, // Mostra o 3
{1, 0, 1, 0, 1, 0, 1}, // Mostra o 4
{1, 0, 1, 1, 1, 0, 1}, // Mostra o 5
{1, 1, 1, 0, 1, 1, 1}, // Mostra o 6
{0, 0, 0, 0, 0, 0, 0} // Não mostra nada
};

int botao = 3; // Pino do botão
int blank = 6; // Quando cair “não mostra nada” define como 6

void setup()
{
for (int i = 0; i < 7; i++) // Definição dos pinos
{
pinMode(leds[i], OUTPUT); // Define todos os pinos dos leds como saída
digitalWrite(leds[i], LOW); // Apaga todos os leds inicialmente
}
randomSeed(analogRead(0)); // Lê a porta analógica 0 e cria um número aleatório
}

void loop()
{
if (digitalRead(botao)) // Lê o estado do botão. Caso seja pressionado (nível alto)
{
rodaodado(); // Roda o dado
}
delay(100); // Tempo de espera para nova rodada do dado
}

/* Código continua na próxima página */

56

/* Continuação do código */

void rodaodado() // Função para a rodada do dado
{
int resultado = 0; // Inicia a variável “resultado” com zero (0)
int comprimentorodada = random(20, 30); /* Ao apertar o botão o dado passa por uma
sequencia aleatória entre 20 e 30 números antes de mostrar o resultado final */
for (int i = 0; i < comprimentorodada; i++) // De 0 até a sequencia aleatória de números
{
resultado = random(0, 6); // Número aleatório entre 0 e 6 (entre 7 algarismos no total)
mostra(resultado); // Mostra o resultado do dado
delay(50 + i * 10); // Demora para mostrar o resultado
}
for (int j = 0; j < 3; j++) // Pisca três vezes o resultado final
{
mostra(blank); // Apaga os leds
delay(500); // Espera 500 ms (0,5 segundos)
mostra(resultado); // Mostra o resultado
delay(500); // Espera 500 ms (0,5 segundos)
}
}

void mostra(int resultado) // Mostra o resultado nos leds
{
for (int i = 0; i < 7; i++) // Controla do led A ao led G (7 resultados no total)
{
digitalWrite(leds[i], formatodado[resultado][i]); /* Acende os leds (ou led) para mostrar o
resultado final */
}
}
Ao transferir o código para a IDE do Arduino inicialmente os leds permanecem apagados até
que a chave seja pressionada. Ao pressionarmos, os leds começam a piscar aleatoriamente
até que um resultado (de um a seis leds) pisque por três vezes e seja mostrado. Para rodar o
dado novamente basta apenas pressionar a microchave e ele mostrará outro resultado (ou o
mesmo) aleatoriamente.
Chegamos ao final desta parte do nosso curso de Arduino onde aprendemos a trabalhar com
leds. Na próxima parte ensinaremos a trabalhar com outros periféricos acoplados ao Arduino.
Para dúvidas, críticas ou sugestões temos nossos e-mails a seguir:
lburgos@terra.com.br e lburgos23@terra.com.br. Nossos sites www.burgoseletronica.net,

http://loja.burgoseletronica.net e www.lojaburgoseletronica.com.br. Nossos parceiros
comerciais www.esquemafacil.com.br e www.livrotec.com.
Até nosso próximo trabalho.

57

APÊNDICE – COMO INSTALAR O ARDUINO MANUALMENTE
1. Instalando drivers para os Arduinos Uno ou Mega 2560 no Windows7, Vista, ou XP:
 Conecte a sua placa e aguarde até que o Windows inicie o processo de instalação de
drivers. Depois de alguns instantes, o processo irá falhar.
 Clique no menu iniciar e vá até o Painel de Controle
 Selecione Sistema e Segurança > Sistema > Gerenciador de Dispositivos.
 Procure na seção "Portas (COM e LPT)". Você deverá encontrar um porta aberta chamada
"Arduino UNO (COMXX)".
 Clique com o botão direito na porta "Arduino UNO (COMXX)" e selecione "Atualizar
Driver...".
 Depois selecione a opção "Procurar software de driver no computador".
 Finalmente, navegue até a pasta "drivers" dentro do aplicativo do Arduino, na pasta que foi
descompactada anteriormente, e selecione o arquivo "arduino.inf".
A partir daí, o Windows completará a instalação dos drivers.
2. Instalando drivers para os Arduinos Duemilanove, Nano, Diecimila ou Alevino com

Nanoshield USB no Windows7, Vista, ou XP:
Quando você conectar a placa, o Windows deve iniciar o processo de instalação dos drivers,
caso você ainda não tenha usado o computador com um Arduino antes.
A janela "Adicionar novo hardware" irá aparecer:
 Nessa janela, selecione "Não, não agora" e clique em avançar.

 Selecione "Instalar o driver de uma lista ou um lugar especifico (avançado)" e clique em
avançar.
 Verifique que "Procurar o melhor driver nesses lugares específicos" está selecionado;
desmarque "Procurar em mídias removiveis"; selecione "Incluir este lugar na procura" e vá
até o diretório "drivers" do Arduino, dentro da pasta que você descompactou anteriormente
(a versão mais atual dos drivers pode ser encontrada no site da FTDI). Depois, clique em
avançar.
 O Windows irá procurar pelo driver e dizer que um "USB Serial Converter" foi encontrado.
Clique em finalizar.
 A janela "Adicionar novo hardware" aparecerá novamente. Siga os mesmos passos,
selecionando as mesmas opções e o mesmo diretório. Dessa vez, uma "USB Serial Port"
será encontrada.
Você pode verificar que os drivers foram instalados clicando no menu iniciar e depois
em Painel de Controle > Sistema e Segurança > Sistema > Gerenciador de Dispositivos.
Procure por uma "USB Serial Port" na seção "Portas (COM e LPT)".

ARDUINO DESCOMPLICADO E DIVERTIDO VOLUME 1
 Como o Arduino funciona;

 Instalação do software;
 Teste da placa do Arduino;
 Programação em C/C+;
 Experiências com LEDs;
 Modificando códigos;
 20 experiências didáticas para montar;
Burgoseletronica e parceiros comerciais

www.esquemafacil.com.br
www.livrotec.com.br

O Arduino Descomplicado e Divertido - Volume 1

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

O Arduino Descomplicado e Divertido - Volume 1

Enviado por

Direitos autorais:

Formatos disponíveis

 Como o Arduino funciona;

LISTA DE MATERIAL PARA O VOL.1

 1 Placa de Arduino UNO;

LISTA DE MATERIAL VOL.1 E VOL.2

 1 Placa de Arduino UNO;

COMPONENTES PARA O VOL.1

COMPONENTES PARA OS VOL.1 E 2

Arduino é um “hardware” (circuito eletrônico) cujo principal componente é um circuito integrado

Figura 1 - Arduino Uno

Arduino Descomplicado e Divertido Luis Carlos Burgos

Arduino Descomplicado e Divertido Luis Carlos Burgos

Antes de iniciarmos as experiências para o aprendizado é necessário instalar o software e

Arduino Descomplicado e Divertido Luis Carlos Burgos

2. - Configuração do software e teste da placa Aruino

Arduino Descomplicado e Divertido Luis Carlos Burgos

Arduino Descomplicado e Divertido Luis Carlos Burgos

Arduino Descomplicado e Divertido Luis Carlos Burgos

1. Experiência nº 1 - Pisca-pisca simples

- Placa de Arduino UNO

Arduino Descomplicado e Divertido Luis Carlos Burgos

Após a montagem do circuito ao ligarmos o Arduino no PC ou alimentá-lo com uma fonte

Arduino Descomplicado e Divertido Luis Carlos Burgos

Noções sobre o código C do Arduino

1.1 - Código x Comentários - Como observamos dentro do programa do Arduino ao colocar o

Arduino Descomplicado e Divertido Luis Carlos Burgos

Mudança no código e comportamento da experiência 1

Simplificação do código da experiência 1

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard:

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard:

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard.

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard.

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard.

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Neste circuito o pino 9 do Arduino é mantido constantemente em nível alto (5 V) através do

Resistores “pull up” e “pull down”

Veja no exemplo abaixo um resistor para cada tipo de finalidade:

Resistores “pull down” mantém o pino do CI ligado ao terra através de um resistor de

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Como podemos observar o código é praticamente o mesmo do experimento anterior só

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

- Placa de Arduino UNO

Monte o circuito como indicado abaixo usando o Arduino e a protoboard.

Arduino Descomplicado e Divertido Página Luis Carlos Burgos

Como podemos observar no comentário abaixo do código, mudando apenas a linha de

Porta E (AND) - Veja a tabela da verdade dela abaixo:

Botão 1 Botão 2 LED

Arduino Descomplicado e Divertido Página Luis Carlos Burgos