Arduino, ESP e componentes práticos

Arduino
&
ESP 8266
Práticas e
Componentes
www.saladeeletronica.com
Sumário
INTRODUÇÃO. ....................................................................................................... 3
INSTALANDO E CONFIGURANDO O ARDUINO IDE .......................................... 4
ARDUINO COM CONTROLADOR USB CH340 .................................................... 7
ARDUINO WAVGAT ............................................................................................. 10
APRENDENDO SOBRE ALGUNS COMPONENTES .......................................... 13
PRÁTICAS COM ARDUINO: ................................................................................ 16
1 LED piscante com Arduino (BLINK) ................................................................................................... 16

2 Sensor DHT11 de umidade e temperatura com Arduino .............................................................. 19
3 Foto sensor, LDR, acionando LED .................................................................................................... 22
4 Detectando objetos próximos com TCRT5000 ................................................................................ 25
5 Testando controle remoto infravermelho ......................................................................................... 28
6 Chave táctil acionando um LED .......................................................................................................... 32
7 Medindo resistência com o Arduino .................................................................................................. 35
8 Controlando LEDs com controle remoto .......................................................................................... 37
9 Controlando LED RGB com Arduino ................................................................................................. 41
10 Sensor de passagem com laser ........................................................................................................ 46
11 Dado eletrônico ..................................................................................................................................... 49
12 Semáforo ................................................................................................................................................... 54
13 Piano com Arduino ............................................................................................................................... 57
14 Seqüencial de LEDs com botão ........................................................................................................ 63
15 Gráfico de Barra com LEDs................................................................................................................ 65
CONFIGURANDO O NODEMCU NO IDE ARDUINO .......................................... 67
PRÁTICAS COM NODEMCU: .............................................................................. 72
1 Dado eletrônico com NodeMCU ........................................................................................................... 72

2 Controlando LED via wifi com o NodeMCU ............................................................................................ 76
3 Monitoramento de luminosidade e sinal wifi com NodeMCU ....................................................... 82
Introdução.
Neste livro abordaremos temas como hardware e software livres, baseados no

projeto Arduino e ESP8266, usaremos como base desenhos semelhantes a
realidade e alguns módulos que facilitam as montagens, não sendo imprescindível
o conhecimento profundo da eletrônica.
O livro funciona da seguinte maneira: os primeiros temas abordados lhe darão
as instruções necessárias para a instalação e configuração do Arduino IDE, que é
o programa que facilitará a carga do código nas placas Arduino e ESP8266, você
também aprenderá conceitos básicos sobre alguns componentes eletrônicos. Na
seqüência são apresentadas algumas práticas que farão com que você evolua nos
seus conhecimentos de maneira gradativa. Ao concluir as práticas você estará
confiante e capacitado para criar seus próprios projetos. Será capaz de adaptar
suas novas habilidades e o conhecimento adquirido para criar novas práticas.
O Arduino e o ESP8266 são produtos excelentes, divertidos e de fonte
aberta. Com o auxilio deste livro, você descobrira como é fácil envolver-se na
computação física e criar seus próprios dispositivos que interagem com o
ambiente.
Instalando e Configurando o Arduino IDE
O software Arduino (IDE), de código aberto, facilita a gravação do programa na

placa Arduino. Ele é executado no Windows, Mac OS X e Linux. O ambiente é
escrito em Java e baseado em Processing e outro software de código aberto.
Este software pode ser usado com qualquer placa Arduino.
Para baixar o software acesse o link abaixo:
Link: https://www.arduino.cc/en/main/software
Escolha a versão mais adequada;
Após baixar o arquivo o arquivo executável, clique nele para iniciar a

instalação. Continue clicando nas telas para terminar a instalação.
Ao finalizar a instalação será criado um ícone na área de trabalho;
Para abrir o Arduino IDE basta clicar no ícone;

Conecte a placa Arduino na USB;
Em seguida na aba Ferramentas escolha a placa Arduino com a qual irá
trabalhar;
Na aba Ferramentas selecione a porta na qual seu Arduino está conectado;
Caso não apareça a porta para selecionar, mesmo com a placa Arduino
conectada, você pode ter adquirido um Arduino com controlador USB CH340;
Arduino com controlador USB CH340
Caso sua placa Arduino tenha o controlador USB CH340, será necessário
instalar um driver para que ela seja reconhecida.
Para verificar se isto está ocorrendo, verifique a placa e acesse o Painel de

Controle do computador, Gerenciador de Dispositivos. Ao conectar o Arduino a
lista irá atualizar e aparecerá uma mensagem de falha (!) como na imagem abaixo:
Baixe o driver no link:
https://sparks.gogo.co.nz/assets/_site_/downloads/CH340_WINDOWS.zip
Ou utilize o driver do CD, está na pasta Driver Arduino.Info.
Descompacte o arquivo CH340 ou abra a pasta CH341SER e clique no SETUP

mais adequado ao seu computador. (32 ou 64).
Será aberta uma tela igual à abaixo, clique em Install.

Após a instalação, retorne ao Gerenciador de Dispositivos do Painel de
Controle do computador, com o Arduino conectado, clique em Portas ( COM e
LPT), verá que a USB-SERIAL CH340 foi instalada e no caso abaixo como COM
3.
Após seguir estes passos pode abrir o ARDUINO IDE novamente e em

ferramentas selecionar a porta correspondente.
Arduino WAVGAT
Diferenças básicas do Arduino WAVGAT para o convencional.
* Processador: AVGA328p ou LGT8F328D ao invés do ATMEGA328P

* Pinos GPIO: 3,3V ao invés de 5V
* Pinos ADC: 3,3V ao invés de 5V
* ADC: 12 bits ao invés de 10 bits (mas pode ser configurado como 10 bits)
* Portas com PWM: 5/6/9/10/11 ao invés de 3/5/6/9/10/11
Caso sua placa Arduino seja WAVGAT, alguns arquivos devem ser copiados
para o ARDUINO IDE.
- Baixe o arquivo UPDATE do link abaixo:

Link : https://drive.google.com/open?id=10gwrG9uTDwaEO-7EudsmBkfgdcyrcABI
Ou copie do CD, caso tenha em mãos.
- Abra a pasta Update,

- Copie o conteúdo do arquivo hardware para o arquivo Hardware do Arduino IDE;
- Copie o conteúdo do arquivo libraries para o arquivo Libraries do Arduino IDE;
Pastas de arquivos do ARDUINO IDE:

- Com o programa Arduino IDE aberto selecione a placa:
WAVGAT.
Pronto, pode utilizar sua placa WAVGAT.

Aprendendo sobre alguns componentes
LED: Diodo Emissor de LUZ.
O LED é um Diodo Emissor de Luz, ao conduzir corrente, na polarização

correta, ele emite luz.
Nas nossas práticas o LED normalmente é conectado assim: no terminal

positivo temos o jumper vermelho, com um resistor ligado em série para limitar a
corrente, no negativo temos um jumper preto.
Nota: Para que o LED não seja submetido a uma corrente elétrica elevada é
necessário a utilização de um resistor. LEDs comuns normalmente conduzem em
torno de 20 mA.
Resistor de 220 ohms.
O resistor é um componente utilizado para limitar a corrente elétrica.

Na primeira imagem temos um com 5 cores, se lermos da esquerda para a
direita as 3 primeiras cores se referem aos números 2, 2 e 0 e a quarta cor é o
multiplicador (x1), assim temos 220 x 1 ohms que é 220 ohms. A quinta cor se
refere a tolerância que no caso é de 1%.
Na segunda imagem temos um resistor com 4 cores, se lermos da esquerda

para a direita as 2 primeiras cores se referem aos números 2, 2 e a terceira cor é o
multiplicador (x10), assim temos 22 x 10 ohms que é 220 ohms. A quarta cor se
refere a tolerância que no caso é de 5%.
Tabela de códigos de cores para resistores
Chave táctil.
A chave táctil de 4 terminais possibilita que quando houver toque no botão o

circuito feche entre os terminais 1 e 2 e os terminais 3 e 4.
Nota: Há vários outros tipos de chaves.

Protobord.
O protobord é uma ferramenta que facilita a montagem de circuitos eletrônicos,

ele possuí vários furos, alguns são interligados. Esta interligação entre alguns
furos permite conectar componentes eletrônicos de forma temporária para testes,
por exemplo.
A figura 2 mostra a interligação dos furos.
Figura 1 Figura 2
O circuito montado abaixo possibilita que ao acionar a chave táctil o LED

acenda.
Vamos fazer uma rápida análise do circuito, os pontos em verde são os pontos
que possibilitam a interligação do resistor com o jumper, por exemplo, e assim
com os demais componentes. Observe a Figura 2 com a Figura 3 e 4, você vai
verificar que as interligações mostradas na Figura 2 possibilitam a interligação dos
componentes.
Figura 3 Figura 4
Aprenderemos mais sobre os componentes nas práticas.

Práticas com Arduino:
1 LED piscante com Arduino (BLINK)
Um das práticas mais simples para quem está iniciando no uso do Arduino é
utilizar os códigos dos exemplos do ARDUINO IDE, um destes exemplos é o
BLINK (piscar). Este programa fará com que um LED pisque de forma
intermitente.
A placa Arduino UNO normalmente vem com um LED ligado ao pino 13, assim
não é necessário montar um circuito.
Se não estiver trabalhando com uma placa ARDUINO UNO ou quiser montar o
circuito para praticar, siga as instruções.
Componentes a serem utilizados:
- LED;
- Protobord;
- Resistor de 220 ohms;
- Jumpers Macho & Macho;
- Arduino;
Faça a montagem abaixo:

Nota: Se estiver trabalhando com outra placa Arduino, verifique no programa qual
o pino do Arduino a ser utilizado.
Executando o programa.
Ao abrir o ARDUINO IDE verá algumas abas na parte superior da tela, clique em
Arquivos, Exemplos, 01.Basics e Blink.
Uma outra tela com o programa aparecerá.

Clique na SETA à direta e o programa será verificado e carregado no Arduino,
após a carga o LED irá piscar.
Programa BLINK:
/*
Blink
Acende um LED por um segundo, depois desliga por um segundo, repetidamente.
A maioria dos Arduinos tem um LED on-board que você pode controlar. UNO, MEGA e
ZERO está ligado ao pino digital 13, no MKR1000 no pino 6. LED_BUILTIN está definido
para o pino de LED correto independente de qual placa é usada.
Este código de exemplo é de dominio público.
*/
// a função de configuração é executada uma vez quando você pressiona reset ou ligar a
placa
void setup() {
// inicialize o pino digital LED_BUILTIN como uma saída.
pinMode(LED_BUILTIN, OUTPUT);
}
//
a função loop é executada repetidamente para sempre
void loop() {
digitalWrite(LED_BUILTIN, HIGH); // Liga o LED
delay(1000); // aguarda um segundo
digitalWrite(LED_BUILTIN, LOW); // Desliga o LED
delay(1000); // aguarda um segundo
}
Nota: O termo “LED_BUILTIN” pode ser substituído pelo número do pino que se
quer acionar.
2 Sensor DHT11 de umidade e temperatura com Arduino
O DHT11 é um sensor de temperatura e unidade relativa, que permite medir

temperaturas de 0 a 50 Celsius, e umidade na faixa de 20 a 90%. Sua faixa de
precisão para temperatura é de 2 graus, e de umidade, 5%.
Módulo DHT11:
Na prática descrita neste artigo vamos ler as informações do sensor e

apresenta essas informações no monitor serial do ARDUINO IDE.
Componentes necessários:
1 Arduino;
1 Módulo DHT 11;
3 jumpers M&M;
1 Protobord;
Montagem:
Arduino DHT11
Pino 5V VCC
Pino GND GND
Pino A1 DATA
Para utilizar o DHT11 com o Arduino e programar no Arduino IDE é necessário

instalar uma biblioteca, que pode ser baixada no link:
http://hobbyist.co.nz/sites/default/files/WeatherStation/DHT.zip
Após descompactar o arquivo baixado e incluí-lo na biblioteca do Arduino IDE,

podemos programar o Arduino.
O programa abaixo faz com que o Arduino leia as informações do sensor e
apresenta essas informações no monitor serial do Arduino IDE.
Copie e cole o código abaixo no Arduino IDE.
Código:
#include <dht.h>
#define dht_dpin A1
dht DHT;
voidsetup()
{
Serial.begin(9600);
delay(1000);
}
voidloop()
{
DHT.read11(dht_dpin);
Serial.print("Umidade = ");
Serial.print(DHT.humidity);
Serial.print("% ");
Serial.print("Temperatura = ");
Serial.print(DHT.temperature);
Serial.println("Celsius ");
delay(2000);
}
Carregue o código no Arduino abra o monitor serial e você verá a leitura de

temperatura e umidade.
Se ficou em dúvida sobre algum procedimento do artigo, no site abaixo há

artigos que explicam como incluir bibliotecas no Arduino IDE, instalar o Arduino
IDE e etc.
Link: www.saladeeletronica.com
3 Foto sensor, LDR, acionando LED
Neste artigo vamos aprender a utilizar o LDR, Resistor Dependente de Luz, e

acender um LED quando escurecer.
O LDR, Resistor Dependente de Luz ou fotorresistência, é um componente
eletrônico passivo do tipo resistor variável, mais especificamente, é um resistor
cuja resistência varia conforme a intensidade da luz que incide sobre ele.
Componentes necessários.
Para fazer a prática vamos utilizar os componentes abaixo:
1 Arduino Uno;
1 LDR;
jumpers M&M;
1 LED
1 Protobord
1 Resistor de 220 ohms
1 Resistor de 10.000 ohms ou 10K ohms
Estes e outros componentes podem ser adquiridos no link:

https://lista.mercadolivre.com.br/_CustId_26327889
Montagem:
O pino digital 10 vai acionar o LED, a corrente é limitada por um resistor de 220
ohms, o pino A5 está ligado entre o LDR e o resistor de 10K ohms.
Programando o Arduino:
O programa abaixo faz com que o Arduino leia as informações de resistência do
sensor e quando a luz parar de incidir sobre ele a resistência se altera e um LED
acenda.
Copie e cole o código abaixo no ARDUINO IDE.
Código:
int portaLed = 10; //define pino digital 10 LED

int portaLDR = A5; //define pino analógico 5 para sensor
void setup()
{
pinMode(portaLed, OUTPUT);
}
void loop()
{
int estado = analogRead(portaLDR);
if (estado > 500)
{
digitalWrite(portaLed, HIGH);
}
else
{
digitalWrite(portaLed, LOW);
}
}
Para testar o circuito, tampe o LDR, o LED deve acender.

4 Detectando objetos próximos com TCRT5000
Neste artigo vamos aprender a utilizar o Sensor Reflexivo IR para acionar um

LED em conjunto com o Arduino Uno. O sensor está sendo usado como sensor de
presença, qualquer objeto que se aproxima do sensor é reconhecido e aciona um
LED, que poderia ser um relé ou outro componente.
Sobre os principais componentes:
O TCRT5000 é um sensor reflexivo que possui embutido um emissor

infravermelho e um fototransistor. O emissor é um led infravermelho que emite um
sinal nessa faixa do espectro. Já o fototransistor é o receptor que faz a leitura do
sinal refletido. A distância máxima de detecção não é grande, ficando em torno de
25mm (dois centímetros e meio), o que pode limitar um pouco a sua aplicação. O
fototransistor vem com um filtro de luz ambiente, o que maximiza a identificação
do feixe infravermelho refletido.
1 Arduino Uno;
jumpers M&M;
jumpers M&F;
1 TCRT5000;
1 LED,
2 Resistor de 220 ohms,

Montagem:
O pino A3 do Arduino recebe um sinal quando um objeto se aproximar do
Receptor Reflexivo, neste momento o Arduino acionará a porta digital 13 e o LED
acenderá.
O código abaixo fará com que qualquer objeto que se aproxime do sensor seja
reconhecido e LED.
Copie o código e cole na tela do Arduino IDE.
Código:
int ledPin = 13; // define o pino digital 13

int analogPin = 3; // define o pino analógico 13
int val = 0;
void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop() {
val = analogRead(analogPin);
Serial.println(val);
delay(500);
if (val > 1000)
digitalWrite(ledPin, OUTPUT);
else
digitalWrite(ledPin, LOW);
}
No lugar do LED podem ser usados outros componentes como um buzzer

ativo ou um Relé que possibilita o acionamento de vários componentes como
lâmpadas ou travas.
5 Testando controle remoto infravermelho
Neste projeto vamos aprender a montar um testador de controle remoto

infravermelho utilizando um receptor de infravermelho no Arduino. Isso é útil para
os casos em que temos dúvidas se um controle de uma TV, por exemplo , está
funcionando.
Lista de componentes:
1 - Arduino Uno;
1 - Controle remoto IR para teste;
1 - Receptor IR;
1 - Protobord;
Alguns jumpers;
Sobre o principal componente:
Existem vários receptores de Infravermelho, abaixo mostro alguns modelos.
VS1838 - Receptor Infravermelho Universal
Se trata de um receptor infravermelho miniaturizado para controle e outras

aplicações que exigem melhor rejeição de luz ambiente.
TSOP38238 - Receptor Infravermelho
Se trata de um receptores para sistemas de controle remoto infravermelho.
Nota: O circuito para aplicação é o circuito a ser montado sugerido pelo fabricante.
KY-022
O Módulo receptor infravermelho modelo KY-022 para utilização em projetos

eletrônicos de sistemas de controle remoto por IR, alarmes e outras aplicações.
O módulo contém um receptor IR 1838 que funciona com tensões entre 2,7 e 5,5V
comunicando-se com o microcontrolador por meio de um único pino de sinal.
Circuito a ser montado:
Para que a placa Arduino leia os códigos do controle remoto, precisamos de

uma biblioteca externa, a biblioteca IRremote, você pode obter a biblioteca
IRremote aqui.
https://github.com/z3t0/Arduino-IRremote
Baixe a biblioteca, clicando em Clone or download e depois em Download ZIP.
Carregue a biblioteca .ZIP na biblioteca do Arduino IDE.

E então executamos o código abaixo para identificar o código dos botões do
controle.
Nota: Se você tiver algum erro ao executar esta biblioteca, remova

“IRremoteTools.cpp” das bibliotecas \ RobotIRremote \ IRremoteTools.cpp
Código Arduino para receber IR como código hexadecimal
#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Inicia o receptor
}
void loop() {
if (irrecv.decode(&results)) {
Serial.println(results.value, HEX);
irrecv.resume(); // Recebe o próximo valor
}
}
Abra o monitor serial, na lupa, para ver os códigos emitidos pelo controle remoto.
Ao apertar alguns botões, no controle remoto, em direção ao receptor, com o

monitor serial aberto verá que estes códigos aparecerão na tela.
No caso acima foram recebidos os códigos: FF807F, FFA05F e FF906F.
Assim verificamos o funcionamento do controle remoto.
6 Chave táctil acionando um LED
Neste artigo vamos aprender a utilizar a chave táctil para acionar um LED.
Vai funcionar assim, quando a chave táctil for acionada o LED acenderá e
apagará quando a chave táctil for acionada novamente.
Sobre o principal componente:
A chave táctil ou push button de 4 terminais possibilita que quando houver

toque no botão o circuito feche entre os terminais 1 e 2 e os terminais 3 e 4.
1 Arduino Uno;
1 Chave táctil;
jumpers M&M;
1 LED
1 Protobord

Montagem:
O pino digital 2 vai acionar o LED, o pino digital 12 vai receber o sinal quando a
chave táctil for acionada. O resistor de 220 ohms junto ao LED serve para limitar a
corrente. A tensão, no resistor de 220 ohms junto a chave, muda de valor, de 0V à
5V, conforme o acionamento da chave.
O programa abaixo faz com que o Arduino leia as informações recebidas no
pino digital 2, quando a chave táctil for acionada o sinal mudará de 0V(Low) para
5V (High), essa informação fará com que o LED acenda, para um primeiro pulso
na chave, e apague para um segundo pulso na chave.
Copie e cole o código abaixo no ARDUINO IDE e execute-o.
Código:
int led=2; // define como led o pino 2

int botao=12; // define como botão o pino 12
int var=0;
int var2=0;
int estado=0; // guarda o valor 0 ou 1 (High ou Low)
void setup()
{
pinMode(led,OUTPUT);
pinMode(botao,INPUT);
}
void loop()
{
var=digitalRead(botao); // ler o valor enviado pelo botão: "High" ou "Low"
if ((var == HIGH) && (var2 == LOW)) {
estado = 1 - estado;
delay(20); // de-bouncing
}
var2=var;
if (estado == 1) {
digitalWrite(led, HIGH); // liga o led
} else {
digitalWrite(led, LOW); // desliga o led
}
}
Você pode trocar o LED por um Relé, e assim pode acionar outros
componentes.
7 Medindo resistência com o Arduino
Neste artigo vamos aprender a utilizar o Arduino para medir o valor de

resistência elétrica de um resistor. Isto pode ser muito útil quando não se tem um
Ohmímetro ou multímetro.
Na prática testei resistores de 100 à 2000 ohms, os valores medidos foram
próximos do valor real, e dentro da margem de tolerância.
1 Arduino Uno;
jumpers M&M;
1 Protobord
Vários resistores para testar.

Montagem:
No espaço do R. teste deve ser inserido o resistor que se quer testar. O pino
A0 está ligado entre o resistor de 1000 ohms e o R. teste.
O programa abaixo faz com que o Arduino leia as informações recebidas no
pino A0 e converta em um valor de resistência. O valor medido é mostrado no
monitor serial do Arduino IDE.
Copie e cole o código abaixo no ARDUINO IDE e execute-o.
Código:
void setup() {
Serial.begin(9600);
}
void loop() {
float tensao = (float)analogRead(A0)*5/1023;
float R1 = (1000*5 - tensao*1000)/tensao;
Serial.println(R1);
delay(1000);
}
Após carregar o código no arduino, clique na lupa do Arduino IDE. Isto irá abrir
a tela do monitor serial e lá será mostrado o valor do R. teste.
Troque o R. teste por valores diversos, o valor da resistência será mostrado no

monitor serial.
8 Controlando LEDs com controle remoto
Neste projeto vamos utilizar um controle remoto e o receptor de infravermelho

(IR) para controlar 3 LEDs com um controle remoto. Vamos LIGAR e
DESLIGAR os LEDs pressionando alguns dos botões do controle remoto.
Nota: Você pode utilizar controles que já tem, como o da TV. Mas utilize controles
de infravermelho.
1 - Arduino Uno;
1 - Controle remoto;
1 - Receptor IR;
1 - Protobord;
3 - LED's;
3 - Resistores de 220 ohms;
Alguns jumpers;

Para que a placa Arduino leia os códigos do controle remoto pela placa
Arduino, precisamos de uma biblioteca externa, a biblioteca IRremote, você pode
obter a biblioteca no link abaixo:
Link: https://github.com/z3t0/Arduino-IRremote
Para ver como inserir uma nova biblioteca no Arduino IDE, acesse o link abaixo:
Link: https://www.arduino.cc/en/Guide/Libraries
Neste projeto, primeiro executamos o programa de exemplo IRrecvDemo a

partir do exemplo da biblioteca IR do arduino, para identicar o código dos botões
do controle.
(Nota: Se você tiver algum erro ao executar esta biblioteca, remova

“IRremoteTools.cpp” das bibliotecas \ RobotIRremote \ IRremoteTools.cpp)
Ou copie e cole o código abaixo no Arduino IDE
Código Arduino para receber IR como código hexadecimal
int RECV_PIN = 11;
void setup()
{
Serial.begin(9600);
irrecv.enableIRIn(); // Inicia o receptor
}
void loop() {
Serial.println(results.value, HEX);
irrecv.resume(); // Recebe o próximo valor
}
}
Abra o monitor serial e veja os códigos recebidos do controle:
Em seguida, usamos os dados decodificados como condição de comutação no

programa para ligar e desligar os três LEDs.
Copie e cole o código abaixo no Arduino IDE, execute-o.
Código Arduino Para Controle Remoto IR
int RECV_PIN = 11; //

int output1 = 2;
int output2 = 4;
int output3 = 6;
int itsONled[] = {0,0,0,0};
#define code1 0xFF807F // Código encontrado no monitor serial

#define code2 0xFFA05F // Código encontrado no monitor serial
#define code3 0xFF906F // Código encontrado no monitor serial
void setup()
{
Serial.begin(9600); //
irrecv.enableIRIn(); //
pinMode(output1, OUTPUT);
}
void loop() {
unsigned int value = results.value;
switch(value) {
case code1:
if(itsONled[1] == 1) { //
digitalWrite(output1, LOW); //
itsONled[1] = 0; //
} else { //
digitalWrite(output1, HIGH); //
itsONled[1] = 1; //
}
break;
case code2:
if(itsONled[2] == 1) {
digitalWrite(output2, LOW);
itsONled[2] = 0;
} else {
digitalWrite(output2, HIGH);
itsONled[2] = 1;
}
break;
case code3:
if(itsONled[3] == 1) {
digitalWrite(output3, LOW);
itsONled[3] = 0;
} else {
digitalWrite(output3, HIGH);
itsONled[3] = 1;
}
break;
}
Serial.println(value); // Você pode comentar esta linha
irrecv.resume(); // Receber o próximo valor
}
}
Neste programa nós usamos os códigos encontrados no monitor serial.
code1 como 0xFF807F

code2 como 0xFFA05F
code3 como 0xFF906F
Você pode alterar estes códigos de acordo com o código recebido no Monitor
serial a partir do primeiro código executado no arduino IDE.
9 Controlando LED RGB com Arduino
Neste projeto vamos aprender a controlar as cores de um LED RGB com o

auxilio do Arduino.
1 - Arduino Uno;
1 - LED RGB de 4 terminais
3 - Resistores de 220 ohms
1 - Potenciômetro de 2 K ohms
1 - Protobord;
Alguns jumpers;
Sobre o principais componentes:
LED RGB com 4 terminais, anodo comum. Possui 4 terminais um para a cor
vermelha, outro para a cor verde, outro para a cor azul e o quarto terminal é
comum. Pode se dizer que são 3 LEDs em um, o consumo é de aproximadamente
20 mA para cada terminal.
Potenciômetro, tem a característica de variar a resistência elétrica conforme a
ação em seu eixo, no nosso caso, conforme se gira o eixo. Veja que os terminais
A e B, da figura abaixo, são fixos e tem uma resistência fixa. O terminal W está
ligado a um cursos que está em contato com a trilha e conforme desliza nesta
trilha altera a resistência entre o terminal central e os laterais.
O pino digital 3 do Arduino é ligado ao “red Cathode” do diodo, o pino digital 5 é

ligado ao “blue cathode”, o pino digital 6 é ligado ao “ green cathode” e o 5V é
ligado ao “commonn anode”, lembrando deve ser colocado um resistor em série,
para limitar a corrente, nos os pinos 3, 5 e 6.
O controle fica por conta de um potenciômetro de 2K ohms ligado ao pino A2,
5V e GND do Arduino.
O código abaixo fará com que ao girar o potenciômetro, as tensões, nos pinos
3, 5 e 6 mudem, assim com tensões diferentes mos terminais do LED ele mudará
de cor.
Código.
Copie e cole o código abaixo na tela do Arduino IDE. Em seguida execute-o.
int pinPotenciometer = 2;
int pinRed = 3;
int pinBlue = 5;
int pinGreen = 6;
float h; // Hue range
int h_int; // Hue color
int r = 0, g = 0, b = 0; // Default RGB values
int val = 0; // Set POT value to default 0
// Instantiate h2rgb and it's variables a.k.a Hue to RGB

void h2rgb(float h, int& R, int& G, int& B);
void setup()
{
Serial.begin(9600);
}
void loop()
{
val = analogRead(pinPotenciometer); // Read the pin and display the value
h = ((float)val) / 1024; // Get the range. pot value / 1024
h_int = (int) 360*h; // Get the color hue by multiplying by 360
h2rgb(h,r,g,b); // Call the h2rgb function passing it the hue value
Serial.print("POT value: ");
Serial.print(val); // Pot value
Serial.print(" = Hue of ");
Serial.print(h_int); // Color Hue value
Serial.print(" degrees. RGB values: ");
Serial.print(r); // Red value
Serial.print(" ");
Serial.print(g); // Green value
Serial.print(" ");
Serial.println(b); // Blue value
analogWrite(pinRed, r); // Changes red led

analogWrite(pinGreen, g); // Changes green led
analogWrite(pinBlue, b); // Changes blue led
}
void h2rgb(float h, int& R, int& G, int& B) {

// Used HSV --> RGB function
// HSV - Hue, Saturation, Value
// RGB - Red, Green, Blue - example (255,255,255)
// Function below does a bunch of math to convert HSV values to RGB
int var_i;
float S=1, V=1, var_1, var_2, var_3, var_h, var_r, var_g, var_b;
if ( S == 0 ) //HSV values = 0 ÷ 1
{
R = V * 255;
G = V * 255;
B = V * 255;
}
else
{
var_h = h * 6;
if ( var_h == 6 ) var_h = 0; //H must be < 1
var_i = int( var_h ) ; //Or ... var_i = floor( var_h )
var_1 = V * ( 1 - S );
var_2 = V * ( 1 - S * ( var_h - var_i ) );
var_3 = V * ( 1 - S * ( 1 - ( var_h - var_i ) ) );
if ( var_i == 0 ) {
var_r = V ;
var_g = var_3 ;
var_b = var_1 ;
}
else if ( var_i == 1 ) {
var_r = var_2 ;
var_g = V ;
var_b = var_1 ;
}
var_r = var_1 ;
var_g = V ;
var_b = var_3 ;
}
var_r = var_1 ;
var_g = var_2 ;
var_b = V ;
}
var_r = var_3 ;
var_g = var_1 ;
var_b = V ;
}
else {
var_r = V ;
var_g = var_1 ;
var_b = var_2 ;
}
R = (1-var_r) * 255; //RGB results = 0 ÷ 255

G = (1-var_g) * 255;
B = (1-var_b) * 255;
}
}
Após carregar o código no Arduino, você pode girar o potenciômetro, as cores

do LED deverão mudar.
10 Sensor de passagem com laser
Neste projeto vamos aprender a fazer um controle de passagem com laser. O

fato de estarmos utilizando um lazer possibilita que a distância monitorada seja
maior.
1 - Arduino Uno;
1 - LED;
2 - Resistores de 220 ohms
1 - Protobord;
1 - LDR;
Alguns jumpers;
Módulo Laser Ky-008 , possuí 3 terminais, “S” de sinal, “-“ conectado ao

negativo da fonte de alimentação e o terminal central que deve ser conectado ao
positivo da fonte de alimentação, suas principais características são:
• Tensão de Operação: 5v
• Potência: 5mW
• Comprimento de onda: 650N.m OD 6 milímetros
Nota: A luz do laser pede ser perigosa se emitida diretamente aos olhos.
LDR, Resistor Dependente de Luz ou fotorresistência, é um componente

eletrônico passivo do tipo resistor variável, mais especificamente, é um resistor
cuja resistência varia conforme a intensidade da luz que incide sobre ele.
O pino A0 do Arduino irá receber 5V quando a luz recebida pelo LDR do laser
for interrompida, fazendo com que os pinos digitais 6 e 7 acionem o LED e o
Buzzer ativo.
O código abaixo fará com que o buzzer ativo e o LED sejam acionados quando
a luz do laser for interrompida.
Código.
int sensorPin=A0;
int sensorValue=0;
void setup(){
pinMode(sensorPin,INPUT);
pinMode(7,OUTPUT);
pinMode(6,OUTPUT);
digitalWrite(7,HIGH);
digitalWrite(6,LOW);
}
void loop(){
sensorValue=analogRead(sensorPin);
if(sensorValue<=1000)
{
digitalWrite(7,HIGH);
} else
{
digitalWrite(7,LOW);
}
sensorValue=1000;
}
Após carregar o código no Arduino, você pode interromper a luz que o laser
emite sobre o LDR, o Buzzer e o LED serão acionados.
11 Dado eletrônico
Neste projeto vamos aprender a fazer um dado eletrônico. Com ele os jogos
que utilizam dado vão ficar mais tecnológicos. Ao acionar a chave táctil o display
irá mostrar um número aleatório de 1 à 6.
1 - Arduino Uno;
1 - Chave táctil;
1 - Protobord;
1 - Display de 7 segmentos;
Alguns jumpers;
Display de 7 segmentos, são comumente usados em eletrônica como forma

de exibir uma informação alfanumérica. Ele é composto de 8 LEDs, 7 mostram a
informação alfanumérica e 1 é o ponto. O mostrado abaixo é de catodo comum.
O pino digital 5 do Arduino irá receber 5V quando a chave táctil for acionada,
isto dará inicio ao sorteio de um número de 1 à 6 que será mostrado no display.
O display será ligado aos pinos digitais de 6 à 12.
O código abaixo fará com que, ao acionar a chave táctil ocorrerá um sorteio
aleatório de um número de 1 à 6 e ele será mostrado no display.
Código.
int segE = 7;
int segD = 8;
int segC = 9;
int segB = 12;
int segA = 6;
int segF = 11;
int segG = 10;
int pinoTilt = 5;
void setup()
{
pinMode(segE, OUTPUT);
pinMode(segD, OUTPUT);
pinMode(segC, OUTPUT);
pinMode(segB, OUTPUT);
pinMode(segA, OUTPUT);
pinMode(segF, OUTPUT);
pinMode(segG, OUTPUT);
pinMode(pinoTilt, INPUT);
}
void loop()
{
if(digitalRead(pinoTilt) == HIGH)
{
jogaDado();
}
}
void jogaDado()
{
for(int i=0; i<25; i++)
{
switch(random(1, 6)) // Escolhe um numero aleatorio entre 1 e 6
{
case 1 :
acende1();
break;
case 2 :
acende2();
break;
case 3 :
acende3();
break;
case 4 :
acende4();
break;
case 5 :
acende5();
break;
case 6 :
acende6();
break;
}
delay(4*i); // O delay aumenta conforme passam mais numeros
}
}
void acende1()
{
digitalWrite(segE,LOW);
digitalWrite(segD,LOW);
digitalWrite(segC,HIGH);
digitalWrite(segB,HIGH);
digitalWrite(segA,LOW);
digitalWrite(segF,LOW);
digitalWrite(segG,LOW);
}
void acende2()
{
digitalWrite(segE,HIGH);
digitalWrite(segD,HIGH);
digitalWrite(segC,LOW);
digitalWrite(segA,HIGH);
digitalWrite(segG,HIGH);
}
void acende3()
{
}
void acende4()
{
digitalWrite(segA,LOW);
digitalWrite(segF,HIGH);
}
void acende5()
{
digitalWrite(segB,LOW);
}
void acende6()
{
}
Após carregar o código no Arduino, você pode apertar a chave táctil várias
vezes e ver os números que são sorteados.
12 Semáforo
Neste projeto vamos aprender a fazer um semáforo. Este projeto tem um

semáforo para carros em conjunto com um para pedestres, funcionando em
sincronismo.
1 - Arduino Uno;
2 - LED verde;
2 - LED vermelho;
1 - LED laranja;
1 - Protobord;
Alguns jumpers;
Os pinos digitais 5 à 9 estão ligados aos LEDs, também em cada LED há um

resistor de 220 ohms para limitar a corrente.
Arduino LED
Pino 5 Vermelho pedestre
Pino 6 Verde pedestre
Pino 7 Verde carro
Pino 8 Vermelho carro
Pino 9 Laranja Carro
O código abaixo fará com que os LED’s acendam na seqüência necessária ao

funcionamento sincronizado de um semáforo para carros em conjunto com um
para pedestres.
Código.
Semáforo
int vda = 7;
int vma = 8;
int lra = 9;
int vdp = 6;
int vmp = 5;
void setup()
{
pinMode(vda, OUTPUT);
pinMode(vma, OUTPUT);
pinMode(lra, OUTPUT);
pinMode(vdp, OUTPUT);
pinMode(vmp, OUTPUT);
}
void loop()
{
carro_l();
delay(3000);
alerta();
delay(1000);
pedestre_l();
delay(3000);
void carro_l()
{
digitalWrite(vda, HIGH);
digitalWrite(vma, LOW);
digitalWrite(lra, LOW);
digitalWrite(vdp, LOW);
digitalWrite(vmp, HIGH);
}
void alerta()
{
digitalWrite(vda, LOW);
digitalWrite(vma, LOW);
digitalWrite(lra, HIGH);
digitalWrite(vdp, LOW);
digitalWrite(vmp, HIGH);
}
void pedestre_l()
{
digitalWrite(vda, LOW);
digitalWrite(vma, HIGH);
digitalWrite(lra, LOW);
digitalWrite(vdp, HIGH);
digitalWrite(vmp, LOW);
}
Após carregar o código no Arduino, você verá o funcionamento sincronizado do

semáforo. Em Delay o tempo de cada LED pode ser alterado.
13 Piano com Arduino
Neste projeto vamos aprender a fazer um piano que após tocar uma música ele
repete o que foi tocado.
1 - Arduino Uno;
8 - chaves táctil;
1 - Protobord;
1 - Buzzer;
Alguns jumpers;
Os pinos digitais 2 à 9 estão ligados às chaves táctil e o pino 10 ao Buzzer.
Arduino Componente
Pino 2 Chave repete
Pino 3 Chave tom
Pino 4 Chave tom
Pino 5 Chave tom
Pino 6 Chave tom
Pino 7 Chave tom
Pino 8 Chave tom
Pino 9 Chave tom
Pino 10 Buzzer
O código abaixo fará com que, quando as chaves de tom forem acionadas o
buzzer emitirá o som correspondente e ao acionar a chave repete, a sequência de
tons tocados se repetirá.
Código.
int val=0;
int buzzer = 10;
unsigned long on_time=0;
unsigned long off_time=0;
unsigned long button_ontime[20];
unsigned long button_offtime[20];
int button_seq[20];
int button1=3;
int button2=4;
int button3=5;
int button4=6;
int button5=7;
int button6=8;
int button7=9;
int button8=10;
int frequency[] = {262, 294, 330, 349, 392, 440, 494};
int buttonPin = 2;
int previousState = HIGH;
unsigned int previousPress;
volatile int buttonFlag;
int buttonDebounce = 20;
int path=1;
int i=0;
int led=13;
void playback (void);
void setup()
{
Serial.begin(9600);
pinMode(buzzer,OUTPUT);
pinMode(led,OUTPUT);
///////////////
pinMode(button1,INPUT_PULLUP);
pinMode(buttonPin,INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(2), button_ISR, CHANGE);
analogWrite(buzzer,0);
digitalWrite(led,HIGH);
}
void loop()
{
if(path==0)
{
Serial.println("playback");
playback();
}
if((millis() - previousPress) > buttonDebounce && buttonFlag)
{
previousPress = millis();
if(digitalRead(buttonPin) == LOW && previousState == HIGH)
{
path =! path;
previousState = LOW;
}
else if(digitalRead(buttonPin) == HIGH && previousState == LOW)

{
previousState = HIGH;
}
buttonFlag = 0;
}
if(digitalRead(button1)==LOW)
{
analogWrite(buzzer,frequency[0]);
on_time=millis();
if(i>0)
{
button_offtime[i-1]=on_time-off_time;
}
while(digitalRead(button1)==LOW);
if(path==1)
{
off_time=millis();
button_ontime[i]=(off_time-on_time);
button_seq[i]=0;
i++;
Serial.println("button 1 stored");
}
}
else if(digitalRead(button2)==LOW)
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=1;
i++;
}
}
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=2;
i++;
}
}
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=3;
i++;
}
}
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=4;
i++;
}
}
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=5;
i++;
}
}
{
on_time=millis();
if(i!=0)
if(path==1)
{
off_time=millis();
button_seq[i]=6;
i++;
}
}
}
void playback (void)
{
digitalWrite(led,LOW);
for(int j=0;j<i;j++)
{
analogWrite(buzzer,frequency[button_seq[j]]);
delay(button_ontime[j]);
delay(button_offtime[j]);
}
i=0;
off_time=0;
on_time=0;
path=1;
digitalWrite(led,HIGH);
}
void button_ISR()
{
buttonFlag = 1;
Após carregar o código no Arduino, toque as chaves para testar o piano.

14 Seqüencial de LEDs com botão
Neste projeto vamos aprender a fazer um seqüencial de LED’s acionado por um

botão.
LISTA DE COMPONENTES:
1 - Arduino Uno;
5 - LED’s, cores diversas;
1 - Protobord;
1 - Chave táctil;
5 - Resistores 220 ohms;
1 - Resistor 10 K ohms;
Alguns jumpers;
Os pinos digitais 2 à 6 estão ligados aos LEDs e o 7 a chaves táctil.
Arduino Componente
Pino 2 LED 1
Pino 3 LED 2
Pino 4 LED 3
Pino 5 LED 4
Pino 6 LED 5
Pino 7 Chave
O código abaixo fará com que, quando a chave for acionada os LEDs vão
acender em uma seqüência, copie e cole o código abaixo no Arduino IDE.
Código.
const int led1 = 2;

const int led2 = 3;
const int led3 = 4;
const int led4 = 5;
const int led5 = 6;
const int botao = 7;
int estadoBotao = 0;
void setup() {
pinMode(led1,OUTPUT);
pinMode(botao,INPUT); .
}
void loop() {
estadoBotao = digitalRead(botao);
if (estadoBotao == HIGH) {
digitalWrite(led1,HIGH);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
delay(1000);
} else {
digitalWrite(led1,LOW);
}
}
Após carregar o código no Arduino, toque a chave para testar acendimento
sequencial. Você pode mudar o tempo de Delay para alterar o tempo de
acendimento.
15 Gráfico de Barra com LEDs
Neste projeto vamos aprender a fazer um gráfico de barra que é controlado por
um potenciômetro.
1 - Arduino Uno;
10 - LEDs;
1 - Protobord;
1 - Potenciômetro;
Alguns jumpers;
Os pinos digitais 2 à 11 estão ligados aos LEDs, também em cada LED há um

resistor de 220 ohms para limitar a corrente. O potenciômetro está ligado ao pino
A0, 5V e GND.
Arduino Componente
Pino 2 LED
Pino 3 LED
Pino 4 LED
Pino 5 LED
Pino 6 LED
Pino 7 LED
Pino 8 LED
Pino 9 LED
Pino 10 LED
Pino 11 LED
Pino A0 Potenciômetro
O código abaixo fará com que ao girar o potenciômetro os LEDs acendam em

seqüência.
Código.
const int analogPin = A0;

const int ledCount = 10;
int ledPins[] = {
2, 3, 4, 5, 6, 7, 8, 9, 10, 11
};
void setup() {
for (int thisLed = 0; thisLed < ledCount; thisLed++) {
pinMode(ledPins[thisLed], OUTPUT);
}
}
void loop() {
int sensorReading = analogRead(analogPin);
int ledLevel = map(sensorReading, 0, 1023, 0, ledCount);
for (int thisLed = 0; thisLed < ledCount; thisLed++) {
if (thisLed < ledLevel) {

digitalWrite(ledPins[thisLed], HIGH);
}
else {
digitalWrite(ledPins[thisLed], LOW);
}
}
}
Após carregar o código no Arduino, você pode girar o potenciômetro para ver o
acendimento seqüencial dos LED’s. Com algumas adaptações podemos trocar o
potenciômetro por uma fonte de som, isto faria com que conforme o som toque os
LEDs acendam na mesma intensidade.
Configurando o NodeMCU no IDE Arduino
O NodeMCU é uma plataforma open source da família ESP8266 criado

para ser utilizado no desenvolvimento de projetos ioT. Esta placa foi iniciada em
2014 e é bem interessante, pois ao contrário de alguns módulos desta família que
necessitam de um conversor USB serial externo para que haja troca de
informações entre computador e o módulo, o NodeMCU já vem com um conversor
USB serial integrado.
Esta plataforma é composta basicamente por um chip controlador
(ESP8266 ESP-12E), uma porta micro USB para alimentação e programação,
conversor USB serial integrado e já possui WiFi nativo.
Abaixo você pode ver as principais características do NodeMCU:

– Processador ESP8266-12E
– Arquitetura RISC de 32 bits
– Processador pode operar em 80MHz / 160MHz
– 4Mb de memória flash
– 64Kb para instruções
– 96Kb para dados
– WiFi nativo padrão 802.11b/g/n
– Opera em modo AP, Station ou AP + Station
– Pode ser alimentada com 5VDC através do conector micro USB– Possui 11
pinos digitais
– Possui 1 pino analógico com resolução de 10 bits
– Pinos digitais, exceto o D0 possuem interrupção, PWM, I2C e one wire
– Pinos operam em nível lógico de 3.3V
– Pinos não tolerantes a 5V
– Possui conversor USB Serial integrado
– Programável via USB ou WiFi (OTA)
– Compatível com a IDE do Arduino
– Compatível com módulos e sensores utilizados no Arduino
O NodeMCU pode ser programado no IDE Arduino, na linguagem padrão do
Arduino.
Isso pode ser feito por meio do gerenciador de placas da IDE do Arduino.
Configuração da IDE Arduino para o NodeMCU
Entre na IDE do Arduino e clique em Arquivo -> Preferências:

Na tela seguinte, digite o link abaixo no campo URLs adicionais de
Gerenciadores de Placas:
LINK: http://arduino.esp8266.com/stable/package_esp8266com_index.json
Clique em OK.
Na sequência clique em Ferramentas -> Placa -> Gerenciador de Placas:
Na próxima tela encontre o esp8266 by ESP8266 Community e clique

em INSTALAR.
Após a instalação a NodeMCU e ass placas da linha ESP8266 já estarão
disponíveis na lista de placas da IDE do Arduino.
No menu da IDE, em Arquivo -> Exemplos, serão adicionados vários

exemplos de uso das placas ESP8266, utiliza alguns dos exemplos para programar
a placa.
Práticas com NodeMCU:
1 Dado eletrônico com NodeMCU
Neste projeto vamos aprender a fazer um dado eletrônico.

Ao acionar a chave táctil, LEDs irão acender e mostrar um número aleatório de 1 à
6.
Com ele os jogos que utilizam dado vão ficar mais tecnológicos.
1 - NodeMCU;
1 - Chave táctil;
1 - Protobord;
6 - LEDs;
Alguns jumpers;
Montagem:
Faça a montagem conforme o desenho abaixo:

Equivalência dos pinos do NodeMCU com o IDE Arduino:
Os projetos para o Arduino podem ser adaptados ao NodeMCU, para isso

é necessário seguir a tela de equivalência.
IDE
NodeMCU Arduino
D0 16
D1 5
D2 4
D3 0
D4 2
D5 14
D6 12
D7 13
D8 15
D9 3
D10 1
Programando o NodeMCU.
O código abaixo irá fazer com que ao acionar a chave táctil de 1 à 6 LED’s
serão acionados aleatoriamente.
Copie o código abaixo no IDE e carregue no NodeMCU.
#include <ESP8266WiFi.h>
int segA = 5;
int segB = 4;
int segC = 0;
int segD = 12;
int segE = 13;
int segF = 15;
int pinoTilt = 14;
void setup()
{
pinMode(segE, OUTPUT);
pinMode(segD, OUTPUT);
pinMode(segC, OUTPUT);
pinMode(segB, OUTPUT);
pinMode(segA, OUTPUT);
pinMode(segF, OUTPUT);
pinMode(pinoTilt, INPUT);
}
void loop()
{
if(digitalRead(pinoTilt) == HIGH)
{
jogaDado();
}
}
void jogaDado()
{
for(int i=0; i<25; i++)
{
switch(random(1, 7)) // Escolhe um numero aleatorio entre 1 e 6
{
case 1 :
acende1();
break;
case 2 :
acende2();
break;
case 3 :
acende3();
break;
case 4 :
acende4();
break;
case 5 :
acende5();
break;
case 6 :
acende6();
break;
}
delay(4*i); // O delay aumenta conforme passam mais numeros
}
}
void acende1()
{
}
void acende2()
{
}
void acende3()
{
}
void acende4()
{
}
void acende5()
{
}
void acende6()
{
}
Testando o experimento.
Após carregar o código, acione a chave e na sequência de 1 à 6 LEds

deverão acender.
2 Controlando LED via wifi com o NodeMCU
Nesta prática iremos programar o NodeMCU para controlar um LED via

Wifi e testar o experimento.
Material necessário:
- NodeMCU
- LED
- Protoboard;
- Resistor ( 220 Ω ou 330 Ω)
- Jumpers
Montagem: D2 -> led -> resistor -> gnd

Equivalência das saídas digitais entre NodeMCU na IDE do Arduino.
Os projetos para o Arduino podem ser adaptados ao NodeMCU, para isso

é necessário seguir a tela de equivalência.
IDE
NodeMCU Arduino
D0 16
D1 5
D2 4
D3 0
D4 2
D5 14
D6 12
D7 13
D8 15
D9 3
D10 1
Programando o NodeMCU.
O código abaixo irá criar uma página na qual você poderá clicar nos
botões e controlar um LED ou outra carga.
Copie o código abaixo no IDE e carregue no NodeMCU.
//Nome da sua rede Wifi

const char* ssid = "nome da rede";
//Senha da rede
const char* password = "senha da rede";
//IP do ESP (para voce acessar pelo browser - voce TEM que mudar este IP tambem)
IPAddress ip(192, 168, 1, 5);
//IP do roteador da sua rede wifi - eu usei o abaixo verifique a sua

IPAddress gateway(192, 168, 1, 1);
//Mascara de rede da sua rede wifi

IPAddress subnet(255, 255, 255, 0);
//Criando o servidor web na porta 80

WiFiServer server(80);
//Pino do NodeMCU que estara conectado ao LED
const int pin = 4; //Equivalente ao D2 no NodeMCU
//Funcao que sera executada apenas ao ligar o ESP8266

void setup() {
//Preparando o pino, que esta lidago ao LED
pinMode(pin, OUTPUT);
digitalWrite(pin, LOW);
//Conectando a rede Wifi

WiFi.config(ip, gateway, subnet);
WiFi.begin(ssid, password);
//Verificando se esta conectado,

//caso contrario, espera um pouco e verifica de novo.
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}
//Iniciando o servidor Web

server.begin();
}
//Funcao que sera executada indefinidamente enquanto o NodeMCU estiver ligado.

void loop() {
//Verificando se o servidor esta pronto.
WiFiClient client = server.available();
if (!client) {
return;
}
//Verificando se o servidor recebeu alguma requisicao

while (!client.available()) {
delay(1);
}
//Obtendo a requisicao vinda do browser

String req = client.readStringUntil('\r');
//Sugestao dada por Enrico Orlando

if(req == "GET /favicon.ico HTTP/1.1"){
req = client.readStringUntil('\r');
}
client.flush();
//Iniciando o buffer que ira conter a pagina HTML que sera enviada para o browser.
String buf = "";
buf += "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE

HTML>\r\n<html>\r\n";
buf += "<head> ";
buf += "<meta charset='UTF-8'> ";
buf += "<meta http-equiv='cache-control' content='max-age=0' /> ";
buf += "<meta http-equiv='cache-control' content='no-cache' /> ";
buf += "<meta http-equiv='expires' content='0' /> ";
buf += "<meta http-equiv='expires' content='Tue, 01 Jan 1980 1:00:00 GMT' /> ";
buf += "<meta http-equiv='pragma' content='no-cache' /> ";
buf += "<title>Automação Residencial</title> ";
buf += "<style> ";
buf += "body{font-family:Open Sans; color:#555555;} ";
buf += "h1{font-size:24px; font-weight:normal; margin:0.4em 0;} ";
buf += ".container { width: 100%; margin: 0 auto; } ";
buf += ".container .row { float: left; clear: both; width: 100%; } ";
buf += ".container .col { float: left; margin: 0 0 1.2em; padding-right: 1.2em; padding-left:
1.2em; } ";
buf += ".container .col.four, .container .col.twelve { width: 100%; } ";
buf += "@media screen and (min-width: 767px) { ";
buf += ".container{width: 100%; max-width: 1080px; margin: 0 auto;} ";
buf += ".container .row{width:100%; float:left; clear:both;} ";
buf += ".container .col{float: left; margin: 0 0 1em; padding-right: .5em; padding-left:
.5em;} ";
buf += ".container .col.four { width: 50%; } ";
buf += ".container .col.tweleve { width: 100%; } ";
buf += "} ";
buf += "* {-moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing:
border-box;} ";
buf += "a{text-decoration:none;} ";
buf += ".btn {font-size: 18px; white-space:nowrap; width:100%; padding:.8em 1.5em;
font-family: Open Sans, Helvetica,Arial,sans-serif; ";
buf += "line-height:18px; display: inline-block;zoom: 1; color: #fff; text-align: center;
position:relative; ";
buf += "-webkit-transition: border .25s linear, color .25s linear, background-color .25s
linear; ";
buf += "transition: border .25s linear, color .25s linear, background-color .25s linear;} ";
buf += ".btn.btn-sea{background-color: #08bc9a; border-color: #08bc9a; -webkit-box-
shadow: 0 3px 0 #088d74; box-shadow: 0 3px 0 #088d74;} ";
buf += ".btn.btn-sea:hover{background-color:#01a183;} ";
buf += ".btn.btn-sea:active{ top: 3px; outline: none; -webkit-box-shadow: none; box-
shadow: none;} ";
buf += "</style> ";
buf += "</head> ";
buf += "<body> ";
buf += "<div class='container'> ";
buf += "<div class='row'> ";
buf += "<div class='col twelve'> ";
buf += "<p align='center'><font size='10'>Controle de lâmpadas</font></p> ";
buf += "</div> ";
buf += "</div> ";
buf += "<div class='row'> ";
buf += "<div class='col four'> ";
buf += "<a href='?f=on' class='btn btn-sea'>Ligar</a> ";
buf += "</div> ";
buf += "<div class='col four'> ";
buf += "<a href='?f=off' class='btn btn-sea'>Desligar</a> ";
buf += "</div> ";
buf += "</div> ";
buf += "<div class='col twelve'> ";
buf += "<p align='center'><font size='5'>www.saladeeletronica.com</font></p> ";
buf += "</div> ";
buf += "</div> ";
buf += "</body> ";
buf += "</html> ";
//Enviando para o browser a 'pagina' criada.

client.print(buf);
client.flush();
//Analisando a requisicao recebida para decidir se liga ou desliga a lampada
if (req.indexOf("on") != -1)
{
digitalWrite(pin, HIGH);
}
else if (req.indexOf("off") != -1)
{
digitalWrite(pin, LOW);
}
else
{
//Requisicao invalida!
client.stop();
}
}
Testando o experimento.
Após carregar o código, abra o browse do seu computador ou celular e

digite o IP do NodeMCU, conforme código acima.
Atenção: O celular ou computador devem estar na mesma rede.
Deve aparecer uma tela igual a abaixo.

3 Monitoramento de luminosidade e sinal wifi com NodeMCU
Nesta prática vamos monitorar a intensidade do sinal wifi e de

luminosidade pelo browser do computator ou celular.
Material necessário:
- NodeMCU;
- Protoboard;
- LDR;
- Resistor de 220 Ω;
- Jumpers;
Montagem:
A porta A0 do NodeMCU é ligada ao resistor e ao LDR, o outro teminal do

resistor é ligado ao GND e o outro terminal do LDR é ligado ao 3,3V.
Faça a montagem do circuito conforme desenho abaixo:

Código.
O código abaixo fará com que o NodeMCU monitore o sinal wifi e leia o
valor do LDR, acesse a rede wifi, gere uma página e mostre as informações de
luminosidade e intensidade de sinal wifi nesta página.
Copie o código abaixo, cole no IDE Arduino e carregue no NodeMCU.
const char* ssid = "nome da rede"; //Configuração de sua rede WiFI
const char* password = "senha";
int ldr = 0; //Setando a utilizaçâo do LDR à porta ADC A0 do Nodemcu

int valorldr = 0;//variáveis aplicadas ao LDR
int id = 1;
signed long rssi = WiFi.RSSI(); //Função "medir" a intensidade do sinal WiFi -

interessante para
//aplicaçôes onde há muitas barreiras, até o ponto onde está localizado //o
roteador.
String myIPAddrStr; //Variável para armazenamento do IP gerado para acesso do

Webservice, optei por ip fixo.
// As funções abaixo são para definiçâo de IP fixo - Caso deseje configurar.
IPAddress ip(192,168,1,5); //Verifque os dados de IP de sua rede // e altere
aqui para o IP Desejado
IPAddress gateway(192,168,1,1); //Gateway da rede
IPAddress subnet(255,255,255,0);//Mascara da rede
WiFiServer server(80); //Definição para o webservice utilizar a porta 80.
void setup() {
Serial.begin(9600);
delay(10);
// Aqui começa a conexão com a rede

Serial.println();
Serial.println();
Serial.print("ESP8266 Conectando à ");
Serial.println(ssid);
WiFi.begin(ssid, password); //Inicia a conexão WiFi, utilizando os parametros

fornecidos.
WiFi.config(ip, gateway, subnet); //Ao setar IP Fixo, descomentar essa linha
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("Conectado");
server.begin();
myIPAddrStr = String(WiFi.localIP().toString());
Serial.println(WiFi.localIP()); //Acesse seu webserver atráves do IP gerado aqui.
}
void loop() {
delay(2000);
rssi = WiFi.RSSI();
valorldr = analogRead(ldr);
WiFiClient client = server.available(); // Comparação se o cliente Wifi, está

disponível
if (!client) {
return;
}
Serial.println("Webserver gerado.");
while(!client.available()){
delay(1);
}
String req = client.readStringUntil('\r');
Serial.println(req);
client.flush();
String url = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE
HTML>\r\n";
//Geração da página HTML
url += "<html>\r\n";
url += "<title>Monitoramento remoto</title>";
url += "<center><h1>Intensidade luminosa e de sinal.</h1>";
url += "<br/>";
url += "<br/>";
url += "<br/>";
url += "<b>Luminosidade = </b>";
url += valorldr;
url += "<br/>";
url += "<b>Intens. Sinal = </b> ";
url += rssi;
url += "<br/>";
url += "<b>IP = </b>";
url += String(myIPAddrStr);
url += "<br/>";
url += "<input type=""button"" value=""Atualizar"" onClick=""history.go(0)"">" ;
//Essa linha gera um botão p/ atualizar a página do webservice.
url += "<br/>";
url += "<br/>";
url += "<br/>";
url += "<br/>";
url += "<br/>";
url += "<br/>";
url += "<b>www.saladeeletronica.com </b>";
url += "</center></html>\n";
client.print(url);
Serial.println();
Serial.println("Fechando a conexão");
delay(30000); //Espera 30 segundos e recomeça o loop.
}
Após carregar o código, abra o browser e coloque o IP do NodeMCU

utlizado no código.
Atenção: O NodeMCU e o computator devem estar na mesma rede wifi.
Deverá aperecer uma tela como essa:

Arduino, ESP e componentes práticos

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Arduino, ESP e componentes práticos

Enviado por

Direitos autorais:

Formatos disponíveis

Arduino

INSTALANDO E CONFIGURANDO O ARDUINO IDE .......................................... 4

ARDUINO COM CONTROLADOR USB CH340 .................................................... 7

ARDUINO WAVGAT ............................................................................................. 10

APRENDENDO SOBRE ALGUNS COMPONENTES .......................................... 13

PRÁTICAS COM ARDUINO: ................................................................................ 16

1 LED piscante com Arduino (BLINK) ................................................................................................... 16

CONFIGURANDO O NODEMCU NO IDE ARDUINO .......................................... 67

PRÁTICAS COM NODEMCU: .............................................................................. 72

1 Dado eletrônico com NodeMCU ........................................................................................................... 72

Neste livro abordaremos temas como hardware e software livres, baseados no

O software Arduino (IDE), de código aberto, facilita a gravação do programa na

Este software pode ser usado com qualquer placa Arduino.

Para baixar o software acesse o link abaixo:

Escolha a versão mais adequada;

Após baixar o arquivo o arquivo executável, clique nele para iniciar a

Para abrir o Arduino IDE basta clicar no ícone;

Na aba Ferramentas selecione a porta na qual seu Arduino está conectado;

Para verificar se isto está ocorrendo, verifique a placa e acesse o Painel de

Ou utilize o driver do CD, está na pasta Driver Arduino.Info.

Descompacte o arquivo CH340 ou abra a pasta CH341SER e clique no SETUP

Será aberta uma tela igual à abaixo, clique em Install.

Após seguir estes passos pode abrir o ARDUINO IDE novamente e em

Diferenças básicas do Arduino WAVGAT para o convencional.

* Processador: AVGA328p ou LGT8F328D ao invés do ATMEGA328P

- Baixe o arquivo UPDATE do link abaixo:

Ou copie do CD, caso tenha em mãos.

- Abra a pasta Update,

- Copie o conteúdo do arquivo libraries para o arquivo Libraries do Arduino IDE;

Pastas de arquivos do ARDUINO IDE:

Pronto, pode utilizar sua placa WAVGAT.

LED: Diodo Emissor de LUZ.

O LED é um Diodo Emissor de Luz, ao conduzir corrente, na polarização

Nas nossas práticas o LED normalmente é conectado assim: no terminal

Resistor de 220 ohms.

O resistor é um componente utilizado para limitar a corrente elétrica.

Na segunda imagem temos um resistor com 4 cores, se lermos da esquerda

A chave táctil de 4 terminais possibilita que quando houver toque no botão o

Nota: Há vários outros tipos de chaves.

O protobord é uma ferramenta que facilita a montagem de circuitos eletrônicos,

O circuito montado abaixo possibilita que ao acionar a chave táctil o LED

Aprenderemos mais sobre os componentes nas práticas.

1 LED piscante com Arduino (BLINK)

Componentes a serem utilizados:

Faça a montagem abaixo:

Uma outra tela com o programa aparecerá.

Este código de exemplo é de dominio público.

O DHT11 é um sensor de temperatura e unidade relativa, que permite medir

Na prática descrita neste artigo vamos ler as informações do sensor e

Para utilizar o DHT11 com o Arduino e programar no Arduino IDE é necessário

Após descompactar o arquivo baixado e incluí-lo na biblioteca do Arduino IDE,

Carregue o código no Arduino abra o monitor serial e você verá a leitura de

Se ficou em dúvida sobre algum procedimento do artigo, no site abaixo há

Neste artigo vamos aprender a utilizar o LDR, Resistor Dependente de Luz, e

Estes e outros componentes podem ser adquiridos no link:

Copie e cole o código abaixo no ARDUINO IDE.

int portaLed = 10; //define pino digital 10 LED

Para testar o circuito, tampe o LDR, o LED deve acender.

Neste artigo vamos aprender a utilizar o Sensor Reflexivo IR para acionar um

Sobre os principais componentes:

O TCRT5000 é um sensor reflexivo que possui embutido um emissor

Estes e outros componentes podem ser adquiridos no link:

Copie o código e cole na tela do Arduino IDE.

float R1 = (10005 - tensao1000)/tensao;