40 Projetos com arduino

Prévia do material em texto

Projetos com Arduino 
 
 
 
40 projetos 
 
 
 
 
Willian Scollonoff 
 
 
 
 
 
 
 
 
 
[ 2 ] 
 
 
 
 
Projetos com Arduino 
 
 
 
40 projetos 
 
 
 
 
 
 
[ 3 ] 
 
 
 
 
[ 4 ] 
 
 
[ 5 ] 
SUMÁRIO 
 
Projeto 01 – Pisca LED ........................................................................................................................................ 7 
Projeto 02 – Semáforo ........................................................................................................................................ 9 
Projeto 03 – Alarme com sonorizador Piezo ..........................................................................................12 
Projeto 04 – Tocador de Melodia com sonorizador Piezo ................................................................15 
Projeto 05 – Sensor de luminosidade com LDR....................................................................................19 
Projeto 06 – Barra de LED’s e LDR ..............................................................................................................25 
Projeto 07 – Sensor de temperatura com LM35 ..................................................................................28 
Projeto 08 – Controle básico com LCD......................................................................................................32 
Projeto 09 – Sensor de temperatura com LCD ......................................................................................36 
Projeto 10 – Controle de temperatura com LCD e cooler ................................................................40 
Projeto 11 – Controle de velocidade de um motor cc........................................................................45 
Projeto 12 – Motor de passo controlado por Arduino........................................................................49 
Projeto 13 – Servo motor controlado por Arduino ..............................................................................53 
Projeto 14 – Controlando um servo motor com joystick .................................................................56 
Projeto 15 – Sensor Ultrassônico Básico .................................................................................................59 
Projeto 16 – Sensor de ré para automóvel .............................................................................................62 
Projeto 17 – Gravando um arquivo .DOC no SD CARD ......................................................................66 
Projeto 18 – Sensor de umidade e temperatura DHT11 ..................................................................71 
Projeto 19 – Arduino como osciloscópio ..................................................................................................74 
Projeto 20 – Arduino como um gerador de frequência (onda quadrada) ................................77 
Projeto 21 – Configurando o shield ethernet com o arduino .........................................................81 
Projeto 22 – Ascendendo LED com shield ethernet............................................................................86 
Projeto 23 – Ascendendo lâmpada com shield ethernet e relê ....................................................92 
Projeto 24 – Escrevendo em um LCD Nokia 5110 ...............................................................................97 
Projeto 25 – Gráfico de leitura de temperatura com um LCD Nokia 5110 ........................... 100 
Projeto 26 – Teclado matricial 4x4 básico ........................................................................................... 104 
Projeto 27 – Acionando relê via teclado matricial 4x4 .................................................................. 108 
Projeto 28 – Utilizando um cartão RFID ............................................................................................... 112 
Projeto 29 – Configurando o módulo bluetooth (JY-MCU) .......................................................... 118 
Projeto 30 – Acionando LED e relê com via bluetooth com arduinocomander .................. 122 
Projeto 31 – Utilizando o PWM via bluetooth com arduinocomander .................................... 131 
Projeto 32 – Utilizando o osciloscópio via bluetooth com arduinocomander ..................... 139 
Projeto 33 – Utilizando sensores do Smartphone via bluetooth com arduinocomander
 ................................................................................................................................................................................... 150 
 
 
Projeto 34 – Verificando código de comando de um controle remoto ................................... 158 
Projeto 35 – Clonando controle remoto de TV ................................................................................... 162 
Projeto 36 – Acionando LED’s e relê com infravermelho .............................................................. 166 
Projeto 37 – Jogo ping pong com LCD Nokia 5110.......................................................................... 170 
Projeto 38 – Jogo dos caminhões com LCD 16x2 ............................................................................. 177 
Projeto 39 – Interface WEB com Arduino ............................................................................................ 184 
Projeto 40 – Monitor de temperatura com Arduino ........................................................................ 190 
 
 
 
 
Projeto 01 – Pisca LED 
 
 
 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protoboard 
1 LED (qualquer cor e tamanho) 
1 Resistor de 100 ohms * 
Fios jumpers 
* Esse valor pode ser diferente, dependendo do LED que você utilizar. 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue sua protoboard, o LED, o resistor e os fios, e conecte tudo como mostra a 
figura: 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 8 ] 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. 
Certifique-se de que seu LED esteja conectado corretamente, com o terminal (ou perna) 
mais longo conectado ao pino digital 10. O terminal longo e o anodo do LED, e deve 
sempre ir para a alimentação de +5 V (nesse caso, saindo do pino digital 10); o terminal 
curto e o cátodo e deve ir para o terra (GND). Quando você estiver seguro de que tudo foi 
conectado corretamente, ligue seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
// Projeto 1 - LED piscante 
int ledPin = 10; // Declaramos uma variável inteira com valor igual a... 
//10 (conectada no pino 10 do Arduino) 
 
void setup() { // Esta função é executada somente uma vez no início... 
//do programa 
 
pinMode(ledPin, OUTPUT); // Define ledPin como pino de saída 
} 
void loop() { // Esta é a função principal do programa, será executada... 
//continuamente enquanto o Arduino estiver ligado 
 
digitalWrite(ledPin, HIGH); // Esta enviado 5 volts para o pino 10 do Arduino 
delay(1000); // Diz ao Arduino espera 1000 milisegundo antes de executar... 
//a próxima instrução 
 
digitalWrite(ledPin, LOW); // Diz para o Arduino desligar o pino 10... 
//deixando-o em 0 volts 
 
delay(1000); // Espera mais 1000 segundos 
} 
 
Para verificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do códigopara seu Arduino. Pronto, 
no seu primeiro projeto você estará vendo o LED piscando em um intervalo de um 
segundo. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 9 ] 
Projeto 02 – Semáforo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, agora vamos fazer um pequeno projeto, um semáforo que irá do verde ao 
vermelho, passando pelo amarelo e, que retornará ao vermelho depois de um intervalo de 
tempo. Este projeto poderá ser utilizado em uma maquete com carinhos simulando uma 
pequena cidade ou mesmo uma estrada de ferro. Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 LED Amarelo 
1 LED Verde 
1 LED Vermelho 
3 Resistores de 100 ohms * 
Fios jumpers 
* Esse valor pode ser diferente, dependendo do LED que você utilizar. 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue sua protoboard, os LED, os resistores e os fios, e conecte tudo como mostra 
a figura. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 10 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, 
a superfície dos furos ainda estará rígida. A não inversão cuidadosa dos componentes 
pode resultar em danos. Certifique-se de que seus LED’s estejam conectados 
corretamente, com o terminal (ou perna) mais longo conectado aos pinos digital 8, 9 e 10 
do arduino. Quando você estiver seguro de que tudo foi conectado corretamente, ligue seu 
Arduino e conecte o cabo USB. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 2 – Semáforo 
int ledDelay = 10000; // Espera entre as alterações 
 
int vermelhoPin = 10; // Declaramos uma variável inteira com valor igual... 
//a 10 (conectada no pino 10 do Arduino) 
 
int amareloPin = 9; // Declaramos uma variável inteira com valor igual... 
//a 9 (conectada no pino 9 do Arduino) 
 
int verdePin = 8; // Declaramos uma variável inteira com valor igual... 
//a 8(conectada no pino 8 do Arduino) 
void setup() { 
pinMode(vermelhoPin, OUTPUT); // Define vermelhoPin como pino de saída 
pinMode(amareloPin, OUTPUT); // Define amareloPin como pino de saída 
pinMode(verdePin, OUTPUT); // Define verdePin como pino de saída 
} 
void loop() { 
 
digitalWrite(vermelhoPin, HIGH); // Acende a luz vermelha 
delay(ledDelay); // Espera 5 segundos 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 11 ] 
 
digitalWrite(amareloPin, HIGH); // Acende a luz amarela 
delay(2000); // Espera 2 segundos 
 
digitalWrite(verdePin, HIGH); // Acende a luz verde 
digitalWrite(vermelhoPin, LOW); // Apaga a luz vermelha 
digitalWrite(amareloPin, LOW); // Apaga a luz amarela 
delay(ledDelay); // Espera ledDelay milissegundos 
 
digitalWrite(vermelhoPin, HIGH); // Acende a luz vermelha 
digitalWrite(verdePin, LOW); // Apaga a luz verde 
delay(2000); // Espera 2 segundos 
 
digitalWrite(amareloPin, LOW); // Apaga a luz amarela 
 // Agora nosso loop se repete 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
no seu segundo projeto você verá um semáforo que irá do verde ao vermelho, passando 
pelo amarelo e, que retornará depois de um intervalo de tempo. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 12 ] 
Projeto 03 – Alarme com sonorizador Piezo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, neste projeto será um pouco barulhento pois, vamos fazer um alarme com 
sonorizador piezo conectado a um pino de saída digital, podendo ser criado um som de 
sirene. Iremos gerar uma onda senoidal para gerar os pulsos e criando o som. Os códigos 
serão todos comentados para melhor entendimento, podendo ser retirados após a 
compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Sonorizador piezo (ou disco piezo) 
Fios jumpers 
 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue sua protoboard, o sonorizador piezo e os fios, e conecte tudo como mostra a 
figura. 
Observação importante: Verifique a polaridade do sonorizador piezo. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 13 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 3 – Alarme com sonorizador piezo 
 
// Armazena o valor de seno que fazer o valor se elevar e diminuir 
float sinVal; 
// Pega o valor armazenado em sinVal e converte-o para frequência... 
//solicitada 
int toneVal; 
 
void setup() { 
pinMode(8, OUTPUT); // Declara o pino 8 como saída 
} 
 
void loop() { 
// Converte graus para radianos, e depois obtém o valor do seno 
for (int x=0; x<180; x++) { 
 
// Gera uma frequência a partir do valor do seno 
sinVal = (sin(x*(3.1416/180))); 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 14 ] 
// Pega 2000 e adiciona sinVal multiplicando por 1000, gerando um... 
//bom intervalo de frequências para o tom crescente e decrescente da... 
//onda senoidal 
toneVal = 2000+(int(sinVal*1000)); 
 
// O comando ton( ) é definido como ton(pin, frequency), o pin... 
//corresponde o pino digital de saída e frequency é a frequência do... 
//tom em Hertz 
tone(8, toneVal); 
 
delay(2); // Espera dois milissegundos entre as alterações de frequência 
} 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
no seu terceiro projeto você ouvirá o som sendo emitido pelo sonorizador piezo. 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 15 ] 
 
Projeto 04 – Tocador de Melodia com sonorizador Piezo 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, neste projeto você aprenderá como fazer melodias ao invés de fazer apenas 
barulhos irritantes. Você fará com seu Arduino o refrão da música “Puff, the Magic 
Dragon”. O esquema será igual ao Projeto 3, porém com o código modificado. Os códigos 
serão todos comentados para melhor entendimento, podendo ser retirados após a 
compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Sonorizador piezo (ou disco piezo) 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue sua protoboard, o sonorizador piezo e os fios, e conecte tudo como mostra a 
figura. 
Observação importante: Verifique a polaridade do sonorizador piezo. 
Projetos comArduino por Willian Scollonoff 
 
 
 
[ 16 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 4 – Tocador de melodia com sonorizador piezo 
 
/* A diretiva #define é muito simples e útil, esta diretiva simplesmente 
um valor e seu token correspondente, por exemplo, #define PI 3.141592653 
589793238462643. No decorrer do seu programa você não precisa digitar 
todo o valor de PI, apenas #define PI.*/ 
 
#define NOTE_C3 131 
#define NOTE_CS3 139 
#define NOTE_D3 147 
#define NOTE_DS3 156 
#define NOTE_E3 165 
#define NOTE_F3 175 
#define NOTE_FS3 185 
#define NOTE_G3 196 
#define NOTE_GS3 208 
#define NOTE_A3 220 
#define NOTE_AS3 233 
#define NOTE_B3 247 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 17 ] 
#define NOTE_C4 262 
#define NOTE_CS4 277 
 
#define NOTE_D4 294 
#define NOTE_DS4 311 
#define NOTE_E4 330 
#define NOTE_F4 349 
#define NOTE_FS4 370 
#define NOTE_G4 392 
#define NOTE_GS4 415 
#define NOTE_A4 440 
#define NOTE_AS4 466 
#define NOTE_B4 494 
 
#define WHOLE 1 
#define HALF 0.5 
#define QUARTER 0.25 
#define EIGHTH 0.125 
#define SIXTEENTH 0.0625 
 
// Definimos um array de valores inteiro tune[], preenchendo as notas da... 
//melodia "Puff, o Dragão Mágico" 
int tune[] = { NOTE_C4, NOTE_C4, NOTE_C4, NOTE_C4, NOTE_C4, NOTE_B3, 
NOTE_G3, NOTE_A3, NOTE_C4, NOTE_C4, NOTE_G3, NOTE_G3, NOTE_F3, 
NOTE_F3, NOTE_G3, NOTE_F3, NOTE_E3, NOTE_G3, NOTE_C4, NOTE_C4, 
NOTE_C4, NOTE_C4, NOTE_A3, NOTE_B3, NOTE_C4, NOTE_D4}; 
 
// Criamos um array de floats que armazena a duração de cada nota, 
//conforme melodia tocada 
float duration[] = { EIGHTH, QUARTER+EIGHTH, SIXTEENTH, QUARTER, 
QUARTER, HALF, HALF, HALF, QUARTER, QUARTER, HALF+QUARTER, 
QUARTER, QUARTER, QUARTER, QUARTER+EIGHTH, EIGHTH, QUARTER, 
QUARTER, QUARTER, EIGHTH, EIGHTH, QUARTER, QUARTER, QUARTER, 
QUARTER, HALF+QUARTER}; 
 
int length;// Este inteiro será utilizado para calcular e armazenar o... 
//comprimento do array (número de notas na melodia) 
 
void setup() { 
 pinMode(8, OUTPUT); // Definimos o pino digital 8 como saída 
 // A função sizeof retorna o número de bytes 
 length = sizeof(tune) / sizeof(tune[0]); 
} 
void loop() { 
// Definimos um loop que itera o número de vezes correspondente as... 
//notas da melodia 
 for (int x = 0; x < length; x ++) { 
// Então a próxima nota do array tune[] é reproduzida no pino digita 8 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 18 ] 
 tone(8, tune[x]); 
// Aqui esperamos o tempo necessario para que a melodia seja reproduzida 
 delay(1500 * duration[x]); 
// Antes que a nota seguinte seja tocada você cessa o tom gerado no pino 8 
 noTone(8); 
} 
 delay(5000); // Espera 5 segundos antes de tocar a melodia novamente 
} 
 
Os países anglófonos mantiveram a utilização de letras para a nomenclatura das notas 
musicais. As letras A, B, C, D, E, F e G são utilizadas para as notas lá, si, do, ré, mi, fá e 
sol, respectivamente (fonte: Wikipedia). 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
no seu terceiro projeto você ouvirá o som sendo emitido pelo sonorizador piezo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 19 ] 
 
Projeto 05 – Sensor de luminosidade com LDR 
 
 
 
 
 
 
Olá pessoal, neste projeto você aprenderá como fazer um sensor de luminosidade básico, e 
uma pequena aplicação, onde você verá três LED‘s acendo conforme variação da 
luminosidade. Os códigos serão todos comentados para melhor entendimento, podendo ser 
retirados após a compreensão de cada linha. Bom trabalho !!! 
Para você visualizar o monitor serial selecione a opção Tools, Serial Monitor (ou 
Ctrl+Shift+M) e pronto. 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protobord 
1 LDR (Light Dependent Resistor (Resistor dependente de luz)) 
1 LED Vermelho 
1 LED Amarelo 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 20 ] 
1 LED Verde 
3 Resistores de 330 ohms * 
1 Resistor de 10K ohms 
Fios jumpers 
* Esse valor pode ser diferente, dependendo do LED que você utilizar. 
 
CONECTANDO OS COMPONENTES 
 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o LDR, o resistor de 10 K ohms e os fios e conecte-os como mostra a figura. 
Observação importante: Verifique a polaridade dos LED’s. 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 21 ] 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 5 - Sensor de luminosidade 
 
// Define o pino analógico A0, onde será lido o valor do sensor 
int sensorAlogPin = 0; 
// Define uma variável qualquer para armazenar o valor lido do pino A0 
int armazenaValor = 0; 
 
void setup(){ 
 // Inicializa a função Serial, configurando sua velocidade 
 Serial.begin(9600); 
} 
 
void loop(){ 
// Faz a leitura da porta analogica A0 e armazena na variável armazenaValor 
armazenaValor = analogRead(sensorAlogPin); 
 
 Serial.print("Lendo valor... "); // Imprime no monitor serial 
 Serial.print(armazenaValor); // Mostra o valor lido pela porta serial 
 
 delay(1000); // Aguarda 1 segundo 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora inicialize o monitor serial e visualize o que acontece quando você muda a 
luminosidade no LDR. 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 22 ] 
 
IMAGEM DA PORTA SERIAL DO IDE DO ARDUINO 
 
 
 
APLICAÇÃO DO SENSOR DE LUMINOSIDADE 
Complemente o projeto anterior conforme mostra a figura 
 
 
COMPLEMENTE O CÓDIGO DA SEGUINTE MANEIRA 
 
// Projeto 5.1 - Sensor de luminosidade com LED’s 
 
// Define o pino analógico A0, onde será lido o valor do sensor 
int sensorAnalogPin = 0; 
// Define uma variável qualquer para armazenar o valor lido do pino A0 
int armazenaValor = 0; 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 23 ] 
// Definindo pinos onde estão conectados os LED’s 
const int ledVerde = 11; 
const int ledAmarelo = 12; 
const int ledVermelho = 13; 
 
void setup(){ 
 
// Ativando o serial monitor queexibirá os valores lidos no sensor 
Serial.begin(9600); 
 
// Definindo pinos digitais dos LED’s como de saída 
 pinMode(ledVerde,OUTPUT); 
 pinMode(ledAmarelo,OUTPUT); 
 pinMode(ledVermelho,OUTPUT); 
} 
 
void loop(){ 
// Faz a leitura da porta analogica A0 e armazena na variável armazenaValor 
int armazenaValor = analogRead(sensorAnalogPin); 
 
//Os valores da luminosidade podem ser alterados conforme a necessidade 
//Luminosidade baixa 
 if (armazenaValor < 600) { 
 apagaLeds(); 
 digitalWrite(ledVermelho,HIGH); 
 } 
 
// Luminosidade média 
 if (armazenaValor >= 600 && valorSensor <= 850) { 
 apagaLeds(); 
 digitalWrite(ledAmarelo,HIGH); 
 } 
 
// Luminosidade alta 
 if (armazenaValor > 850) { 
 apagaLeds(); 
 digitalWrite(ledVerde,HIGH); 
 } 
 
// Exibindo o valor do sensor no serial monitor. 
 Serial.print("Lendo valor... "); // Imprime no monitor serial 
 Serial.println(valorSensor); // Mostra o valor lido pela porta serial 
 delay(1000); 
} 
 
// Está função criada para apagar todos os leds de uma vez 
void apagaLeds() { 
 digitalWrite(ledVerde,LOW); 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 24 ] 
 digitalWrite(ledAmarelo,LOW); 
 digitalWrite(ledVermelho,LOW); 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você verá os LED’s trocando de cor conforme variação de luminosidade. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 25 ] 
Projeto 06 – Barra de LED’s e LDR 
 
 
 
Olá pessoal, neste projeto você aprenderá como fazer uma barra de LED’s e LDR como 
sensor de luminosidade. Você perceberá que conforme a variação da luminosidade e 
consequentemente variação de resistência, a sequência de LED’s irão acender ou apagar. 
Os códigos serão todos comentados para melhor entendimento, podendo ser retirados após 
a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protobord 
1 LDR (Light Dependent Resistor (Resistor dependente de luz)) 
8 LED’s de qualquer cor 
8 Resistores de 330 ohms * 
1 Resistor de 10K ohms 
Fios jumpers 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 26 ] 
* Esse valor pode ser diferente, dependendo do LED que você utilizar. 
CONECTANDO OS COMPONENTES 
 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue todos os componentes acima e conecte-os como mostra a figura. 
Observação importante: Verifique a polaridade dos LED’s. 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 6 – Barra de LED’s e LDR 
 
/* A função Map do Arduino, mapeia uma faixa de valores em outra. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 27 ] 
Segundo o site do Arduino temos o seguinte prototipo: 
 
map(value, fromLow, fromHigh, toLow, toHigh) 
 
onde, 
 
value: Informa o valor lido da porta analógica. 
fromLow: Início da escala de origem. 
fromHigh: Fim da escala de origem. 
toLow: Início da escala de destino. 
toHigh: Fim da escala de destino. 
 
Esta função converte os parâmetros PWM de 0, 1023 para a escala de 0, 255 
 
*/ 
 
 
int ldrMap = 0; // Variável iniciando com valor igual a 0. 
int analogPin = 1; // Variável utilizando o pino analógico A1. 
 
void setup() 
{ 
 for(int a = 0; a<=10; a++) // Iniciando os pino digitais do Arduino... 
 pinMode(a, OUTPUT); // como saída 
} 
 
void loop() 
{ 
 // Verifica a função Map, o 22 pode ser mudado 
 ldrMap = map(analogRead(analogPin), 0, 1023, 22, 0); 
 for(int a = ldrMap; a>=0; a--) // Quando a resistência do LDR diminui... 
 digitalWrite(a, HIGH); // acende todos os LED's 
 
 for(int a = ldrMap; a<=10; a++) // Quando a resistência do LDR aumenta... 
 digitalWrite(a, LOW); // apaga todos os LED's 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora verifique o que acontece quando você muda a luminosidade(resistência) no LDR. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 28 ] 
Projeto 07 – Sensor de temperatura com LM35 
 
 
 
Olá pessoal, agora iremos ver um sensor muito interessante e útil. O LM35 é um sensor de 
temperatura de precisão. Este sensor pode ler temperaturas entre -55ºC a 150ºC. Podendo 
ser utilizador em diversos projetos tais como controle de refrigeração de uma câmara fria, 
controle de aquecimento de um forno, entre outras. Então vamos ao trabalho. Os códigos 
serão todos comentados para melhor entendimento, podendo ser retirados após a 
compreensão de cada linha. Bom trabalho !!! 
Para você visualizar o monitor serial selecione a opção Tools, Serial Monitor (ou 
Ctrl+Shift+M) e pronto. 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protoboard 
1 LM35 – Sensor de temperatura 
Fios jumpers 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 29 ] 
 
CONECTANDO OS COMPONENTES 
 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o LM35 e os fios e conecte-os como mostra a figura. Observação importante: 
Vcc (Pino +), Output (Pino de retorno) e Ground (Pino -), com visão frontal do mesmo da 
esquerda para direita. 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 7 – Sensor de temperatura com LM35 
 
float tempC; // Cria variável para armazenar temperatura 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 30 ] 
int tempPin = 0; // Declara o pin analógico 0 
 
 
void setup() 
{ 
 Serial.begin(9600); // Abre porta serial, inicializa dados a 9600 bps 
 
} 
 
void loop() // O código continuará a ficar em loop 
{ 
 tempC = analogRead(tempPin); // Le o valor analógico do sensor LM35 
 // Converte a entrada de temperatura em graus centigrados 
 tempC = (5.0 * tempC * 100.0)/1024.0; 
 // Imprime no monitor serial - Lendo temperatura... 
 Serial.println("Lendo temperatura ... "); 
 Serial.print((byte)tempC); // Envia dados para o computador 
 Serial.println(" C"); // Imprime o C de Celsius no monitor serial 
 
 delay(1000); // Espera 1 segundos 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seuArduino. Pronto, 
agora inicialize o monitor serial e visualize o que acontece quando você muda a 
temperatura do LM35. 
 
 
 
IMAGEM DA PORTA SERIAL DO IDE DO ARDUINO 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 31 ] 
 
 
 
FOTO DO PROJETO PRONTO 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 32 ] 
 
 
 
 
 
 
Projeto 08 – Controle básico com LCD 
 
 
 
Olá pessoal, agora vamos deixar nossos projetos visualmente mais interessantes. Iremos 
aprender como utilizar o LCD (Liquid Crystal Display), nós utilizaremos o modelo JHD 162A, 
deixando nossos projetos mais amigáveis. Para isso teremos que utilizar a biblioteca 
LiquidCrystal.h, que já inclui todas as funções sem precisarmos declarar linha por linha. 
Bom trabalho !!! Os códigos serão todos comentados para melhor entendimento, podendo 
ser retirados após a compreensão de cada linha. Bom trabalho !!! 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 33 ] 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 LCD (JHD 162A de 16 colunas e 2 linhas) ou outro modelo com back light 
2 Potenciômetros de 10K ohms (Um para o contraste e o outro para a luz de fundo) * 
Fios jumpers 
 
* Este modelo que utilizei não possui o back light, porém o projeto foi montado com se 
tivesse essa função. 
 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o LCD, os potênciometros e os fios e conecte-os como mostra a figura. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 34 ] 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
SEGUE O ESQUEMA ABAIXO PARA MELHOR ENTENDIMENTO 
 
- Pino 1 do LCD ligado ao GND do Arduino; 
 
- Pino 2 do LCD ligado ao 5V do Arduino; 
 
- Pino 3 do LCD ligado ao pino central do primeiro 
potenciômetro (controle de contraste); 
 
- Pino 4 do LCD ligado ao pino digital 9 do Arduino; 
 
- Pino 5 do LCD ligado ao GND do Arduino; 
 
- Pino 6 do LCD ligado ao pino digital 8 do Arduino; 
 
- Pino 11 do LCD ligado ao pino digital 5 do Arduino; 
 
- Pino 12 do LCD ligado ao pino digital 4 do Arduino; 
 
- Pino 13 do LCD ligado ao pino digital 3 do Arduino; 
 
- Pino 14 do LCD ligado ao pino digital 2 do Arduino; 
 
- Pino 15 do LCD ligado ao pino central do segundo 
potenciômetro (controle do brilho); 
 
- Pino 16 do LCD ligado ao GND do Arduino. 
 
 
Obs.: Os demais pinos não serão utilizados neste projeto. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 8 - Controle básico com LCD 
 
// Define a utilização da biblioteca para controle de telas LCD’s 
#include <LiquidCrystal.h> 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 35 ] 
 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Cria um objeto LCD e atribui os pinos 
 
void setup() { 
 
 lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas 
} 
 
void loop() { 
 lcd.clear(); // Limpa o display do LCD 
 lcd.print("Ola pessoal !!"); // Imprime a string no display do LCD 
 // Espera 2 segundos antes de imprimir a proxima string no LCD 
 delay(2000); 
 
 lcd.clear(); 
 lcd.print("Este e um"); 
 lcd.setCursor(0,1); // Posiciona o cursor na coluna 0 linha 1 do LCD 
 lcd.print("controle basico"); 
 delay(2000); 
 
 lcd.clear(); 
 lcd.print("de LCD !!"); 
 delay(2000); 
 
 lcd.clear(); 
 lcd.print("www.facacomarduino.info"); 
 delay(1000); 
 
 for (int i = 0; i < 16; i++) { // Rolando o display para a esquerda 16 vezes 
 lcd.scrollDisplayLeft(); 
 delay(600); 
 } 
 
 delay(3000); 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você poderá ajustar o contraste e luz de fundo para melhor visualização. 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 36 ] 
 
 
 
 
 
 
 
Projeto 09 – Sensor de temperatura com LCD 
 
 
 
Olá pessoal, já vimos basicamente como utilizar um LCD com o Arduino, agora vamos 
utilizar o mesmo esquema anterior acrescentando um sensor temperatura LM35 - que 
também já vimos. Este projeto tem pouca complexidade, desde que montado com calma 
para não se perderem nas conexões dos jumpers. Os códigos serão todos comentados para 
melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 37 ] 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protobord 
1 LCD (JHD 162A de 16 colunas e 2 linhas) ou outro modelo com back light 
2 Potenciômetros de 10K ohms (Um para o contraste e o outro para a luz de fundo) * 
1 Sensor LM35 
Fios jumpers 
* Este modelo que utilizei não possui o back light, porém o projeto foi montado com se 
tivesse essa função. 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o LCD, os potenciômetros, o sensor LM35 e os fios e conecte-os como mostra 
a figura. 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 38 ] 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
 
SEGUE O ESQUEMA ABAIXO PARA MELHOR 
ENTENDIMENTO 
 
- Pino 1 do LCD ligado ao GND do Arduino; 
 
- Pino 2 do LCD ligado ao 5V do Arduino; 
 
- Pino 3 do LCD ligado ao pino central do primeiro 
Potenciômetro (controle de contraste); 
 
- Pino 4 do LCD ligado ao pino digital 9 do Arduino; 
 
- Pino 5 do LCD ligado ao GND do Arduino; 
 
- Pino 6 do LCD ligado ao pino digital 8 do Arduino; 
 
- Pino 11 do LCD ligado ao pino digital 5 do Arduino; 
 
- Pino 12 do LCD ligado ao pino digital 4 do Arduino; 
 
- Pino 13 do LCD ligado ao pino digital 3 do Arduino; 
 
- Pino 14 do LCD ligado ao pino digital 2 do Arduino; 
 
- Pino 15 do LCD ligado ao pino central do segundo 
Potenciômetro (controle do brilho); 
 
- Pino 16 do LCD ligado ao GND do Arduino. 
 
 
Obs.: Os demais pinos não serão utilizados neste projeto. 
 
AGORA VAMOS AO CÓDIGO 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 39 ] 
// Projeto 9 - Sensor de temperatura com LCD 
 
#include <LiquidCrystal.h> 
#include <Limits.h> 
 
// Pino analógico em que o sensor de temperatura está conectado 
const int sensorTemp = 0; 
 
// Declara o pino analógico 0 para ler o valor do sensor de temperatura 
int tempPin = 0; 
// Variável usada para ler o valor de temperatura 
int valorSensorTemp = 0; 
// Variável usada para armazenaro menor valor de temperatura 
int valorTemp = INT_MAX; 
 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Cria um objeto LCD e atribui os pinos 
 
void setup() { 
 
 lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas 
} 
 
void loop() { 
 
 /*Para evitar as grandes variações de leitura do componente 
 LM35 são feitas 6 leitura é o menor valor lido prevalece*/ 
 
 // Inicializando a variável com o maior valor int possível 
 valorTemp = INT_MAX; 
 for (int i = 1; i <= 6; i++) { // Lendo o valor do sensor de temperatura 
 
 valorSensorTemp = analogRead(sensorTemp); 
 
 // Transforma o valor lido do sensor de temperatura em graus celsius... 
 //aproximados 
 valorSensorTemp *= 0.54 ; 
 
 // Mantendo sempre a menor temperatura lida 
 if (valorSensorTemp < valorTemp) { 
 valorTemp = valorSensorTemp; 
 } 
 
 delay(100); 
 } 
 
 // Exibindo valor da leitura do sensor de temperatura no display LCD 
 lcd.clear(); // Limpa o display do LCD 
 lcd.print("Temperatura:"); // Imprime a string no display do LCD 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 40 ] 
 lcd.print(valorTemp); 
 lcd.write(B11011111); // Símbolo de graus Celsius 
 lcd.print("C"); 
 
 delay(2000); // Aguarda 2 segundos 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você irá visualizar no visor do LCD a temperatura que está no ambiente em que você 
se encontra. Caso seja necessário, ajuste o contraste e luz de fundo para melhor 
visualização. 
 
 
Projeto 10 – Controle de temperatura com LCD e cooler 
 
Olá pessoal, já vimos basicamente como utilizar um LCD com o Arduino, agora vamos fazer 
um pequena aplicação utilizando o mesmo esquema do projeto anterior acrescentando um 
cooler. Este projeto tem pouca complexidade, desde que montado com calma para não se 
perderem nas inserções dos jumpers. Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protobord 
1 LCD (JHD 162A de 16 colunas e 2 linhas) ou outro modelo com back light 
2 Potenciômetros de 10K ohms (Um para o contraste e o outro para a luz de fundo) * 
1 Sensor LM35 
1 Cooler ** 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 41 ] 
Fios jumpers 
* Este modelo que utilizei não possui o back light, porém o projeto foi montado com se 
tivesse essa função. 
** Dependendo do cooler que você utilizar será necessária uma fonte externa para 
alimentá-lo. Uma vez que a saída do Arduino possui apenas 5V. 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o LCD, os potenciômetros, o sensor LM35, o cooler e os fios e conecte-os 
como mostra a figura. 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 42 ] 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
SEGUE O ESQUEMA ABAIXO PARA MELHOR ENTENDIMENTO 
 
- Pino 1 do LCD ligado ao GND do Arduino; 
 
- Pino 2 do LCD ligado ao 5V do Arduino; 
 
- Pino 3 do LCD ligado ao pino central do primeiro 
Potenciômetro (controle de contraste); 
 
- Pino 4 do LCD ligado ao pino digital 9 do Arduino; 
 
- Pino 5 do LCD ligado ao GND do Arduino; 
 
- Pino 6 do LCD ligado ao pino digital 8 do Arduino; 
 
- Pino 11 do LCD ligado ao pino digital 5 do Arduino; 
 
- Pino 12 do LCD ligado ao pino digital 4 do Arduino; 
 
- Pino 13 do LCD ligado ao pino digital 3 do Arduino; 
 
- Pino 14 do LCD ligado ao pino digital 2 do Arduino; 
 
- Pino 15 do LCD ligado ao pino central do segundo 
Potenciômetro (controle do brilho); 
 
- Pino 16 do LCD ligado ao GND do Arduino. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 43 ] 
 
 
Obs.: Os demais pinos não serão utilizados neste projeto 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 10 - Controle de temperatura com LCD e Cooler 
 
#include <LiquidCrystal.h> 
#include <Limits.h> 
 
// Pino analógico em que o sensor de temperatura está conectado 
const int sensorTemp = 0; 
 
int fan = 13; // Declara o pino digital 13 para acionar o cooler 
// Declara o pino analógico 0 para ler o valor do sensor de temperatura 
int tempPin = 0; 
int valorSensorTemp = 0; // Variável usada para ler o valor de temperatura 
// Variável usada para armazenar o menor valor de temperatura 
int valorTemp = INT_MAX; 
 
// Cria um objeto LCD e atribui os pinos 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); 
 
void setup() { 
 
 pinMode (fan, OUTPUT); // Define o pino 13 como saída 
 lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas 
} 
 
void loop() { 
 
 /*Para evitar as grandes variações de leitura do componente 
 LM35 são feitas 6 leitura é o menor valor lido prevalece*/ 
 
 // Inicializando a variável com o maior valor int possível 
 valorTemp = INT_MAX; 
 for (int i = 1; i <= 6; i++) { // Lendo o valor do sensor de temperatura 
 
 valorSensorTemp = analogRead(sensorTemp); 
 
 // Transforma o valor lido do sensor de temperatura em graus... 
 //Celsius aproximados 
 valorSensorTemp *= 0.54 ; 
 
 // Mantendo sempre a menor temperatura lida 
 if (valorSensorTemp < valorTemp) { 
 valorTemp = valorSensorTemp; 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 44 ] 
 } 
 
 delay(100); 
 } 
 
 if(valorTemp > 35) // Indica condição para acionamento do cooler 
 { 
 // Define a coluna 0 e linha 1 do LCD onde será impresso a string 
 lcd.setCursor(0,1); 
 lcd.write("Fan ligado !"); // Imprime no LCD 
 digitalWrite(fan, HIGH); // Quando condição verdadeira, liga o cooler 
 } 
 else 
 { 
 lcd.setCursor(0,1); 
 lcd.write("Fan desligado !"); 
 // Desliga cooler quando este estiver a baixo da valorTemp, indicando... 
 //no LCD que esta desligado 
 digitalWrite(fan, LOW); 
 } 
 delay(1000); 
 
 // Exibindo valor da leitura do sensor de temperatura no display LCD 
 lcd.clear(); // Limpa o display do LCD 
 lcd.print("Temperatura:"); // Imprime a string no display do LCD 
 lcd.print(valorTemp); 
 lcd.write(B11011111); // Símbolo de graus Celsius 
 lcd.print("C"); 
 
 delay(2000); // Aguarda 2 segundos 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você irá visualizar no visor do LCD a temperatura que está no ambiente e se o cooler 
está desligado ou ligado - dependendo da temperatura que você estipulou para acioná-lo. 
Caso seja necessário, ajuste o contraste e luz de fundo para melhor visualização. 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 45 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projeto 11 – Controle de velocidadede um motor cc 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 46 ] 
 
 
 
 
 
 
 
 
Olá pessoal, a partir de agora vamos começar a utilizar motores com Arduino. Iniciaremos 
com um motor de corrente contínua e posteriormente iremos ver outros tipos de motores 
tais como: motores de passo e servo motores. Este código é muito simples de ser 
entendido, portanto vamos lá. Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
 
1 Arduino Uno R3 
1 Protobord 
1 Potenciômetro de 10K ohms 
1 Motor CC de 5 Volts 
1 Transistor de potência TIP120 
1 Diodo Zener 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 47 ] 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o potenciômetro, o motor, o transistor e os fios e conecte-os como mostra a 
figura. 
 
 
 
Não 
importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, desde 
que os componentes e os fios estejam conectados na mesma ordem da figura. Tenha 
cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 48 ] 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 11 - Controle de velocidade de um motor CC 
 
// Pino analógico onde o potenciômetro está conectado 
int const potenciometro = 1; 
int const transTIP120 = 10; // Pino digital onde o TIP120 está conectado 
 
int valPotenciometro = 0; // Armazena o valor lido no potenciômetro 
 
 void setup() { // Função executada sempre quando o Arduino é ligado 
 
 pinMode(transTIP120, OUTPUT); // Define o pino digital 10 como saída 
} 
 
// Esta função é executada repetidamente enquanto o Arduino estiver ligado 
void loop() { 
 
 /* Lendo o valor do potenciômetro (0 até 1023) e dividindo por 4 para obter 
 um valor entre 0 e 255 que são valores adequados para a base do TIP120 */ 
 
 valPotenciometro = analogRead(potenciometro) / 4; 
 
 // Atribui o valor lido no potenciômetro a base do TIP120 
 analogWrite(transTIP120, valPotenciometro); 
 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora para aumentar ou diminuir a velocidade do motor basta girar o potenciômetro. 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 49 ] 
Projeto 12 – Motor de passo controlado por Arduino 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, já vimos como controlar um motor CC. Agora vamos ver como funciona um 
motor de passo com Arduino. Neste projeto foi utilizado um Shield para controle de motor 
com ULN2003. Projeto simples de ser implementado. Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Modulo para motor ULN2003 
1 Motor de passo modelo 28BYJ-48 
Fios jumpers 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 50 ] 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, o driver, o motor de passo e os fios e conecte-os como mostra a imagem abaixo. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SEGUE O ESQUEMA ABAIXO PARA MELHOR ENTENDIMENTO 
 
Pinos do módulo para motor ULN2003 Pinos do Arduino 
IN1 4 
IN2 5 
IN3 6 
IN4 7 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 12 - Motor de passo controlado por Arduino 
 
// Declarando variáveis para os pinos do motor 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 51 ] 
 
int motorPin1 = 4; // Azul - Pino 1 do motor 28BYJ-48 
int motorPin2 = 5; // Rosa - Pino 2 do motor 28BYJ-48 
int motorPin3 = 6; // Amarelo - Pino 3 do motor 28BYJ-48 
// Laranja - Pino 4 do motor 28BYJ-48 o pino 5 (Vermelho) é o pino de... 
//alimentação do motor de passo (VCC) 
int motorPin4 = 7; 
 
int velocMotor = 1200; // Variáveis para configurar a velocidade do motor 
int contagem = 0; // Variável usada como contador de passos 
int passosPorRotacao = 512; // Número de passos por rontação completa 
int vetorLigDesl[8] = {B01000, B01100, B00100, B00110, B00010, B00011, 
B00001, B01001}; 
 // Vetor que manipula os pinos do motor entre 0 e 1 (Desliga/Liga) 
 
void setup() { 
 // Declara os pinos do motor como pinos de saída 
 
 pinMode(motorPin1, OUTPUT); 
 pinMode(motorPin2, OUTPUT); 
 pinMode(motorPin3, OUTPUT); 
 pinMode(motorPin4, OUTPUT); 
} 
 
void loop(){ 
 if(contagem < passosPorRotacao ) 
 sentidoHorario(); // Função para rotacionar em sentido horário 
 else if (contagem == passosPorRotacao * 2) 
 contagem = 0; 
 else 
 sentidoAntiHorario(); // Função para rotacionar em sentido anti horário 
 contagem++; 
} 
 
/*Configurando os pinos para ULN2003. 
o delay "motorSpeed" determina o tempo para a velocidade do motor*/ 
 
void sentidoAntiHorario() 
{ 
 for(int i = 0; i < 18; i++) 
 { 
 setOutput(i); 
 delayMicroseconds(velocMotor); 
 } 
} 
 
void sentidoHorario() 
{ 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 52 ] 
 for(int i = 17; i >= 0; i--) 
 { 
 setOutput(i); 
 delayMicroseconds(velocMotor); 
 } 
} 
 
void setOutput(int out) // Faz a manipulação de 0 e 1 
{ 
 digitalWrite(motorPin1, bitRead(vetorLigDesl[out], 0)); 
 digitalWrite(motorPin2, bitRead(vetorLigDesl[out], 1)); 
 digitalWrite(motorPin3, bitRead(vetorLigDesl[out], 2)); 
 digitalWrite(motorPin4, bitRead(vetorLigDesl[out], 3)); 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
o motor irá rotacionar para o sentido horário e depois para o sentido anti horário. 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 53 ] 
Projeto 13 – Servo motor controlado por Arduino 
 
 
 
 
 
 
 
 
 
Olá pessoal, já vimos como controlar um motor CC e motor de passo. Agora vamos ver 
como funciona um servo motor conectado ao Arduino. Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Servo motor TG9 (ou equivalente) 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-odo cabo USB. 
Agora, pegue o servo motor e os fios e conecte-os como mostra a figura. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 54 ] 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 13 - Servo motor controlado por Arduino 
 
#include <Servo.h> 
 
Servo servo1; // Cria um objeto servo 
 
// Variável para armazenar a posição do servo1 
int pos = 0; 
 
void setup() 
{ 
 // Agrega o objeto servo1 ao pino digital 11 
 servo1.attach(11); 
} 
 
 
void loop() 
{ 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 55 ] 
 for(pos = 0; pos < 180; pos += 1) // Vai de 0 grau a 180 em passo de 1 grau 
 { 
 // Chama o servo1 para ir para a posição da variavel "pos" 
 servo1.write(pos); 
 delay(50); // Agurade 50ms para para o servo1 atingir a posição 
 } 
 for(pos = 180; pos>=1; pos-=1) // Vai de 180 graus ate 0 
 { 
 // Chama o servo1 para ir para a posição da variavel "pos" 
 servo1.write(pos); 
 delay(10); // Aguarda 10ms para o servo1 atingir a posição 
 } 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você poderá movimentar o Joystick na horizontal e o servo também se movimentará 
para direita e esquerda conforme seu comando. 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 56 ] 
Projeto 14 – Controlando um servo motor com joystick 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, muitos já viram controlar um servo com potenciômetro, agora vamos ver 
como controlar um servo com joystick. Com este projeto você pode facilmente controlar a 
rotação de uma câmera, de uma cabeça de um robô ou qualquer outro controle que 
envolva movimento, não é difícil de ser implementado, por tanto vamos lá. Os códigos 
serão todos comentados para melhor entendimento, podendo ser retirados após a 
compreensão de cada linha. Bons projetos a todos !! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Módulo de Joystick PS2 
1 Servo motor TG9 
Fios jumpers 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 57 ] 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o módulo, o servo e os fios e conecte-os como mostra a figura. 
 
 
 
 
 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 14 - Controlando um servo motor com Joystick 
 
#include <Servo.h> 
 
Servo servo1; // Cria um objeto servo 
int portCom; // Cria uma variável para armazenar dados do Joystick 
int servoPin = 11; // Pino digital 11 conectado no servo1 
 
void setup(){ 
 servo1.attach(servoPin); 
 servo1.write(90); // Inicia o servo1 em 90 graus 
} 
 
void loop(){ 
 portCom = analogRead(0); // Pino X do Joystick para receber dados 
 // Faz um mapeamento dos dados recebidos 
 portCom = map(portCom, 0, 1023, 0, 180); 
 
 // O servo se movimenta de acordo com a posição do Joystick 
 servo1.write(portCom); 
 delay(15); // Tempo leitura do pino analogico A0 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 58 ] 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora você poderá movimentar o Joystick na horizontal e o servo também se movimentará 
para direita e esquerda conforme seu comando. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 59 ] 
 
Projeto 15 – Sensor Ultrassônico Básico 
 
Olá pessoal, vamos aprender como utilizar o sensor ultrassônico em nossos projetos. O 
modelo utilizado será o HC-SRO4 encontrado em qualquer loja que contenha componentes 
para Arduino. Os códigos serão todos comentados para melhor entendimento, podendo ser 
retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protoboard 
1 Módulo ultrassônico HC-SRO4 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o sensor ultrassônico e os fios e 
conecte-os como mostra a figura. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 60 ] 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 15 - Sensor ultrasônico básico 
 
#define trigPin 12 
#define echoPin 13 
 
 
void setup() { 
 Serial.begin (9600); 
 pinMode(trigPin, OUTPUT); 
 pinMode(echoPin, INPUT); 
 
} 
 
void loop() { 
 long duration, distance; 
 // Configura o pino 12 com um pulso baixo "LOW" ou desligado ou ainda 0 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); // Aguarda 2 microssegundos 
 
 // Configura o pino 12 com pulso alto "HIGH" ou ligado ou ainda 1 
 digitalWrite(trigPin, HIGH); 
 delayMicroseconds(10); // Aguarda 10 microssegundos 
 // Configura o pino 12 com pulso baixo novamente 
 digitalWrite(trigPin, LOW); 
 // PulseIn lê o tempo entre a chamada e o pino entrar em High 
 duration = pulseIn(echoPin, HIGH); 
 
 /*Esse calculo é baseado em s = v . t, lembrando que o tempo vem dobrado 
 porque é o tempo de ida e volta do ultrassom */ 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 61 ] 
 distance = ((duration/2) / 29.1); 
 
 Serial.print(distance); 
 Serial.println(" Cm"); 
 
 delay(500); 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
abra o Serial Monitor e coloque um objeto na frente no sensor ultrassônico e vocêverá a 
distância que o objeto está em relação ao sensor. 
IMAGEM DO SERIAL MONITOR 
 
 
 
IMAGEM DO PROJETO PRONTO 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 62 ] 
 
 
Projeto 16 – Sensor de ré para automóvel 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, vamos fazer agora um sensor de ré que emite um alerta sonoro quando um 
objeto chega a uma certa distância. Para ficar mais visível iremos utilizar um LCD que nos 
informará a distância do objeto próximo ao sensor. Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Módulo ultrassônico HC-SRO4 
1 LCD (JHD 162A de 16 colunas e 2 linhas) ou outro modelo com back light 
2 Potenciômetros de 10 K ohms (Um para o contraste e o outro para a luz de fundo) * 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 63 ] 
1 Sonorizador piezo 
Fios jumpers 
* Este modelo que utilizei não possui o back light, porém o projeto foi montado com se 
tivesse essa função. 
Obs.: Verifique a polaridade do sonorizador piezo. 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o sensor ultrassônico, o LCD, o piezo, os potenciômetros e os fios e conecte-
os como mostra a figura. 
 
 
 
 
 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 16 - Sensor de ré para automóvel 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 64 ] 
 
#include <LiquidCrystal.h> // Biblioteca necessária para iniciar o LCD 
 
#define buzina 6 // Define um variável chamada buzina no pino digital 6 
 
#define trigPin 12 
#define echoPin 13 
 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Cria um objeto LCD e atribui os pinos 
 
void setup() { 
 
 lcd.begin(12, 6); // Inicializa o LCD 
 
 
 pinMode(buzina, OUTPUT); // Declara o pino 6 como saída 
 pinMode(trigPin, OUTPUT); 
 pinMode(echoPin, INPUT); 
 
} 
 
void loop() { 
 
 long duration, distance; 
 // Configura o pino 12 com um pulso baixo "LOW" ou desligado ou ainda 0 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); // Aguarda 2 microssegundos 
 
 // Configura o pino 12 com pulso alto "HIGH" ou ligado ou ainda 1 
 digitalWrite(trigPin, HIGH); 
 delayMicroseconds(10); // Aguarda 10 microssegundos 
 // Configura o pino 12 com pulso baixo novamente 
 digitalWrite(trigPin, LOW); 
 // PulseIn lê o tempo entre a chamada e o pino entrar em High 
 duration = pulseIn(echoPin, HIGH); 
 
 /*Esse calculo é baseado em s = v . t, lembrando que o tempo vem dobrado 
 porque é o tempo de ida e volta do ultrassom */ 
 
 distance = ((duration/2) / 29.1); 
 
 lcd.clear(); 
 lcd.print("Distancia:"); 
 lcd.print(distance); 
 lcd.print(" CM"); 
 { 
 delay(500); 
} 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 65 ] 
 
// Condição para ativar a buzina quando atingir a distância necessária 
 if(distance < 30){ 
 digitalWrite(buzina, HIGH); // Pino lógico 6 habilitado (5 Volts) 
 lcd.setCursor(0,1); 
 lcd.println("Muito proximo ! "); 
} 
else 
{ 
 digitalWrite(buzina, LOW); // Pino lógico 6 desabilitado (0 Volts) 
 lcd.setCursor(0,1); 
 lcd.println("Ainda seguro ! "); 
} 
 delay(500); 
 } 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora gire os potenciômetros para regular o contraste e o brilho. Coloque algum objeto 
próximo ao ultrassônico e quando o objeto chegar ao uma distância inferior a 30 cm o 
piezo emitirá um som de alerta. Isso tudo você também poderá visualizar no LCD. 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 66 ] 
 
 
Projeto 17 – Gravando um arquivo .DOC no SD CARD 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, agora vamos ver como gravar e visualizar um arquivo .doc no cartão SD, 
gravando com o Arduino e visualizando o arquivo no notebook, desktop, tablet, ou até 
mesmo no seu smartphone. Neste projeto foi utilizado um adaptador de microSD da 
Samsung, não tive problemas com este cartão, portanto se houver problemas com o que 
você utilizar deixe um comentário. Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
Obs. importante: Antes de compilar, coloque o cartão SD. 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Modulo SD 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 67 ] 
Fios jumpers 
 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o módulo e os fios e conecte-os como mostra a figura. 
 
 
Pinos do módulo SD Pinos do Arduino 
MOSI 11 
MISO 12 
CLK ou SCK 13 
CS 6 
 
Obs.: Neste modulo tem que conectar também o 2 GND, 1 Vcc de 3V e 1 Vcc 5V todos no 
Arduino. 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 68 ] 
AGORA VAMOS AO CÓDIGO 
 
//Projeto 17 - Gravando um arquivo .doc no SD Card 
 
#include <SD.h> // Biblioteca para manipular os dados no Cartão 
 
// Criação de uma variável para guardar os dados inseridos 
File meuArquivo; 
 
void setup() 
{ 
 // Abre a comunicação serial liberando a porta 
 
 Serial.begin(9600); 
 while (!Serial) { 
 
 ; // Aguarda a porta serial conectar. 
 } 
 
 
 Serial.print("Inicializando SD card..."); // Inicializa o cartão SD 
 
 // Esta condição analisa se o cartão está inserido corretamente no shield 
 if (!SD.begin(6)) { 
 Serial.println("A inicializacao falhou! "); 
 return; 
 } 
 // Imprime no Serial Monitor que foi bem sucedida a inserção do SD card 
 Serial.println("Inicializacao concluida! "); 
 
 // Abre o arquivo test.doc 
 meuArquivo = SD.open("test.doc", FILE_WRITE); 
 
 // Se o arquivo esta ok, então será escrito isso 
if (meuArquivo) { 
 Serial.print("Escrevendo test.doc..."); 
 meuArquivo.println("Parabens voce conseguiu! www.facacomarduino.info"); 
 // Fecha o arquivo: 
 meuArquivo.close(); 
 Serial.println("Concluido! "); 
 } else { 
 // Se o arquivo não abriu, um menssagem de erro será mostrada 
 Serial.println("Erro ao abrir arquivotest.doc"); 
 } 
 
 // Abre novamente o arquivo para lê-lo 
 
 meuArquivo = SD.open("test.doc"); 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 69 ] 
 if (meuArquivo) { 
 Serial.println("test.doc:"); 
 
 // Le o arquivo até que não há mais nada nele 
 
 while (meuArquivo.available()) { 
 Serial.write(meuArquivo.read()); 
 } 
 // Fecha o arquivo 
 
 meuArquivo.close(); 
 } else { 
 // Se o arquivo não abriu, será mostrado uma menssagem de erro 
 
 Serial.println("Erro ao abrir arquivo test.doc"); 
 } 
} 
 
void loop() 
{ 
 // Nada acontece aqui 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
abra o Serial Monitor e logo você verá os passos para gravação do arquivo, assim que 
gravar retire o cartão e insira-o no computador lá terá um arquivo chamado TEST, clique 
nele e ele será aberto. 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 70 ] 
 
 
CAPTURA DO SERIAL MONITOR 
 
 
 
CAPTURA DENTRO DA RAIZ DO SD CARD 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 71 ] 
 
 
Projeto 18 – Sensor de umidade e temperatura DHT11 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, sabemos que a umidade relativa do ar influencia na nossa sensação de 
conforto, sendo uma umidade de 45% uma umidade ideal. A umidade baixa pode provocar 
alguns efeitos no ser humano, tais como: ressecamento da pele, aumento na eletricidade 
estática, entre outras. Por isso vamos aprender como utilizar o sensor DHT11. Este sensor 
é um pequeno módulo comprado em sites da China ou no Brasil. Você pode utilizar este 
projeto para monitora a temperatura e a umidade em algum lugar de sua residência, então 
vamos lá. Os códigos serão todos comentados para melhor entendimento, podendo ser 
retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protoboard 
1 Display LCD 16X2 
1 Módulo DHT11 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 72 ] 
1 Potenciômetros de 10K (Para controle de contraste) * 
Fios jumpers 
*Você pode utilizar mais um potenciômetro para controle de brilho (Verifique o Projeto 10 
- Controle de temperatura com LCD e cooler); 
Observação importante: Antes de compilar o código você deve antes adicionar a biblioteca 
do sensor antes, por isso siga os passos para fazê-lo. 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO DHT11 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo DHT11; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o módulo DHT11, o potenciômetro, o LCD e os fios e conecte-os como 
mostra a figura. 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 73 ] 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino e conecte o cabo USB. 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 18 - Sensor de temperatura com LCD 
 
#include <LiquidCrystal.h> // Biblioteca utilizada para controle do LCD 
#include <dht11.h> // Biblioteca utilizada para controle de sensor DHT11 
 
dht11 DHT; // Cria um objeto que o sensor DHT11 
// Pino analógico em que o sensor DHT11 está conectado 
const int dhtpin = A0; 
 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Cria um objeto LCD e atribui os pinos 
 
void setup() { 
 
 lcd.begin(16, 2); // Define o display com 16 colunas e 2 linhas 
} 
 
void loop() { 
 
 DHT.read(dhtpin); //Lê as informações do sensor 
 
 // Exibindo valor da leitura do sensor de temperatura no display LCD 
 lcd.clear(); // Limpa o display do LCD 
 lcd.print("Temperatura:"); // Imprime a string no display do LCD 
 lcd.print(DHT.temperature); 
 lcd.write(B11011111); // Símbolo de graus Celsius 
 lcd.print("C"); 
 lcd.setCursor(0,1); // Coloca o cursor na linha 0 e coluna 1 
 lcd.print("Umidade:"); 
 lcd.print(DHT.humidity); 
 lcd.print("%"); 
 delay(2000); // Aguarda 2 segundos 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 74 ] 
você agora pode ajustar o contraste girando o potenciômetro, e verificar a umidade e a 
temperatura do ambiente. 
 
Projeto 19 – Arduino como osciloscópio 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, nós que gostamos de mexer com eletrônica sempre ficamos na curiosidade de 
sabermos qual é o tipo de onda que está sendo gerada em um circuito qualquer, pois 
então vamos aprender como fazer um osciloscópio com o Arduino, o programa é muito útil 
e fácil de utilizar, com ele podemos tirar nossa curiosidade em relação as ondas em 
circuitos eletrônicos. Vamos saciar nossa curiosidade? Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protoboard 
1 Potenciômetro de 10KΩ (Ou outro equivalente) 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 75 ] 
Fios jumpers 
 
 
 
FAÇA O DOWNLOAD DO ARQUIVO SEGUINDO OS PASSOS ABAIXO: 
1) Faça o download do arquivo Arquivos Osciloscópio 
emhttps://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Após feito o download, descompacte o arquivo; 
3) Coloque o potenciômetro na protoboard e conecte um fio jumper no pino analógico A0 
do Arduino e no pino central do potenciômetro (como mostra a figura abaixo); 
4) Com o Arduino conectado ao computador abra o arquivo XOscillo, abrirá a IDE com o 
código, logo após isto você deverá grava-lo em seu Arduino; 
5) Depois de gravar o código, abra o programa executável XOscillo; 
6) Com o programa aberto clique na abra File, New Analog Arduino e pronto; 
7) Gire o potenciômetro e você irá ver a oscilação no respectivo programa; 
CONECTANDO OS COMPONENTES 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 76 ] 
 
 
 
 
 
IMAGEM DETALHADA DO PROGRAMA XOSCILLO 
 
 
 
 
 
 
 
Obs.: A imagem acima mostra alguns recursos disponíveis que o programa oferece, 
explore-o e terá mais conhecimento cada vez mais. 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 77 ] 
 
 
 
 
 
 
Projeto 20 – Arduinocomo um gerador de frequência (onda 
quadrada) 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, neste projeto vou ensinar como fazer do Arduino um gerador de frequências 
em ondas quadras variando de 0Hz a 980Hz mostrando no Serial Monitor a passagem das 
frequências geradas a cada 2 segundos. Os pinos 5 e 6 tem uma frequência de 
aproximadamente 980Hz enquanto os demais pinos possuem apenas 490Hz. Utilizei o a 
função tone para gerar as frequências no pino 6 do Arduino. Com este projeto você pode 
controlar leds, motores, sonorizador piezo ou até mesmo inserir este sinal em filtros. O 
código é bem simples e de fácil compreensão. Os códigos serão todos comentados para 
melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 78 ] 
Para você visualizar o monitor serial selecione a opção Tools, Serial Monitor (ou 
Ctrl+Shift+M) e pronto. 
 
 
 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Sonozidor piezo 
Fios jumpers 
CONECTANDO OS COMPONENTES 
 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue o sonorizador e conecte – o como mostra a figura. Observação importante: 
Verificar a polaridade do sonozidaror. 
 
 
 
 
 
 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 79 ] 
Certifique-se de que todos os componentes estejam conectados corretamente. Quando 
você estiver seguro de que tudo foi conectado corretamente, ligue seu Arduino e conecte o 
cabo USB. 
 
 
AGORA VAMOS AO CÓDIGO 
 
 // Projeto 20 – Arduino como um gerador de frequência (Onda quadrada) 
 
void setup() { 
 
 Serial.begin(9600); // Inicia o Serial Monitor 
} 
 
void loop() { 
 // Imprime na tela a frequência gerada 
 Serial.println("A frequencia eh de: 0 Hz"); 
 { 
 tone(6, 0); // Defini o pino em OUTPUT, e a frequencia gerada no pino 
 delay(2000); // Gera a frequência por 2 segundos 
 } 
 Serial.println("A frequencia eh de: 100 Hz"); 
 { 
 tone(6, 100); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 200 Hz"); 
 { 
 tone(6, 200); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 300 Hz"); 
 { 
 tone(6,300); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 400 Hz"); 
 { 
 tone(6,400); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 500 Hz"); 
 { 
 tone(6,500); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 600 Hz"); 
 { 
 tone(6,600); delay(2000); 
 } 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 80 ] 
 Serial.println("A frequencia eh de: 700 Hz"); 
 { 
 tone(6,700); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 800 Hz"); 
 { 
 tone(6,800); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 900 Hz"); 
 { 
 tone(6,900); delay(2000); 
 } 
 Serial.println("A frequencia eh de: 980 Hz"); 
 { 
 tone(6,980); delay(2000); 
 } 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 81 ] 
 
 
 
Projeto 21 – Configurando o shield ethernet com o arduino 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, hoje iremos aprender como utilizar a placa ethernet junto com o Arduino, a 
partir daí podemos fazer várias coisas tais como: controlar luzes em um ambiente de nossa 
casa, ligar ou desligar aparelhos eletrônicos entre outras coisas, ou seja podemos fazer um 
ambiente automatizado. Mas vamos partir do básico primeiro. O shield utilizado é o 
Ethernet shield Wiznet W5100, onde se pode encontrar facilmente pela internet em lojas 
especializadas. Então vamos lá galera! Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Ethernet shield Wiznet W5100 
CONECTANDO OS COMPONENTES 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 82 ] 
 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o shield ethernet como mostra a figura abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CONECTANDO O CABO DE REDE 
Com o shield devidamente encaixado no Arduino, agora devemos ligá-lo ao cabo de rede e 
a energia com o cabo USB. Na parte superior temos os leds de indicação que mostram o 
funcionamento do módulo e o status de conexão da rede como as figuras abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 83 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
AGORA VAMOS AO CÓDIGO 
 
 // Projeto 21 – Configurando o shield ethernet com o Arduino 
 
// Protocolo utilizado para fazer a comunicação com o Arduino e... 
//Shield Ethernet 
#include <SPI.h> 
#include <Ethernet.h> // Biblioteca utilizada para funções internas do shield 
 
// A linha abaixo permite definir o endereço físico (MAC ADDRESS) da placa... 
//de rede. 
 
byte mac[] = { 0xAB, 0xCD, 0x12, 0x34, 0xFF, 0xCA }; 
 
//Os valores abaixo definem o endereço IP, gateway e máscara. 
 
IPAddress ip(192,168,2,104); // Define o endereço IP. 
IPAddress gateway(192,168,2,254); // Define o gateway. 
IPAddress subnet(255, 255, 255, 0); // Define a máscara de rede. 
 
void setup() 
{ 
 Ethernet.begin(mac, ip); // Inicializa a placa com os dados fornecidos 
} 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 84 ] 
 
void loop() { // Nada a declarar na função de loop. 
 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
OBS.: PARA VISUALIZAR AS DEFINIÇÕES DE SUA REDE PARA PREENCHER OS 
DADOS DE IP, GATEWAY E SUBNET, SIGA OS PASSOS ABAIXO: 
1) Entre no campo executar de seu Windows; 
2) Digite CMD, irá abrir a tela do DOS; 
3) Digite ipconfig, e aperte ENTER; 
4) Pronto os dados reais de sua rede serão mostrados; 
5) Preencha o código acima com os dados, e pronto; 
TESTANDO A PLACA 
Com o programa já copilado vamos verificar de agora esta funcionando corretamente, siga 
os passos abaixo. 
1) Entre no campo executar de seu Windows; 
2) Digite CMD, irá abrir a tela do DOS; 
3) Digite ping 192.168.2.104 (este IP você deve trocar pelo seu), e aperte ENTER; 
4) Após feito isto você verá uma tela parecida como a figura abaixo: 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 85 ] 
Se você fizer corretamente todos os passos acima, então sua placa estará configurada 
corretamente! Aguardem, pois iremos acionar leds utilizando a internet como se fosse um 
“controle remoto”. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 86 ] 
Projeto 22 – Ascendendo LED com shield ethernet 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olápessoal, hoje iremos aprender como ligar e desligar um LED utilizando o Ethernet 
shield Wiznet W5100, este Shield você pode encontrar facilmente pela internet em lojas 
especializadas, começando pelo básico você pode acionar motores, reles para acionar 
diversos equipamentos dentro ou fora de sua casa como monitoramento de alarme, portão 
eletrônico, enfim muito pode ser feito com este pequeno Shield, mas primeiro vamos 
ascender um LED. Então vamos lá galera! Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Ethernet shield Wiznet W5100 
1 LED (qualquer cor) 
1 Resistor de 300Ω 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 87 ] 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o shield ethernet como mostra a figura abaixo: 
 
Agora pegue o LED, o resistor e os jumpers e monte o circuito abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 88 ] 
 
 
CONECTANDO O CABO DE REDE 
Com o shield devidamente encaixado no Arduino, agora devemos ligá-lo ao cabo de rede e 
a energia com o cabo USB. Na parte superior temos os leds de indicação que mostram o 
funcionamento do módulo e o status de conexão da rede como as figuras abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 89 ] 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 22 – Ascendo LED com o Shield Ethernet 
 
#include <SPI.h> 
// Biblioteca utilizada para comunicação com o Arduino 
#include <Ethernet.h> 
 
// A linha abaixo permite definir o endereço físico (MAC ADDRESS) da placa... 
//de rede. 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
 
byte ip[] = { 192, 168, 2, 103 }; // Define o endereço IP. 
 
// Porta onde estará aberta para comunicação Internet e Arduino. 
EthernetServer server(80); 
 
String readString; 
int Pin = 9; // Pino digital onde será ligado e desligado o LED. 
 
void setup(){ 
 
 pinMode(Pin, OUTPUT); // Define o Pino 9 como saída. 
 Ethernet.begin(mac, ip); // Chama o MAC e o endereço IP da placa Ethernet. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 90 ] 
 // Inicia o servidor que esta inserido junto a placa Ethernet. 
 server.begin(); 
} 
 
void loop(){ 
 EthernetClient client = server.available(); 
 if (client) { 
 while (client.connected()) { 
 if (client.available()) { 
 char c = client.read(); 
 
 if (readString.length() < 100) { 
 readString += c; 
 } 
 
 if (c == '\n') { 
 client.println("HTTP/1.1 200 OK"); 
 client.println("Content-Type: text/html"); 
 client.println(); 
 
 // A partir daqui começa os códigos html. 
 
 client.println("<HTML>"); 
 client.println("<BODY>"); 
 client.println("<H1>Acende LED</H1>"); 
 client.println("<H1>Projeto basico para demonstracao com Shield 
 Ethernet</H1>"); 
 client.println("<hr />"); 
 client.println("<br />"); 
 
 client.println("<a href=\"/facacomarduino/LedOn\"\">Ascender 
 led</a>"); 
 client.println("<a href=\"/facacomarduino/LedOff\"\">Apagar 
 led</a><br />"); 
 
 client.println("</BODY>"); 
 client.println("</HTML>"); 
 
 delay(1); 
 client.stop(); 
 
 if(readString.indexOf("facacomarduino/LedOn") > 0) 
 { 
 digitalWrite(Pin, HIGH); // Liga LED. 
 } 
 else { 
 if(readString.indexOf("facacomarduino/LedOff") > 0) 
 { 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 91 ] 
 digitalWrite(Pin, LOW); // Desliga LED. 
 } 
 } 
 readString=""; 
 } 
 } 
 } 
 } 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
PARA VISUALIZAR AS DEFINIÇÕES DE SUA REDE SIGA OS PASSOS ABAIXO: 
1) Entre no campo executar de seu Windows; 
2) Digite CMD, irá abrir a tela do DOS; 
3) Digite ipconfig, e aperte ENTER; 
4) Pronto os dados reais de sua rede serão mostrados; 
5) Se o seu IP for 192.168.2.189, você deverá mudar o ultimo digito por 4 por exemplo e 
preencher no código acima para não haver conflito com seu MAC / IP reais; 
ASCENDENDO O LED 
Com o programa já copilado vamos verificar se agora está funcionando corretamente, siga 
os passos abaixo: 
1) Entre em seu navegador (Eu usei o Chrome e Firefox: funcionou perfeitamente); 
2) Digite na barra de endereço o IP com o ultimo digito diferente do seu, por exemplo 
192.168.2.184 e ENTER; 
3) Pronto você irá ver uma página HTML contendo um pequena descrição e dois links 
“Ascender led” e “Apagar led”, clique neles e verá o LED ascender ou apagar; 
OBS.: Você também pode digitar o endereço IP em seu tablet ou smarthone, ligando ou 
desligando o LED. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 92 ] 
 
Projeto 23 – Ascendendo lâmpada com shield ethernet e 
relê 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá galera, já vimos com testar nossa placa ethernet, com ascender led, e agora vamos 
aprender como ascender lâmpada com o Shield Ethernet. Com este projeto você também 
poderá acionar outros eletrodomésticos, como ventiladores, ar condicionados, entre outros. 
O shield utilizado é o Ethernet shield Wiznet W5100, onde se pode encontrar facilmente 
pela internet em lojas especializadas. Então vamos lá galera! Os códigos serão todos 
comentados para melhor entendimento, podendo ser retirados após a compreensão de 
cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Ethernet shield Wiznet W5100 
1 Lampada com soquete 
1 Plug macho 
Fios jumpers 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 93 ] 
Fio para conexão 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o shield ethernet e os demais componentes assim como mostra a figura 
abaixo. 
 
CONECTANDO O CABO DE REDE 
Com o shield devidamente encaixado no Arduino, agora devemos ligá-lo ao cabo de rede e 
a energia com o cabo USB. Na parte superior temos os leds de indicação que mostram o 
funcionamento do módulo e o status de conexão da rede como as figuras abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 94 ] 
 
 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 23 – Ascendendo lâmpada com Shield Ethernet e rele 
 
#include <SPI.h> 
// Biblioteca utilizada para comunicação com o Arduino 
#include <Ethernet.h> 
 
// A linha abaixo permite definir o endereço físico (MAC ADDRESS) da... 
//placa de rede. 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
 
byte ip[] = { 192, 168, 2, 103 }; //Define o endereço IP. 
 
// Porta onde estará aberta para comunicação Internet e Arduino. 
EthernetServer server(80); 
 
String readString; 
int Pin = 9; // Pino digital onde será ligado e desligado o LED. 
 
void setup(){ 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 95 ] 
pinMode(Pin, OUTPUT); // Define o Pino 9 como saída. 
Ethernet.begin(mac, ip); // Chama o MAC e o endereço IP da placa Ethernet. 
server.begin(); // Inicia o servidor que esta inserido junto a placa Ethernet. 
} 
 
voidloop(){ 
 EthernetClient client = server.available(); 
 if (client) { 
 while (client.connected()) { 
 if (client.available()) { 
 char c = client.read(); 
 
 if (readString.length() < 100) { 
 readString += c; 
 } 
 
 if (c == '\n') { 
 client.println("HTTP/1.1 200 OK"); 
 client.println("Content-Type: text/html"); 
 client.println(); 
 
 // A partir daqui começa os códigos html. 
 
 client.println("<HTML>"); 
 client.println("<BODY>"); 
 client.println("<H1>Acende Lampada</H1>"); 
 client.println("<H1>Ascendendo lampada com Shield Ethernet e 
 rele</H1>"); 
 client.println("<hr />"); 
 client.println("<br />"); 
 
 client.println("<a href=\"/facacomarduino/LampadaOn\"\">Ascender 
 lampada</a>"); 
 client.println("<a href=\"/facacomarduino/LampadaOff\"\">Apagar 
 lampada</a><br />"); 
 
 client.println("</BODY>"); 
 client.println("</HTML>"); 
 
 delay(1); 
 client.stop(); 
 
 if(readString.indexOf("facacomarduino/LampadaOn") > 0) 
 { 
 digitalWrite(Pin, HIGH); // Liga Lampada. 
 } 
 else { 
 if(readString.indexOf("facacomarduino/LampadaOff") > 0) 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 96 ] 
 { 
 digitalWrite(Pin, LOW); // Desliga Lampada. 
 } 
 } 
 readString=""; 
 } 
 } 
 } 
 } 
} 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
PARA VISUALIZAR AS DEFINIÇÕES DE SUA REDE SIGA OS PASSOS ABAIXO: 
1) Entre no campo executar de seu Windows; 
2) Digite CMD, irá abrir a tela do DOS; 
3) Digite ipconfig, e aperte ENTER; 
4) Pronto os dados reais de sua rede serão mostrados; 
5) Se o seu IP for 192.168.2.189, você deverá mudar o ultimo digito por 4 por exemplo e 
preencher no código acima para não haver conflito com seu MAC / IP reais; 
ASCENDENDO A LÂMPADA 
Com o programa já copilado vamos verificar se agora está funcionando corretamente, siga 
os passos abaixo: 
1) Entre em seu navegador (Eu usei o Chrome e Firefox: funcionou perfeitamente); 
2) Digite na barra de endereço o IP com o ultimo digito diferente do seu, por exemplo 
192.168.2.184 e ENTER; 
3) Pronto você irá ver uma página HTML contendo um pequena descrição e dois links 
“Ascender lâmpada” e “Apagar lâmpada”, clique neles e verá a lâmpada ascender ou 
apagar; 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 97 ] 
Projeto 24 – Escrevendo em um LCD Nokia 5110 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, hoje iremos aprender como utilizar um LCD Nokia 5110, simples mas que 
muda totalmente o projeto, deixando sua interface com visualização das informações muito 
mais agradáveis do que um LCD comum. Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Resistor de 220Ω 
1 Módulo Nokia 5110 
1 Protoboard 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o módulo Nokia 5110 e o resistor assim como mostra a figura abaixo. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 98 ] 
 
SEGUE O ESQUEMÁTICO ABAIXO PARA MELHOR ENTENDIMENTO: 
 
Pinos LCD Nokia 5110 Pinos do Arduino 
RST 11 
CE 12 
DC 10 
Din 9 
Clk 8 
VCC 5V 
GND GND 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO LCD NOKIA 5110 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo LCD5110_Basic; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 24 – Escrevendo em um LCD Nokia 5110 
 
// Biblioteca utilizada para controle do LCD Nokia 5110. 
#include <LCD5110_Graph.h> 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 99 ] 
 
LCD5110 myGLCD(8,9,10,11,12); // Cria um objeto LCD e atribui os pinos. 
 
// Função que define a fonte a ser exibida como Small - pequena. 
extern uint8_t SmallFont[]; 
 
int y; // Cria uma variável para manipular o deslizar na tela. 
 
void setup() 
{ 
 myGLCD.InitLCD(); // Inicializa o LCD. 
 myGLCD.setFont(SmallFont); // Setando a fonte com tamanho e formato. 
 randomSeed(analogRead(0)); // Joga dos para o LCD imprimindo-o. 
} 
 
void loop() 
{ 
 y = random(0, 40); 
 for (int i=80; i>=-(57*6); i--) 
 { 
 // Texto definido pelo usuário. 
 myGLCD.print("FacaComArduino-Seus melhores projetos estão aqui!!",i,y); 
 myGLCD.update(); // Atualiza o LCD 
 delay(50); // A cada 5 segundos volta a exibir o texto na tela. 
 } 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Se tudo estiver OK você verá escrito na tela do LCD o texto digitado no código. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 100 ] 
 
Projeto 25 – Gráfico de leitura de temperatura com um LCD 
Nokia 5110 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, com o Nokia 5110 podemos fazer variarias coisas, como visualizar na tela 
imagens, textos e muito mais, irei mostrar como visualizar um gráfico de temperatura com 
este maravilhoso LCD juntamente com um sensor de temperatura LM35, deixando com 
uma visualização mais compreensível aos usuários. Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Resistor de 220Ω 
1 Módulo Nokia 5110 
1 Protobord 
1 Sensor de temperatura LM35 
Fios jumpers 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 101 ] 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o módulo Nokia 5110, o LM35 e o resistor assim como mostra a figura 
abaixo: 
 
SEGUE O ESQUEMÁTICO ABAIXO PARA MELHOR ENTENDIMENTO: 
Pinos LCD Nokia 5110 Pinos do Arduino 
RST 11 
CE 12 
DC 10 
Din 9 
Clk 8 
VCC 5V 
GND GND 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO LCD NOKIA 5110 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo PCD8544; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 102 ] 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 25 – Gráfico de leitura de temperatura com um LCD Nokia 5110 
 
// Biblioteca utilizada para controle de gráficos e/ou desenhos. 
#include <PCD8544.h> 
 
static const byte SensorTemp = 0; // Pino analógico onde está o LM35. 
 
// Definindo as dimensões do LCD (em pixels). 
static const byte LCD_WIDTH = 84; 
static const byte LCD_HEIGHT = 48; 
 
// Define o número de linhas para exibir o caracter de temperatura. 
static const byte CHART_HEIGHT= 5; 
 
// Define o símbolo gráfico para ser exibido no LCD. 
static const byte DEGREES_CHAR = 1; 
static const byte degrees_glyph[] = { 0x00, 0x07, 0x05, 0x07, 0x00 }; 
 
// Uma imagem bitmap gráfica de 10X2 do termômetro. 
static const byte THERMO_WIDTH = 10; 
static const byte THERMO_HEIGHT = 2; 
static const byte thermometer[] = 
{ 0x00, 0x00, 0x48, 0xfe, 0x01, 0xfe, 0x00, 0x02, 0x05, 0x02, 
0x00, 0x00, 0x62, 0xff, 0xfe, 0xff, 0x60, 0x00, 0x00, 0x00}; 
 
static PCD8544 lcd; 
 
 
void setup() { 
 lcd.begin(LCD_WIDTH, LCD_HEIGHT); 
 
 // Registra o símbolo personalizado do termômetro. 
 lcd.createChar(DEGREES_CHAR, degrees_glyph); 
 
 
 /* A referência 1.1V interno prevê uma melhor 
 Resolução do LM35, e também é mais estável 
 Quando alimentado a partir de uma entrada USB. */ 
 
 analogReference(INTERNAL); 
} 
 
 
void loop() { 
 
 // Define a borda do LCD. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 103 ] 
 static byte xChart = LCD_WIDTH; 
 
 
 // Lê a temperatura em graus Celsius. 
 float SensorTemp = (1.1 * analogRead(SensorTemp) * 100.0) / 1024.0; 
 
 // Imprime a temperatura na tela do LCD. 
 lcd.setCursor(0, 0); 
 lcd.print("Temp: "); 
 lcd.print(SensorTemp, 1); 
 lcd.print(" \001C "); 
 
 // Desenhar o bitmap termômetro no canto inferior esquerdo ... 
 lcd.setCursor(0, LCD_HEIGHT/8 - THERMO_HEIGHT); 
 lcd.drawBitmap(thermometer, THERMO_WIDTH, THERMO_HEIGHT); 
 
 // Define a posição do gráfico. 
 if (xChart >= LCD_WIDTH) { 
 xChart = THERMO_WIDTH + 2; 
 } 
 
 // Atualiza o gráfico de temperatura. 
 lcd.setCursor(xChart, 1); 
 // Define uma faixa entre 0 - 45°C 
 lcd.drawColumn(CHART_HEIGHT, map(SensorTemp, 0, 45, 0, 
 CHART_HEIGHT*8)); 
 // Define uma posição correta do gráfico. 
 lcd.drawColumn(CHART_HEIGHT, 0); 
 
 xChart++; 
 
 delay(500); 
} 
 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Se tudo estiver OK você verá na tela a temperatura real, juntamente com um gráfico que 
irá mudar de acordo com a temperatura. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 104 ] 
Projeto 26 – Teclado matricial 4x4 básico 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, hoje vamos aprender como utilizar o teclado matricial 4x4 (4 colunas por 4 
linhas. Com este teclado podemos ligar LED, motores entre outros, basta apenas configurar 
as funções para cada botão do teclado, simples e fácil. Então vamos lá galera! Os códigos 
serão todos comentados para melhor entendimento, podendo ser retirados após a 
compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Protobord 
1 Resistor de 220Ω 
1 LED (Qualquer cor) 
1 Teclado matricial 4X4 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, siga o modelo como mostra a figura abaixo. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 105 ] 
 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO KEYPAD 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo Keypad; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 26 - Teclado matricial 4x4 básico 
 
// Biblioteca para controle do teclado de matrizes. 
#include <Keypad.h> 
 
const byte ROWS = 4; // Quatro linhas por... 
const byte COLS = 4; // Quatro colunas. 
 
// Define o Keypad (mapa do circuito do teclado). 
char keys[ROWS][COLS] = { 
 {'1','2','3','A'}, 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 106 ] 
 {'4','5','6','B'}, 
 {'7','8','9','C'}, 
 {'*','0','#','D'} 
}; 
 
// Conecta o teclado matricial em linha 0, linha 1, linha 2, linha 3 e linha 4... 
//dos pinos do arduino. 
byte rowPins[ROWS] = { 9, 8, 7, 6 }; 
 
// Conecta o teclado matricial em coluna 0, coluna 1, coluna 2, coluna 3 e... 
//coluna 4 do arduino. 
byte colPins[COLS] = { 12, 11, 10, 5 }; 
 
// Cria um objto Keypad. 
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); 
 
#define ledpin 13 // Led conectado no pino 13 do arduino. 
 
void setup() 
{ 
 pinMode(ledpin,OUTPUT); // Define o pino 13 como sendo de saída. 
 digitalWrite(ledpin, HIGH); // incializa com o led ligado. 
 Serial.begin(9600); // Inicia o Serial Monitor. 
} 
 
void loop() 
{ 
 char key = kpd.getKey(); 
 if(key) // Checa se um botão foi pressionado. 
 { 
 switch (key) 
 { 
 case '*': // Se for pressionado... 
 digitalWrite(ledpin, LOW); // o led apaga. 
 break; // Parada, aguardando pressionar outro botão. 
 case '#': // Se for pressionado... 
 digitalWrite(ledpin, HIGH); // o led ascende. 
 break; 
 case 'A': 
 digitalWrite(ledpin, HIGH); 
 break; 
 case 'B': 
 digitalWrite(ledpin, LOW); 
 break; 
 case 'C': 
 digitalWrite(ledpin, HIGH); 
 break; 
 case 'D': 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 107 ] 
 digitalWrite(ledpin, LOW); 
 break; 
 default: 
 Serial.println(key); 
 } 
 } 
} 
 
Para confirmar se está tudo certo aperto o botão Verify/Upload. Se estiver correto você 
pode abrir o Serial Monitor em Tools, Serial Monitor ou selecionando simultaneamente os 
botões Ctrl+Shift+M, aperte os botões numéricos do teclado e este será impresso na tela, 
dá para utilizar como um “controle remoto”. 
IMAGEM DO SERIAL MONITOR 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 108 ] 
Projeto 27 – Acionando relê via teclado matricial 4x4 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Olá pessoal, já vimos como utilizar o teclado matricial da forma mais simples controlando 
um LED, agora vamos utilizar este mesmo teclado para acionar um rele. Para este projeto 
será incluído uma nova biblioteca a "Password.h" que tem como função o controle de 
strings, validando-as. Por default a senha deste projeto será 1234, mas pode ser 
modificada (fica a seu critério). Aqui foi utilizado para acionar um rele, mas pode ser para 
acionar um solenoide por exemplo, ou para outros fins. Os códigos serão todos 
comentados para melhor entendimento, podendo ser retirados após a compreensão de 
cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Arduino Uno R3 
1 Shield rele 
1 Teclado matricial 4X4 
Fios jumpers 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte o shield rele e o teclado matricial como mostra a figura abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 109 ] 
 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO PASSWORD E 
KEYPAD 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download dos arquivos Password e Keypad; 
3) Descompacte os arquivos; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
os arquivos descompactados nesta pasta; 
5) Pronto para utilizar; 
AGORA VAMOS AO CÓDIGO 
 
// Projeto 27 – Acionando rele via teclado matricial 4X4 
 
#include<Password.h> // Biblioteca utilizada para controle de senha. 
#include <Keypad.h> // Biblioteca para controle do teclado de matrizes. 
 
// Senha utilizada para acionamento do rele. 
Password password = Password( "1234" ); 
 
const byte ROWS = 4; // Quatro linhas por... 
const byte COLS = 4; // Quatro colunas. 
 
// Define o Keypad (mapa do circuito do teclado). 
char keys[ROWS][COLS] = { 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 110 ] 
 {'1','2','3','A'}, 
 {'4','5','6','B'}, 
 {'7','8','9','C'}, 
 {'*','0','#','D'} 
}; 
 
// Conecta o teclado matricial em linha 0, linha 1, linha 2, linha 3 e linha 4... 
//dos pinos do arduino. 
byte rowPins[ROWS] = {9,8,7,6}; 
 
// Conecta o teclado matricial em coluna 0, coluna 1, coluna 2, coluna 3 e... 
//coluna 4 do arduino. 
byte colPins[COLS] = {12,11,10,5}; 
 
// Cria um objeto Keypad. 
Keypad keypad=Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS); 
 
void setup(){ 
 pinMode(4, OUTPUT); // Define pino 4 como saída. 
 Serial.begin(9600); // Inicializa Serial Monitor. 
 keypad.addEventListener(keypadEvent); 
 keypad.setDebounceTime(250); 
} 
 
void loop(){ 
 keypad.getKey(); 
} 
 
void keypadEvent(KeypadEvent eKey){ 
 switch (keypad.getState()){ // Condição switch... 
 case PRESSED: // Se precionado algum botão... 
 Serial.print("Digitado: "); // Aparecera no Serial Monitor, Digitado: "X". 
 Serial.println(eKey); // Armazena numero digitado na variável eKey. 
 switch (eKey){ 
 // Pressionando "C" confirma se a senha foi digitado corretamente. 
 case 'C': guessPassword(); 
 break; 
 default: 
 password.append(eKey); 
 } 
} 
} 
 
void guessPassword(){ 
// Informa no Serial Monitor "Verificando, aguarde...". 
 Serial.print("Verificando, aguarde... "); 
 if (password.evaluate()){ 
 // Informa no Serial Monitor "Acionando rele...". 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 111 ] 
 Serial.println("Acionando rele... "); 
 digitalWrite(4, HIGH); // Ativa o rele. 
 delay(2000); // Rele fica acionado por 2 segundos e depois... 
 digitalWrite(4, LOW); // Desativa o rele. 
 password.reset(); // Apaga a senha. 
 }else{ 
 digitalWrite(4, LOW); 
 Serial.println("Senha Invalida !"); 
 password.reset(); // Apaga a senha. 
 } 
} 
 
Para confirmar se está tudo certo aperto o botão Verify/Upload. Se estiver correto você 
pode abrir o Serial Monitor em Tools, Serial Monitor ou selecionando simultaneamente os 
botões Ctrl+Shift+M, digite a senha 1234 e aperte o botão C, pronto seu rele irá acionar 
por 2 segundos e depois será desativado. 
IMAGEM DO SERIAL MONITOR 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 112 ] 
Projeto 28 – Utilizando um cartão RFID 
 
 
 
 
 
Olá pessoal, neste projeto iremos utilizar o módulo de identificação por rádio frequência o 
RFID-RC522 encontrado em lojas especializadas do ramo de eletrônica. Este projeto 
consiste em apenas visualizar os dados contidos no cartão. Posteriormente iremos acionar 
um rele a partir do código do cartão. Então mãos aos componentes !! Os códigos serão 
todos comentados para melhor entendimento, podendo ser retirados após a compreensão 
de cada linha. Bom trabalho !!! 
Obs.: Para visualizar o Serial Monitor, basta ir em Tools e Serial Monitor ou pressionar 
Crtl+Shift+M e pronto. 
COMPONENTES NECESSÁRIOS 
1 Shield RFID-RC522 
Fios jumpers do tipo macho/fêmea 
CONECTANDO-SE AO MODULO RFID 
1) Faça o download do arquivo Rfid_master 
emhttps://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Após feito o download, descompacte o arquivo; 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 113 ] 
3) Com o arquivo descompactado, vá em (C:) e na pasta Arquivos de Programas, Arduino, 
libraries, copie o arquivo descompactado nesta pasta e pronto. 
CONECTANDO OS COMPONENTES 
 
 
SEGUE O ESQUEMÁTICO ABAIXO PARA MELHOR ENTENDIMENTO: 
Pinos do módulo RFID-RC522 Pinos do Arduino 
RST 9 
SDA 10 
MOSI 11 
MISO 12 
SCK 13 
GND GND 
VCC 3.3V 
AGORA VAMOS AO CÓDIGO 
 
// Biblioteca do Serial Peripheral Interface (Interface Periférica Serial). 
#include <SPI.h> 
#include <MFRC522.h> // Biblioteca do módulo RFID-RC522. 
 
#define SS_PIN 10 // Define o pino 10 como Escravo. 
#define RST_PIN 9 // Define o pino 9 como Reset. 
MFRC522 mfrc522(SS_PIN, RST_PIN); // Cria um objeto MFRC522. 
 
void setup() { 
Serial.begin(9600); // Inicializa a comunicação serial com o PC. 
SPI.begin(); // Inicializa o SPI bus. 
mfrc522.PCD_Init(); // Inicializa o cartão MFRC522. 
// Imprime no Serial Monitor a frase entre " ". 
Serial.println("Scan a MIFARE Classic PICC to demonstrate Value Blocks."); 
} 
 
void loop() { 
// Procura por novos cartões. 
if ( ! mfrc522.PICC_IsNewCardPresent()) { 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 114 ] 
return; 
} 
 
// Seleciona um dos cartões. 
if ( ! mfrc522.PICC_ReadCardSerial()) { 
return; 
} 
// Agora um cartão é selecionado. O UID e SAK estão no mfrc522.unis. 
 
 // Descarrega UID. 
Serial.print("Card UID:"); 
for (byte i = 0; i < mfrc522.uid.size; i++) { 
Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); 
Serial.print(mfrc522.uid.uidByte[i], HEX); 
} 
Serial.println(); 
 
// Descarrega PICC. 
byte piccType = mfrc522.PICC_GetType(mfrc522.uid.sak); 
Serial.print("PICC type: "); 
Serial.println(mfrc522.PICC_GetTypeName(piccType)); 
if ( piccType != MFRC522::PICC_TYPE_MIFARE_MINI 
&& piccType != MFRC522::PICC_TYPE_MIFARE_1K 
&& piccType != MFRC522::PICC_TYPE_MIFARE_4K) { 
Serial.println("This sample only works with MIFARE Classic cards."); 
return; 
} 
 
// Orepara a chave - todas as chaves estão configuradas para... 
//FFFFFFFFFFFFh (Padrão de fábrica). 
MFRC522::MIFARE_Key key; 
for (byte i = 0; i < 6; i++) { 
key.keyByte[i] = 0xFF; 
} 
 
// Nesta amostra nos usamos o segundo setor (bloco 4-7). 
byte sector = 1; 
byte valueBlockA = 5; 
byte valueBlockB = 6; 
byte trailerBlock = 7; 
// Valida usando a chave A. 
Serial.println("Authenticating using key A..."); // Imprime no Serial Monitor. 
byte status; 
status = mfrc522.PCD_Authenticate 
(MFRC522::PICC_CMD_MF_AUTH_KEY_A, trailerBlock, &key, &(mfrc522.uid)); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("PCD_Authenticate() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 115 ] 
return; 
} 
// Precisamos de um setor que define blocos 5 e 6 com valores de blocos... 
//e que permita a chave B. 
byte trailerBuffer[] = { 255,255,255,255,255,255, 0,0,0, 
0, 255,255,255,255,255,255}; // Mantem por teclas padrão. 
 
mfrc522.MIFARE_SetAccessBits(&trailerBuffer[6], 0, 6, 6, 3); 
// Agora nos lemos o setor e vemos se isto ista como nos queremos... 
//que seja. 
Serial.println("Reading sector trailer..."); 
byte buffer[18]; 
byte size = sizeof(buffer); 
status = mfrc522.MIFARE_Read(trailerBlock, buffer, &size); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Read() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
return; 
} 
if ( buffer[6] != trailerBuffer[6] 
&& buffer[7] != trailerBuffer[7] 
&& buffer[8] != trailerBuffer[8]) { 
Serial.println("Writing new sector trailer..."); // Imprime no Serial Monitor. 
status = mfrc522.MIFARE_Write(trailerBlock, trailerBuffer, 16); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Write() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status));return; 
} 
} 
// Valida usando chave B. 
// Imprime no Serial Monitor. 
Serial.println("Authenticating again using key B..."); 
status = mfrc522.PCD_Authenticate 
(MFRC522::PICC_CMD_MF_AUTH_KEY_B, trailerBlock, &key, &(mfrc522.uid)); 
if (status != MFRC522::STATUS_OK) { 
// Se haver falha na autenticação uma mensagem será exibida no... 
//Serial Monitor. 
Serial.print("PCD_Authenticate() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
return; 
} 
 
/*OBS.: O valor dos blocos tem um valor com sinal de 32 bit armazenado 
três vezes e um endereço de 8 bits armazenados 4 vezes. Certifique-se 
de blocos valueBlockA e valueBlockB tem esse formato: formatBlock 
(alueBlockA); */ 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 116 ] 
// Adciona 1 no valor de valueBlockA e armazena o resultado em... 
//valueBlockA. 
Serial.print("Adding 1 to value of block "); Serial.println(valueBlockA); 
status = mfrc522.MIFARE_Increment(valueBlockA, 1); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Increment() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
return; 
} 
status = mfrc522.MIFARE_Transfer(valueBlockA); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Transfer() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
return; 
} 
 
// Descarrega o resultado. 
mfrc522.PICC_DumpMifareClassicSectorToSerial(&(mfrc522.uid), 
&key, sector); 
 
// Pausa PICC 
mfrc522.PICC_HaltA(); 
 
// Para a criptografia em PCD. 
mfrc522.PCD_StopCrypto1(); 
} 
 
void formatBlock(byte blockAddr) { 
Serial.print("Reading block "); Serial.println(blockAddr); 
byte buffer[18]; 
byte size = sizeof(buffer); 
byte status = mfrc522.MIFARE_Read(blockAddr, buffer, &size); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Read() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
return; 
} 
 
if ( (buffer[0] == (byte)~buffer[4]) 
&& (buffer[1] == (byte)~buffer[5]) 
&& (buffer[2] == (byte)~buffer[6]) 
&& (buffer[3] == (byte)~buffer[7]) 
&& (buffer[0] == buffer[8]) 
&& (buffer[1] == buffer[9]) 
&& (buffer[2] == buffer[10]) 
&& (buffer[3] == buffer[11]) 
&& (buffer[12] == (byte)~buffer[13]) 
&& (buffer[12] == buffer[14]) 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 117 ] 
&& (buffer[12] == (byte)~buffer[15])) { 
Serial.println("Block has correct Block Value format."); 
} 
else { 
Serial.println("Writing new value block..."); 
byte valueBlock[] = { 0,0,0,0, 255,255,255,255, 0,0,0,0, blockAddr,~blockAddr, 
blockAddr,~blockAddr }; 
status = mfrc522.MIFARE_Write(blockAddr, valueBlock, 16); 
if (status != MFRC522::STATUS_OK) { 
Serial.print("MIFARE_Write() failed: "); 
Serial.println(mfrc522.GetStatusCodeName(status)); 
} 
} 
} // Fim do formatBlock() 
Obs.: Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo 
estiver correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Pronto, agora você pode passar o cartão sobre o leitor do módulo e você verá uma imagem 
igual a descrita abaixo: 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 118 ] 
Projeto 29 – Configurando o módulo bluetooth (JY-MCU) 
 
 
 
 
Olá pessoal, antes de começarmos a acionar componentes pelo smartphone e/ou tablet via 
bluetooth se faz necessário algumas configurações do módulo antes disto, para que tudo 
funcione corretamente. Então... mãos aos componentes !! Os códigos serão todos 
comentados para melhor entendimento, podendo ser retirados após a compreensão de 
cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
 
1 Shield JY-MCU (Módulo Bluetooth) 
Fios jumpers do tipo macho/fêmea 
 
CONECTANDO OS COMPONENTES 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 119 ] 
SEGUE O ESQUEMÁTICO ABAIXO PARA MELHOR ENTENDIMENTO: 
Pinos do módulo JY-MCU Pinos do Arduino 
VCC 5V 
GND GND 
TXD 10 
RXD 11 
OBS.: Verifique qual a tensão do seu módulo, pois poderá ser de 3.3V. Se for o caso utilize 
o respectivo pino do Arduino. 
 
SIGA OS PASSOS ABAIXO PARA COMUNICAÇÃO E CONFIGURAÇÃO DE SEU 
MÓDULO: 
1) Depois de tudo conectado ao seu Arduino. Conecte-o à porta USB de seu computador; 
2) Abra o IDE do Arduino e cole o seguinte código: 
 
// Projeto 29 – Configurando o modulo de bluetooth (JY-MCU) 
 
// Biblioteca responsável pela comunicação serial. 
#include <SoftwareSerial.h> 
 
SoftwareSerial mySerial(11, 10); // RX, TX 
String command = ""; // Responsável por reconhecer os comandos no AT. 
 
void setup() 
{ 
 // Abre a porta de comunicação serial para reconhecer os comandos AT. 
 Serial.begin(115200); 
 Serial.println("Type AT commands!"); 
 mySerial.begin(9600); // Taxa de transferência na "Porta COM X" a 9600bps. 
} 
 
void loop() 
{ 
 // Lê o dispositivo de saída disponível. 
 if (mySerial.available()) 
 { 
 while(mySerial.available()) 
 { // Enquanto haver mais para ser lido, mantenha lendo. 
 command += (char)mySerial.read(); 
 } 
 Serial.println(command); 
 command = ""; 
 } 
 
 // Lê a entrada o usuário se disponível. 
 if (Serial.available()) 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 120 ] 
 { 
 delay(10); // Pequeno delay. 
 mySerial.write(Serial.read()); 
 } 
 
} // Fim do loop. 
3) Após carregado o código para seu Arduino, abra o Serial Monitor (mantenha apertados 
Control+Shift+M); 
4) Altere a velocidade de 9600 para 115200 como mostra a imagem abaixo: 
 
 
 
5) Quando alterado irá aparecer a tela para inserirmos os comandos AT; 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 121 ] 
 
6) Agora iremos inserir o comando AT+MEUBLUETOOTH para alterarmos o nome do nosso 
dispositivo que será “MEUBLUETOOTH” ou outro nome caso queira muda-lo; 
 
7) Este comando deverá retornar um “OKsetname”, confirmando a troca do nome do 
dispositivo; 
8) Pronto !! As configurações já foram concluídas; 
OBS.: Segue abaixo outros comandos que podem ser utilizados: 
AT - Retorna "OK", o que indica que o módulo bluetooth está respondendo aos comandos. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 122 ] 
AT+NAME - Altera o nome do módulo Bluetooth. 
AT+VERSION - Retorna a versão do firmware da placa. 
AT+PINXXXX - Altera a senha do bluetooth, onde XXXX é a nova senha, e você pode 
utilizar qualquer combinação de 4 números. Este comando retorna "OKsetPIN". 
 
 
 
 
 
 
 
Projeto 30 – Acionando LED e relê com via bluetooth com 
arduinocomander 
 
 
 
 
Olá pessoal, como prometido, irei mostrar como acionar LED e rele via bluetooth. Este 
projeto se aplica tanto a smartphones quanto a tablets. Muito mais fácil de usar com este 
app do que com outros que você possa encontrar pela internet. Mãos aos componentes! 
 
COMPONENTES NECESSÁRIOS 
1 Shield JY-MCU (Módulo Bluetooth) 
1 Shield rele 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 123 ] 
1 resistor de 330Ω 
1 LED (qualquer cor) 
1 Smartphone com Android 
Fios jumper do tipo macho/femea e macho/macho 
 
 
 
 
 
ESQUEMA PARA MONTAGEM 
 
 
CÓDIGO PARA COMUNICAR O ARDUINO AO APP SIGAS OS PASSOS ABAIXO: 
1) Abra o IDE do Arduino; 
2) Clique em File >> Examples >> Firmata e StandardFirmata; 
3) Irá abrir o código StandardFirmata; 
4) Dê um Ctrl+F e busque por 57600; 
5) Troque o valor por 9600; 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 124 ] 
Pronto agora faça o upload parao Arduino *; 
* OBS.: Antes de passar o código para o Arduino retire os jumpers dos pinos RX e TX. Se 
não for feito isso não irá carregar o código para o Arduino, dando erro. 
CONECTANDO-SE AO ARDUINOCOMMANDER 
1) Baixe o app ArduinoCommander no Play Store ou emArduinoCommander - Google play; 
2) Após ter instalado, abra-o. Ficará assim a tela: 
 
3) Clique em “Discover devices” para encontrar seu Shield Bluetooth. Se o 
seu aparelho estiver com o bluetooth desligado, ele irá habilitar o mesmo. Como mostra na 
imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 125 ] 
 
4) Agora pesquise novamente os dispositivos em “Discover devices” e irá aparecer os 
dispositivos bluetooth ao alcance, como mostra a imagem abaixo: 
 
5) O meu shield está com o nome ELTONSHIELD, visualize o seu e clique clique nele para 
seleciona-lo; 
6) Após isto irá se conectar a sua placa Arduino como mostra a imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 126 ] 
 
 
 
7) Se algo der errado ira aparecer algo assim: 
 
AGORA VAMOS ACIONAR O LED E O RELE NO ARDUINOCOMMADER 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 127 ] 
1) Clique em cima do pino 7, ira aparecer as opções para setar o pino como output ou 
input. Selecione output assim como mostra a imagem abaixo: 
 
 
2) Se você quiser deixar este pino desligado basta apenar clicar em OK. Caso queira liga-lo 
clique em cima de OFF e ira ficar ON, clique em OK e pronto o LED ira ascender como 
mostra as imagens abaixo: 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 128 ] 
 
3) Para apaga-lo clique em cima do pino 7 novamente e clique em ON para ficar OFF e OK. 
Pronto LED desligado. 
4) Para acionar o rele segue a mesma linha de raciocínio. Clique em cima do pino 11, 
selecione output e clique em cima de OFF para ficar ON e OK acionar o rele. 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 129 ] 
 
5) Para desabilitar o pino clique em cima dele, selecione ON para ficar OFF e OK. 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 130 ] 
 
6) Para desconectar do bluetooth clique na tecla de menu do smartphone e selecione 
“Disconnect”, aguarde alguns segundos e pronto. 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 131 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projeto 31 – Utilizando o PWM via bluetooth com 
arduinocomander 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 132 ] 
Olá pessoal! Continuando com este excelente app, hoje vou mostrar como utilizar o PWM 
com o ArduinoCommander. Temos duas maneiras para enviar os comandos por largura de 
pulso pelo ArduinoCommander, são eles: manualmente ou “automaticamente”, por código. 
Pode se utilizar este recurso em todos pino simultaneamente sem nenhum problema. 
Vamos lá? Os códigos serão todos comentados para melhor entendimento, podendo ser 
retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Shield JY-MCU (Módulo Bluetooth) 
1 resistor de 330Ω 
1 LED (qualquer cor) 
1 Smartphone com Android 
Fios jumper do tipo macho/femea e macho/macho 
 
ESQUEMA PARA MONTAGEM 
 
 
 
CÓDIGO PARA COMUNICAR O ARDUINO AO APP SIGAS OS PASSOS ABAIXO: 
1) Abra o IDE do Arduino; 
2) Clique em File >> Examples >> Firmata e StandardFirmata; 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 133 ] 
3) Irá abrir o código StandardFirmata; 
4) Dê um Ctrl+F e busque por 57600; 
5) Troque o valor por 9600; 
Pronto agora faça o upload para o Arduino*; 
*OBS.: Antes de passar o código para o Arduino retire os jumpers dos pinos RX e TX. Se 
não for feito isso não irá carregar o código para o Arduino, dando erro. 
CONECTANDO-SE AO ARDUINOCOMMANDER 
1) Baixe o app ArduinoCommander no Play Store ou emArduinoCommander - Google play; 
2) Após ter instalado, abra-o. Ficará assim a tela: 
 
3) Clique em “Discover devices” para encontrar seu Shield Bluetooth. Se o 
seu aparelho estiver com o bluetooth desligado, ele irá habilitar o mesmo. Como mostra na 
imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 134 ] 
 
4) Agora pesquise novamente os dispositivos em “Discover devices” e irá aparecer os 
dispositivos bluetooth ao alcance, como mostra a imagem abaixo: 
 
5) O meu shield está com o nome ELTONSHIELD, visualize o seu e clique clique nele para 
seleciona-lo; 
6) Após isto irá se conectar a sua placa Arduino como mostra a imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 135 ] 
 
 
 
7) Se algo der errado ira aparecer algo assim: 
 
AGORA VAMOS UTILIZAR O PWM PELO ARDUINOCOMMADER 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 136 ] 
1) Para mudar o pulso manualmente, clique em cima do pino 10, ira aparecer as opções 
para setar o pino como output ou input... Selecione o “Analog output (PWM)” e em seguida 
“Manual”. Arraste o componente slider para aumentar ou diminuir o pulso PWM, como 
mostra as imagens abaixo: 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 137 ] 
2) Clique em “OK” e repare que o LED mudou de intensidade, estando seu brilho mais ou 
menos forte de acordo com o que você selecionou ao arrastar a barra e no pino mostra a 
tensão que está sendo enviado ao LED: 
 
3) Há uma forma mais incrementada para ser enviar o pulso. Para isso você deverá seguir 
estes passos. Clique novamente em cima do pino 10 e selecione a opção “Anolog output 
(PWM)”, “Use generator” e clique no botão “Configure”. 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 138 ] 
4) Irá abrir uma nova janela, onde você deverá digitar o seguinte comando: 
 
Obs.: O pulso PWM vai de 0 a 255 ou de 0V a 5V por apenas 5 segundos. Para aumentar 
este tempo basta mudar “sin in 5 sec” por outro valor e “OK”. 
5) Depois de ter digitado o comando basta clicar em “OK” e você verá o seu led de aceso a 
totalmente apagado, gradativamente. 
6) Para desconectar do bluetooth clique da tecla de menu do smartphone e selecione 
“Disconnect”, aguarde alguns segundos e pronto. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 139 ] 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projeto 32 – Utilizando o osciloscópio via bluetooth com 
arduinocomander 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 140 ] 
 
 
Olá pessoal! Continuando com este excelente app, hoje vou mostrar como utilizar o 
osciloscópio com o ArduinoCommander. Iremos utilizar um potenciômetro para verificarmos 
como o osciloscópio se comporta, experimento simples porém podemos utiliza-lo para 
várias aplicações. Este osciloscópio nos permite observar a onda por apenas 5 segundos, 
porém na versão paga não há limite, sendo bem flexível é permitido até mudar a cor da(s) 
onda(s) gerada(s) bem como sua espessura, podemos pausar o osciloscópio e analisarmos 
o que for necessário. Os códigos serão todos comentados para melhor entendimento, 
podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Shield JY-MCU (Módulo Bluetooth) 
1 Potenciômetro de 10 KΩ (ou qualquer outro valor) 
Fios jumpers 
 
 
 
 
 
 
CONECTANDO OS COMPONENTES 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 141 ] 
 
 
CÓDIGO PARA COMUNICAR O ARDUINO AO APP SIGAS OS PASSOS ABAIXO: 
1) Abra o IDE do Arduino; 
2) Clique em File >> Examples>> Firmata e StandardFirmata; 
3) Irá abrir o código StandardFirmata; 
4) Dê um Ctrl+F e busque por 57600; 
5) Troque o valor por 9600; 
Pronto agora faça o upload para o Arduino*; 
*OBS.: Antes de passar o código para o Arduino retire os jumpers dos pinos RX e TX. Se 
não for feito isso não irá carregar o código para o Arduino, dando erro. 
CONECTANDO-SE AO ARDUINOCOMMANDER 
1) Baixe o app ArduinoCommander no Play Store ou emArduinoCommander - Google play; 
2) Após ter instalado, abra-o. Ficará assim a tela: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 142 ] 
 
3) Clique em “Discover devices” para encontrar seu Shield Bluetooth. Se o 
seu aparelho estiver com o bluetooth desligado, ele irá habilitar o mesmo. Como mostra na 
imagem abaixo: 
 
4) Agora pesquise novamente os dispositivos em “Discover devices” e irá aparecer os 
dispositivos bluetooth ao alcance, como mostra a imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 143 ] 
 
5) O meu shield está com o nome ELTONSHIELD, visualize o seu e clique clique nele para 
seleciona-lo; 
6) Após isto irá se conectar a sua placa Arduino como mostra a imagem abaixo: 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 144 ] 
7) Se algo der errado ira aparecer algo assim: 
 
AGORA VAMOS UTILIZAR O OSCILOSCÓPIO 
1) Clique no pino analógico “1”, em seguida selecione a opção “Analog input”, “Simple” 
e “OK”, como mostra as imagens abaixo: 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 145 ] 
 
 
2) Gire o potenciômetro e percebera que o valor da tensão no pino também irá mudar: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 146 ] 
 
 
3) Para visualizarmos o osciloscópio clique no botão de menu do seu Smartphone e irá 
aparecer a seguinte tela: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 147 ] 
 
4) Clique em “Osciloscope *”, irá aparecer o osciloscópio: 
 
Obs.: Não se faz necessário deixar a opção “Bézier curve”. Se estiver utilizando mais de um 
pino para gerar as ondas no osciloscópio, basta deslizar o dedo no meio da tela esquerda e 
seleciona-lo ou não, para ser gerado. 
5) Clique em “Start” e movimente o potenciômetro e verá as ondas geradas: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 148 ] 
 
Obs.: Para mudar a cor da onda clique em “Color” e mude-a. Caso queira mudar a 
espessura da onda clique em “- ou +”. 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 149 ] 
 
6) Para desconectar do bluetooth clique da tecla de menu do Smartphone e selecione 
“Disconnect”, aguarde alguns segundos e pronto. 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 150 ] 
Projeto 33 – Utilizando sensores do Smartphone via 
bluetooth com arduinocomander 
 
 
 
 
Olá pessoal! Hoje irei mostrar como utilizar o sensor acelerômetro do seu próprio 
Smartphone para controlar um LED. Além deste, o appArduinoCommander possui outros 
mais, como sensor de proximidade, sensor de campo magnético, sensor de orientação. 
Para utiliza-los basta que seu aparelho possua os respectivos sensores. Os códigos serão 
todos comentados para melhor entendimento, podendo ser retirados após a compreensão 
de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Shield JY-MCU (Módulo Bluetooth) 
1 LED (qualquer cor) 
1 Resistor de 330Ω 
Fios jumpers 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 151 ] 
CONECTANDO OS COMPONENTES 
 
 
 
CÓDIGO PARA COMUNICAR O ARDUINO AO APP SIGAS OS PASSOS ABAIXO: 
1) Abra o IDE do Arduino; 
2) Clique em File >> Examples >> Firmata e StandardFirmata; 
3) Irá abrir o código StandardFirmata; 
4) Dê um Ctrl+F e busque por 57600; 
5) Troque o valor por 9600; 
Pronto agora faça o upload para o Arduino*; 
*OBS.: Antes de passar o código para o Arduino retire os jumpers dos pinos RX e TX. Se 
não for feito isso não irá carregar o código para o Arduino, dando erro. 
CONECTANDO-SE AO ARDUINOCOMMANDER 
1) Baixe o app ArduinoCommander no Play Store ou emArduinoCommander - Google play; 
2) Após ter instalado, abra-o. Ficará assim a tela: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 152 ] 
 
3) Clique em “Discover devices” para encontrar seu Shield Bluetooth. Se o seu aparelho 
estiver com o bluetooth desligado, ele irá habilitar o mesmo. Como mostra na imagem 
abaixo: 
 
4) Agora pesquise novamente os dispositivos em “Discover devices” e irá aparecer os 
dispositivos bluetooth ao alcance, como mostra a imagem abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 153 ] 
 
5) O meu shield está com o nome ELTONSHIELD, visualize o seu e clique clique nele para 
seleciona-lo; 
6) Após isto irá se conectar a sua placa Arduino como mostra a imagem abaixo: 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 154 ] 
7) Se algo der errado ira aparecer algo assim: 
 
UTILIZANDO O SENSOR ACELERÔMETRO 
1) Clique no pino digital PWM “9”, em seguida selecione a opção “Analog output”, “Use 
device sensor” e “Configure”, como mostra a imagem abaixo: 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 155 ] 
2) Irá abrir uma outra tela para selecionarmos o sensor e fazer as configurações 
necessárias: 
 
Obs.: Infelizmente por se tratar de versão free, mesmo mudando o tempo para que se 
utilize este recurso, somente poderá ser utilizado por um período máximo de 10 segundos. 
Para se familiarizar com o app, configure como mostrado a cima. Podendo modificar o eixo 
posteriormente. Para setar os valores na posição Z você deverá deixar o aparelho na 
horizontal em pé e clique em “Current -> 0” e depois deixo-o na horizontal deitado e clique 
em “Current -> 1”. Clique em “OK”. 
3) Na tela posterior confirme clicando em “OK”: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 156 ] 
 
4) Clique em “OK” novamente e movimente seu aparelho para baixo e para cima (na 
horizontal), e verá o LED acender e apagar conforme o movimento exercido. Na tela 
do seu aparelho você verá mudar a tensão no pino conforme o movimento: 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 157 ] 
 
 
5) Para desconectar do bluetooth clique da tecla de menu do Smartphone e selecione 
“Disconnect”, aguarde alguns segundos e pronto. 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 158 ] 
Projeto 34 – Verificando código de comando de um controle 
remoto 
 
 
 
 
Olá pessoal, vamos descobrir como utilizar uma tecnologia um pouco antiga, porém ainda 
muito utilizado: o infravermelho. Ao apertar um botão de um controle remoto de uma TV, o 
CI envia um comando binário ou hexadecimal pelo emissor e o receptor capta estes dados 
e realiza a função programada pelo respectivo comando. Nós sabemos o valor 
hexadecimal/binário de cada botão? Não, até agora! Os códigos serão todos comentados 
para melhor entendimento, podendo ser retirados após a compreensão de cada linha. Bom 
trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 Infravermelho receptor TL1838 (ou similar) 
1 Protoboard 
Fios jumpers 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 159 ] 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO 
IRREMOTE_MASTER: 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo IRremote_Master; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos deProgramas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
CONECTANDO OS COMPONENTES 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 160 ] 
CÓDIGO DO PROJETO 
 
// Projeto 34 – Verificando código de comando de um controle remoto 
 
// Biblioteca para conunicação com o Arduino. 
#include <IRremote.h> 
 
// Pino utilizado para fazer a leitura dos valores dos botões... 
//do controle remoto. 
int RECV_PIN = 6; 
 
IRrecv irrecv(RECV_PIN); 
 
decode_results results; // Decodifica os dados do controle remoto. 
 
void setup() 
 
{ 
 
 Serial.begin(9600); // Inicia o Serial Monitor. 
 
 irrecv.enableIRIn(); // Inicia o infrared receptor. 
 
} 
 
void loop() { 
 
 if (irrecv.decode(&results)) { 
 
// Imprime na tela do Serial Monitor o valor dos botões do controle... 
//remoto em hexatecimal. 
 Serial.println(results.value, HEX); 
 
// Aguarda para receber o novo valor quando for pressionado um... 
//outro botão. 
 irrecv.resume(); 
 
 } 
 
 delay(100); // Dá um tempo de 100 ms entre um valor e outro. 
 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Abra seu Serial Monitor pressionado as teclas Ctrl + Shift + M simultaneamente. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 161 ] 
Pressione qualquer botão de seu controle remoto e se tudo estiver OK você verá impresso 
na tela do Serial Monitor os dados de seu controle remoto. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 162 ] 
Projeto 35 – Clonando controle remoto de TV 
 
 
 
 
Olá pessoal, neste tutorial vamos apreender como enviar comandos em hexadecimais para 
controlar sua TV como volume, trocar de canal e ligar/desligar. O projeto em si é de fácil 
compreensão, desde que seguindo como foi explicado no passo a passo. Então mãos aos 
componentes. Os códigos serão todos comentados para melhor entendimento, podendo ser 
retirados após a compreensão de cada linha. Bom trabalho !!! 
COMPONENTES NECESSÁRIOS 
1 LED infravermelho emissor TIL32 (ou similar) 
5 Pushes buttons 
6 Resistores de 330Ω 
1 Protoboard 
Fios jumpers 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 163 ] 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO 
IRREMOTE_MASTER: 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo IRremote_Master; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
CONECTANDO OS COMPONENTES 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 164 ] 
CÓDIGO DO PROJETO 
 
 // Projeto 35 – Clonando controle remoto de TV 
 
 #include <IRremote.h> // Biblioteca para controlar o led infravermelho 
 IRsend irsend; // Variável para poder enviar o código a TV 
 
 // Variáveis constantes para o controle remoto 
 // Pino onde estará o botão para aumentar o volume 
 const int mais_volume = 4; 
 
 // Pino responsavél por diminuir o volume 
 const int menos_volume = 5; 
 
 // Pino onde estará o botão para mudar o canal em ordem crescente 
 const int mais_canal = 6; 
 
 // Pino responsavél por mudar o canal em ordem decrescente 
 const int menos_canal = 7; 
 
 // Pino onde estará o botão que iremos ligar/desligar a TV 
 const int liga_desliga = 8; 
 
 // Pino onde iremos conectar o LED emissor de infravermelho 
 const int ledIR = 3; 
 
 // Inicia o botão com o valor do estado em 0 
 int buttonState = 0; 
 
 void setup() { 
 pinMode(ledIR ,OUTPUT); // Definimos o LED de infra como de saída 
 
 Serial.begin(9600); // Iniciamos o Serial Monitor 
 
 // Configurando as entradas dos botões como de entrada 
 pinMode(mais_volume, INPUT); 
 pinMode(menos_volume, INPUT); 
 pinMode(mais_canal, INPUT); 
 pinMode(menos_canal, INPUT); 
 pinMode(liga_desliga, INPUT); 
 } 
 
 void loop(){ 
 // Se o botão mais_volume for pressionado ele ira enviar o código... 
 //para aumentar o volume na TV 
 if (digitalRead(mais_volume) == HIGH) { 
 
 // Código que será enviado a TV para aumentar o volume (Como a... 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 165 ] 
 //sintaxe manda devemos iniciar com 0x + número em hexadecimal, 32) 
 irsend.sendNEC(0xE0E0E01F, 32); 
 
 } 
 
// Se o botão menos_volume for pressionado ele irá enviar o código para... 
//diminuir o volume na TV 
 if (digitalRead(menos_volume) == HIGH) { 
 
// Código que será enviado a TV para diminuir o volume 
 irsend.sendNEC(0xE0E0D02F, 32); 
 } 
 
// Se o botão mais_canal for pressionado ele irá enviar o código para... 
//aumentar o canal na TV 
 if (digitalRead(mais_canal) == HIGH) { 
 irsend.sendNEC(0xE0E048B7, 32); 
 } 
 
// Se o botão menos_canal for pressionado ele irá enviar o código para... 
//diminuir o canal na TV 
 if (digitalRead(menos_canal) == HIGH) { 
 irsend.sendNEC(0xE0E008F7, 32); 
 } 
 
// Se o botão liga_desliga for pressionado ele irá enviar o código para... 
//ligar/desligar a TV 
 if (digitalRead(liga_desliga) == HIGH) { 
 irsend.sendNEC(0xE0E040BF, 32); 
 } 
 } 
 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Abra seu Serial Monitor pressionado as teclas Ctrl + Shift + M simultaneamente. 
Pressione qualquer botão de seu controle remoto e se tudo estiver OK você verá impresso 
na tela do Serial Monitor os dados de seu controle remoto. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 166 ] 
Projeto 36 – Acionando LED’s e relê com infravermelho 
 
 
 
Olá pessoal, hoje iremos acionar LED’s e rele via controle remoto. Qualquer controle 
remoto serve: de TV, rádio...etc. Para você fazer este projeto, você precisará saber qual o 
valor hexadecimal de cada botão que será utilizado neste projeto, para saber como 
visualizar o código veja o tutorial Projeto 34 – Verificando código de comando de um 
controle remoto. Já obteve os respectivos valores hexadecimais? Então vamos ao projeto !! 
Os códigos serão todos comentados para melhor entendimento, podendo ser retirados após 
a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Infravermelho receptor TL1838 (ou similar) 
1 Shield Rele 
2 Resistores de 330Ω 
2 LED’s 
1 Protoboard 
Fios jumpers 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 167 ] 
FAZENDO O DOWNLOAD E IMPORTANDO A BIBLIOTECA DO 
IRREMOTE_MASTER: 
1) Acesse o 
link https://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122; 
2) Faça o download do arquivo IRremote_Master; 
3) Descompacte o arquivo; 
4) Agora entre no diretório (C:) e na pasta Arquivos de Programas, Arduino, libraries, copie 
o arquivo descompactado nesta pasta; 
5) Pronto para utilizar; 
CONECTANDO OS COMPONENTES 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 168 ] 
CÓDIGO DO PROJETO 
 
// Projeto 36 – AcionandoLED's e rele com infravermelho 
 
// Biblioteca necessária para controle do infravermelho receptor. 
#include <IRremote.h> 
 
int RECV_PIN = 6; // Pino responsável por receber o código do IR. 
int armazenavalor = 0; // Iniciando com valor igual a zero. 
int pino_rele = 7; // Pino onde o rele foi conectado no arduino. 
int pino_led1 = 8; // Pino onde o primeiro LED esta conectado no arduino. 
int pino_led2 = 9; // Pino onde o segundo LED esta conectado no arduino. 
int estado_rele = LOW; // Inicia com o rele desligado. 
int estado_led1 = LOW; // Inicia com o primeiro LED apagado. 
int estado_led2 = LOW; // Inicia com o segundo LED também apagado. 
 
IRrecv irrecv(RECV_PIN); 
decode_results results; 
 
void setup() 
{ 
 pinMode(pino_rele, OUTPUT); // Define todos os pino como de saída. 
 pinMode(pino_led1, OUTPUT); 
 pinMode(pino_led2, OUTPUT); 
 
 digitalWrite(pino_rele, estado_rele); // Coloca os pinos todos os pino em... 
 digitalWrite(pino_led1, estado_led1); // estado baixo (pinos desligados). 
 digitalWrite(pino_led2, estado_led2); 
 
 Serial.begin(9600); // Inicializa a serial monitor. 
 irrecv.enableIRIn(); // Inicializa o receptor IR. 
} 
 
 
 
void loop() 
{ 
 // Verifica se o sensor IR recebeu algum sinal. 
 if (irrecv.decode(&results)) 
 { 
 // Mostra na serial o valor lido pelo sensor IR. 
 Serial.print("Valor lido : "); 
 Serial.println(results.value, HEX); 
 
 // Armazena o sinal recebido pelo sensor IR. 
 armazenavalor = (results.value); 
 switch (armazenavalor) 
 { 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 169 ] 
 
 // Verifica se o botão número 1 do controle remoto foi prescionada. 
 case 0xE0E020DF: 
 // Se prescionado aciona o rele. 
 estado_rele = !estado_rele; 
 digitalWrite(pino_rele, estado_rele); 
 break; 
 
 // Verifica se o botão número 2 do controle remoto foi prescionada. 
 case 0xE0E0A05F: 
 // Se prescionado acende o primeiro LED. 
 estado_led1 = !estado_led1; 
 digitalWrite(pino_led1, estado_led1); 
 break; 
 
 // Verifica se o botão número 3 do controle remoto foi prescionada. 
 case 0xE0E0609F: 
 // Se prescionado ascende o segundo LED. 
 estado_led2 = !estado_led2; 
 digitalWrite(pino_led2, estado_led2); 
 break; 
 } 
 irrecv.resume(); //Le o próximo valor 
 } 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. 
Abra seu Serial Monitor pressionado as teclas Ctrl + Shift + M simultaneamente. 
Pressione qualquer um dos botões: 1, 2, 3 de seu controle uma vez e verá o rele, os LED’s 
serem acionados. Para desliga-los basta pressiona-los novamente. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 170 ] 
Projeto 37 – Jogo ping pong com LCD Nokia 5110 
 
 
 
 
 
 
Olá pessoal, conforme prometido neste projeto iremos utilizar o módulo LCD Nokia 5110 
para fazermos um jogo simples e muito conhecido - o ping pong. Eu utilizei dois joysticks 
como controle para controlar as barras, porém se vocês não tiverem este componente em 
mãos vocês podem utilizar potenciômetros que fará a mesma função do joystick. Então 
mãos aos componentes !! Os códigos serão todos comentados para melhor entendimento, 
podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Shield LCD Nokia 5110 
1 Buzzer 
2 Joysticks ou potenciômetros 
1 Resistor de 220 Ω 
Fios jumper do tipo macho/fêmea e macho/macho 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, conecte todos componentes como mostra a figura abaixo: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 171 ] 
 
SEGUE O ESQUEMA ABAIXO PARA MELHOR ENTENDIMENTO 
 
Pinos do módulo LCD Nokia 5110 Pinos do Arduino 
RST 6 
CE 7 
DC 5 
Din 4 
Clk 3 
Vcc 5V 
Gnd GND 
BL Resistor 
 
 
 
AGORA VAMOS AO CÓDIGO: 
 
// Projeto 37 – Jogo do Ping Pong com LCD Nokia 5110 
 
// Setando os pinos do LCD Nokia 5110 no Arduino Uno 
#define PIN_SCE 7 
#define PIN_RESET 6 
#define PIN_DC 5 
#define PIN_SDIN 4 
#define PIN_SCLK 3 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 172 ] 
#define PIN_BUZZER 8 
 
#define LCD_C LOW 
#define LCD_D HIGH 
 
// Inicializa o LCD com apenas 504 pixels de resolução. 
#define LCD_X 84 
#define LCD_Y 6 
 
int barWidth = 14; // Comprimento das barras. 
int barHeight = 4; // Largura das barras. 
int ballPerimeter = 5; // Tamanho da bola. 
unsigned int bar1X = 0; 
unsigned int bar1Y = 0; 
unsigned int bar2X = 0; 
unsigned int bar2Y = LCD_Y * 8 - barHeight; 
int ballX = 0; 
int ballY = 0; 
boolean isBallUp = false; 
boolean isBallRight = true; 
 
byte pixels[LCD_X][LCD_Y]; 
unsigned long lastRefreshTime; 
const int refreshInterval = 150; 
byte gameState = 3; // Estágios do game. 
byte ballSpeed = 4; // Velocidadeda bola. 
byte player1WinCount = 0; 
byte player2WinCount = 0; 
byte hitCount = 0; 
 
void setup(){ 
 
 pinMode(PIN_BUZZER, OUTPUT); 
 // Inicializa as funções abaixo. 
 LcdInitialise(); 
 restartGame(); 
} 
 
void loop(){ 
 
 unsigned long now = millis(); 
 if(now - lastRefreshTime > refreshInterval){ 
 update(); 
 refreshScreen(); 
 lastRefreshTime = now; 
 } 
} 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 173 ] 
 
// Função reinciar jogo. 
void restartGame(){ 
 
 ballSpeed = 1; 
 gameState = 1; 
 ballX = random(0, 60); 
 ballY = 20; 
 isBallUp = false; 
 isBallRight = true; 
 hitCount = 0; 
 
 } 
 
 
// Função atualzar tela do LCD. 
void refreshScreen(){ 
 
 if(gameState == 1){ 
 for(int y = 0; y < LCD_Y; y++){ 
 for(int x = 0; x < LCD_X; x++){ 
 byte pixel = 0x00; 
 int realY = y * 8; 
 
 // Inicia a bola na tela. 
 if(x >= ballX && x <= ballX + ballPerimeter -1 && ballY + ballPerimeter > 
 realY && ballY < realY + 8 ){ 
 byte ballMask = 0x00; 
 for(int i = 0; i < realY + 8 - ballY; i++){ 
 ballMask = ballMask >> 1; 
 if(i < ballPerimeter) 
 ballMask = 0x80 | ballMask; 
 } 
 pixel = pixel | ballMask; 
 } 
 
// Inicia a barra na tela. 
if(x >= bar1X && x <= bar1X + barWidth -1 && bar1Y + barHeight > realY && 
bar1Y < realY + 8 ){ 
 byte barMask = 0x00; 
 for(int i = 0; i < realY + 8 - bar1Y; i++){ 
 barMask = barMask >> 1; 
 if(i < barHeight) 
 barMask = 0x80 | barMask; 
 } 
 pixel = pixel | barMask; 
 } 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 174 ] 
if(x >= bar2X && x <= bar2X + barWidth -1 && bar2Y + barHeight > realY 
&& bar2Y < realY + 8 ){ 
 byte barMask = 0x00; 
 for(int i = 0; i < realY + 8 - bar2Y; i++){ 
 barMask = barMask >> 1; 
 if(i < barHeight) 
 barMask = 0x80 | barMask; 
 } 
 pixel = pixel | barMask; 
 } 
 LcdWrite(LCD_D, pixel); 
 } 
 } 
 } else if(gameState == 2){ 
 // Faz a tratativa dos estágios do jogo. 
 int pinOut = 8; 
 int freq = 150; 
 int duration = 1000;tone(pinOut, freq, duration); 
 
 } 
 
} 
 
void update(){ 
 
 if(gameState == 1){ 
 int barMargin = LCD_X - barWidth; 
 // Lê os joysticks e posiciona as barras no LCD. 
 int joystick1 = analogRead(A0); 
 int joystick2 = analogRead(A1); 
 bar1X = joystick1 / 2 * LCD_X / 512; 
 bar2X = joystick2 / 2 * LCD_X / 512; 
 
 if(bar1X > barMargin) bar1X = barMargin; 
 if(bar2X > barMargin) bar2X = barMargin; 
 
 // Movimento da bola. 
 if(isBallUp) 
 ballY -= ballSpeed; 
 else 
 ballY += ballSpeed; 
 if(isBallRight) 
 ballX += ballSpeed; 
 else 
 ballX -= ballSpeed; 
 
 // Verifica se ouve colisões. 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 175 ] 
 if(ballX < 1){ 
 isBallRight = true; 
 ballX = 0; 
 } 
 else if(ballX > LCD_X - ballPerimeter - 1){ 
 isBallRight = false; 
 ballX = LCD_X - ballPerimeter; 
 } 
 if(ballY < barHeight){ 
 
 // Faz com que a bola ping para a barra 1. 
 if(ballX + ballPerimeter >= bar1X && ballX <= bar1X + barWidth){ 
 isBallUp = false; 
 if(ballX + ballPerimeter/2 < bar1X + barWidth/2) 
 isBallRight = false; 
 else 
 isBallRight = true; 
 ballY = barHeight; 
 if(++hitCount % 10 == 0 && ballSpeed < 5) 
 ballSpeed++; 
 }else{ 
 // Jogador 2 é o vencedor. 
 gameState = 2; 
 player2WinCount++; 
 } 
 } 
 if(ballY + ballPerimeter > LCD_Y * 8 - barHeight){ 
 
 // Faz com que a bola ping para a barra 2. 
 if(ballX + ballPerimeter >= bar2X && ballX <= bar2X + barWidth){ 
 isBallUp = true; 
 if(ballX + ballPerimeter/2 < bar2X + barWidth/2) 
 isBallRight = false; 
 else 
 isBallRight = true; 
 ballY = LCD_Y * 8 - barHeight - ballPerimeter; 
 if(++hitCount % 10 == 0 && ballSpeed < 5) 
 ballSpeed++; 
 } 
 else{ // Jogar 1 é o vencedor. 
 gameState = 2; 
 player1WinCount++; 
 } 
 } 
 }else if(gameState == 2){ 
 for(int i =0; i < 4; i++){ 
 LcdWrite(LCD_C, 0x0D ); // LCD no modo inverso. 
 delay(300); 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 176 ] 
 LcdWrite(LCD_C, 0x0C ); 
 delay(300); 
 } 
 restartGame(); // Chama da função para resetar o game. 
 } 
} 
 
// Inicializa o LCD. 
void LcdInitialise(void){ 
 
 pinMode(PIN_SCE, OUTPUT); 
 pinMode(PIN_RESET, OUTPUT); 
 pinMode(PIN_DC, OUTPUT); 
 pinMode(PIN_SDIN, OUTPUT); 
 pinMode(PIN_SCLK, OUTPUT); 
 delay(200); 
 digitalWrite(PIN_RESET, LOW); 
 delay(500); 
 digitalWrite(PIN_RESET, HIGH); 
 LcdWrite(LCD_C, 0x21 ); // Comandos ampliados do LCD. 
 LcdWrite(LCD_C, 0xB1 ); // Configura o contraste do LCD. 
 LcdWrite(LCD_C, 0x04 ); // Configura o tempo de coeficiente. 
 LcdWrite(LCD_C, 0x14 ); 
 LcdWrite(LCD_C, 0x0C ); // LCD em modo normal. 
 LcdWrite(LCD_C, 0x20 ); 
 LcdWrite(LCD_C, 0x80 ); 
 LcdWrite(LCD_C, 0x40 ); 
 LcdWrite(LCD_C, 0x0C ); 
} 
 
void LcdWrite(byte dc, byte data){ 
 
 digitalWrite(PIN_DC, dc); 
 digitalWrite(PIN_SCE, LOW); 
 shiftOut(PIN_SDIN, PIN_SCLK, MSBFIRST, data); 
 digitalWrite(PIN_SCE, HIGH); 
} 
Para confirmar se está tudo certo clique no botão Verify/Upload. Não havendo nenhum erro 
parabéns!! Agora divirta-se com este divertido jogo. 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 177 ] 
Projeto 38 – Jogo dos caminhões com LCD 16x2 
 
 
 
Olá pessoal, para quem não tem um LCD nokia 5110 também pode fazer jogos muito legais 
com um LCD 16X2. Este jogo consiste em desviar dos caminhões, evitando assim as 
colisões. Parece ser fácil, porém a velocidade vai aumentando e a colisão é certeira!! Para 
movermos o carrinho para baixo e para cima dispomos de um potenciômetro como 
controle. Então vamos ao trabalho. Os códigos serão todos comentados para melhor 
entendimento, podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Protoboard 
1 LCD 16X2 
1 Buzzer 
2 Potenciômetros 
Fios jumper 
Obs.: Você pode utilizar mais de um potenciômetro para controle de brilho (Verifique 
o post cooler) 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 178 ] 
CONECTANDO OS COMPONENTES 
Primeiro, certifique-se de que seu Arduino esteja desligado, desconectando-o do cabo USB. 
Agora, pegue a protobord, o LCD, o buzzer, os potenciômetros e os fios jumpers e conecte-
os assim como mostra a figura abaixo: 
 
Não importa se você utiliza fios de cores diferentes ou furos diferentes na protoboard, 
desde que os componentes e os fios estejam conectados na mesma ordem da figura. 
Tenha cuidado ao inserir os componentes na protoboard. Caso sua protoboard seja nova, a 
superfície dos furos ainda estará rígida. A não inserção cuidadosa dos componentes pode 
resultar em danos. Certifique-se de que todos os componentes estejam conectados 
corretamente. Quando você estiver seguro de que tudo foi conectado corretamente, ligue 
seu Arduino conectando-o ao cabo USB. 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 179 ] 
CÓDIGO DO PROJETO 
 
// Projeto 38 - Jogo dos caminhões com LCD 16X2 
 
// Declarando a biblioteca para comunicação com o LCD. 
#include <LiquidCrystal.h> 
 
LiquidCrystal lcd(9, 8, 5, 4, 3, 2); // Declarando os pinos a serem usados. 
const int POTPIN = 1; // Potenciometro no pino A1 do Arduino 
 
// Precisamos girar todo o potenciometro para o carrinho subir e... 
//descer no visor do LCD. 
const int MAXPOT = 1024; 
 
// Declara o pino digital 10 para acionar o Speaker. 
const int SPEAKERPIN = 10; 
 
// Um pino analogico que não esta conectado a nada. 
const int RANDSEEDPIN = 0; 
 
// Inicia devagar e a cada milisegundos vai aumetando a velocidade... 
const int MINSTEPDURATION = 150; 
 
// Até chegar ao máximo de sua velocidade. 
const int MAXSTEPDURATION = 300; 
const int NGLYPHS = 6; 
byte glyphs[NGLYPHS][8] = { // Iremos criar os carros e caminhões... 
 
 // Imagem carro para cima. 
 { B00000, 
 B01110, 
 B11111, 
 B01010, 
 B00000, 
 B00000, 
 B00000, 
 B00000} 
 
 // Imagem carro para baixo. 
 ,{B00000, 
 B00000, 
 B00000, 
 B00000, 
 B01110, 
 B11111, 
 B01010, 
 B00000} 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 180 ] 
 // Imagem do caminhão para cima. 
 ,{B00000, 
 B11110, 
 B11111, 
 B01010, 
 B00000, 
 B00000, 
 B00000, 
 B00000} 
 
 // Imagem do caminhão para baixo. 
 ,{B00000, 
 B00000, 
 B00000, 
 B00000, 
 B11110, 
 B11111, 
 B01010, 
 B00000} 
 
 // Imagem de batida para cima. 
 ,{B10101, 
 B01110, 
 B01110, 
 B10101, 
 B00000, 
 B00000, 
 B00000, 
 B00000} 
 
 // Imagem de batida para baixo. 
 ,{B00000, 
 B00000, 
 B00000, 
 B10101, 
 B01110, 
 B01110, 
 B10101, 
 B00000} 
 
}; 
 
const int NCARPOSITIONS = 4; 
 
const char BLANK=32; 
 
char car2glyphs[NCARPOSITIONS][2] = { 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 181 ] 
 {1,BLANK},{2,BLANK},{BLANK,1},{BLANK,2} 
 
}; 
 
char truck2glyphs[NCARPOSITIONS][2] = { 
 
 {3,BLANK},{4,BLANK},{BLANK,3},{BLANK,4} 
 
}; 
 
char crash2glyphs[NCARPOSITIONS][2] = { 
 
 {5,BLANK},{6,BLANK},{BLANK,5},{BLANK,6} 
 
};const int ROADLEN = 15; // Largura do LCD (sem contar nosso carro). 
 
int road[ROADLEN]; // Posição dos outros carros. 
 
char line_buff[2+ROADLEN]; 
 
int road_index; 
 
int car_pos; 
 
// Off-the-grid posição significa coluna vazia, então MAXROADPOS 
 
 // Determina a probabilidade de um carro numa coluna 
 
 // Por exemplo 3 * NCARPOSITIONS dá p = 1/3 
 
const int MAXROADPOS = 3*NCARPOSITIONS; 
 
int step_duration; 
 
int crash; // Verdadeiro se haver colisão. 
 
unsigned int crashtime; 
 
const int CRASHSOUNDDURATION = 250; 
 
 
 
const char *INTRO1="OlhePARAfrente"; 
 
const char *INTRO2="Tenha cuidado"; 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 182 ] 
const int INTRODELAY = 2000; // Introdução com duração de dois segundos. 
 
void setup() 
 
{ 
 
 crash = crashtime = road_index = 0; 
 
 step_duration = MAXSTEPDURATION; 
 
 line_buff[1+ROADLEN] = '\0'; 
 
 randomSeed(analogRead(RANDSEEDPIN)); 
 
 for (int i=0; iMINSTEPDURATION) { 
 
 step_duration--; 
 
 } 
 
 } 
 
} 
 
void getSteeringWheel() { 
 
 car_pos = map(analogRead(POTPIN),0,1024,0,NCARPOSITIONS); 
 
}void drawRoad() { 
 
 for (int i=0; i<2; i++) { 
 
 if (crash) { 
 
 line_buff[0]=crash2glyphs[car_pos][i]; 
 
 } 
 
 else { 
 
 line_buff[0]=car2glyphs[car_pos][i]; 
 
 } 
 
 for (int j=0; j=0 && pos < NCARPOSITIONS ? truck2glyphs[pos][i] : BLANK; 
 
 } 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 183 ] 
 lcd.setCursor(0,i); 
 
 lcd.print(line_buff); 
 
 } 
 
} 
Para certificar se o código está correto pressione o botão Verify/Compile. Se tudo estiver 
correto pressione o botão Upload para fazer o upload do código para seu Arduino. Pronto, 
agora ajuste o contraste do seu LCD girando o potenciômetro correspondente. O jogo irá 
começar em breve, quando isso acontecer gire o potenciômetro para o carrinho subir e 
descer afim de desviar dos caminhões. Boa diversão!!! 
Obs.: Quando você colidir com algum dos caminhões, reset o jogo pressionando o botão de 
reset de seu Arduino. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 184 ] 
Projeto 39 – Interface WEB com Arduino 
 
 
 
 
 
Olá pessoal, neste projeto iremos aprender a criar uma interface web simples utilizando o 
arduino. Para isso você irá precisar de um potenciômetro e um Shield Ethernet para que 
seja possível realizar a conexão com a rede de internet. O projeto é de fácil compreensão 
deixando de forma clara e objeta com vários comentários nas linhas do código. Então 
vamos ao trabalho !! Os códigos serão todos comentados para melhor entendimento, 
podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Protoboard 
1 Potenciômetro de 10KΩ (Ou outro equivalente) 
1 Shield Ethernet 
Fios jumper 
DOWNLOAD DA PÁGINA WEB 
Faça o download do arquivo da página web neste 
linkhttps://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122 (
OneDrive). 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 185 ] 
SIGAS OS PASSOS ABAIXO: 
1) Faça o download do arquivo “Index”. 
2) Após feito o download, extraia o arquivo index.htm, copie e cole o arquivo em um micro 
SD – formate o SD antes de copiar o arquivo. 
3) Insira o cartão no slot acoplado ao Shield Ethernet. 
4) Com o arduino já conectado à porta USB de seu computador e o Shield ao cabo de rede, 
copie e cole o código abaixo para a IDE e mude o IP conforme sua rede, após isso transfira 
- o para seu arduino. 
5) Abra seu browser e digite o IP que você definiu no código e dê um enter. 
6) Uma página web será exibida com uma interface recebendo os valores do 
potenciômetro. 
7) Gire o potenciômetro e você irá ver o ponteiro se movimentar de acordo o valor do 
potenciômetro. 
CONECTANDO OS COMPONENTES 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 186 ] 
 
CÓDIGO DO PROJETO 
 
// Projeto 39 - Interface Web com arduino 
 
#include <SPI.h> 
#include <Ethernet.h> 
#include <SD.h> 
 
// Tamanho do buffer utilizado para capturar os pedidos HTTP 
#define REQ_BUF_SZ 50 
 
// Setando Endereço MAC e IP para a placa Ethernet 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
// Configurando o endereço IP (mudar conforme sua rede) 
IPAddress ip(192, 168, 2, 120); 
EthernetServer server(80); // Criar um servidor na porta 80 
File webFile; // Arquivo da página web no cartão SD 
// Armazena o buffer requerido a página web 
char HTTP_req[REQ_BUF_SZ] = {0}; 
char req_index = 0; // Índice no HTTP_req buffer 
 
void setup() 
{ 
 // Desativar o chip de Ethernet 
 pinMode(10, OUTPUT); 
 digitalWrite(10, HIGH); 
 
 Serial.begin(9600); // Adicionado para depuração 
 
 // Inicializa o SD card 
 Serial.println("Initializing SD card..."); 
 if (!SD.begin(4)) { 
 Serial.println("ERROR - SD card initialization failed!"); 
 return; // Inicialização falhou 
 } 
 Serial.println("SUCCESS - SD card initialized."); 
 // Verifica se exite o arquivo index.htm 
 if (!SD.exists("index.htm")) { 
 Serial.println("ERROR - Can't find index.htm file!"); 
 return; // Não pode encontrar o arquivo especificado 
 } 
 Serial.println("SUCCESS - Found index.htm file."); 
 // Arquivo index.htm encontrado com sucesso 
 
 Ethernet.begin(mac, ip); // Inicializa o dispositivo Ethernet 
 server.begin(); // Inicializa o servidor web 
} 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 187 ] 
 
void loop() 
{ 
 EthernetClient client = server.available(); // tentar obter cliente 
 
 if (client) { 
 boolean currentLineIsBlank = true; 
 while (client.connected()) { 
 if (client.available()) { // Dados do cliente disponível para leitura 
 char c = client.read(); // Lê 1 byte (atributo) do cliente 
 // Primeira parte do pedido HTTP em ordem HTTP_req 
 /* Deixa o último elemento na matriz como 0 para terminar... 
 a string (REQ_BUF_SZ - 1)*/ 
 if (req_index < (REQ_BUF_SZ - 1)) { 
 HTTP_req[req_index] = c; // Salva o atributo HTTP requerido 
 req_index++; 
 } 
 // A última linha da requisão do cliente fica em branco e ternina com \n 
 // Responde para o cliente somente depois da última linha recebida 
 if (c == '\n' && currentLineIsBlank) { 
 // Enviar um cabeçalho de resposta HTTP padrão 
 client.println("HTTP/1.1 200 OK"); 
 
 // Restante do cabeçalho segue abaixo, dependendo se... 
 // Página web ou página XML é solicitada 
 // Pedido Ajax - Enviar arquivo XML 
 if (StrContains(HTTP_req, "ajax_inputs")) { 
 // Enviar restante do cabeçalho HTTP 
 client.println("Content-Type: text/xml"); 
 client.println("Connection: keep-alive"); 
 client.println(); 
 
 // Enviar arquivo XML contendo estados de entrada 
 XML_response(client); 
 } 
 else { // Solicitação de página web 
 // Enviar restante do cabeçalho HTTP 
 client.println("Content-Type: text/html");client.println("Connection: keep-alive"); 
 client.println(); 
 // Envia página web 
 // Abre o arquivo da página web 
 webFile = SD.open("index.htm"); 
 if (webFile) { 
 while(webFile.available()) { 
 client.write(webFile.read()); // Cliente recebe a página web 
 } 
 webFile.close(); 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 188 ] 
 } 
 } 
 // Exibição na porta de serial o pedido recebido de HTTP 
 Serial.print(HTTP_req); 
 // Reseta o buffer para 0 
 req_index = 0; 
 StrClear(HTTP_req, REQ_BUF_SZ); 
 break; 
 } 
 // Cada linha de texto recebidas do cliente termina com \ r \ n 
 if (c == '\n') { 
 
 // Iniciar nova linha com a próxima leitura de caracteres 
 currentLineIsBlank = true; 
 } 
 else if (c != '\r') { 
 // Caracter recebido pelo cliente 
 currentLineIsBlank = false; 
 } 
 } 
 } 
 delay(1); // Dá um tempo para o browser receber os dados 
 client.stop(); // Fecha a conexão 
 } // Fim do laço if (client) 
} 
 
// Envia ao arquivo XML os valores do pino analogico 
void XML_response(EthernetClient cl) 
{ 
 int analog_val; 
 
 cl.print(""); 
 cl.print(""); 
 // Lê o pino A3 
 analog_val = analogRead(3); 
 cl.print(""); 
 cl.print(analog_val); 
 cl.print(""); 
 cl.print(""); 
} 
 
// Seta todos os elementos de str para 0 (limpa o vetor) 
void StrClear(char *str, char length) 
{ 
 for (int i = 0; i < length; i++) { 
 str[i] = 0; 
 } 
} 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 189 ] 
 
char StrContains(char *str, char *sfind) 
{ 
 char found = 0; 
 char index = 0; 
 char len; 
 
 len = strlen(str); 
 
 if (strlen(sfind) > len) { 
 return 0; 
 } 
 while (index < len) { 
 if (str[index] == sfind[found]) { 
 found++; 
 if (strlen(sfind) == found) { 
 return 1; 
 } 
 } 
 else { 
 found = 0; 
 } 
 index++; 
 } 
 
 return 0; 
} 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 190 ] 
Projeto 40 – Monitor de temperatura com Arduino 
 
 
 
 
Olá pessoal, neste projeto iremos aprender a fazer um monitor de temperatura web com o 
arduino. Para isso você irá precisar de um sensor LM 35 e um Shield Ethernet para que 
seja possível realizar a conexão com a rede de internet. O projeto é de fácil compreensão 
deixando de forma clara e objeta com vários comentários nas linhas do código. Então 
vamos ao trabalho !! Os códigos serão todos comentados para melhor entendimento, 
podendo ser retirados após a compreensão de cada linha. Bom trabalho !!! 
 
COMPONENTES NECESSÁRIOS 
1 Protoboard 
1 Sensor LM 35 
1 Shield Ethernet 
Fios jumper 
DOWNLOAD DA PÁGINA WEB 
 
Faça o download do arquivo da página web neste 
linkhttps://onedrive.live.com/?cid=F877FDED1DE63FAA&id=F877FDED1DE63FAA%21122 (
OneDrive). 
 
SIGAS OS PASSOS ABAIXO: 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 191 ] 
1) Faça o download do arquivo “Index1”. 
2) Após feito o download, extraia o arquivo index1.htm, copie e cole o arquivo em um micro SD – 
formate o SD antes de copiar o arquivo. 
3) Insira o cartão no slot acoplado ao Shield Ethernet. 
4) Com o arduino já conectado à porta USB de seu computador e o Shield ao cabo de rede, copie e 
cole o código abaixo para a IDE e mude o IP conforme sua rede, após isso transfira - o para seu 
arduino. 
5) Abra seu browser e digite o IP que você definiu no código e dê um enter. 
6) Uma página web será exibida com uma interface recebendo os valores analogicos de seu sensor 
de temperatura LM 35. 
7) Estimule o sensor a variações de temperatura para oscilar o ponteiro do marcador em seu 
navegador. 
CONECTANDO OS COMPONENTES 
 
 
CÓDIGO DO PROJETO 
 
// Projeto 40 - Monitor de temperatura com arduino 
 
#include <SPI.h> 
#include <Ethernet.h> 
#include <SD.h> 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 192 ] 
 
// Tamanho do buffer utilizado para capturar os pedidos HTTP 
#define REQ_BUF_SZ 50 
 
// Setando Endereço MAC e IP para a placa Ethernet 
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; 
// Configurando o endereço IP (mudar conforme sua rede) 
IPAddress ip(192, 168, 2, 121); 
EthernetServer server(80); // Criar um servidor na porta 80 
File webFile; // Arquivo da página web no cartão SD 
// Armazena o buffer requerido a página web 
char HTTP_req[REQ_BUF_SZ] = {0}; 
char req_index = 0; // Índice no HTTP_req buffer 
 
void setup() 
{ 
 // Desativar o chip de Ethernet 
 pinMode(10, OUTPUT); 
 digitalWrite(10, HIGH); 
 
 Serial.begin(9600); // Adicionado para depuração 
 
 // Inicializa o SD card 
 Serial.println("Initializing SD card..."); 
 if (!SD.begin(4)) { 
 Serial.println("ERROR - SD card initialization failed!"); 
 return; // Inicialização falhou 
 } 
 Serial.println("SUCCESS - SD card initialized."); 
 // Verifica se exite o arquivo index1.htm 
 if (!SD.exists("index1.htm")) { 
 Serial.println("ERROR - Can't find index1.htm file!"); 
 return; // Não pode encontrar o arquivo especificado 
 } 
 Serial.println("SUCCESS - Found index1.htm file."); 
 
 Ethernet.begin(mac, ip); // Inicializa o dispositivo Ethernet 
 server.begin(); // Inicializa o servidor web 
} 
 
void loop() 
{ 
 EthernetClient client = server.available(); // tentar obter cliente 
 
 if (client) { 
 boolean currentLineIsBlank = true; 
 while (client.connected()) { 
 if (client.available()) { // Dados do cliente disponível para leitura 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 193 ] 
 char c = client.read(); // Lê 1 byte (atributo) do cliente 
 // Primeira parte do pedido HTTP em ordem HTTP_req 
 // Deixa o último elemento na matriz como 0 para terminar... 
 //a string (REQ_BUF_SZ - 1) 
 if (req_index < (REQ_BUF_SZ - 1)) { 
 HTTP_req[req_index] = c; // Salva o atributo HTTP requerido 
 req_index++; 
 } 
 // A última linha da requisão do cliente fica em branco e ternina com \n 
 // Responde para o cliente somente depois da última linha recebida 
 if (c == '\n' && currentLineIsBlank) { 
 // Enviar um cabeçalho de resposta HTTP padrão 
 client.println("HTTP/1.1 200 OK"); 
 
 // Restante do cabeçalho segue abaixo, dependendo se... 
 // Página web ou página XML é solicitada 
 // Pedido Ajax - Enviar arquivo XML 
 if (StrContains(HTTP_req, "ajax_inputs")) { 
 // Enviar restante do cabeçalho HTTP 
 client.println("Content-Type: text/xml"); 
 client.println("Connection: keep-alive"); 
 client.println();// Enviar arquivo XML contendo estados de entrada 
 XML_response(client); 
 } 
 else { // Solicitação de página web 
 // Enviar restante do cabeçalho HTTP 
 client.println("Content-Type: text/html"); 
 client.println("Connection: keep-alive"); 
 client.println(); 
 // Envia página web 
 // Abre o arquivo da página web 
 webFile = SD.open("index1.htm"); 
 if (webFile) { 
 while(webFile.available()) { 
 client.write(webFile.read()); // Cliente recebe a página web 
 } 
 webFile.close(); 
 } 
 } 
 // Exibição na porta de serial o pedido recebido de HTTP 
 Serial.print(HTTP_req); 
 // Reseta o buffer para 0 
 req_index = 0; 
 StrClear(HTTP_req, REQ_BUF_SZ); 
 break; 
 } 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 194 ] 
 // Cada linha de texto recebidas do cliente termina com \ r \ n 
 if (c == '\n') { 
 
 // Iniciar nova linha com a próxima leitura de caracteres 
 currentLineIsBlank = true; 
 } 
 else if (c != '\r') { 
 // Caracter recebido pelo cliente 
 currentLineIsBlank = false; 
 } 
 } 
 } 
 delay(1); // Dá um tempo para o browser receber os dados 
 client.stop(); // Fecha a conexão 
 } // Fim do laço if (client) 
} 
 
// Envia ao arquivo XML os valores do pino analogico 
void XML_response(EthernetClient cl 
{ 
 
 float tempC; // Cria variável para armazenar temperatura 
 float tempPin = A2; // Declara o pin analógico 0 
 
 
 tempC = analogRead(tempPin); // Lê o valor analógico do sensor LM35 
 tempC = (5.0 * tempC * 100.0)/1024.0; // Converte a entrada de... 
 //temperatura em graus centigrados 
 
 
 
 cl.print(""); 
 cl.print(""); 
 // Lê o pino A2 
 cl.print(""); 
 cl.print(tempC); 
 cl.print(""); 
 cl.print(""); 
} 
 
// Seta todos os elementos de str para 0 (limpa o vetor) 
void StrClear(char *str, char length) 
{ 
 for (int i = 0; i < length; i++) { 
 str[i] = 0; 
 } 
} 
 
Projetos com Arduino por Willian Scollonoff 
 
 
 
[ 195 ] 
char StrContains(char *str, char *sfind) 
{ 
 char found = 0; 
 char index = 0; 
 char len; 
 
 len = strlen(str); 
 
 if (strlen(sfind) > len) { 
 return 0; 
 } 
 while (index < len) { 
 if (str[index] == sfind[found]) { 
 found++; 
 if (strlen(sfind) == found) { 
 return 1; 
 } 
 } 
 else { 
 found = 0; 
 } 
 index++; 
 } 
 
 return 0; 
}