O Arduino Descomplicado e Divertido - Volume 2 PDF

 Sons com Arduino;

 Display de leds;
 Display LCD;
 Motor DC;
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 EXCLUSIVO – VOL. 2
 1 Mini alto falante “buzzer” de 5 V;

 1 Resistor de 100 KΩ x ¼ W;
 1 Capacitor eletrolítico de 47 µF x 16 V;
 1 Display de leds de 7 segmentos e catodo comum;
 1 Display LCD 16 x 2 com backlight;
 1 Motor DC de 6 V;
 1 Porta Pilhas para 4 pilhas AA;
 4 pilhas AA;
 1 Diodo 1N4007;
 2 Transistores TIP41;
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;
 6 Resistores de 100 Ω x ¼ W;
 10 Resistores de 220 Ω x ¼ W;
 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 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 EXCLUSIVOS PARA O VOL.2
COMPONENTES PARA OS VOL.1 E 2

ÍNDICE
1. Experiência nº 21 – Produzindo som com Arduino _____________________________01

2. Experiência nº 22 – Carga e descarga de capacitor ____________________________03
3. Experiência nº 23 – Músicas e efeitos sonoros com Arduino _____________________05
4. Experiência nº 24 – Contador de 0 a 9 com display de leds ______________________16
5. Experiência nº 25 – Contador de 0 a 19 com display de leds _____________________19
6. Experiência nº 26 – Contador crescente e decrescente _________________________21
7. Experiência nº 27 – Semáforo com leds e display de leds _______________________24
8. Experiência nº 28 – Contador binário-decimal _________________________________27
9. Experiência nº 29 – Minuteria com dois leds e display de leds ____________________30
10. Experiência nº 30 – Portas lógicas com display de leds _________________________33
11. Experiência nº 31 – Rodar números no display com potenciômetro ________________36
12. Experiência nº 32 – Testando o display lcd ___________________________________39
13. Experiência nº 33 – Operando o display lcd em 4 e 8 bits ________________________42
14. Experiência nº 34 – Mensagem no display lcd _________________________________44
15. Experiência nº 35 – Led RGB com display lcd _________________________________46
16. Experiência nº 36 – Relógio com hora e data __________________________________50
17. Experiência nº 37 – Caracteres customizados no display lcd ______________________55
18. Experiência nº 38 – Botão liga-desliga e display lcd _____________________________59
19. Experiência nº 39 – Controle de velocidade para motor DC _______________________61
20. Experiência nº 40 – Sentido de rotação para motor DC usando duas teclas __________64

O ARDUINO DESCOMPLICADO E DIVERTIDO - VOL. 2

Por Luis Carlos Burgos
www.burgoseletronica.net
Iniciaremos aqui o volume 2 de nosso curso sobre Arduino. No volume anterior fizemos várias
experiências usando leds em diversas combinações. Neste volume ensinaremos a usar além
dos leds, outros periféricos que também podem ser controlados por Arduino como motores,
displays, etc. As técnicas de utilização e programação do arduino você tem no volume 1 desta
obra. Neste volume daremos continuidade à utilização do mesmo através de novas
experiências e códigos.
1. Experiência nº 21 - Produzindo som com Arduino
Lista de materiais
- Placa de Arduino UNO

- Protoboard de 830 pinos
- 1 Resistor de 100 Ω (marrom-preto-marrom)
- 1 mini alto falante buzzer de 5 V
- Fios para as ligações
Procedimento
Monte o circuito como indicado abaixo usando o Arduino e a protoboard.
Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Página 1

Coloque o seguinte código no programa do Arduino:
// Experiência nº 21 ‐ Produzindo som com Arduino

int buzzer = 10; // Pino do buzzer

void setup() {
pinMode(buzzer, OUTPUT); // Pino do buzzer como saída

}
void loop() {
tone(buzzer, 2000); // Buzzer apita numa frequência de 2000 Hz ou 2 kHz
delay(500); // Espera de 500 ms ou 0,5 s
noTone(buzzer); // Buzzer silencia
delay(500); // Espera de 500 ms ou 0,5 s
}
Ao transferir o código para o programa do Arduino (IDE) podemos ouvir um som agudo
produzido pelo buzzer a intervalos de meio segundo conforme definido no código. Fica
parecendo som destes despertadores de baixo custo fabricados na China. Também parece
com o som “beep” emitido por um forno micro-ondas quando termina o tempo de preparo.
Mudando o valor contido na linha de comando tone(buzzer, 2000); podemos alterar a frequência
do som produzido pelo buzzer, deixando-o mais agudo ou grave. Experimente colocar outros
valores, assim como o valor do delay e por consequência o tempo de intervalo entre os “beeps”
emitidos pelo buzzer.
Observação - Buzzer é um pequeno alto falante de cristal que emite um som pela vibração dos
cristais, diferente dos falantes comuns que emitem som pelo movimento de um cone
impulsionado por uma bobina móvel dentro do campo magnético de um imã.

Página 2

2. Experiência nº 22 - Carga e descarga de capacitor
Lista de materiais

- 3 Resistores de 220 Ω (vermelho-vermelho-marrom)
- 1 Resistor de 100 K (marrom-preto-amarelo)
- 1 Led vermelho de 5 mm
- 1 Capacitor eletrolítico de 47 µF x 16 V
- 1 Microchave de toque
Procedimento

Página 3

// Experiência nº 22 ‐ Carga e descarga de capacitor

int led = 11; // Pino do led
int capacitor = 1; // Pino analógico onde está ligado o capacitor (no caso A1)
int tensaocap = 0; /* Tensão inicial do capacitor. A tensão aplicada nas entradas analógicas do
Arduino é dividida em 1024 passos, ou seja, vão de 0 a 1023 */

void setup() {
pinMode(buzzer, OUTPUT); // Buzzer como saída
pinMode(led, OUTPUT); // Led como saída
}

void loop() {
tensaocap = analogRead(capacitor); // Tensão lida no capacitor entre 0 e 1023
if(tensaocap < 100) { // Se a tensão armazenada no capacitor for menor que 100
noTone(buzzer); // Buzzer fica mudo
digitalWrite(led, HIGH); // O led acende
}
if(tensaocap >= 100) { //Se a tensão armazenada no capacitor for igual ou maior que 100
tone(buzzer, tensaocap); // Buzzer emite som cuja frequência depende da carga do capacitor
digitalWrite(led, LOW); // O led apaga
delay(10); // Atraso de 10 ms para recomeçar o ciclo
}
}
Ao carregarmos o código para o programa do Arduino, inicialmente o capacitor está

descarregado e desta forma o pino analógico A1 recebe uma tensão muito baixa (perto de 0 V).
Desta forma o led fica aceso e não há som no buzzer. Ao pressionarmos a chave o capacitor
se carrega com aproximadamente 5 V fazendo o buzzer emitir um som agudo e o led
permanecer apagado. Lembrando que o terminal analógico de entrada do Arduino divide a
tensão em 1024 passos. Ao soltarmos o botão o capacitor se descarrega a partir do resistor R3
diminuindo a tensão no terminal A1. Assim o som do buzzer vai ficando cada vez mais grave e
quando a tensão no capacitor atinge menos de 100 passos (cerca de 0,48 V) o buzzer fica
mudo e acende o led. O ciclo se repete a cada toque na chave. Você pode experimentar outros
valores de capacitores e observar que quanto maior o valor, mais lenta é a queda da
frequência do som devido ao maior tempo que este leva para descarregar.

Página 4

3. Experiência nº 23 - Músicas e efeitos sonoros com Arduino
Lista de materiais

- 1 Resistor de 220 Ω (vermelho-vermelho-marrom)
Procedimento

Página 5

Esta experiência proposta tem o hardware (circuito) igual à experiência nº 21, porém através de
pesquisas na internet você pode encontrar códigos para músicas, melodias e efeitos sonoros
através deste circuito. Nesta lição colocarei à disposição alguns códigos interessantes de som
que encontrei pela internet, porém há vários outros que podem ser encontrados ou feitos para
esta finalidade. Então a seguir temos os códigos citados:
// Experiência nº 23A ‐ Sirene de polícia

#define tempo 10 // Tempo entre os tons
int frequencia = 0; // Frequência inicial

void setup()
{
pinMode(buzzer, OUTPUT); //Pino do buzzer como saída
}

void loop()
{
for (frequencia = 150; frequencia < 1800; frequencia += 1) // Aumenta a frequência do som
{
tone(buzzer, frequencia, tempo);
delay(1);
}
for (frequencia = 1800; frequencia > 150; frequencia ‐= 1) // Diminui a frequência do som
{
tone(buzzer, frequencia, tempo);
delay(1);
}
}
// Experiência 23 B ‐ Marcha imperial

int ledPin = 13; // Led ligado no pino 13 (opcional) para acompanhar a música

int speakerPin = 12; // Buzzer ligado no pino 11

#define c 261
#define d 294 // Frequências envolvidas na música
#define e 329
#define f 349

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

Página 6

#define g 391
#define gS 415
#define a 440
#define aS 455
#define b 466
#define cH 523
#define cSH 554 // Frequências envolvidas na música
#define dH 587 // Fonte: http://home.mit.bme.hu/~bako/tonecalc/tonecalc.htm
#define dSH 622
#define eH 659
#define fH 698
#define fSH 740
#define gH 784
#define gSH 830
#define aH 880

void setup()
{
pinMode(ledPin, OUTPUT); // Pino do led como saída
pinMode(speakerPin, OUTPUT); // Pino do buzzer como saída
}
void loop()
{
march();
}
void beep (unsigned char speakerPin, int frequencyInHertz, long timeInMilliseconds)
{
digitalWrite(ledPin, HIGH); // Acende o led de visualização da música

int x;
long delayAmount = (long)(1000000/frequencyInHertz);
long loopTime = (long)((timeInMilliseconds*1000)/(delayAmount*2));
for (x=0;x<loopTime;x++)
{
digitalWrite(speakerPin,HIGH);
delayMicroseconds(delayAmount);
digitalWrite(speakerPin,LOW);
delayMicroseconds(delayAmount);
}

digitalWrite(ledPin, LOW); // Apaga novamente o led

delay(20); // pequeno atraso de 20 ms para separar os tons da música
}

Página 7

void march()
{
// Partitura da música no site a seguir:
//http://www.musicnotes.com/sheetmusic/mtd.asp?ppn=MN0016254
// Esta é apenas uma tradução da partitura para frequências / tempo em ms
//Tempo de 500 ms para um quarto de nota

beep(speakerPin, a, 500);
beep(speakerPin, f, 350);
beep(speakerPin, cH, 150);


beep(speakerPin, eH, 500);
beep(speakerPin, fH, 350);

beep(speakerPin, gS, 500);

beep(speakerPin, aH, 500);
beep(speakerPin, gSH, 250);
beep(speakerPin, gH, 250);

beep(speakerPin, fSH, 125);
delay(250);
beep(speakerPin, aS, 250);
beep(speakerPin, dSH, 500);
beep(speakerPin, dH, 250);
beep(speakerPin, cSH, 250);


Página 8

beep(speakerPin, b, 125);
delay(250);


beep(speakerPin, gSH, 250);
beep(speakerPin, gH, 250);

delay(250);
beep(speakerPin, aS, 250);
beep(speakerPin, dSH, 500);
beep(speakerPin, dH, 250);
beep(speakerPin, cSH, 250);

beep(speakerPin, b, 125);
delay(250);

beep(speakerPin, c, 125);
}

/* Fim do código*/

Página 9

Hinos dos principais clubes do estado de São Paulo
Este projeto curioso foi extraído do excelente site http://labdegaragem.com. Para o Arduino
tocar o hino dos quatro principais clubes de futebol do estado de SP, necessitaremos de um
arquivo chamado “pitches.h” que está dentro da pasta dos códigos que acompanham o curso.
Tal arquivo também pode ser baixado do site citado linhas acima. Antes de usar os códigos das
músicas dos clubes no programa do Arduino siga o procedimento para ativar o arquivo
“pitches.h”: Abra o programa do Arduino e no menu selecione: Sketch > Adicionar arquivo.
Procure a pasta do seu PC onde está o arquivo “pitches.h” e abra-o. Veja abaixo:
Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

10

Após abrir o arquivo “pitches.h” podemos copiar e colar os códigos no programa do Arduino
que o circuito executará a melodia do hino do clube escolhido. Os códigos estão a seguir:
//Experiência 23C ‐ Hino do São Paulo F.C.
#include "pitches.h"
#define NO_SOUND 0
int melodia[] = { // Notas que devem ser tocadas ordenadamente;
NOTE_D4,NOTE_E4,NOTE_FS4,NOTE_E4,NOTE_D4,NOTE_B3,NOTE_A3,
NOTE_A3,NOTE_A3,NOTE_D4,NOTE_D4,NOTE_E4,NOTE_E4,NOTE_B3,NOTE_B3,NOTE_D4,NOTE_C
S4,
NO_SOUND,NOTE_CS4,NOTE_D4,NOTE_E4,NOTE_D4,NOTE_CS4,NOTE_D4,NOTE_CS4,NOTE_B3,
NO_SOUND,NOTE_B3,NOTE_CS4,NOTE_D4,NOTE_CS4,NOTE_E4,NOTE_D4,NOTE_B3,NOTE_A3,//G
3
NO_SOUND,NOTE_A3,NOTE_B3,NOTE_CS4,NOTE_B3,NOTE_CS4,NOTE_D4,NOTE_E4,NOTE_E4,NO
TE_D4,
NOTE_E4,NOTE_D4,NOTE_E4,NOTE_FS4,NOTE_GS4,NOTE_E4,NOTE_A4,NOTE_A4,
NO_SOUND,NO_SOUND,NOTE_A4,NOTE_G4,NOTE_FS4,NOTE_E4,NOTE_A4,NOTE_E4,NOTE_A4,
NOTE_E4,NOTE_A3,NOTE_B3,NOTE_CS4,NOTE_B3,NOTE_B3,NOTE_A3,//teste
NO_SOUND,NOTE_FS4,NOTE_G4,NOTE_FS4,NOTE_E4,NOTE_A4,NOTE_E4,NOTE_A4,NOTE_E4,
NOTE_A4,NOTE_A4
};
// Duração das Notas: Colcheia:8; Semínima: 4; Mínima:2; Semibreve:1
int tempoNotas[] = {
3,8,8,8,8,8,2,
3,8,3,8,8,8,8,8,4,4,
4,3,8,8,8,8,8,2,4,
4,3,8,8,8,8,8,2,4,
4,3,8,8,8,8,8,2,3,8,
8,8,3,8,8,8,2,3,
8,4,4,4,4,4,4,4,4,
4,8,8,4,4,8,2,
8,4,4,4,2,2,4,4,4,
2,2
};
const int compasso = 1450; // Altera o compasso da música
void setup() { // Nada para configurar aqui
}
void loop(){
for (int Nota = 0; Nota < 80; Nota++) { //o número 80 indica quantas notas tem a nossa matriz.
int tempo = compasso/tempoNotas[Nota]; //Tempo = compasso dividido pela indicação da matriz
//tempoNotas.
tone(12, melodia[Nota],tempo); //Toca a nota indicada pela matriz melodia durante o tempo.
// Para distinguir as notas adicionamos um tempo entre elas (tempo da nota + 20%).
delay(tempo*1.2);
}
}

11

// Experiência 23D ‐ Hino da S.E. Palmeiras
#define NO_SOUND 0
NOTE_G3, NOTE_G3, NOTE_G3,NOTE_A3,NOTE_B3,NOTE_C4,NOTE_D4,NOTE_C4,NOTE_E4,
NOTE_E4,NOTE_D4,NOTE_B3,NOTE_D4,NOTE_A3,NOTE_G3,NOTE_A3,NOTE_G3,NOTE_B3,NOTE_
A3,
NOTE_A3,NOTE_A3,NOTE_A3,NOTE_A3,NOTE_B3,NOTE_D4,NOTE_CS4,NOTE_D4,NOTE_E4,NOTE_
G4,NOTE_F4,
NO_SOUND,NOTE_F4,NOTE_E4,NOTE_G4,NOTE_F4,NOTE_D4,NOTE_B3,NOTE_A3,NOTE_G3,NOTE
_E4,NOTE_E4,
NO_SOUND,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_C4,NOTE_E4,NOTE
_D4,
NOTE_D4,NOTE_G4,NOTE_G4,NOTE_G4,NOTE_F4,NOTE_E4,NOTE_E4,NOTE_G4,NOTE_E4,NOTE_D
4,
NO_SOUND,NOTE_A3,NOTE_B3,NOTE_C4,NOTE_B3,NOTE_C4,NOTE_D4,NOTE_C4,NOTE_D4,
NOTE_E4,NOTE_DS4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_GS4,NOTE_A4,NOTE_A3,
NOTE_E4,NOTE_E4,NOTE_C4
};
8,8,4,8,8,4,8,8,4,
2,8,8,4,8,8,4,8,8,4,
2,8,8,4,8,8,4,8,8,4,4,
4,8,8,4,8,8,4,8,8,4,4,
4,8,8,4,8,8,4,8,8,4,
2,8,8,4,8,8,4,8,8,2,
4,8,8,4,8,8,4,8,8,
4,8,8,4,8,8,4,4,
4,4,2
};
}
void loop(){
int tempo = compasso/tempoNotas[Nota]; //Tempo = compasso dividido pela indicação da
//matriz tempoNotas.
delay(tempo*1.2);
}
}

12

// Experiência 23E ‐ Hino do S.C. Corinthians P.
#define NO_SOUND 0
NO_SOUND, NOTE_C5,NOTE_B4,NOTE_G4,NOTE_E4,NOTE_E4,
NO_SOUND,NOTE_B3,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_B4,NOTE_A4,NOTE_G4,NOTE_F4,NOTE
_F4,
NO_SOUND,NOTE_A4,NOTE_F4,NOTE_E4,NOTE_DS4,NOTE_DS4,
NO_SOUND,NOTE_DS4,NOTE_DS4,NOTE_E4,NOTE_F4,NOTE_A4,NOTE_G4,NOTE_F4,NOTE_B4,
NO_SOUND,NOTE_B4,NOTE_A4,NOTE_GS4,NOTE_A4,NOTE_A4,
NO_SOUND,NOTE_A4,NOTE_A4,NOTE_B4,NOTE_C5,NOTE_E5,NOTE_C5,NOTE_A4,NOTE_G4,
NO_SOUND,NOTE_E5,NOTE_B4,NOTE_G4,NOTE_F4,NOTE_F4,
NO_SOUND,NOTE_A4,NOTE_B4,NOTE_C5,NOTE_B4,NOTE_A4,NOTE_G4,NOTE_F4,NOTE_E4,
NO_SOUND,NOTE_B3,NOTE_CS4,
NOTE_DS4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_F4,NOTE_C5,NOTE_C5,NOTE_B4,NOTE_
A4,NOTE_G4,NOTE_A4,
NOTE_B4,NOTE_B3,NOTE_CS4,
NOTE_DS4,NOTE_E4,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_F4,NOTE_C5,NOTE_C5,NOTE_B4,NOTE_
A4,NOTE_G4,NOTE_A4,
NOTE_B4,NOTE_B4,
NO_SOUND,NOTE_B4,NOTE_A4,NOTE_GS4,NOTE_A4,NOTE_A4,
NO_SOUND,NOTE_A4,NOTE_G4,NOTE_F4,NOTE_G4,NOTE_G4,
NO_SOUND,NOTE_E5,NOTE_B4,NOTE_G4,NOTE_F4,
NO_SOUND,NOTE_F4,NOTE_G4,NOTE_A4,NOTE_B4,NOTE_A4,NOTE_G4,NOTE_F4,NOTE_E4
};
int tempoNotas[] = { // Duração das Notas: Colcheia:8; Semínima: 4; Mínima:2; Semibreve:1
4,4,4,4,2,2,
8,8,8,8,8,8,8,8,2,2,
4,4,4,4,2,2,
8,8,8,8,8,8,8,8,1,
4,4,4,4,2,2,
8,8,8,8,8,8,8,8,1,
4,4,4,4,2,2,
8,8,8,8,8,8,8,8,1,
4,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,
4,8,8,
8,8,8,8,8,8,8,8,8,8,8,8,
2,2,
4,4,4,4,2,2,
4,4,4,4,2,2,
4,4,4,4,1,
8,8,8,8,4,8,8,2,2
} ; /*Código continua na próxima página*/

13

}

void loop() {
int tempo = compasso/tempoNotas[Nota]; //tempo = compasso dividido pela indicação da
// Para distinguir as notas adicionamos um tempo entre as elas (tempo da nota + 20%).
delay(tempo*1.2);
}
}
// Experiência 23F ‐ Hino do Santos F.C.

#define NO_SOUND 0

NO_SOUND,NOTE_E4,
NOTE_A4,NOTE_B4,NOTE_C5,NOTE_E5,NOTE_D5,NOTE_B4,NOTE_GS4,NOTE_E4,
NOTE_B4,NOTE_A4,NOTE_A4,
NOTE_D5,NOTE_E5,NOTE_F5,NOTE_A5,NOTE_G5,NOTE_E5,NOTE_CS5,NOTE_A3,
NOTE_E5,NOTE_D5,NOTE_G5,NOTE_F5,
NOTE_G5,NOTE_F5,NOTE_D5,NOTE_B4,NOTE_G5,NOTE_D5,NOTE_G5,NOTE_F5,
NOTE_F5,NOTE_E5,NO_SOUND,NOTE_C5,NOTE_A4,
NOTE_B4,NOTE_B4,NOTE_DS5,NOTE_FS5,NOTE_A5,NOTE_C6,NOTE_B5,NOTE_A5,
NOTE_A5,NOTE_GS5,NO_SOUND,
NOTE_G5,NOTE_A5,NOTE_B5,NOTE_G5,NOTE_F5,NOTE_E5,
NOTE_F5,NOTE_E5,NOTE_E5,NOTE_B4,NOTE_C5,NOTE_D5,NOTE_E5,
NOTE_D5,NOTE_CS5,NOTE_D5,NOTE_F5,NOTE_A5,NOTE_D5,
NOTE_C5,NOTE_B4,NOTE_C5,NOTE_E5,NOTE_D5,
NOTE_B5,NOTE_GS5,NOTE_F5,NOTE_E5,NOTE_C6,NOTE_B5,NOTE_A5
};

14

8,8,
8,8,8,8,8,8,8,8,
8,2,8,
8,8,8,8,8,8,8,8,
8,3,4,8,
8,8,8,8,8,8,8,8,
8,3,8,4,8,
8,8,8,8,8,8,8,8,
8,2,2,
8,8,8,8,8,1,
8,4,3,8,8,8,1,
8,8,8,8,3,8,
8,8,8,8,2,
8,8,8,8,4,4,2
};

}

void loop(){
int tempo = compasso/tempoNotas[Nota]; //Tempo = compasso dividido pela indicação da
delay(tempo*1.2);
}
}
E assim vimos que com um circuito bem simples com Arduino e buzzer podemos tocar
praticamente qualquer música ou melodia basta ter o código dela para copiar no programa.
Conforme visto você pode encontrar na internet diversos códigos de Arduino para diversas
canções bastando apenas coloca-lo no programa e gravá-lo no software. As demais músicas
eu deixo por conta da criatividade para cada um produzir o código ou procurar na internet.

15

4. Experiência nº 24 - Contador de 0 a 9 com display de leds catodo comum
Display de leds
Em várias experiências de nosso curso usaremos os displays de leds. Eles

são formados por 7 segmentos compondo o número “8” e mais um ponto
representando as dezenas. Cada um destes 8 segmentos é iluminado por um
led minúsculo e estes leds podem ser interligados pelo catodo (display de
catodo comum) ou pelo anodo (display de anodo comum). Para saber se o
display é de catodo ou anodo comum basta observar uma letra “A” ou “C” no
corpo dele. Veja ao lado o esquema de um display de catodo comum. Ele
possui 10 terminais e os segmentos são representados pelas letras de “a” até “g”. A letra “K”
representa o catodo de todos interligados. Um dos terminais do display não tem ligação com o
circuito onde ele está.
Lista de materiais

- 1 Display de leds de 7 segmentos e catodo comum
Procedimento

16

// Experiência nº 24 ‐ Contador de 0 a 9 com display de leds

byte display_sete_digitos[10][7] = { // 10 Dígitos a serem formados/7 segmentos do display

// Aqui temos uma relação entre os segmentos do display e o nível lógico para formar dígitos

// Segmentos a,b,c,d,e,f,g
{ 1,1,1,1,1,1,0 }, // = Digito 0
{ 0,1,1,0,0,0,0 }, // = Digito 1
{ 1,1,0,1,1,0,1 }, // = Digito 2
{ 1,1,1,1,0,0,1 }, // = Digito 3
{ 0,1,1,0,0,1,1 }, // = Digito 4
{ 1,0,1,1,0,1,1 }, // = Digito 5
{ 1,0,1,1,1,1,1 }, // = Digito 6
{ 1,1,1,0,0,0,0 }, // = Digito 7
{ 1,1,1,1,1,1,1 }, // = Digito 8
{ 1,1,1,0,0,1,1 }, // = Digito 9

};

/* Código continua na página seguinte*/

17

void setup()
{
pinMode(2, OUTPUT); // Pino 2 ligado ao segmento a
pinMode(3, OUTPUT); // Pino 3 ligado ao segmento b
pinMode(4, OUTPUT); // Pino 4 ligado ao segmento c
pinMode(5, OUTPUT); // Pino 5 ligado ao segmento d
pinMode(6, OUTPUT); // Pino 6 ligado ao segmento e
pinMode(7, OUTPUT); // Pino 7 ligado ao segmento f
pinMode(8, OUTPUT); // Pino 8 ligado ao segmento g

}

void displayWrite(byte digito) // Aciona o display
{
byte pino = 2; // Primeiro pino usado para o display

for (byte contagem = 0; contagem < 7; ++contagem) // Liga e desliga os leds formando os dígitos
{
digitalWrite(pino, display_sete_digitos[digito][contagem]); // Forma os dígitos
++pino; // Passa ao pino seguinte do Arduino
}

}

void loop()
{

for (byte numero = 0; numero < 10; numero++) // Conta os números em sequência
{
delay(500); // Intervalo de 0,5 segundos entre um dígito mostrado e o próximo
displayWrite(numero); // Mostra o número no display
}
}
Ao carregar o código para o programa do Arduino podemos observar como o display vai contar
de 0 a 9 continuamente até que a alimentação seja desligada. A velocidade da contagem pode
ser alterada na penúltima linha de comando delay(500); Aí ele está configurado para contar
numa velocidade de 0,50 segundos ou 500 ms. Alterando este valor podemos fazer o contador
andar mais rápido ou devagar. Colocando por exemplo 1000 fazemos o circuito contar de 1 em
1 segundo.

18

5. Experiência nº 25 - Contador de 0 a 19 com display de leds catodo comum
Lista de materiais

Procedimento

19

// Experiência nº 25 ‐ Contador de 0 a 19 com display de leds

{ 1,1,1,1,1,1,0 }, // = Digito 0
{ 0,1,1,0,0,0,0 }, // = Digito 1
{ 1,1,0,1,1,0,1 }, // = Digito 2
{ 1,1,1,1,0,0,1 }, // = Digito 3
{ 0,1,1,0,0,1,1 }, // = Digito 4
{ 1,0,1,1,0,1,1 }, // = Digito 5
{ 1,0,1,1,1,1,1 }, // = Digito 6
{ 1,1,1,0,0,0,0 }, // = Digito 7
{ 1,1,1,1,1,1,1 }, // = Digito 8
{ 1,1,1,0,0,1,1 }, // = Digito 9
};
void setup()
{
pinMode(9, OUTPUT); // Pino ligado ao ponto da dezena
writePonto(0); // Começa com o ponto da dezena apagado
}
void writePonto(byte ponto)
{
digitalWrite(9, ponto); // Aciona o ponto da dezena
}
{
{
}
}
/*Código continua na próxima página*/

20

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

void loop()
{

for (byte numero = 0; numero < 10; numero++) // Conta os números de 0 a 9
{
delay(1000); // Intervalo de 1 segundo entre um dígito mostrado e o próximo
writePonto(0); // Mantém o ponto desligado para contar as unidades
}

for (byte numero = 0; numero < 10; numero++) // Conta os números de 10 a 19
{
writePonto(1); // Mantém o ponto aceso para servir como dezena
}

}

Agora copie o código para o programa do Arduino e observe como o contador vai de 0 a 9 e
após o 9 acende o ponto que neste caso está representando o dígito “1” das dezenas. Após a
contagem com o ponto da dezena, o ciclo se repete. A velocidade de contagem para este
circuito é de 1 segundo podendo ser alterada facilmente no comando “delay”. Note que este
circuito é semelhante ao anterior, porém agora acrescentamos o segmento do ponto no display
e modificamos um pouco o código para que este ponto funcione. H´diversas experiências com
Arduino usando displays tanto com led quanto lcd e ao longo deste curso vamos mostrando os
mais comuns.
6. Experiência nº 26 - Contador crescente e decrescente
Lista de materiais

Procedimento
Monte o circuito como indicado na pagina seguinte e cole o código no programa do Arduino:

21

// Experiência nº 26 ‐ Contador crescente e decrescente

{ 1,1,1,1,1,1,0 }, // = Digito 0
{ 0,1,1,0,0,0,0 }, // = Digito 1
{ 1,1,0,1,1,0,1 }, // = Digito 2
{ 1,1,1,1,0,0,1 }, // = Digito 3
{ 0,1,1,0,0,1,1 }, // = Digito 4
{ 1,0,1,1,0,1,1 }, // = Digito 5
{ 1,0,1,1,1,1,1 }, // = Digito 6
{ 1,1,1,0,0,0,0 }, // = Digito 7
{ 1,1,1,1,1,1,1 }, // = Digito 8
{ 1,1,1,0,0,1,1 }, // = Digito 9
};
/*código continua na página seguinte*/

22

void setup()
{
}

{

{
}
}

void loop()
{
for (byte numero = 0; numero < 10; numero++) // Contagem crescente
{
}
delay(1000); // Espera 1 segundo para iniciar a contagem decrescente
for (byte numero = 10; numero >0; numero‐‐) // Contagem decrescente
{
}
delay(1000); // Espera 1 segundo para iniciar a contagem crescente
}

Ao ligar o circuito veremos a contagem dos números de 0 a 9 no intervalo de meio segundo

entre um e outro. Chegando ao 9 após um segundo a contagem vai no sentido decrescente de
9 ao 0 e chegando ao zero o ciclo se repete.

23

7. Experiência nº 27 - Semáforo com leds e display de leds
Lista de materiais

- 1 Led verde de 5 mm
- 1 Led amarelo de 5 mm
Procedimento

24

// Experiência nº 27 ‐ Semáforo com leds e display de leds


// Aqui temos uma relação entre os segmentos do display e o nível lógico para formar dígitos

{ 1,1,1,1,1,1,0 }, // = Digito 0
{ 0,1,1,0,0,0,0 }, // = Digito 1
{ 1,1,0,1,1,0,1 }, // = Digito 2
{ 1,1,1,1,0,0,1 }, // = Digito 3
{ 0,1,1,0,0,1,1 }, // = Digito 4
{ 1,0,1,1,0,1,1 }, // = Digito 5
{ 1,0,1,1,1,1,1 }, // = Digito 6
{ 1,1,1,0,0,0,0 }, // = Digito 7
{ 1,1,1,1,1,1,1 }, // = Digito 8
{ 1,1,1,0,0,1,1 }, // = Digito 9

};
void setup()
{
pinMode(10, OUTPUT); // Pino 10 ligado ao led vermelho
pinMode(11, OUTPUT); // Pino 11 ligado ao led amarelo
pinMode(12, OUTPUT); // Pino 12 ligado ao led verde
}

{
{
}
}
/*código continua na próxima página*/

25

void loop()
{

digitalWrite(10, HIGH); // Acende o led vermelho
digitalWrite(11, LOW); // Apaga o led amarelo
digitalWrite(12, LOW); // Apaga o led verde
for (byte numero = 10; numero > 0; numero‐‐) // contagem decrescente começando do 9
{
}

digitalWrite(10, LOW); // Apaga o led vermelho
digitalWrite(11, LOW); // Apaga o led amarelo
digitalWrite(12, HIGH); // Acende o led verde
{
}

digitalWrite(10, LOW); // Apaga o led vermelho
digitalWrite(11, HIGH); // Acende o led amarelo
digitalWrite(12, LOW); // Apaga o led verde
{
}
}
Ao carregarmos o código no programa do Arduino veremos inicialmente o led vermelho aceso

por um tempo que vai decrescendo no display até acender o led verde. Daí o tempo decresce
novamente para então acender o amarelo, depois o vermelho outra vez e o ciclo se repete.
Observe como o led amarelo fica menos tempo aceso como nos semáforos reais.
Observação - Neste circuito ligamos apenas um resistor do catodo do display ao terra ao invés
de ligar um em cada segmento como fizemos nas demais experiências. Este tipo de circuito
tem uma vantagem e desvantagem:
Vantagem - Necessitamos de apenas um resistor para ligar no catodo uma vez que os
segmentos (anodos) são alimentados diretamente pelos pinos do Arduino;
Desvantagem - O brilho do display varia um pouco de acordo com dígito apresentado porque
como toda a corrente deve passar no resistor único, ela será dividida entre os segmentos e
quanto mais segmentos funcionando menor será a corrente em cada um deles diminuindo
desta forma o brilho total do dígito. Mas nada que atrapalhe a experiência. Ligando um resistor
em cada segmento a corrente é exatamente igual em cada um para cada dígito.

26

8. Experiência nº 28 - Contador binário-decimal
Lista de materiais

- 4 Leds vermelhos de 5 mm
Procedimento

27

// Experiência nº 28 – Contador binário‐decimal

void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(7, OUTPUT); // Define os pinos de saída para os segmentos do display e leds
pinMode(8, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
}
void loop() {

digitalWrite(2, 1); digitalWrite(3, 1); digitalWrite(4, 1); digitalWrite(5, 1);
digitalWrite(10, 0); digitalWrite(11, 0); digitalWrite(12, 0);
delay(5000); // Mostra o decimal “0” no display e o binário 0000 nos leds, espera 5 segs



28





}

Nesta experiência vemos o display contar de 0 a 9 em decimais e os 4 leds formando os bits

para a contagem binária. Quando o led acende indica como bit 1 e quando apaga, bit 0. Para a
contagem binária dos bits contamos os leds da direita para a esquerda. Sendo o bit da direita o
menos significativo e o da esquerda o mais significativo. Em termos de conversão para o
sistema decimal, o led (bit) da esquerda aceso vale 1, o seguinte, 2, o próximo, 4 e o mais à
esquerda, 8. Temos algumas observações em relação ao código usado nesta experiência:
1 - Função void setup() - Aqui já indicamos os pinos de saída do Arduino sendo do 2 ao 8

para os segmentos do display e do 9 ao 12 para os leds;
2 - Função void loop() - Aqui ao invés de usarmos as palavras HIGH (alto) ou LOW (baixo)
usamos os números 1 para nível alto e 0 para nível baixo.
3 - Diminuição de linhas - Observe que colocamos várias vezes os comandos digitalWrite

numa mesma linha para economia de espaço, porém basta separá-los por ponto e vírgula que
eles funcionarão normalmente.
Fizemos estas duas últimas mudança devido ao fato deste código ser relativamente extenso e
assim ficar mais fácil de representa-lo dentro do retângulo e não haver necessidade de tanto
espaço (folhas) para esta experiência.

29

9. Experiência nº 29 – Minuteria com dois leds e display
Lista de materiais

- 1 Led verde de 5 mm
Procedimento

30

// Experiência nº 29 – Minuteria com dois leds e display

int botao = 10; // Pino do botão
int estadobotao = 0; // Estado inicial do botão
void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT); // Define os pinos dos leds e display como saídas
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(botao, INPUT_PULLUP); // Pino do botão como entrada
}
void loop() {
digitalWrite(12, 0); // Mostra o número “0” no display

estadobotao = digitalRead(botao);
if(estadobotao == LOW) { // Se o botão estiver pressionado (nível baixo no pino);
ledvermelho(); // Vai para a função contador led vermelho
}
if(estadobotao == LOW) { // Se o botão estiver pressionado (nível baixo no pino);
ledverde(); // Vai para a função contador led verde
}
}
void ledvermelho() {
digitalWrite(11, 1); // Mostra o 9 no display e aguarda 1 segundo
delay(1000);
delay(1000); // Mostra o 8 no display e aguarda 1 segundo


31

digitalWrite(11, 0); // Mostra o 1 no display e aguarda 1 segundo
delay(1000);
}

void ledverde() {



32

digitalWrite(6, 1); digitalWrite(7, 1); digitalWrite(8, 0); // Mostra o 0 no display

}
Ao copiar o código para o programa do Arduino veremos que o display vai mostrar
permanentemente o número zero e os dois leds permanecerão apagados. Ao apertar o botão
os dois leds acendem e inicia a contagem de 9 até 0. Quando chega ao zero, o led vermelho
apaga e inicia uma nova contagem de 9 ao 0. Quando chega novamente ao zero o led verde
apaga e a contagem pára até que pressionemos novamente o botão o ciclo se repita. Este
circuito funciona como as minuterias usadas em corredores de prédio, porém esta nossa temos
um contador com display de leds. Em nosso caso a contagem é feita em intervalos de 1
segundo.
10. Experiência nº 30 – Portas lógicas com displays de leds
Lista de materiais

- 2 microchaves de toque
Procedimento
Monte o circuito como indicado na página seguinte usando o Arduino e a protoboard. Neste
circuito o led de saída foi substituído pelo display que indicará H para nível alto e L para nível
baixo e como já vimos ele pode funcionar como qualquer porta lógica.

33

Copie o código que está na página a seguir para o programa do Arduino:

34

// Experiência nº 30 – Portas lógicas com display de leds

void setup() {
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT); // Define dos pinos 2 ao 8 saídas para o display
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(10, INPUT_PULLUP); // Entrada para um dos botões com a função “pull up”
pinMode(11, INPUT_PULLUP); // Entrada para o outro botão com a função “pull up”
}
void loop() {

boolean estadobotao1 = digitalRead(10); // Lê o botão ligado ao pino 10
boolean estadobotao2 = digitalRead(11); // Lê o botão ligado ao pino 11
boolean estadosaida; // Define a saída para o display
estadosaida = (estadobotao1 & estadobotao2); // porta E (AND)
// !(estadobotao1 & estadobotao2); // porta NE (NAND)
// (estadobotao1 | estadobotao2); // porta OU (OR)
// !(estadobotao1 | estadobotao2); // porta NOU (NOR)
// (estadobotao1 ^ estadobotao2); // porta OU exclusiva (XOR)
// !(estadobotao1 ^ estadobotao2); // porta NOU exclusiva (XNOR)
if(estadosaida == 1) { // Se a saída for 1 ou nível alto
high(); // Vai para a função “high”
}else{ // Senão
low(); // Vai para a função “low”
}
}
void high() {
} // Mostra a letra H de HIGH ou nível alto no display
void low() {
} // Mostra a letra L de LOW ou nível baixo no display
Ao carregar o código para o Arduino observamos que aparece uma letra H de HIGH (nível alto
no display. Como a porta E que é a primeira configuração necessita que os dois pinos dos
botões estejam em nível alto para a saída indicar nível alto. Sem apertar os botões os pinos
ficam em nível alto devido aos resistores de “pull up” internos. Ao apertarmos qualquer tecla ou
as duas a saída fica baixa (L). Para este circuito funcionar em cada uma das portas lógicas
basta alterar uma linha de comando como podemos ver no próprio código.

35

11. Experiência nº 31 – Rodar números no display com potenciômetro
Lista de materiais

- 1 Potenciômetro de 20 K
Procedimento

36

Copie o código a seguir no programa do Arduino:
// Experiência nº 31 – Rodar números no display com potenciômetro

void setup()
{
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT); // Define os pinos de 2 ao 8 para o display
pinMode(6, OUTPUT);
pinMode(7, OUTPUT);
pinMode(8, OUTPUT);
pinMode(A1, INPUT); // Define o pino A1 como entrada (analógica)

}
void loop() {
int valorpot = 0; // Valor inicial do potenciômetro
valorpot = analogRead(A1); // Lê o pino do potenciômetro e define o valor

if(valorpot <= 102) {zero();}
if(valorpot == 103 & valorpot <= 204) {um();}
if(valorpot == 205 & valorpot <= 306) {dois();}
if(valorpot == 307 & valorpot <= 408) {tres();} // Define os intervalos de valores do
if(valorpot == 409 & valorpot <= 510) {quatro();} // potenciômetro para acionar as funções
if(valorpot == 511 & valorpot <= 612) {cinco();}
if(valorpot == 613 & valorpot <= 714) {seis();}
if(valorpot == 715 & valorpot <= 816) {sete();}
if(valorpot == 817 & valorpot <= 918) {oito();}
if(valorpot == 919 & valorpot <= 1023) {nove();}
}
void zero() {
} // Mostra o dígito “0” no display
void um() {
void dois() {



37

void tres() {
void quatro() {
void cinco() {
void seis() {
void sete() {
void oito() {
void nove() {

Ao carregarmos o código para o programa do Arduino veremos que a princípio o display não
vai acender, mas ao girar o eixo do potenciômetro ele mostra um dígito que vai aumentando à
medida que vamos girando o potenciômetro para uma das extremidades e diminuindo quando
giramos o eixo para o outro lado. Como já vimos o potenciômetro tem sua rotação dividida em
1024 pontos (0 a 1023) para o Arduino e dependendo do ponto que estiver ele vai mostrar um
dos dez algarismos entre 0 e 9 no display. Cada digito a ser mostrado usa uma base de
aproximadamente 102 pontos do potenciômetro. Como são dez dígitos a serem mostrados
basta dividir o total de pontos do potenciômetro pelos dez dígitos resultando em cerca de 102
(na verdade 102,4) pontos para cada dígito.

38

12. Experiência nº 32 – Testando o display LCD
Em nossas próximas experiências usaremos um display de cristal líquido (LCD) que pode
formar caracteres em 16 colunas e 2 linhas. Desta forma ele é chamado de 16 x 2 e possui 32
elementos formados por vários pontos pretos que se alinham para formar os caracteres de
acordo com as instruções recebidas. Nosso display possui 16 terminais que podem ser
organizados de duas formas diferentes conforme visto abaixo:
Como observamos ele possui 14 pinos contados da direita para a esquerda mais os dois pinos
do led que ilumina o “backlight”. Estes são chamados de +L e –L e podem ficar à direita ou à
esquerda dos demais pinos. Mas não se preocupe que esta pinagem vem marcada no próprio
display. A função dos pinos do display estão indicadas a seguir:
Pinos +L e –L = Alimentam o led do backlight. Serão ligados ao +B de 5 V e o GND;

Pino 1 = VSS = Vai ligado ao terra do circuito (0 V ou GND);
Pino 2 = VDD = Ligado à linha de +B de 5 V;
Pino 3 = V0 = Ligado ao potenciômetro o contraste (com 0 V o máximo contraste);
Pino 4 = RS = Quando em nível alto o display recebe dados e em nível baixo instrução;
Pino 5 = W/R = Nível alto para leitura do display ou nível baixo para escrita nele;
Pino 6 = E = Em nível alto habilita o display;

39

Pinos 7 ao 14 = Pinos dos dados digitais DB0 ao DB7 para reprodução dos caracteres. Este
display pode trabalhar em 4 ou 8 bits. No caso do Arduino vamos usar ele em 4 bits, portanto
só serão usados os pinos do 11 ao 14 (DB4 ao DB7).
Lista de materiais

- 1 Display LCD 16 x 2
Procedimento

40

// Experiência nº 32 – Testando o display LCD

#include <LiquidCrystal.h> // Biblioteca do Arduino para o display

LiquidCrystal lcd(7, 6, 5, 4, 3, 2); // Inicializa a biblioteca com os pinos usados

void setup() {

lcd.begin(16, 2); // Número de colunas e linhas do display
lcd.setCursor(0, 0); // Coloca o cursor na coluna 0 e linha 0
lcd.print("Bem‐vindos a"); // Escreve a mensagem na primeira linha (linha 0)
lcd.print("Burgoseletronica"); // Escreve a mensagem na segunda linha (linha 1)
}

void loop() {

// (Obs: no display a segunda linha é linha 1 porque a contagem começa no 0)

lcd.print(millis()/1000); // Escreve a quantidade de segundos desde que o display foi
// ligado ou resetado
}
Ao copiar o código para o programa do Arduino o display acende e indica “Bem-vindos a

Burgoseletronica”. Na linha superior (linha 0) aparece um contador de segundos que vai contar
indefinidamente até que o circuito seja desligado. Se quiser alterar a palavra mostrada no
display basta alterar a linha de código lcd.print("Burgoseletronica"); e dentro dos parênteses
você escreve a palavra que quiser entre aspas.
Na verdade este circuito é só para comprovar o perfeito funcionamento do display LCD que
será usado em outras experiências também. Alterando o número na linha de comando
lcd.print(millis()/1000); podemos variar a velocidade do contador que aparece no display.
Aumentando o número o contador fica mais lento e diminuindo o número o contador fica mais
rápido. Se quiser pode experimentar estas mudanças de código em seu circuito.
Observação importante: Os pinos do display 4 (RS), 6 (E), 11, 12, 13 e 14 (D4 a D7) podem
ser ligados a quaisquer pinos entre o 2 e o 13 do Arduino. Porém a sequência 4-6-11-12-13-14
do display deve ser mantida no código do Arduino. Se por exemplo você ligar o pino 2 do
Arduino no 4 do display, o 3 do Arduino no 6 do display, o 4 do Arduino no 11 do display,
o 5 do Arduino no 12 do display, o 6 do Arduino no 13 do display e o 7 do Arduino no 14
do display, deverá colocar no código a sequência: LiquidCrystal lcd(2, 3, 4, 5, 6, 7); Lembrando
que a sequência a ser colocada no código é a de pinos do Arduino e não do display. No código
deste circuito especificamente o pino 4 do display está no 7 do Arduino e assim por diante.

41

13. Experiência nº 33 – Operando o display LCD em 4 e 8 bits
Lista de materiais

Procedimento

42

// Experiência nº 33 – Operando o display LCD em 4 ou 8 bits


LiquidCrystal lcd(11, 10, 9, 8, 7, 6, 5, 4, 3, 2); // Habilita a opção 8 bits
// LiquidCrystal lcd(11, 10, 5, 4, 3, 2); // Habilita a opção 4 bits

void setup() {

lcd.print("Display em"); // Escreve a mensagem na primeira linha (linha 0)
lcd.print("4 ou 8 bits"); // Escreve a mensagem na segunda linha (linha 1)
}

void loop() {

// (Obs: no display a segunda linha é linha 1 porque a contagem começa no 0)

lcd.print(millis()/1000); // Escreve a quantidade de segundos desde que o display foi
// ligado ou resetado
}

Quando o código é copiado para o Arduino vemos a indicação de “Display em 4 o 8 bits” na

tela. Conforme expliquei no circuito anterior o display pode funcionar recebendo 4 ou 8 bits por
vez. Para a opção 8 bits usamos todos os 8 pinos de dados e ligamos no Arduino. A diferença
será no código para ambos formatos. Temos as duas linhas de comando:
LiquidCrystal lcd(11, 10, 9, 8, 7, 6, 5, 4, 3, 2); // Habilita a opção 8 bits
// LiquidCrystal lcd(11, 10, 5, 4, 3, 2); // Habilita a opção 4 bits

No modo que está o display funcionará em 8 bits porque todos os pinos de dados dele estão
habilitados. Para a opção 4 bits basta colocar as duas barras “//” na linha de cima e retirar
estas mesmas barras da linha de baixo. Assim habilitamos apenas os 4 últimos pinos de
dados. Observe como praticamente não há diferença visual entre os dois modos de operação.
Como se trata de um display para mostrar apenas caracteres não compensa operá-lo em 8 bits
porque serão necessários mais pinos do Arduino, pinos estes que poderiam ser usados para a
ligação de outros periféricos. Especialmente para o Arduino UNO de nosso curso que possui
poucos pinos para a ligação de componentes externos.

43

14. Experiência nº 34 – Mensagem no display LCD
Lista de materiais

Procedimento

44

// Experiência nº 34 – Mensagem no display LCD

LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Ordem dos pinos em nosso circuito proposto

void setup() {
}
void loop() {
lcd.clear(); // Limpa o display
lcd.print("Ola querido aluno(a)"); // Imprime a mensagem destacada no display
delay(2000); // Aguarda 2 segs
for (int i = 0; i < 4; i++) { // Rola o texto 4 colunas para a esquerda
lcd.scrollDisplayLeft(); // Comando para rolar o texto à esquerda
delay(500); } // Velocidade de rolagem (1 coluna a cada 0,5 segs)
lcd.setCursor(4,1); // Coloca o cursor na coluna 4 linha 1 do display.
lcd.print("Beleza????"); // Imprime a mensagem destacada no display
lcd.print("Gostou do curso"); // Imprime a mensagem destacada no display
lcd.print("de Arduino?"); // Imprime a mensagem destacada no display
lcd.print("Que legal!!!!"); // Imprime a mensagem destacada no display
lcd.print("Temos outros cursos em"); // Imprime a mensagem destacada no display
delay(1000); // Aguarda 1 seg
lcd.print("http//loja.burgoseletronica.net"); // Imprime a mensagem destacada no display
}
Você pode substituir a mensagem destacada por qualquer outra mensagem neste código.

45

15. Experiência nº 35 – LED RGB com display LCD
Lista de materiais

- 1 led RGB de 4 terminais
- 3 resistores de 220 Ω (vermelho-vermelho-marrom)
Procedimento

46

// Experiência nº 35 – LED RGB com display LCD

int temp = 9; // Variável para contagem de tempo no display (começa em 9 segundos)

void setup() {
pinMode(10, OUTPUT); // Saída para o led vermelho
pinMode(11, OUTPUT); // Saída para o led verde
pinMode(12, OUTPUT); // Saída para o led azul
}
void loop()
{
if(temp == 0) { //Se a contagem chegar ao dígito 1 (equivale aqui ao 0 (0 a 9 = dez dígitos))
temp = 9; // Volta ao dígito 9
leds(); // Função de controle dos leds
}
lcd.setCursor(0, 0); // Cursor na primeira linha e primeira coluna
lcd.print("Iniciar em"); // Escreve na primeira linha
lcd.setCursor(2, 1); // Cursor na segunda linha e terceira coluna
lcd.print("segundos"); // Escreve na segunda linha
lcd.setCursor(0, 1); // Cursor na segunda linha e primeira coluna
lcd.print(temp‐‐); //Escreve contagem regressiva de 9 a 0
delay(1000); //Aguarda 1 segundo
}
void leds() { // Inicia função de controle dos leds
lcd.setCursor(0, 0); // Cursor na primeira linha e primeira coluna
lcd.print("BRANCO"); // Escreve na primeira linha
lcd.setCursor(0, 1); // Cursor na segunda linha e primeira coluna
lcd.print("WHITE"); // Escreve na segunda linha
digitalWrite(10, 1); digitalWrite(11, 1); digitalWrite(12, 1); // Acende o led branco
delay(2000); // Aguarda 2 segundos
for(int i = 0; i < 16; i++) { // Rola o texto 16 colunas para a direita
lcd.scrollDisplayRight(); // Função rolar para a direita
delay(200); } // Velocidade de rolagem (1 coluna a cada 0,2 segundos)
for(int i = 16; i > 0; i‐‐) { // Rola o texto 16 colunas para a esquerda
lcd.scrollDisplayLeft(); // Função rolar para a esquerda
delay(200); } // Velocidade de rolagem (1 coluna a cada 0,2 segundos)
lcd.clear(); // Apaga o display
//Daqui para frente todas as cores do led terão as mesmas funções mudando apenas o texto a ser
// exibido pelo display LCD. Continua na página seguinte.

47

lcd.setCursor(0, 0);
lcd.print("VERDE");
lcd.print("GREEN");
digitalWrite(10, 0); digitalWrite(11, 1); digitalWrite(12, 0); // Acende o led verde
delay(2000);
for(int i = 0; i < 16; i++) {
lcd.scrollDisplayRight();
delay(200); }
for(int i = 16; i > 0; i‐‐) {
lcd.scrollDisplayLeft();
delay(200); }
lcd.clear();
lcd.clear();
lcd.print("AZUL");
lcd.print("BLUE");
digitalWrite(10, 0); digitalWrite(11, 0); digitalWrite(12, 1); // Acende o led azul
delay(2000);
for(int i = 0; i < 16; i++) {
delay(200); }
for(int i = 16; i > 0; i‐‐) {
delay(200); }
lcd.clear();
lcd.clear();
lcd.print("AMARELO");
lcd.print("YELLOW");
digitalWrite(10, 1); digitalWrite(11, 1); digitalWrite(12, 0); // Acende o led amarelo
delay(2000);
for(int i = 0; i < 16; i++) {
delay(200); }
for(int i = 16; i > 0; i‐‐) {
delay(200); }
lcd.clear();

// Código continua na página seguinte

48

lcd.print("ROXO");
lcd.print("PURPLE");
digitalWrite(10, 1); digitalWrite(11, 0); digitalWrite(12, 1); // Acende o led roxo
delay(2000);
for(int i = 0; i < 16; i++) {
delay(200); }
for(int i = 16; i > 0; i‐‐) {
delay(200); }
lcd.clear();
lcd.clear();
lcd.print("CIANO");
lcd.print("CYAN");
digitalWrite(10, 0); digitalWrite(11, 1); digitalWrite(12, 1); // Acende o led ciano
delay(2000);
for(int i = 0; i < 16; i++) {
delay(200); }
for(int i = 16; i > 0; i‐‐) {
delay(200); }
lcd.clear();
apagaled(); // Vai para a função de apagar os leds
delay(1000); // Espera 1 segundo e recomeça o ciclo
}

void apagaled() { // Executa a função de apagar os leds
digitalWrite(10, 0); digitalWrite(11, 0); digitalWrite(12, 0); // Apaga os três leds
}

Ao transferir o código para o programa do Arduino observamos que vai aparecer uma
contagem regressiva de 9 a 0 e após isso o led tricolor vai acender na cor branca e ao mesmo
tempo aparece as palavras “BRANCO” e “WHITE”. Tais palavras vão rolar para a direita e para
a esquerda, enquanto isso o led permanece aceso na cor branca. Após o movimento do texto,
o led acende verde indicando ‘VERDE” e “GREEN” no display. O texto rola e depois acende o
vermelho. E assim por diante passando pelas cores branco, verde, vermelho, azul, amarelo,
roxo e ciano. Depois o display e o led apagam e o ciclo recomeça. É um experimento bem
divertido que testa o funcionamento tanto do display quanto do led tricolor RGB.

49

16. Experiência nº 36 – Relógio com hora e data
Lista de materiais

Procedimento

50

// Experiência nº 36 – Relógio com hora e data

int segundo,minuto, hora, dia, mes, ano; // Variáveis de data e horário
unsigned long UtlTime; // Variável de tempo

void setup()
{
UtlTime=0;
minuto=0;
hora=0;
dia=0;
mes=0;
ano=0;
Serial.begin(9600); // Inicio da comunicação serial com o monitor do Arduino
lcd.begin(16, 2);
lcd.setCursor(0,0);
lcd.print(" Data e hora ");
lcd.setCursor(0,1);
lcd.print(" com Arduino");
delay (2000);

lcd.clear(); // Ajuste dos minutos
lcd.setCursor(0,0);
lcd.print("Minuto: ");
Serial.print("\nEntre Minuto:"); // Escreve mensagem no monitor do Arduino
while(minuto==0) {
if (Serial.available() > 0) {
minuto= Serial.parseInt(); }
}
lcd.print(minuto);
delay(1000);

lcd.clear(); // Ajuste das horas
lcd.setCursor(0,0);
lcd.print("Hora: ");
Serial.print("\nEntre Hora:"); // Escreve mensagem no monitor do Arduino
while(hora==0) {
hora= Serial.parseInt(); }
}
lcd.print(hora);
delay(1000); // Código continua na página seguinte

51

lcd.clear(); // Ajuste do dia
lcd.setCursor(0,0);
lcd.print("Dia: ");
Serial.print("\nEntre Dia:"); // Escreve mensagem no monitor do Arduino
while(dia==0) {
dia= Serial.parseInt();
}
}
lcd.print(dia);
delay(1000);

lcd.clear(); // Ajuste do mês
lcd.setCursor(0,0);
lcd.print("Mes: ");
Serial.print("\nEntre Mes:"); // Escreve mensagem no monitor do Arduino
while(mes==0) {
mes= Serial.parseInt();
}
}
lcd.print(mes);
delay(1000);

lcd.clear(); // Ajuste do ano
lcd.setCursor(0,0);
lcd.print("Ano: ");
Serial.print("\nEntre ano:"); // Escreve mensagem no monitor do Arduino
while(ano==0) {
ano= Serial.parseInt();
}
}
lcd.print(ano);
delay(1000);
lcd.clear();
}
void loop()
{
if(millis()‐UtlTime<0) {
UtlTime=millis();
} else {
segundo=int((millis()‐UtlTime)/1000); // Define a contagem de segundo em segundo
}
// Código continua na próxima página

52

if(segundo>59) { // Depois de 59 segundos
segundo=0; // Zera os segundos
minuto++; // Avança um minuto
UtlTime=millis();
if(minuto>59) { // Depois de 59 minutos
hora++; // Avança uma hora
minuto=0; // Zera os minutos
if(hora>23) { // Depois de 23 horas
dia++; // Avança um dia
hora=0; // Zera as horas
if(mes==1||mes==3||mes==5||mes==7||mes==8||mes==10||mes==12) {
if(dia>31) { // Depois de 31 dias em alguns meses
dia=1; // Volta para o dia 1º
mes++; // Avança um mês
if(mes>12) { // Depois de 12 meses
ano++; // Avança um ano
mes=1; } // Volta para o 1º mês
}
}
else if(mes==2) { // No mês dois
if(ano%400==0) { // No ano bissexto
if(dia>29) { // Depois de 29 dias
mes++; } // Avança um mês
}
else if((ano%4==0)&&(ano%100!=0)) { // No ano bissexto
}
else { // Nos anos não bissextos
}
}
else { // Nos meses de 30 dias
}
}
}
}

53

Serial.print(dia); // Escreve no monitor do Arduino
Serial.print("/");
Serial.print(mes);
Serial.print("/");
Serial.print(ano);
Serial.println();

lcd.setCursor(0,0); // Escreve no display LCD
lcd.print("Data ");
lcd.print(dia);
lcd.print("/");
lcd.print(mes);
lcd.print("/");
lcd.print(ano);

Serial.print(hora);
Serial.print(":");
Serial.print(minuto);
Serial.print(":");
Serial.print(segundo);
Serial.print("\n");
Serial.println();

lcd.setCursor(0,1);
lcd.print("Hora ");
lcd.print(hora);
lcd.print(":");
lcd.print(minuto);
lcd.print(":");
lcd.print(segundo);

}
Após carregar o código para o Arduino, vai aparecer no display a mensagem “minuto”, então
você abre o monitor no programa do Arduino como já ensinado em outra parte do curso (botão
com o símbolo de uma lupa localizado na parte superior à direita no programa do Arduino. Tal
botão se chama “monitor serial”. Ao abrir o monitor ele vai exibir a palavra “minuto”, daí é só
digitar os minutos do horário atual e teclar Enter. Logo em seguida aparece a palavra “hora”.
Só teclar a hora atual e dar Enter, depois vai aparecer a palavra “dia”, só colocar o dia, a
palavra “mês”, só colocar o mês e por último a palavra “ano” e só colocar o ano. Colocadas
estas 5 informações o relógio funciona mesmo que fechemos o programa do Arduino.
Lembrando que o relógio usa como base de contagem 24 horas. Porém há uma pequena falha
neste relógio que quando chega no 59 segundos ao invés de contar 00 segundos, ele mostra
09 segundos no display, depois 19, 29, 39 até o 10 segundos mas serve bem para ver o
princípio de funcionamento de um relógio digital.

54

17. Experiência nº 37 – Caracteres customizados no display LCD
Lista de materiais

Procedimento

55

// Experiência nº 37 – Caracteres customizados no display LCD

byte coracao[8] = { // Forma o caractere do coraçãozinho
B00000,
B01010,
B11111,
B11111,
B11111,
B01110,
B00100,
B00000
};
byte feliz[8] = { // Forma o caractere da carinha feliz
B00000,
B11011,
B01010,
B00000,
B10101,
B10001,
B01110,
B00000
};
byte serio[8] = { // Forma o caractere da carinha séria
B00000,
B11011,
B01010,
B00000,
B00100,
B00000,
B11111,
B00000
};
byte triste[8] = { // Forma o caractere da carinha triste
B00000,
B01010,
B11011,
B00000,
B00100,
B00000,
B11111,
B10001
}; // Código continua na próxima página

56

byte bravo[8] = { // Forma o caractere da carinha brava
B10001,
B01010,
B01010,
B00000,
B00100,
B00000,
B11111,
B00000
};
void setup() {
lcd.createChar(0, coracao); // Criando e armazenando os caracteres novos
lcd.createChar(1, feliz);
lcd.createChar(2, serio);
lcd.createChar(3, triste);
lcd.createChar(4, bravo);
}
void loop() {

lcd.setCursor(0,0); // Coloca o cursor na primeira coluna e primeira linha
lcd.print("Ola. Como esta seu humor hoje?"); // Escreve a mensagem no display
delay(2000); // Espera 2 segundos

for(int x = 0; x < 14; x++) { // Rola o texto 14 colunas para a esquerda
lcd.scrollDisplayLeft(); // Função de rolagem do texto à esquerda
delay(300); // Velocidade de rolagem (1 coluna a cada 0,3 segundos)
}
delay(1000); // Espera 1 segundo
lcd.print("Romantico (a)"); // Escreve a mensagem no display
for(int c = 0; c < 5; c++) { // Faz o coraçãozinho piscar 5 vezes no display
lcd.setCursor(8,1); // Coloca o cursor na nona coluna e segunda linha
lcd.write(byte(0)); // Escreve o caractere do coraçãozinho no display
delay(300); // Espera 0,3 segundos
lcd.print(" "); // Não escreve nada (quando o coraçãozinho some)
delay(300); // Espera 0,3 segundos
}



57

lcd.print("Feliz"); // Escreve a mensagem no display
lcd.write(byte(1)); // Escreve a carinha feliz no display
lcd.print("Serio"); // Escreve a mensagem no display
lcd.write(byte(2)); // Escreve a carinha séria no display
lcd.print("Triste"); // Escreve a mensagem no display
lcd.write(byte(3)); // Escreve a carinha triste no display
lcd.print("Bravo"); // Escreve a mensagem no display
lcd.write(byte(4)); // Escreve a carinha brava no display
delay(2000); // Espera 2 segundos e todo o loop recomeça
}
Ao carregar o código, você verá a mensagem e alguns caracteres diferentes como um

coraçãozinho e algumas carinhas em cada mensagem que vai aparecendo. Estes caracteres
podem ser criados modificando os códigos que estão nas linhas de comandos byte. Porém
fazer este processo manualmente dá um certo trabalho até porque não se está vendo como
sairão os caracteres. Porém para facilitar esta tarefa de criar novos caracteres para o display e
usá-lo em determinadas situações existe um programinha bem fácil de usar chamado
LCDv1.0.jar. Este programa em java vai junto com o curso e você o achará dentro da pasta
código, porém pode ser encontrado facilmente na internet. Nele você vai criar o caractere
personalizado e já obterá o código da linha de comando byte. Basta apenas copiar e colar o
código do programa para o software do Arduino. Bem tranquilo de usar.

58

18. Experiência nº 38 – Botão liga-deliga e display LCD
Lista de materiais

- 2 Microchaves de toque
Procedimento

59

// Experiência nº 38 – Botões liga‐desliga e o display LCD

void setup() {
pinMode(8, INPUT_PULLUP); // Pino de entrada do botão 1
pinMode(9, INPUT_PULLUP); // Pino de entrada do botão 2
pinMode(12, OUTPUT); // Pino de saída para o led
lcd.begin(16, 2); // Inicia o display de 16 colunas e 2 linhas
lcd.setCursor(0, 0); // Posiciona o cursor na primeira coluna e primeira linha
lcd.print("Iniciando . . ."); // Mostra a mensagem no display
lcd.setCursor(0, 1); // Posiciona o cursor na primeira coluna e segunda linha
lcd.print("Aguarde"); // Mostra a mensagem no display
lcd.print("Aperte o botao 1"); // Mostra a mensagem no display
lcd.print("para ligar"); // Mostra a mensagem no display
lcd.print("Aperte o botao 2"); // Mostra a mensagem no display
lcd.print("para desligar"); // Mostra a mensagem no display
}
void loop() {
int botao1 = digitalRead(8); // Lê o botão 1 no pino 8
int botao2 = digitalRead(9); // Lê o botão 2 no pino 9
if(botao1 == 0) { // Se o botão 1 está em nível baixo (pressionado)
lcd.setCursor(2, 0); // Posiciona o cursor na terceira coluna e primeira linha
lcd.print("Led ligado!"); // Mostra a mensagem no display
digitalWrite(12, 1); // Acende o led no pino 12
delay(50); } // Espera 50 milisegundos
if(botao2 == 0) { // Se o botão 2 está em nível baixo (pressionado)
lcd.print("Led desligado!"); // Mostra a mensagem no display
digitalWrite(12, 0); // Apaga o led no pino 12
delay(50); } // Espera 50 milisegundos
}
Este circuito embora muito simples pode servir de base a muitos outros mais sofisticados.
Usamos dois botões para controlar um led (poderia ser um relê) e mostramos no display.

60

19. Experiência nº 39 – Controle de velocidade para motor DC
Lista de materiais

- 1 Motor DC de 6 ou 9 V (pode ser de outras tensões)
- 1 Bateria/fonte DC de 6 ou 9 V de acordo com a tensão do motor usado
- 1 Diodo 1N4007
- 1 Transistor TIP41
Procedimento

61

// Experiência nº 39A – Controle de velocidade do motor DC com potenciômetro

void setup() {
pinMode(A0, INPUT); // Pino de entrada analógica para o potenciômetro
pinMode(11, OUTPUT); // Pino de saída para o controle do motor (“driver”)
}
void loop() {
int valorpot = analogRead(A0); // Leitura do pino do potenciômetro
int velocidade = map(valorpot, 0, 1023, 0, 255); // Valor do potenciômetro para 0 a 255
analogWrite(11, velocidade); // Controla o motor com a tensão PWM
}
Neste circuito controlamos a rotação de um motorzinho de CC girando o potenciômetro. Este

mesmo circuito tem uma versão com microchaves como mostrado a seguir:
Experiência nº 39B – Controle de velocidade para motor DC com microchaves
Lista de materiais

- 1 Diodo 1N4007
- 1 Transistor TIP41
Procedimento

62

// Experiência nº 39B – Controle de velocidade do motor DC com teclas

int velocidade = 0; // Variável de ajuste de velocidade

void setup() {
pinMode(8, INPUT_PULLUP); // Entrada de uma das teclas (a de aumento de rotação)
pinMode(9, INPUT_PULLUP); // Entrada de uma das teclas (a de redução de rotação)
pinMode(11, OUTPUT); // Saída para controle do motor (“driver”)
analogWrite(11, 0); // Condição inicial do pino de controle do motor
}
void loop() {
int acelera = digitalRead(8); // Leitura da tecla de aceleração
int freia = digitalRead(9); // Leitura da tecla de desaceleração
if(acelera == 0) { // Se a tecla de aceleração está em nível baixo (pressionada)
velocidade++; // aumenta a velocidade do motor
}
if(freia == 0) { // Se a tecla de desaceleração está em nível baixo (pressionada)
velocidade = velocidade‐1; // diminui a velocidade do motor
}
delay(50); // Espera 50 milissegundos
analogWrite(11, velocidade); // Controla o motor com a tensão PWM
}
No caso desta experiência temos duas teclas. Se pressionarmos uma delas o motor vai girar
cada vez mais rápido (até o limite) e no caso da outra tecla o motor vai girar cada vez mais
devagar até parar por completo.

63

20. Experiência nº 40 – Sentido de rotação para motor DC usando duas teclas
Lista de materiais

- 2 Transistores TIP41
- 2 Transistores TIP42
Procedimento

64

// Experiência nº 40 – Sentido de rotação do motor DC com duas teclas

void setup() {
pinMode(3, INPUT_PULLUP); // Entrada para uma das teclas
pinMode(4, INPUT_PULLUP); // Entrada para a outra tecla
pinMode(11, OUTPUT); // Saída para a base de um dos transistores NPN (TIP41)
pinMode(10, OUTPUT); // Saída para a base de um dos transistores PNP (TIP42)
pinMode(7, OUTPUT); // Saída para a base do outro transistor NPN (TIP41)
pinMode(6, OUTPUT); // Saída para a base do outro transistor PNP (TIP42)
}
void loop() {
int sentido1 = digitalRead(3); // Leitura do estado de uma das teclas
int sentido2 = digitalRead(4); // Leitura do estado da outra tecla
if(sentido1 == 0) { // Se uma das teclas está pressionada (nível baixo)
digitalWrite(11, 1); // Pino 11 em nível alto liga um dos transistores NPN (Q1)
digitalWrite(6, 0); // Pino 6 em nível baixo liga um dos transistores PNP (Q4)
digitalWrite(10, 1); // Pino 10 em nível alto desliga o outro transistor PNP (Q2)
digitalWrite(7, 0); // Pino 7 em nível baixo desliga o outro transistor NPN (Q3)
}
if(sentido2 == 0) { // Se a outra tecla está pressionada (nível baixo)
digitalWrite(11, 0); // Pino 11 em nível baixo desliga um dos transistores NPN (Q1)
digitalWrite(6, 1); // Pino 6 em nível alto desliga um dos transistores PNP (Q4)
digitalWrite(10, 0); // Pino 10 em nível baixo liga o outro transistor PNP (Q2)
digitalWrite(7, 1); // Pino 7 em nível alto liga o outro transistor NPN (Q3)
}
}
Como podemos ver de acordo com o código ao apertar uma tecla os transistores Q1 e Q4
conduzem fazendo a corrente fluir pelo motor em um determinado sentido e o motor gira numa
certa direção. Ao apertar a outra tecla, conduzem Q2 e Q3 fazendo a corrente passar no outro
sentido pelo motor fazendo-o girar em sentido contrário. Então temos uma ponte de quatro
transistores para controlar o sentido que o motor vai girar. Se for usar este circuito para alguma
aplicação não se esqueça de colocar um dissipador de calor nos transistores junto com um
pouco de pasta térmica porque eles esquentam se ficarem por longo tempo ligados.
Chegamos ao final de mais um curso esperando que ele possa ser muito proveitoso e dê
uma boa base para fazer e usar projetos com Arduino. Este livro acompanha o DVD com
vídeo aula onde você verá o funcionamento de todas as experiências apresentadas aqui
além de mais alguns detalhes acerca do Arduino. Qualquer dúvida, crítica ou sugestão
você pode os e-mails: Lburgos23@terra.com.br e Lburgos@terra.com.br. Nossas lojas
estão abaixo (nossa e de nossos parceiros comerciais):
www.livrotec.com.br

65

ARDUINO DESCOMPLICADO E DIVERTIDO VOLUME 2
 Produzindo sons no Arduino;

 Display de LEDs;
 Display LCD;
 Motor DC;
 Modificando códigos;
 20 experiências didáticas para montar;
Burgoseletronica e parceiros comerciais

www.livrotec.com.br

O Arduino Descomplicado e Divertido - Volume 2 PDF

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

O Arduino Descomplicado e Divertido - Volume 2 PDF

Diunggah oleh

Hak Cipta:

Format Tersedia

 Sons com Arduino;

LISTA DE MATERIAL EXCLUSIVO – VOL. 2

 1 Mini alto falante “buzzer” de 5 V;

LISTA DE MATERIAL VOL.1 E VOL.2

 1 Placa de Arduino UNO;

COMPONENTES EXCLUSIVOS PARA O VOL.2

COMPONENTES PARA OS VOL.1 E 2

1. Experiência nº 21 – Produzindo som com Arduino _____________________________01

O ARDUINO DESCOMPLICADO E DIVERTIDO - VOL. 2

1. Experiência nº 21 - Produzindo som com Arduino

- Placa de Arduino UNO

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

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Coloque o seguinte código no programa do Arduino:

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

- Placa de Arduino UNO

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

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Ao carregarmos o código para o programa do Arduino, inicialmente o capacitor está

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

- Placa de Arduino UNO

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

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Em várias experiências de nosso curso usaremos os displays de leds. Eles

- Placa de Arduino UNO

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

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Coloque o seguinte código no programa do Arduino:

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 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 ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

6. Experiência nº 26 - Contador crescente e decrescente

- Placa de Arduino UNO

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Ao ligar o circuito veremos a contagem dos números de 0 a 9 no intervalo de meio segundo

Arduino Descomplicado e Divertido ‐ vol. 2 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 ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Ao carregarmos o código no programa do Arduino veremos inicialmente o led vermelho aceso

Arduino Descomplicado e Divertido ‐ vol. 2 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 ‐ vol. 2 Página Luis Carlos Burgos

Arduino Descomplicado e Divertido ‐ vol. 2 Página Luis Carlos Burgos

Nesta experiência vemos o display contar de 0 a 9 em decimais e os 4 leds formando os bits

1 - Função void setup() - Aqui já indicamos os pinos de saída do Arduino sendo do 2 ao 8