Arduino Kit Intermediario V1 0

Prévia do material em texto

ARDUINO KIT INTERMEDIÁRIO V1.0 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 2 / 32 
 
 
 
Parabéns por adquirir o Kit Arduino Intermediário da RoboCore! 
 
Este material é composto por 08 experimentos, indicados para usuários que já tem contato com a 
plataforma Arduino e conhecem os componentes eletrônicos básicos. Os usuários interessados em 
seguir este manual, necessitam ter algum conhecimento prévio em linguagem C. Caso você não 
tenha nenhum conhecimento em Arduino, componentes e programação em linguagem C, indicamos 
que adquira o Arduino Kit Iniciante da RoboCore. Mais detalhes no site www.RoboCore.net. 
 
Por se tratar de um kit indicado a usuários com conhecimento prévio, você notará que não existem 
explicações aprofundadas em artigos básicos, como a função de componentes básicos e/ou sintaxe 
de programação básica. Caso você tenha sido usuário do Arduino Kit Iniciante da RoboCore, verá 
uma grande diferença no que diz respeito à diagramação dos circuitos. Neste material não será 
utilizado esquematização gráfica dos circuitos em softwares como o Fritzing. Os esquemas serão 
apresentados sob a forma de esquemas universais, com símbolos conhecidos em esquemas 
eletrônicos. Para estes experimentos, será necessário o uso de uma protoboard – não inclusa no kit. 
 
Neste kit acompanham alguns componentes que não necessariamente serão utilizados nos 
experimentos, como a Proto PCB para Arduino e os conectores empilháveis de 06 e 08 pinos. Estes 
itens estão no kit afim de que, se, por ventura, o usuário queira fazer uma placa dedicada a algum 
experimento, ele pode utilizar estes componentes. É interessante aqui ressaltar o funcionamento da 
Proto PCB. Veja a imagem da mesma abaixo: 
 
 
 
Arduino Shield – Proto PCB para Arduino UNO/2009 
 
 
 
Conforme foi dito anteriormente, por se tratar de um kit para usuários intermediários, não serão 
explicados a fundo conceitos básicos. Em todo caso, vale ressaltar que esta placa possui, além de 
furos independentes para ligação de componentes, algumas trilhas já ligadas, como a trilha de 5V e a 
trilha com GND. Além disso, esta placa possui espaçamentos padrões caso o usuário queira soldar 
um circuito integrado em encapsulamento DIP ou SMD, além de um espaço pronto para soldar um 
botão de 4 terminais para reset, botão o qual pode ser encontrado no Arduino Kit Iniciante. 
 
Note que, caso queira fazer um circuito nesta placa é necessário o uso de um ferro de solda e 
estanho. Caso não tenha experiência com estas ferramentas, tome cuidado e peça ajuda a alguém 
experiente. Além disso, é aconselhável o uso de um multímetro para fazer testes de condução para 
verificar se o circuito está ligado corretamente após soldado. 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 3 / 32 
 
 
 
 
 
Veja abaixo a lista de experimentos que podem ser construídos com o auxílio deste material: 
 
 
• Servo Motor pág. 05 
Componentes: 01 Servo Motor 
Descrição: Aprenda conceitos básicos de movimentação de servo motores, além de ver 
como você pode modificar seu servo motor de movimento angular para servo motor de 
rotação contínua. 
 
 
• Led RGB pág. 08 
Componentes: 01 Led RGB 
Descrição: Aprenda como utilizar o led RGB, um led que possui em um mesmo 
encapsulamento três leds com as cores primárias. Utilizando a modulação de largura de 
pulso (PWM) você poderá ver todas as cores do espectro de cores. 
 
 
• Piezo pág. 11 
Componentes: 01 Elemento Piezo Elétrico 
Descrição: Aprenda como usar este elemento, muito útil para sentir toques e/ou emissão de 
ruídos. 
 
 
• Microfone de Eletreto pág. 13 
Componentes: 01 Placa com Microfone de Eletreto 
Descrição: Aprenda os fundamentos de um microfone de eletreto e o que ele precisa para se 
comunicar com um microcontrolador. Neste experimento entrará o conceito de Amplificador 
Operacional, ou apenas AmpOp. 
 
 
• Sensor Infravermelho pág. 16 
Componentes: 01 Placa com Sensor Infravermelho 
Descrição: Aprenda os conceitos de sensores medidores de distância e/ou obstáculo, com 
uma placa muito utilizada em robôs seguidores de linha. 
 
 
• Acionamento de Cargas com Relé pág. 18 
Componentes: 01 Transistor + 01 Diodo + 01 Relé 
Descrição: Aprenda como acionar cargas de maior porte. Com este experimento será 
possível acionar e desacionar qualquer carga cuja especificação esteja dentro das 
especificações do relé. 
 
 
• Display de 7 Segmentos pág. 21 
Componentes: 01 Display de 7 Segmentos + 01 CI 4511 
Descrição: Aprenda a utilizar o display de 7 segmentos juntamente a um conversor BCD para 
display. Neste experimento será explicado os fundamentos básicos de um circuito integrado 
e contagem binária. 
 
 
• Shield LCD+Botões pág. 27 
Componentes: 01 Arduino Shield LCD+Botões 
Descrição: Aprenda a funcionalidade dos Shields para Arduino, além de traduzir dados do 
microcontrolador e trazê-los para o ambiente externo inteligível aos seres humanos. 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 4 / 32 
 
 
Veja abaixo os itens que acompanham este kit: 
 
 
Arduino Shield – Proto PCB 
 
Conectores Empilháveis de 06 e 08 
Pinos 
 
Micro Servo Motor 
 
 
LED RGB 
 
Elemento Piezo Elétrico 
 
Microfone de Eletreto 
 
 
 
Barra de 40 Pinos 
 
 
Sensor Infravermelho Analógico 
Transistor BC337 
 
Diodo 1N4148 
 
Relé 5V 
 
Display de 7 Segmentos 
 
Circuito Integrado (CI) 4511 
 
 
LCD Shield + Botões 
 
Resistores de 330Ω, 1kΩ e 1MΩ. 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 5 / 32 
 
 
• Servo Motor 
Componentes: 01 Servo Motor 
Descrição: Aprenda conceitos básicos de movimentação de servo motores, além de ver 
como você pode modificar seu servo motor de movimento angular para servo motor de 
rotação contínua. 
 
Neste experimento, utilizaremos a biblioteca Servo. Bibliotecas nada mais são do que um conjunto 
de funções prontas para serem utilizadas pelo desenvolvedor. Atualmente, como milhões de pessoas 
estão utilizando as placas Arduino ao redor do mundo, você pode encontrar milhões de bibliotecas 
diferentes, para as mais diversas funções. A biblioteca servo permite que, com apenas um comando 
simples você consiga mover o eixo de seu servo motor. O servo motor que acompanha o kit é um 
servo motor para posição angular. Ou seja, o curso deste servo motor é de 0º a 180º, sendo 90º o 
ângulo que corresponde ao meio do curso. Existem também servos de rotação contínua. Ao final 
deste experimento será mostrado como fazer esta alteração. Trata-se de um processo simples 
porém trabalhoso. Um servo motor de rotação contínua não possui fins de curso, podendo seu eixo 
girar bem como um motor DC. Quando um servo motor é de rotação contínua, a posição 90º, que 
antes era o meio do curso, agora representa a “velocidade” zero, ou seja, motor parado. Para que o 
servo gire seu eixo para um lado com toda velocidade, basta acioná-lo a 180º. Para que o servo gire 
seu eixo para o outro lado com toda velocidade, basta acioná-lo a 0º. Vale dizer que, por se tratar de 
um servo motor sua velocidade final não é alta. 
 
Veja abaixo o esquema de ligação do servo no Arduino para este experimento: 
 
 
 
 
 
Os esquemas de montagem neste material serão apresentados desta forma. Apenas para título de 
explicação neste experimento, você deve ligar o fio vermelho do servo no 5V da placa Arduino, o fio 
marrom no GND e o fio laranja na porta digital 03. Ligaremos na porta 03, pois é uma porta digital 
com função PWM (esta porta está ligada a um dos conversores analógico-digital do microcontrolador 
ATmega328 da placa Arduino). 
 
 
Após feita esta ligação, um código inicial apenas para ver algo acontecer com o eixo de seu servo 
motor pode ser o seguinte: 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 6 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O código acima é muito simples, e pouco funcional, pois ele simplesmente faz o eixo do servomotor 
ir até a posição 90º e por lá ficar. Você pode testar trocar o valor 90 para quaisquer valores entre 0 e 
180. Você verá que o eixo do servo irá rodar até a posição desejada. A fim de tornar este 
experimento mais dinâmico, você pode compilar o código de exemplo da biblioteca Servo chamado 
Knob. Para tanto você irá precisar de um potenciômetro (caso você tenha o Arduino Kit Iniciante, 
pode utilizar o potenciômetro de 10kΩ que o acompanha). 
 
Vamos agora fazer um programa um pouco mais interativo para mexer o eixo deste servo. Grave o 
seguinte programa em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O código acima faz com que, cada vez que chegar um símbolo de positivo (+) pela porta serial, o 
servo aumente sua posição em 10 e, cada vez que chegar um símbolo de negativo (-), o servo 
diminua sua posição em 10. Você pode mudar este passo para o número que quiser para ter mais ou 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Servo Motor 1 ** 
\***************************************/ 
#include <Servo.h> //Este comando inclui a biblioteca Servo neste código 
 
Servo Servo1; //Identifica um objeto do tipo Servo chamado Servo1 
 
void setup() 
{ 
 Servo1.attach(3); //Pino onde o servo deve estar colocado 
} 
 
void loop() { 
 Servo1.write(90); //Posição em graus do eixo do servo 
} 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Servo Motor 2 ** 
\***************************************/ 
#include <Servo.h> //Este comando inclui a biblioteca Servo neste código 
 
Servo Servo1; //Identifica um objeto do tipo Servo chamado Servo1 
int Recebido; //Variável que armazenará o valor recebido pela serial 
int posicao; //Variável que armazenará as posições do servo 
 
void setup(){ 
 Servo1.attach(3); //Pino onde o servo deve estar colocado 
 Serial.begin(9600); //Inicia a comunicação serial com taxa de 9600 
} 
 
void loop(){ 
 if (Serial.available() > 0) { //Se algo vier pela porta serial... 
 Recebido = Serial.read(); //O que receber, armazenar na variavel Recebido 
 if (Recebido == '+'){ //se receber o sinal de + pela serial faça: 
 Serial.println(posicao); //mostra no Monitor Serial o valor da posição 
 posicao = posicao + 10; //adicione 10 à variável incremento 
 } 
 if (Recebido == '-'){ //se receber o sinal de - pela serial faça: 
 Serial.println(posicao); //mostra no Monitor Serial o valor da posição 
 posicao = posicao - 10; //subtraia 10 à variável incremento 
 } 
 Servo1.write(posicao); //Escreve a posição no servo 
 } 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 7 / 32 
 
 
menos resolução na movimentação do eixo do servo. Para enviar um símbolo de positivo ou negativo 
para sua placa Arduino, basta abrir o Monitor Serial (o sétimo botão na IDE do Arduino, cujo ícone 
representa um monitor). Com o Monitor Serial aberto, selecione no canto inferior direito a taxa de 
comunicação de 9600, que significa que a placa irá enviar/receber dados a uma taxa de 9600. Então 
digite um sinal de positivo e clique em Send (ou aperte a tecla enter). Você verá o eixo do servo se 
mover em um sentido e poderá ler na tela do computador via monitor serial em qual ângulo está o 
eixo do servo. 
 
Servo motores são muito utilizados em braços robóticos, mãos robóticas, robôs humanóides, ponte-H 
mecânica com switches, etc, por causa de sua facilidade e precisão nos movimentos. Porém, 
também é possível utilizar servo motores como motores para um robô se mover com rodas. Para isto 
é necessário adquirir um Servo Motor de Rotação Contínua, ou modificar um servo para esta função. 
 
Para modificar um servo comum para rotação contínua, deve-se retirar os 04 parafusos na parte 
traseira de seu servo motor e retirar todos os componentes de dentro do mesmo. Tome cuidado para 
não perder as engrenagens da parte superior e sua ordem de instalação. Corte com um alicate a 
trava de plástico na engrenagem branca sempre com cuidado para não comprometer a engrenagem 
em si. O próximo passo é retirar o potenciômetro existente dentro do servo e substituí-lo por dois 
resistores de mesmo valor. O mais indicado é utilizar dois resistores de 2,2kΩ. Esta substituição 
serve para “enganar” o servo, pois a partir de agora ele sempre pensará que estará na posição 
central (pois não há mais referência de resistência – que era fornecida pelo potenciômetro) e passará 
a se comportar como um servo de rotação contínua, onde 180 agora representa a velocidade total 
para um lado e 0 representa a velocidade total para o outro lado, sendo 90 a posição de parado. Este 
processo parece simples, porém você deve estar acostumado com circuitos eletrônicos para fazer tal 
modificação. Para ilustrar, você deverá fazer a troca do potenciômetro pelos resistores segundo a 
imagem abaixo: 
 
 
 
 
ATENÇÃO: Ao modificar um servo normal para rotação contínua, não será possível modifica-lo 
novamente para sua condição original de fábrica. As modificações são permanentes. Caso você não 
saiba o que está fazendo, não tente modificar seu servo pois, provavelmente, você irá inutiliza-lo 
 
 
 
 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 8 / 32 
 
 
• Led RGB 
Componentes: 01 Led RGB 
Descrição: Aprenda como utilizar o led RGB, um led que possui em um mesmo 
encapsulamento 03 leds com as cores primárias. Utilizando a modulação de largura de pulso 
(PWM) você poderá ver todas as cores do espectro de cores. 
 
Um led RGB nada mais é do que três leds juntos, um vermelho (daí a letra R de RED), um verde (daí 
a letra G de GREEN) e um azul (daí a letra B de BLUE). Combinando estas três cores em um só 
encapsulmento, podemos apreciar as mais diversas cores que as combinações de vermelho, verde e 
azul podem nos oferecer. 
 
 
 
Monte o seguinte circuito, e nunca se esqueça de utilizar os resistores de 330Ω que servem como 
limitadores de corrente: 
 
 
 
Observação: neste led existe um terminal que é maior que os outros. Este terminal deve ser ligado 
no GND. 
 
O código a seguir acende cada uma das cores, com um intervalo de 500 milisegundos, ou 0,5 
segundos, entre cada acionamento: 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 9 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Este teste foi extremamente fácil de fazer e compreender. Vamos passar para algo um pouco mais, 
no mínimo, bonito – e quanto mais bonito, mais complexo. Grave o seguinte código no Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Led RGB 1 ** 
\***************************************/ 
 
int R = 9; 
int B = 10; 
int G = 11; 
 
void setup(){ 
 pinMode(R, OUTPUT); 
 pinMode(G, OUTPUT); 
 pinMode(B, OUTPUT); 
} 
 
void loop(){ 
 digitalWrite(R, HIGH); 
 digitalWrite(G, LOW); 
 digitalWrite(B, LOW); 
 delay(500); 
 digitalWrite(R, LOW); 
 digitalWrite(G, HIGH); 
 digitalWrite(B, LOW); 
 delay(500); 
 digitalWrite(R, LOW); 
 digitalWrite(G, LOW); 
 digitalWrite(B, HIGH); 
 delay(500); 
} 
/***************************************\ 
 ** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
 * * 
 ** Led RGB 2 ** 
 \***************************************/ 
 
int R = 9; 
int B = 10; 
int G = 11; 
int ValorRed = 255 ; 
int ValorBlue = 0 ; 
int ValorGreen = 0 ; 
 
void setup(){ 
 pinMode(R, OUTPUT); 
 pinMode(G, OUTPUT); 
 pinMode(B, OUTPUT); 
 analogWrite(G, ValorGreen); 
 analogWrite(R, ValorRed); 
 analogWrite(B, ValorBlue); 
} 
 
void loop(){ 
 for (ValorGreen = 0; ValorGreen <255; ValorGreen=ValorGreen+5){ 
 analogWrite(G, ValorGreen); 
 delay(50);} 
 for (ValorRed = 255; ValorRed > 0; ValorRed=ValorRed-5){ 
 analogWrite(R, ValorRed); 
 delay(50); 
 } 
 for (ValorBlue = 0; ValorBlue < 255; ValorBlue=ValorBlue+5){ 
 analogWrite(B, ValorBlue); 
 delay(50); 
 } 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 10 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Veja se você compreende este programa. Ele simplesmente utiliza a técnica de PWM, através da 
palavra chave analogWrite , para “escrever” analogicamente diversos valores de tensão nos 
terminais do led RGB. Quando a função analogWrite escreve em um terminal o valor de 255, quer 
dizer que terá uma tensão de 5V passando por este terminal. Analogamente, quando a função 
analogWrite escreve em um terminal o valor de 127, quer dizer que terá uma tensão de 
aproximadamente 2,5V passando por este terminal. Este conceito de técnica PWM foi muito 
difundida no manual que acompanha o Arduino Kit Iniciante da RoboCore e, portanto, não há 
necessidade aqui de entrar neste mérito. 
 for (ValorGreen = 255; ValorGreen > 0; ValorGreen=ValorGreen-5){ 
 analogWrite(G, ValorGreen); 
 delay(50); 
 
 } 
 for (ValorRed = 0; ValorRed < 255; ValorRed=ValorRed+5){ 
 analogWrite(R, ValorRed); 
 delay(50); 
 
 } 
 for (ValorBlue = 255; ValorBlue > 0; ValorBlue=ValorBlue-5){ 
 analogWrite(B, ValorBlue); 
 delay(50); 
 } 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 11 / 32 
 
 
• Piezo 
Componentes: 01 Elemento Piezo Elétrico 
Descrição: Aprenda como usar este elemento, muito útil para sentir toques e/ou emissão de 
ruídos. 
 
Um elemento piezo elétrico, ou simplesmente piezo, é um componente que tem a capacidade de 
gerar corrente elétrica a partir de uma pressão mecânica. Ele tem polaridade, portanto fique atento 
quanto a isto. O fio vermelho deve ser usado como terminal positivo e o fio preto deve ser usado 
como terminal negativo. 
 
Primeiramente, iremos explorar a função de emitir ruídos com nosso elemento piezoelétrico. Ele se 
comporta como um buzzer. Ao injetar tensão variável em seus terminais, simulando assim a 
formação de um período e, conseqüentemente, uma freqüência, você poderá ouvir cada freqüência 
neste pequeno driver de sons. Vamos tentar escutar uma freqüência singular, muito conhecida pelos 
músicos: a freqüência de 440Hz, utilizada para afinação de instrumentos. Coloque o fio vermelho no 
pino digital 09 e o preto em qualquer porta GND. Grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Não iremos entrar a fundo neste programa, pois o mesmo já foi amplamente discutido em um dos 
experimentos do Arduino Kit Iniciante da RoboCore. Apenas para deixar claro, este programa 
simplesmente deixa o pino, onde está o piezo, ligado, espera por um intervalo de tempo igual a 
metade do período da freqüência, desliga o pino e aguarda a outra metade do intervalo de tempo, 
tendo assim um período completo. Portanto, para uma freqüência (f) de 440Hz, temos um período (T) 
valendo aproximadamente 0,00227s pois f = 1 / T . Desta forma temos que metade do período vale 
0,001135s. Como o comando delayMicroseconds( ) deve conter um tempo em microsegundos, 
colocamos o valor do meio período em microsegundos, onde temos o valor de Tempo = 1135. 
Portanto, o valor de Tempo = 1135 representa a freqüência de 440Hz em nosso programa. 
 
 
O código acima é muito útil para aprender o conceito de como gerar uma frequência. Porém uma 
ótima alternativa é utilizar a função tone() do Arduino. Esta função é muito útil pois permite gerar 
frequências de maneira muito simples e rápida, além de não travar o processamento do programa 
pois não utiliza funções como delayMicroseconds(). 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Piezo 1 ** 
\***************************************/ 
 
const int Piezo = 9; 
int Tempo = 0; 
 
void setup() { 
 pinMode(Piezo, OUTPUT); 
 Tempo = 1135; 
} 
void loop(){ 
 digitalWrite(Piezo, HIGH); 
 delayMicroseconds(Tempo); 
 digitalWrite(Piezo, LOW); 
 delayMicroseconds(Tempo); 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 12 / 32 
 
 
O código com o mesmo funcionamento do anterior, porém utilizando a função tone(), ficará da 
seguinte forma: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Como pode ser observado o código ficou extremamente mais simples. Essa é uma das grandes 
vantagens de se utilizar o Arduino, pois existem inúmeras bibliotecas que facilitam muito a 
programação, além de economizar muito tempo. 
 
 
 
 
Uma das maiores utilidades dos elementos piezoelétricos é sentir toques mecânicos e o traduzir 
para corrente elétrica, fazendo assim com que um microcontrolador entenda que ocorreu um toque. 
Existem diversos projetos que podem ser encontrados na internet que utilizam sensores do tipo piezo 
para fazer baterias eletrônicas, por exemplo. 
 
Monte o seguinte circuito: 
 
Note que existe um resistor de 1MΩ em paralelo com o Piezo. 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Piezo 1 – utilizando função tone() ** 
\***************************************/ 
 
const int Piezo = 9; 
 
void setup() { 
 pinMode(Piezo, OUTPUT); 
} 
void loop(){ 
 tone(Piezo, 440) ; 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 13 / 32 
 
 
Agora grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Como você pode perceber, cada vez que você toca o piezo, aparece a palavra “Toque!” no Monitor 
Serial. Para ajustar a sensibilidade, altere o valor do threshold. 
 
Pense que você pode adicionar mais alguns piezos, e fazer com que, quando cada um é 
pressionado, acontece algo diferente com o Arduino, ou seja, você pode colocar pinos digitais em 
nível alto, acionando assim diferentes cargas com simples toques. 
 
 
Dica : Tanto para ouvir o som no primeiro experimento, quanto para sentir o toque, é aconselhável 
deixar o piezo sobre uma superfície plana, com o lado de metal dourado totalmente encostado sobre 
a superfície. 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Piezo 2 ** 
\***************************************/ 
 
const int Piezo = A0; // Piezo conectado ao pino analógico 0 
const int threshold = 75; // Valor do gatilho que irá dizer se houve ou não 
toque 
int valorPiezo = 0; // variável para armazenar o valor do sensor 
 
void setup() { 
 Serial.begin(9600); 
} 
 
void loop() { 
 valorPiezo = analogRead(Piezo); //armazena em valorPiezo os valores lidos 
analógicamente na porta Piezo (A0) 
 if (valorPiezo >= threshold) { //Se o valor lido for mais que o valor do 
gatilho, faça: 
 Serial.println("Toque!"); //Imprima no Monitor Serial a palavra Toque! 
mostrando que houve toque. 
 } 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 14 / 32 
 
 
• Microfone de Eletreto 
Componentes: 01 Placa com Microfone de Eletreto 
Descrição: Aprenda os fundamentos de um microfone de eletreto e o que ele precisa para se 
comunicar com um microcontrolador. Neste experimento entrará o conceito de Amplificador 
Operacional, ou apenas AmpOp. 
 
Um microfone de eletreto é um componente muito útil para trazer ruídos do meio externo para dentro 
de um microcontrolador. Com esta peça, facilmente você poderá fazer com que determinadas 
funções ocorram, segundo o nível de ruído do ambiente. Porém, o microfone de eletreto por si só, 
não possui nível suficiente para excitar as portas de um microcontrolador. É necessário que o áudio 
percebido pelo mesmo seja amplificado de alguma forma para que o microcontrolador o sinta. O 
componente eletrônico mais famoso por amplificar níveis de tensão chama-se Amplificador 
Operacional, ou simplesmente AmpOp . Para entendê-lo melhor, vamos observar o esquema de um 
AmpOp: 
 
Basicamente este circuito faz com que haja uma amplificação de 100 vezes do sinal de entrada, na 
saída. Deste modo, temos que Vout = 100xVin. 
 
Encontrar o valor da amplificação é muito simples: basta dividir o valor do resistor que liga o pino 4 
ao pino 1 (tipicamente conhecido como resistor de realimentação), pelo valor do resistor que liga o 
sinal de entrada ao pino 4 do circuito integrado. O circuito integrado, para amplificadores 
operacionais, é usualmente simbolizado como um triângulo deitado. 
 
Desta forma temos: 
k
M
10
1
, ou seja, 
000.10
000.000.1
 = 100 vezes. 
 
Vale dizer também que, pelo sinal de entrada estar ligado a porta com um sinal de menos ( - ), diz-se 
que trata-se de um circuito inversor. 
 
Caso você repare, existe uma parte da figura anterior um tanto quanto apagada, com dois resistores 
ligados ao pino 3 do AmpOp. Estes resistores ligados ao VCC e GND fazem um divisor de tensão, 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 15 / 32 
 
 
colocando uma tensão fixa na entrada positiva ( + ) do AmpOp. Esta ligação é feita para o AmpOp 
trabalhar como um comparador de tensão. 
 
O circuito anterior, com o AmpOp, foi retirado do esquema da placa do microfone de eletreto que 
acompanha o Arduino Kit Intermediário que você recebeu. Caso queira analisar o esquema 
completo, sugerimos entrar na página da Loja Virtual da RoboCore e procurar por “Microfone de 
Eletreto”. Ao entrar na página do produto, clique em “Esquema”. 
 
Visto o básico de amplificadores operacionais, podemos partir para nosso experimento. 
 
Nossa placa com microfone de eletreto pode ser entendida como um simples sensor. 
Você deve ligá-la no Arduino conforme o esquema a seguir: 
 
 
 
Grave o seguinte código no Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Microfone de Eletreto 1 ** 
\***************************************/ 
 
const int Eletreto = A0; 
int Som = 0; 
boolean ledState; 
 
void setup() { 
 pinMode(13, OUTPUT); 
} 
void loop(){ 
 Som = analogRead(Eletreto); 
 if (Som > 1000){ 
 ledState = !ledState; 
 delay(100); 
 } 
 
 if (ledState){ 
 digitalWrite(13, HIGH); 
 } 
 
 if (!ledState){ 
 digitalWrite(13, LOW); 
 } 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 16 / 32 
 
 
Após terminar de salvar o código no Arduino, bata uma simples palma ou estale seus dedos próximo 
ao microfone de eletreto. Você deverá ver o led do pino 13, aquele que já está na placa do Arduino, 
acender. Ao bater outra palma, você deverá ver o led apagar. Isto pode ser muito útil para diversos 
projetos, inclusive o famoso projeto Clapper , que aciona uma lâmpada com uma simples palma, e a 
desaciona com outra palma. Obviamente, este código é muito simples e pode apresentar algumas 
falhas, portanto é indicado que, caso queira fazer um circuito para um clapper, faça um código mais 
robusto, prevendo falhas e que seja mais completo, com temporizadores e timers. 
 
NUNCA “brinque” com altas tensões! Caso você não sa iba o que está fazendo, NÃO FAÇA! 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 17 / 32 
 
 
• Sensor Infravermelho 
Componentes: 01 Placa com Sensor Infravermelho 
Descrição: Aprenda os conceitos de sensores medidores de distância e/ou obstáculo, com 
uma placa muito utilizada em robôs seguidores de linha. 
 
Que tal fazer um robô seguidor de linha? A placa com sensor de distância que acompanha este kit é 
muito utilizada para fazer robôs seguidores de linha, bem como robôs que precisam detectar um final 
de curso no chão, como robôs de sumo. Na placa que você recebeu existe simplesmente um led 
emissor de raios infravermelhos e um led do tipo fototransistor. O conjunto funciona da seguinte 
forma: o led emissor fica ligado todo o tempo e, quando uma barreira faz com que os raios 
infravermelhos retornem a placa, o fototransistor “sente” a intensidade de raios que retornam. Quanto 
maior a quantidade retornada, mais baixa será a tensão na saída da placa. Analogamente, sensores 
de distância infravermelhos também utilizam esta técnica para fazer suas medições, como os 
famosos sensores de distância da Sharp, e a distância pode ser recebida e lida pelo microcontrolador 
por uma das portas de entrada analógica. 
 
Vamos fazer a ligação da placa no Arduino, como se fosse um sensor qualquer de 03 pinos. 
Tome cuidado com a ordem dos pinos! Você pode danif icar sua placa caso a ligue errado. 
 
Conforme o esquema acima, ligue o pino VCC da placa do sensor infravermelho ao 5V do Arduino, o 
pino OUT ao pino analógico 0, e o pino GND ao pino GND do Arduino. 
 
Primeiramente, vamos fazer um programa que nos mostra o range do sensor, ou seja, a faixa de 
distância que o mesmo “enxerga”. Você verá que esta faixa é muito pequena, pois este sensor é feito 
para robôs seguidores de linha, e costuma ficar a 3mm da linha desenhada no chão. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Sensor Infravermelho 1 ** 
\***************************************/ 
const int IRSensor = A0; 
int Distancia = 0; 
 
void setup(){ 
 Serial.begin(9600); 
} 
 
void loop(){ 
 Distancia = analogRead(IRSensor); 
 Serial.println(Distancia); 
 delay(100); 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 18 / 32 
 
 
Enquanto o sensor fica mirado para cima, você verá valores altos na tela do Monitor Serial, valores 
entre 1000 e 1023. Quando você aproxima uma barreira a este sensor, verá que o valor diminui, e 
quando você encosta esta barreira no sensor o valor lido é aproximadamente 70. Para fazer este 
teste, você pode utilizar seu próprio dedo. Fique atento em não utilizar uma superfície de vidro, pois 
neste tipo de superfície, nenhum raio infravermelho retorna ao sensor. 
 
Já que estamos citando tantas vezes os robôs seguidores de linha, vale a pena fazer uma pequena 
introdução à programação dos mesmos. 
 
 
 
A programação de um robô seguidor de linha pode ser extremamente simples, como também pode 
ser extremamente complexa. A idéia principal por trás de um robô deste tipo é que, quando o sensor 
encontra a linha desenhada no chão, o sensor retorna um determinado valor. Sendo assim, quando o 
robô anda para frente e sai desta linha, o sensor percebe que o valor foi alterado e o 
microcontrolador faz com que os motores hajam de forma a reencontrar a linha, e o reencontro da 
linha se dá quando o sensor volta ao valor pré-determinado. 
 
Existem diversas formas de deixar o código de um robô deste tipo mais complexo e robusto. Uma 
delas é utilizando sensores chamados encoders . Os encoders permitem que o microcontrolador 
saiba exatamente quantas voltas cada uma das rodas deu e em que sentido elas estão se movendo. 
Desta forma, o robô consegue desenvolver o traçado de uma maneira mais apurada e precisa. 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 19 / 32 
 
 
• Acionamento de Cargas com Relé 
Componentes: 01 Transistor + 01 Diodo + 01 Relé 
Descrição: Aprenda como acionar cargas de maior porte. Com este experimento será 
possível acionar e desacionar qualquer carga cuja especificação esteja dentro das 
especificações do relé. 
 
Este provavelmente é um dos projetos mais utilizados por estudantes e hobbistas, que admiram a 
arte da eletrônica. O simples uso de um pequeno sinal de corrente contínua de 5V, para acionar uma 
lâmpada de 110V, por exemplo. Pense nas possibilidades. Você pode construir seu próprio projeto 
de domótica, ou seja, automatizar toda uma residência com uma simples placa Arduino. Como?Que 
tal colocar o controle de sua casa inteira na internet, acessível por um site cuja senha e login só você 
tem? Isto lhe permitiria verificar se deixou alguma luz acesa em casa quando saiu para passear, ou 
acender uma luz a noite quando a casa estiver sozinha para ter mais segurança. Pense nas 
possibilidades de poder ativar ou desativar qualquer aparelho, estando a kilômetros de distância de 
sua casa. Você pode fazer isso de diversos modos, seja com um Shield Ethernet e um cabo ethernet 
com conexão à internet, ou um Shield WiFly (que se conecta a um roteador wireless com internet), 
ou mesmo utilizando um Shield Celular (ou GSM), e fazer todo o controle de ambientes via 
mensagens SMS. Ok, se domótica não for bem seu interesse, você pode acionar relés afim de 
controlar a movimentação de um robô, com as velhas e boas pontes H feitas de relé. 
 
Chega de falar sobre o que pode ser feito, e vamos fazer. Acionar um relé com Arduino não é uma 
tarefa difícil. Um relé nada mais é que um componente que, através de condução eletromagnética faz 
uma chave se movimentar. Portanto, um relé é simplesmente uma chave liga e desliga! Normalmente 
um relé possui 5 terminais. Dois deles são os terminais de uma bobina de acionamento. Esta bobina, 
no relé que acompanha este kit, é de 5V. Ou seja, você precisa de uma tensão DC de 5V para fazer 
a bobina conduzir e fazer o “relé bater”, ou acionar a chave. Os outros três terminais são como de 
uma simples chave, um é o terminal comum, ou seja, ele é comum ao circuito. Nele sempre passará 
a corrente. Os outros dois terminais são os contatos, um é normalmente aberto (NO, do inglês 
Normally Open ) e outro é normalmente fechado (NC, do inglês Normally Closed ). Eles são 
contatos com funções cujo próprio nome está dizendo. O normalmente fechado está em contato com 
o pino COMUM em todo momento até que a bobina 5V conduza corrente. Quando a bobina conduz 
corrente, o contato do relé se fecha, e o pino COMUM se liga ao pino NORMALMENTE ABERTO, 
fazendo-o ficar fechado e conduzir a corrente. Para fazer este experimento, monte o seguinte 
circuito: 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 20 / 32 
 
 
Muitos símbolos novos? Circuito muito estranho? Vamos lhe ajudar neste. Vamos começar com o 
transistor BC337. 
 
 
Um transistor é basicamente uma chave eletrônica. Ao dar um pulso de corrente na base, o coletor 
entra em contato com o emissor. Nesta hora, dizemos que o transistor está conduzindo. O intuito 
deste material é apresentar alguns projetos que podem ser feitos com Arduino. Caso você queira um 
estudo mais aprofundado sobre estes componentes, sugerimos procurar em livros de eletrônica e 
microeletrônica, pois como é intrínseco a todo apaixonado por eletrônica, a busca pelo conhecimento 
e a pesquisa nunca devem cessar. 
 
Vamos dar uma olhada no diodo, neste caso o 1N4148 e como ele deve ser colocado no circuito: 
 
 
 
 
Diodo é um semicondutor que conduz corrente em apenas 
um sentido (sempre do ânodo para o cátodo). Neste circuito, 
ele serve para fazer a proteção contra correntes que 
eventualmente podem percorrer o circuito e danificar o 
mesmo na mudança de estado do relé. Estas correntes 
podem trazer sérios danos ao circuito e este diodo não 
permite que a corrente retorne. Caso precise de um diodo 
que suporte maior corrente de retorno, sugerimos alterar 
este por um 1N4001 ou até um TIP102. O diodo que 
acompanha o kit é bom para relés que suportam cargas 
baixas. 
 
 
 
 
 
O entendimento do relé é muito simples. Olhando na parte debaixo dele, você verá um desenho de 
ligações. De um lado, existem 3 terminais, que são: terminal da bobina, seguido do pino COMUM, 
seguido do outro terminal da bobina. Do outro lado, existem 2 terminais que são o NORMALMENTE 
FECHADO e NORMALMENTE ABERTO. Você pode verificar isso vendo o desenho no relé. Fique 
muito atento ao montar este circuito! É necessário utilizar um transistor para acionar um relé com 
Arduino, pois a corrente que sai das portas digitais da placa não é suficiente para excitar a bobina do 
relé. 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 21 / 32 
 
 
Um código simples para ver se o circuito está funcionando, é o exemplo mais básico do Arduino, o 
blink: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Caso você ainda não tenha ciência disto, o código blink pode ser encontrado em 
FILE > EXAMPLES > 1. BASICS > BLINK 
 
Se tudo der certo, você deverá ouvir o ruído de uma chave abrindo e fechando, no caso, o contato do 
relé. Caso não esteja ouvindo este ruído, revise o circuito e verifique se o código foi gravado 
corretamente. 
 
Pronto! O relé já está funcionando e agora sua imaginação é o limite. Veja abaixo um exemplo de 
circuitos utilizando relé para acionar cargas: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
NOTA 
A RoboCore não se responsabiliza por danos à rede e létrica e/ou à integridade física do 
praticante do experimento, bem como quaisquer pesso as que possam vir a ser lesadas por 
estes experimentos. 
Se você não sabe ou não tem certeza do que está faz endo, procure por maiores informações 
e, principalmente, não faça nada que você não tenha certeza! 
 
/* 
 Blink 
 Turns on an LED on for one second, then off for one second, repeatedly. 
 
 This example code is in the public domain. 
 */ 
 
void setup() { 
 // initialize the digital pin as an output. 
 // Pin 13 has an LED connected on most Arduino boards: 
 pinMode(13, OUTPUT); 
} 
 
void loop() { 
 digitalWrite(13, HIGH); // set the LED on 
 delay(1000); // wait for a second 
 digitalWrite(13, LOW); // set the LED off 
 delay(1000); // wait for a second 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 22 / 32 
 
 
 
• Display de 7 Segmentos 
Componentes: 01 Display de 7 Segmentos + 01 CI 4511 
Descrição: Aprenda a utilizar o display de 7 segmentos juntamente a um conversor BCD para 
display. Neste experimento será explicado os fundamentos básicos de um circuito integrado 
e contagem binária. 
 
Este experimento irá mostrar como utilizar um display de 7 segmentos. Este tipo de display é 
amplamente utilizado em relógios digitais, eletrodomésticos, equipamentos industriais, contadores, é 
muito visto em filmes fazendo contagem decrescente de tempo, e por aí vai. O circuito encapsulado 
no display de 7 segmentos é extremamente simples. Trata-se apenas de 8 leds ligados com um 
ponto em comum. É possível encontrar no mercado, displays de catodo comum e de ânodo comum. 
O que iremos utilizar neste experimento é do tipo catodo comum, ou seja, cada terminal catodo de 
cada led está ligado entre si. Para ilustrar, dê uma olhada na imagem abaixo. Ela é auto-explicativa. 
 
Como se pode ver, não existe um resistor que limita a corrente no encapsulamento, portanto deve 
ser usado um resistor afim de não queimar os leds devido a alta corrente. Utilize para isto, resistores 
de 330Ω. 
 
A posição dos pinos é obtida conforme a figura abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 23 / 32 
 
 
Como o display de 7 segmentos é simplesmente um conjunto de leds, nada nos impede de tratá-los 
como simples leds! Portanto, poderíamos fazer um contador com a placa Arduino utilizando 7 saídas 
digitais. Obviamente, este não é o melhor método de se utilizar este display, porém, caso você não 
tenha um conversor BCD para display de 7 segmentos, esta se torna uma boa saída. Primeiramente, 
vamos fazer um circuito deste tipo com o Arduino. Monte o circuito da próxima página com o Arduino 
e o display: 
 
 
Grave no Arduino o seguinte código: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Display 7 Segmentos 1 ** 
\***************************************/ 
 
int A = 10; // Primeiramentesetamos os 7 pinos 
int B = 9; 
int C = 6; 
int D = 7; 
int E = 8; 
int F = 11; 
int G = 12; 
 
void setup(){ 
 pinMode(A, OUTPUT); // seta todos as portas que estão os leds do display como 
saída 
 pinMode(B, OUTPUT); 
 pinMode(C, OUTPUT); 
 pinMode(D, OUTPUT); 
 pinMode(E, OUTPUT); 
 pinMode(F, OUTPUT); 
 pinMode(G, OUTPUT); 
} 
 
void loop(){ 
 digitalWrite(A, HIGH); //acende os leds que representam o número 0 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, HIGH); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, LOW); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 24 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 digitalWrite(A, LOW); //acende os leds que representam o número 1 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, LOW); 
 digitalWrite(E, LOW); 
 digitalWrite(F, LOW); 
 digitalWrite(G, LOW); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, HIGH); //acende os leds que representam o número 2 
 digitalWrite(B, HIGH); 
 digitalWrite(C, LOW); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, HIGH); 
 digitalWrite(F, LOW); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, HIGH); //acende os leds que representam o número 3 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, LOW); 
 digitalWrite(F, LOW); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, LOW); //acende os leds que representam o número 4 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, LOW); 
 digitalWrite(E, LOW); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, HIGH); //acende os leds que representam o número 5 
 digitalWrite(B, LOW); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, LOW); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, LOW); //acende os leds que representam o número 6 
 digitalWrite(B, LOW); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, HIGH); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, HIGH); //acende os leds que representam o número 7 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, LOW); 
 digitalWrite(E, LOW); 
 digitalWrite(F, LOW); 
 digitalWrite(G, LOW); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 digitalWrite(A, HIGH); //acende os leds que representam o número 8 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, HIGH); 
 digitalWrite(E, HIGH); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 25 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
Quase duas páginas inteiras de código para fazer um display de 7 segmentos fazer uma simples 
contagem de 0 a 9 com intervalos de 1 segundo? Deve ter algum modo mais fácil, não? Sim! Graças 
a um pequeno circuito integrado, não é necessário perder espaço na memória de seu 
microcontrolador para programar apenas o display. Juntamente ao Arduino Kit Intermediário você 
recebeu um CI 4511, ou seja, um circuito integrado do tipo 4511. Circuitos integrados são compostos 
de milhares de conjuntos de transistores (de um tamanho comparável a um grão de areia) que, 
através da lógica entre eles, desempenha funções específicas. A função específica do CI 4511 é a 
de conversor BCD para display de 7 segmentos. Conveniente não? Para saber mais sobre este, e 
qualquer outro CI, você deve procurar pelo datasheet do mesmo. Os datasheets, como o nome diz, 
são folhas de dados onde são apresentados todas as características do circuito integrado. Faça uma 
busca de “datasheet 4511” no Google e veja o arquivo .PDF que você irá encontrar. Mas o que seria 
um conversor BCD para display de 7 segmentos? 
 
O que é BCD? 
 
Entende-se pela sigla BCD o termo binary-coded decimal , ou seja, é um número decimal, porém 
em formato binário. Um número binário é um número que é representado apenas por números 0 e 
números 1. Para ter uma explicação aprofundada deste assunto, é amplamente aconselhável 
procurar por livros de eletrônica e microeletrônica. Apenas para o conhecimento, e para dar 
continuidade a este manual, veja na tabela abaixo como este chip entenderá cada número colocado 
em suas entradas: 
 
N.º em Binário N.º em Decimal 
0 0 0 0 0 
0 0 0 1 1 
0 0 1 0 2 
0 0 1 1 3 
0 1 0 0 4 
0 1 0 1 5 
0 1 1 0 6 
0 1 1 1 7 
1 0 0 0 8 
1 0 0 1 9 
 
O conceito de número binário é algo muito extenso para ser tratado aqui. Por isto é sempre 
aconselhado procurar fontes de leitura externas para aprimorar seus conhecimentos. A saber, para 
continuar os experimentos: números binários são tratados na eletrônica como níveis. Um número 0 é 
tratado como nível lógico baixo e um número 1 é tratado como nível lógico alto. O que seria nível 
lógico? Nada mais é do que DESLIGADO (nível lógico 0) e LIGADO (nível lógico 1). Em um circuito 
como o Arduino, nível lógico 0 seria 0V de tensão, ou seja, nenhuma tensão, a porta estaria 
desligada. Nível lógico 1 seria 5V nas portas digitais, ou seja, tensão total, a porta estaria ligada. Este 
zero e um é comumente visto em chaves liga/desliga (ou você achava que aquela bolinha e aquele 
traço vertical na chave significava alguma outra coisa se não um 0 e um 1, de desligado e ligado?). 
 
digitalWrite(A, HIGH); //acende os leds que representam o número 9 
 digitalWrite(B, HIGH); 
 digitalWrite(C, HIGH); 
 digitalWrite(D, LOW); 
 digitalWrite(E, LOW); 
 digitalWrite(F, HIGH); 
 digitalWrite(G, HIGH); 
 delay(1000); //aguarda 1 segundo para mostrar próximo número 
} 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 26 / 32 
 
 
Toda esta explicação foi feita, pois na entrada do circuito integrado 4511 é necessário introduzir 
sinais binários para que o display acenda o número desejado. O usuário mais experto já percebeu 
que, se introduzir, por exemplo, o número binário 0110 no circuito integrado, ele responderá ligando 
automaticamente um número 6 no display, pois ele é um conversor BCD para display de 7 
segmentos! 
 
Vamos verificar como funciona o circuito, trabalhando com este CI. Monte o seguinte circuito: 
 
 
ATENÇÃO : Fique atento à ligação do circuito integrado. Se ligar um fio errado, pode danificar o 
componente de tal forma que pode queimá-lo e deixá-lo inutilizável! 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 27 / 32 
 
 
Grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O código está um pouco mais enxuto, mas o que mais diferencia do código anterior é que agora 
estamos usando apenas 4 saídas digitais. Ou seja, utilizando a contagem binária e o circuito 
integrado 4511, nós ganhamos mais espaço em nossa memória do microcontrolador e temos mais 
entradas/saídas disponíveis em nossa placa Arduino para colocar mais componentes no projeto. 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Display 7 Segmentos 2 ** 
\***************************************/ 
 
int a = 4; 
int b = 5; 
int c = 6; 
int d = 7; 
 
void setup(){ 
pinMode(a, OUTPUT); 
pinMode(b, OUTPUT); 
pinMode(c, OUTPUT); 
pinMode(d, OUTPUT); 
} 
void loop(){ 
 digitalWrite(a, LOW);//DIGITO 0 
 digitalWrite(b, LOW); 
 digitalWrite(c,LOW); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, HIGH);//DIGITO 1 
 digitalWrite(b, LOW); 
 digitalWrite(c, LOW); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, LOW);//DIGITO 2 
 digitalWrite(b, HIGH); 
 digitalWrite(c, LOW); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, HIGH);//DIGITO 3 
 digitalWrite(b, HIGH); 
 digitalWrite(c, LOW); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, LOW);//DIGITO 4 
 digitalWrite(b, LOW); 
 digitalWrite(c, HIGH); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, HIGH);//DIGITO 5 
 digitalWrite(b, LOW); 
 digitalWrite(c, HIGH); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, LOW);//DIGITO 6 
 digitalWrite(b, HIGH); 
 digitalWrite(c, HIGH); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, HIGH);//DIGITO 7 
 digitalWrite(b, HIGH); 
 digitalWrite(c, HIGH); 
 digitalWrite(d, LOW); 
 delay(1000); 
 digitalWrite(a, LOW);//DIGITO 8 
 digitalWrite(b, LOW); 
 digitalWrite(c, LOW); 
 digitalWrite(d, HIGH); 
 delay(1000); 
 digitalWrite(a, HIGH); //DIGITO 9 
 digitalWrite(b, LOW); 
 digitalWrite(c, LOW); 
 digitalWrite(d, HIGH); 
 delay(1000); 
} 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 28 / 32 
 
 
 
• Shield LCD+Botões 
Componentes: 01 Arduino Shield LCD+Botões 
Descrição: Aprenda a funcionalidade dos Shields para Arduino, além de traduzir dados do 
microcontrolador e trazê-los para o ambiente externo, inteligível aos seres humanos. 
 
Displays de LCD são objetos muito comuns em circuitos eletrônicos. Eles servem para trazer ao 
mundo, de uma maneira “legível”, dados que o microcontrolador carrega consigo. Pense em um 
display de LCD como um Monitor Serial, da IDE do Arduino, porém portátil! Com este componente é 
possível não só trazer números para o ambiente externo (como nos displays de 7 segmentos), mas 
também texto. Por exemplo, você pode fazer a leitura de uma temperatura utilizando um sensor NTC 
e, após feita a calibragem, mostrar a mesma no display indicando que se trata de uma temperatura. 
Você pode também fazer relógios, cronômetros, e assim por diante. Tudo que puder ser escrito, 
poderá ser lido! 
 
O shield LCD que acompanha este kit possui em sua placa mais que apenas um LCD de 16x2 
caracteres (este nome é dado pois é possível escrever 16 caracteres em cada uma das 2 linhas que 
este display possui), existem 5 botões de uso geral e 1 botão para reset da placa. Ainda existe um 
pequeno potenciômetro azul, o chamado TRIMPOT, para ajustar o brilho do display. Além disso, algo 
muito útil são as entradas em três vias para sensores do tipo VCC – GND – SINAL. Você pode 
encontrar muitos sensores que possuem este tipo de cabo de sinal na página de sensores na loja 
virtual da RoboCore, não deixe de conferir! 
 
Chega de papo, vamos ao que interessa. Antes de colocar o shield em seu Arduino e antes de gravar 
o primeiro código, é necessário comentar que já existem duas bibliotecas prontas para se usar 
displays de LCD deste tipo com Arduino. Estas bibliotecas prontas fazem toda a “parte chata da 
conversa” entre microcontrolador e display. Uma das bibliotecas é a LiquidCrystal (nativa do 
programa Arduino) e a outra é a LCD4Bit_mod . Ambas funcionam muito bem. Caso haja o interesse 
em instalar esta última em sua IDE do Arduino, siga o seguinte procedimento: 
 
Copie a pasta “LCD4Bit_mod” (que está dentro da pasta BIBLIOTECAS deste CD) para a pasta de 
bibliotecas onde o Arduino está instalado em seu computador. Caso o Arduino esteja no disco raiz 
(comumente chamado de C:\), a pasta de bibliotecas deve estar em “C:\arduino-0022\libraries”. Abra 
o programa do Arduino, verifique se a biblioteca consta no mesmo, olhando em “SKETCH > IMPORT 
LIBRARY...”. Caso exista uma biblioteca chamada “LCD4Bit_mod”, está tudo certo (não é necessário 
clicar na biblioteca). Caso não apareça o nome da biblioteca, você deve fechar o programa Arduino e 
colocar na pasta correta a biblioteca. Após isto, abra novamente o programa Arduino e veja se ela 
está lá. 
 
Aqui iremos utilizar exemplos que usam apenas a biblioteca LiquidCrystal, pois a mesma já vem com 
o ambiente de desenvolvimento Arduino quando você o baixa do site da Arduino ou da RoboCore. 
 
Primeiramente vamos estudar um dos códigos mais simples que podemos colocar no Arduino para o 
mesmo trabalhar com o LCD. Compile e grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 29 / 32 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Mas este código é um tanto quanto torpe, visto que colocamos no loop do programa informações 
estáticas, ou seja, que, neste programa, nunca mudam. Poderíamos muito bem, para poupar 
processador, colocando as linhas de código do loop no setup do programa. Deste modo, o LCD 
seria escrito apenas uma vez (quando o programa passasse pelo setup e só, e não ficaria 
escrevendo e reescrevendo todo o tempo, enquanto faz a rotina do loop ). 
 
Para ver se você realmente entendeu como posicionar caracteres no display, tente colocar este texto 
que acabamos de escrever no centro do display e faça-o ser escrito apenas uma vez, para poupar 
processamento. Veja como o código deve parecer abaixo (lembrando que existem diversas maneiras 
de escrever códigos para Arduino, e o mostrado aqui é apenas um exemplo): 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Muito simples, não? 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Shield LCD+Botões 1 ** 
\***************************************/ 
#include <LiquidCrystal.h> // importa a biblioteca do LCD 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //diz quais portas serão usadas pelo LCD 
 
void setup(){ 
 lcd.begin(16, 2); //inicializa a biblitoeca, dizendo que iremos usar um display 16x2 
 } 
 
void loop(){ 
 lcd.setCursor(0,0); //este comando é muito importante: ele seta onde estará o cursor que 
 //escreverá no display. 0,0 significa que o cursor está na linha 0 
 //e posição 0, ou seja, primeiro caracter no canto esquerdo superior. 
 //Deste modo, podemos concluir que o último caractér será escrito em 
 //(15,1), certo? 
 
 lcd.print("LCD diz:"); //escreve estes 8 caractéres na primeira linha 
 lcd.setCursor(0,1); //muda a posição do cursor para a segunda linha, primeiro espaço 
 lcd.print("Ola Mundo ;)"); //escreve estes 12 caractéres. 
} 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Shield LCD+Botões 2 ** 
\***************************************/ 
 
#include <LiquidCrystal.h> // importa a biblioteca do LCD 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //diz quais portas serão usadas pelo LCD 
 
void setup(){ 
 lcd.begin(16, 2); //inicializa a biblitoeca, dizendo que iremos usar um display 16x2 
 lcd.setCursor(4,0); 
 lcd.print("LCD diz:"); 
 lcd.setCursor(2,1); 
 lcd.print("Ola Mundo ;)"); 
 } 
 
void loop(){ 
 
} 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 30 / 32 
 
 
Para ver ser você entendeu mesmo como se faz a mudança do lugar do cursor, examine o código 
abaixo e, antes de gravá-lo no Arduino, tente descobrir o que ele faz: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Vamos agora aprender a utilizar outro recurso de nosso Shield LCD. Vamos entender como 
funcionam os botões deste shield. 
 
Neste shield é utilizado uma técnica muito interessante para se utilizar botões, feita para economizar 
portas de entrada/saída. Se você olhar o esquema elétrico deste shield, verá que muitas das portas 
de entrada/saída convencionais estão sendo usadas pelo display de LCD. Então os botões foram 
colocados em uma única porta analógica! Sim! Uma porta analógica! Como funciona?A porta 
analógica lê valores de 0 a 1023 (do nível 0V ao nível 5V, através de um conversor analógico-digital 
de 10 bits, dando a precisão de 1024 valores). Os 5 botões de uso geral estão ligados a esta porta 
analogia, no caso porta A0, e tem seus resistores de pull-down de diferentes valores. Portanto, 
quando um botão é apertado, um valor é lido pela entrada analógica. Quando outro botão é apertado, 
um outro valor completamente diferente é lido pela mesma porta analógica, e assim vai. É um jeito 
muito interessante e inteligente de se poupar portas para uso de botões e sinais digitais em geral. 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Shield LCD+Botões 3 ** 
\***************************************/ 
#include <LiquidCrystal.h> 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
int a, b = 0 ; 
 
void setup(){ 
 lcd.begin(16, 2); 
} 
 
void loop(){ 
 for(int i = 0; i < 16; i++){ 
 lcd.setCursor(i,0); 
 lcd.print(">"); 
 delay(250); 
 } 
 for(int k=16; k > -1; k--){ 
 lcd.setCursor(k,1); 
 lcd.print("<"); 
 delay(250); 
 } 
 for(int i = 0; i < 16; i++){ 
 lcd.setCursor(i,0); 
 lcd.print(" "); 
 delay(250); 
 } 
 for(int k=16; k > -1; k--){ 
 lcd.setCursor(k,1); 
 lcd.print(" "); 
 delay(250); 
 } 
 
} 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 31 / 32 
 
 
Grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Shield LCD+Botões 4 ** 
\***************************************/ 
#include <LiquidCrystal.h> 
 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
 
int lcd_key = 0; 
int adc_key_in = 0; 
#define btnRIGHT 0 
#define btnUP 1 
#define btnDOWN 2 
#define btnLEFT 3 
#define btnSELECT 4 
#define btnNONE 5 
 
int read_LCD_buttons() 
{ 
 adc_key_in = analogRead(0); 
 if (adc_key_in > 1000) return btnNONE; 
 if (adc_key_in < 50) return btnRIGHT; //os valores desta e das seguintes linhas 
 if (adc_key_in < 195) return btnUP; //são os valores lidos pela entrada analógica 0 
ao apertar um botão. 
 if (adc_key_in < 380) return btnDOWN; 
 if (adc_key_in < 555) return btnLEFT; 
 if (adc_key_in < 790) return btnSELECT; 
 return btnNONE; 
} 
 
void setup() 
{ 
 lcd.begin(16, 2); 
 lcd.setCursor(0,0); 
 lcd.print("Aperte os botoes"); 
} 
 
void loop() 
{ 
 lcd.setCursor(9,1); 
 lcd.print(millis()/1000); 
 lcd.setCursor(0,1); 
 lcd_key = read_LCD_buttons(); 
 
 switch (lcd_key) 
 { 
 case btnRIGHT: 
 { 
 lcd.print("RIGHT "); 
 break; 
 } 
 case btnLEFT: 
 { 
 lcd.print("LEFT "); 
 break; 
 } 
 case btnUP: 
 { 
 lcd.print("UP "); 
 break; 
 } 
 case btnDOWN: 
 { 
 lcd.print("DOWN "); 
 break; 
 } 
 case btnSELECT: 
 { 
 lcd.print("SELECT"); 
 break; 
 } 
 case btnNONE: 
 { 
 lcd.print("NONE "); 
 break; 
 } 
 } 
 
} 
 
 
ARDUINO KIT INTERMEDIÁRIO V1.0 
 
 
www.robocore.net 32 / 32 
 
 
O exemplo da página anterior é um dos exemplos que podem ser encontrados no manual deste 
shield, que pode ser encontrado no seguinte link: 
http://www.robocore.net/modules.php?name=GR_LojaVirtual&prod=201 
 
Com o exemplo acima, podemos ter uma idéia de como os botões funcionam. De maneira muito 
simples, se a leitura da porta analógica 0 for tal número, sabemos que um determinado botão foi 
pressionado e escrevemos na tela qual foi o botão. Você pode ver também neste exemplo, um timer 
dizendo a quantos segundos o programa está rodando. Com o conceito do timer, já é possível fazer 
um relógio e mostrá-lo no display, e com os botões é possível alterar a hora (como em um rádio-
relógio convencional). 
 
Vamos agora fazer um experimento interessante: escrever em tempo real dados em nosso display. 
Grave o seguinte código em seu Arduino: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Após concluir a gravação do código em sua placa Arduino, abra o Monitor Serial e selecione o baud 
rate para 9600. Escreve algo no monitor serial e envie para o Arduino. Você deverá ver na tela do 
LCD o que enviar pelo Monitor Serial. 
 
 
 
Com estes conceitos já é possível explorar um pouco mais de sua placa Arduino, verificar como 
funcionam os Shields e como interfacear outros tipos de componentes à placa. 
 
Aqui foram colocados apenas códigos introdutórios para componentes de nível intermediário. Como 
as opções de códigos e projetos são muito amplas, não é possível contemplar todos em um único 
manual, porém para qualquer dúvida em projeto sinta-se a vontade em entrar em contato com a 
RoboCore pelo e-mail info@robocore.net 
 
 
 
 
 
 
 
 
Arduinize o Mundo 
RoboCore Arduino Kit Intermediário 
WWW.ROBOCORE.NET 
/***************************************\ 
** ROBOCORE ARDUINO KIT INTERMEDIÁRIO ** 
* * 
** Shield LCD+Botões 5 ** 
\***************************************/ 
#include <LiquidCrystal.h> 
int incomingByte; 
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); 
 
void setup(){ 
 Serial.begin(9600); 
 lcd.begin(16, 2); 
 lcd.setCursor(0,0); 
 
} 
 
void loop(){ 
 
 if (Serial.available() > 0) { 
 incomingByte = Serial.read(); 
 lcd.print(char(incomingByte)); 
 } 
}