Tutorial Arduino

DIEGO DUTRA SAMPAIO

O que é Arduino

O Arduino é uma placa de desenvolvimento baseada em um microcontrolador Atmel

AVR. Possui conectores de entrada e saída para controle de dispositivos e um circuito
que facilita sua conexão com um computador via porta USB. Foi criada em 2005 por
professores que desejavam fornecer aos alunos uma plataforma de fácil
desenvolvimento e aprendizado de eletrônica e desenvolvimento de software.

Além da placa, existe todo um ecossistema em volta do Arduino como, software de

programação e desenvolvimento (IDE), bibliotecas, tutoriais, fóruns, comunidade,
hardwares adicionais, entre outros.

Materiais necessários

Para seguir com este tutorial e dar seus primeiros passos com arduino, você irá precisar
dos seguintes componentes:

 Placa Uno R3 com cabo USB

 Protoboard
 LED vermelho
 Resistor 150 ohm
 Jumpers macho/macho
 Computador

Funcionamento

O Arduino funciona com 5V em suas saídas digitais. Ou seja, quando ligamos um pino
temos 5V e quando desligamos temos 0V. Mas é importante notar que o LED funciona
apenas com 2V. Se colocarmos 5V em um LED provavelmente ele irá queimar. Para
isso fazemos uso do resistor, que tem a função de diminuir a tensão do LED e limitar a
corrente.

Essas informações podemos extrair do datasheet do LED. Datasheet é basicamente um

documento de um componente eletrônico que contém as informações necessárias de
funcionamento do respectivo componente.

Analisando o datasheet de um LED 5mm vermelho, podemos ver que ele funciona com
uma tensão de 2V e corrente de 20mA. Agora precisamos encontrar um valor de resistor
que fará o circuito chegar próximo de 2V e 20mA.

V = R x I (Tensão = Resistência x Corrente)

Onde V é a tensão da fonte (5V porta Arduino) menos tensão do LED(2V), resultando
em 3V.

Assim teríamos:

3V = R x 0,02A

R = 3V / 0,02A

R = 150 ohm

Caso não tenha um resistor de 150 ohms a mão, pode utilizar qualquer outro valor até
de 1K. O LED irá acender, mas talvez com um brilho mais forte ou fraco dependendo do
valor de resistência.

Caso queira ir mais a fundo neste tema de eletrônica, estude sobre Lei de
Ohm e circuitos elétricos.

Como funciona uma protoboard

Uma protoboard serve para prototipagem de circuitos eletrônicos. É de fácil utilização e

segue o seguinte esquema de conexão interna:

Nas seções A e D geralmente são conectados VCC e GND. As seções B e C são

utilizadas para conexão dos componentes eletrônicos.

Primeiros passos com Arduino

Neste tutorial iremos fazer um LED piscar. Para isso precisamos do LED, de um resistor,
protoboard e alguns jumpers macho/macho.

Montagem do circuito

É importante notar que o LED possui polaridade, ou seja, terminal positivo (Anodo) e
negativo (Catodo). O terminal maior do LED é o positivo e o menor é o negativo. Ou veja
também pelo chanfro, que é o lado negativo.
O circuito deve ficar da seguinte maneira na protoboard:

Baixando e instalando a IDE Arduino

Uma IDE (Integrated Development Environment ou Ambiente de Desenvolvimento

Integrado) é um programa de computador que possui as ferramentas necessárias para
desenvolvimento de software. Basicamente possui um editor de código fonte e
compilador.

Com a IDE Arduino podemos dar os primeiros passos com arduino e desenvolver
programas, instalar bibliotecas adicionais e realizar a compilação e gravação dos
programas na placa.

Para fazer o download da IDE Arduino entre no site oficial do Arduino na seção Software
-> Downloads e escolha sua versão de sistema operacional(Windows, Linux, MacOS).

Execute o arquivo instalador ‘.exe’ e siga as instruções de instalação.

Certifique-se de que todos os componentes na tela abaixo estejam selecionados.

Após a instalação, abra a IDE Arduino pelo atalho criado na sua área de trabalho.

Estrutura de um programa Arduino

Ao abrir a IDE Arduino você se depara com uma estrutura padrão de programa contendo
as funções setup () e loop ().

Setup () – É nessa parte do programa que você configura as opções iniciais do seu
programa: os valores iniciais de uma variável, se uma porta será utilizada como entrada
ou saída, mensagens para o usuário, etc. Essa função irá executar apenas uma vez no
início do programa.

Loop () – Diferente da função setup (), essa parte do programa repete uma estrutura de
comandos de forma contínua ou até que algum comando de “parar” seja enviado ao
Arduino.

Vamos ver exatamente como isso funciona, levando em consideração o programa

abaixo, que acende e apaga o lied embutido na placa Arduino em intervalos de 1
segundo:

//Programa: Pisca Led Arduino

//Autor: FILIPEFLOP

void setup()

{
 //Define a porta do led como saida

pinMode(13, OUTPUT);

void loop()

//Acende o led

digitalWrite(13, HIGH);

//Aguarda o intervalo especificado

delay(1000);

//Apaga o led

digitalWrite(13, LOW);

//Aguarda o intervalo especificado

delay(1000);

Exemplo Pisca LED

Vimos acima um programa exemplo para piscar nosso LED, o famoso “Hello World” da
eletrônica e um dos primeiros passos com arduino. O exemplo Blink LED.

A primeira coisa que fazemos no início do programa é colocar uma pequena observação
sobre o nome do programa, sua função e quem o criou:

// Programa : Pisca Led Arduino

// Autor : FILIPEFLOP

Comece uma linha com barras duplas ( // ) e tudo o que vier depois dessa linha será
tratado como um comentário. Uma das boas práticas de programação é documentar o
seu código por meio das linhas de comentário. Com elas, você pode inserir observações
sobre como determinada parte do programa funciona ou o que significa aquela
variável xyz que você criou. Isso será útil não só para você, se precisar alterar o código
depois de algum tempo, como também para outras pessoas que utilizarão o seu
programa.

Após os comentários, vem a estrutura do setup(). É nela que definimos que o pino 13
do Arduino será utilizado como saída.

void setup()
 {

//Define a porta do led como saida

pinMode(13, OUTPUT);

Por último, temos o loop (), que contém as instruções para acender e apagar o led, e
também o intervalo entre essas ações:
void loop()
{
//Acende o led
digitalWrite(13, HIGH);

//Aguarda o intervalo especificado

delay(1000);

//Apaga o led
digitalWrite(13, LOW);

//Aguarda o intervalo especificado

delay(1000);
}

A linha do código contendo digitalWrite(13, HIGH) coloca a porta 13 em nível alto (HIGH,
ou 1), acendendo o led embutido na placa. O comando delay (1000), especifica o
intervalo, em milissegundos, no qual o programa fica parado antes de avançar para a
próxima linha.

O comando digitalWrite(13, LOW), apaga o led, colocando a porta em nível baixo (LOW,
ou 0), e depois ocorre uma nova parada no programa, e o processo é então reiniciado.

Quando o código estiver pronto para ser carregado na placa, conecte a placa Arduino
no seu computador, entre no menu ferramentas, escolha o modelo da placa e a porta
na qual a mesma está conectada:
Então clique no botão de compilação. Isso irá verificar se existe algum erro no código e
gerar o arquivo de programa necessário para carregar na placa.

Se estiver tudo OK, clique no botão carregar. Isso irá gravar o programa na placa.

Sons no Arduino usando buzzer

Você sabia que é possível gerar sons a partir do Arduino?

Você pode utilizar essa função do Arduino para criar sistemas de avisos e alarmes,
usar em brinquedos, jogos, máquinas e explorar outras possibilidades, em conjunto
com sensores, módulos e atuadores.

Sons no Arduino com a função TONE

Na programação do Arduino a função tone é responsável por comandar a geração
de sons, e esse comando tem o seguinte formato:

tone(pino, frequencia, duração)

onde a frequência do tom é setada em hertz, e a duração, em milisegundos.

Para efeito de testes, usei um pequeno buzzer , desses que se usam em placa-mãe de
computador, como esse:

A ligação é feita com o pino 10 do Arduino ligado ao positivo (+) do buzzer/falante,

e o outro pino do buzzer ligado ao GND:

Apesar de usarmos nos testes uma placa Arduino Uno, o circuito não funciona apenas
nessa placa, funcinando também com outras placas da linha como Mega e Nano.

Para testar, carregue o programa abaixo e ouça uma linda melodia. Basicamente temos
as notas musicais (do, re, mi…) e vamos alternando o uso dessas notas variando a
duração de cada uma. Lembrando que o valor “10” no comando tone se refere ao pino
onde está conectado o buzzer:

//Program a: Som n o Arduino - Do Re Mi

//Autor: Arduino e Cia

v oid s etup()

{
pinMod e(10,OUTPUT); //Pino do buzz er

v oid loop()

del ay(2000);

ton e(10,262,200); //DO

del ay(200);

ton e(10,294,300); //RE

del ay(200);

ton e(10,330,300); //MI

del ay(200);

ton e(10,349,300); //FA

del ay(300);

ton e(10,349,300); //FA

del ay(300);

ton e(10,349,300); //FA

del ay(300);

ton e(10,262,100); //DO

del ay(200);

ton e(10,294,300); //RE

del ay(200);

ton e(10,262,100); //DO

del ay(200);

ton e(10,294,300); //RE

del ay(300);

ton e(10,294,300); //RE

del ay(300);

ton e(10,294,300); //RE

del ay(300);

ton e(10,262,200); //DO

del ay(200);

ton e(10,392,200); //SO L

del ay(200);

ton e(10,349,200); //FA

del ay(200);
ton e(10,330,300); //MI

del ay(300);

ton e(10,330,300); //MI

del ay(300);

ton e(10,330,300); //MI

del ay(300);

ton e(10,262,200); //DO

del ay(200);

ton e(10,294,300); //RE

del ay(200);

ton e(10,330,300); //MI

del ay(200);

ton e(10,349,300); //FA

del ay(300);

ton e(10,349,300); //FA

del ay(300);

ton e(10,349,300); //FA

del ay(300);

Use este programa, que aumenta e diminui a frequência do som, criando o efeito que precisamos:

//Program a: Som n o Arduino - Siren e

//Autor: Arduino e Cia

#define tempo 10

int frequencia = 0;

int Pinofalante = 10 ;

v oid s etup()

pinMod e(Pinofalante,OUTPUT); //Pino do buzz er

v oid loop()

for (frequencia = 15 0; frequencia < 1800; frequencia += 1)

{
tone(Pinofalante, frequencia, tempo);

del ay(1);

for (frequencia = 18 00; frequencia > 150; frequencia -= 1)

ton e(Pinofalante, frequencia, tempo);

del ay(1);

Como usar o Teclado Matricial 4×4 com Arduino

Este Teclado Matricial 4×4 é um componente do Arduino muito utilizado para entrada de
dados. Ele possui 16 teclas dispostas em 4 linhas x 4 colunas, e um conector de 8 pinos
para ligação:

Pinagem Teclado Matricial 4X4:

Internamente são 16 teclas push-buttons tipo membrana dispostos na configuração

abaixo em um formato keypad. Conforme a tecla é pressionada, é feita a conexão entre
a linha e a coluna correspondentes. Se pressionarmos a tecla A no teclado matricial,
será feita a conexão entre os pinos 1 (linha 1) e 8 (coluna 4), se pressionarmos a tecla 7,
será feita uma conexão entre os pinos 3 (linha 3) e 5 (coluna 1), e assim por diante:
 Conectando Teclado Matricial ao Arduino:
Neste tutorial vamos utilizar 8 portas do Arduino para ligação ao teclado matricial, sendo
4 para as linhas, e 4 para as colunas. Os pinos das linhas deverão ser configurados
como OUTPUT (Saída), e os pinos das colunas como INPUT (Entrada). Nos pinos
referente às colunas, vamos utilizar 4 resistores pull-down, mantendo-as em nível baixo
quando não houver acionamento das teclas:

Programando o Arduino para mapeamento das teclas:

No programa, primeiro definimos todos os pinos das linhas como saída (pinos 3, 4, 5 e
6), e os pinos de colunas como entrada (pinos 8,9,10 e 11). Um loop se encarrega de
colocar cada pino de saída (linhas) em estado alto (HIGH), e verificar se alguma tecla
foi pressionada, por meio de um comando IF para cada coluna. Caso isso aconteça, é
gerada uma saída no serial monitor com a informação correspondente à qual tecla foi
pressionada no teclado matricial:

//Programa : Teste teclado matricial 4x4

//Autor : FILIPEFLOP
void setup()

//Pinos ligados aos pinos 1, 2, 3 e 4 do teclado - Linhas

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

//Pinos ligados aos pinos 5, 6, 7 e 8 do teclado - Colunas

pinMode(8, INPUT);

pinMode(9, INPUT);

pinMode(10, INPUT);

pinMode(11, INPUT);

Serial.begin(9600);

Serial.println("Aguardando acionamento das teclas...");

Serial.println();

void loop()

for (int ti = 3; ti<7; ti++)

//Alterna o estado dos pinos das linhas

digitalWrite(3, LOW);

digitalWrite(4, LOW);

digitalWrite(5, LOW);

digitalWrite(6, LOW);

digitalWrite(ti, HIGH);

//Verifica se alguma tecla da coluna 1 foi pressionada

if (digitalRead(8) == HIGH)

imprime_linha_coluna(ti-2, 1);

while(digitalRead(8) == HIGH){}
 }

//Verifica se alguma tecla da coluna 2 foi pressionada

if (digitalRead(9) == HIGH)

imprime_linha_coluna(ti-2, 2);

while(digitalRead(9) == HIGH){};

//Verifica se alguma tecla da coluna 3 foi pressionada

if (digitalRead(10) == HIGH)

imprime_linha_coluna(ti-2, 3);

while(digitalRead(10) == HIGH){}

//Verifica se alguma tecla da coluna 4 foi pressionada

if (digitalRead(11) == HIGH)

imprime_linha_coluna(ti-2, 4);

while(digitalRead(11) == HIGH){}

delay(10);

void imprime_linha_coluna(int x, int y)

Serial.print("Linha : ");

Serial.print(x);

Serial.print(" x Coluna : ");

Serial.print(y);

delay(10);

Serial.println();

Configuramos o programa para mostrar a informação Linha x Coluna da tecla

pressionada. Carregado o programa no Arduino, abra o serial monitor e acione as teclas,
e você terá um resultado como esse abaixo:
Com a posição das teclas, é possível configurar o teclado para exibir os caracteres que
você desejar, ou até mesmo acionar outras portas do Arduino, já que , como
comentamos no início, o teclado nada mais é do que uma série de push-buttons
dispostos em forma de matriz.

Como conectar o Sensor Ultrassônico HC-SR04 ao Arduino

O Sensor Ultrassônico HC-SR04 é um componente muito comum em projetos com

Arduino, e permite que você faça leituras de distâncias entre 2 cm e 4 metros, com
precisão de 3 mm. Pode ser utilizado simplesmente para medir a distância entre o
sensor e um objeto, como para acionar portas do microcontrolador, desviar um robô de
obstáculos, acionar alarmes, etc. Neste tutorial ensinaremos a conectar o HC-SR04 ao
Arduino.

O funcionamento do HC-SR04 (datasheet) se baseia no envio de sinais ultrassônicos pelo

sensor, que aguarda o retorno (echo) do sinal, e com base no tempo entre envio e retorno,
calcula a distância entre o sensor e o objeto detectado.
Primeiramente é enviado um pulso de 10µs, indicando o início da transmissão de dados.
Depois disso, são enviado 8 pulsos de 40 KHz e o sensor então aguarda o retorno (em
nível alto/high), para determinar a distância entre o sensor e o objeto, utilizando a
equação Distância = (Tempo echo em nível alto * velocidade do som) /2

Para ligação do sensor ao microcontrolador, são utilizados 4 pinos: Vcc, Trigger,

ECHO e GND.

Conectando o Sensor HC-SR04 ao Arduino

A ligação do sensor ao Arduino no nosso programa vai utilizar, além dos pinos de
alimentação, os pinos digitais 4 para o Trigger, e 5 para o Echo. A alimentação será
feita pelo pino 5V do Arduino:
//Programa: Conectando Sensor Ultrassonico HC-SR04 ao Arduino
//Autor: FILIPEFLOP

//Carrega a biblioteca do sensor ultrassonico

#include <Ultrasonic.h>

//Define os pinos para o trigger e echo

#define pino_trigger 4
#define pino_echo 5

//Inicializa o sensor nos pinos definidos acima

Ultrasonic ultrasonic(pino_trigger, pino_echo);

void setup()
{
Serial.begin(9600);
Serial.println("Lendo dados do sensor...");
}

void loop()
{
//Le as informacoes do sensor, em cm e pol
float cmMsec, inMsec;
long microsec = ultrasonic.timing();
cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);
inMsec = ultrasonic.convert(microsec, Ultrasonic::IN);
//Exibe informacoes no serial monitor
Serial.print("Distancia em cm: ");
Serial.print(cmMsec);
Serial.print(" - Distancia em polegadas: ");
Serial.println(inMsec);
delay(1000);
}
No programa todo o cálculo é feito por meio da biblioteca Ultrasonic. O sensor é
inicializado nos pinos trigger e echo, e depois efetuamos a leitura dos dados do sensor,
atribuindo às variáveis cmMsec e inMsec os valores das distâncias em centímetros e
polegadas, respectivamente. Os dados são mostrados no serial monitor:

Micro Servo Motor 9g SG90 com Arduino Uno

O Micro Servo TowerPro 9g SG90 é um servo de alta qualidade e excelente para as

suas necessidades seja em aeromodelismo ou em projetos mecatrônicos. Pensando
nisso bolamos um post simples para fazer os primeiros movimentos com o seu Micro
Servo 9g SG90 e um Arduino Uno.

Conecte a alimentação do Micro Servo 9g ao Arduino. Fio Marrom com GND, Fio
Vermelho com 5v e Fio Laranja na Porta Digital 6.

Programando:
#include <Servo.h>

#define SERVO 6 // Porta Digital 6 PWM

Servo s; // Variável Servo

int pos; // Posição Servo

void setup ()
{
s.attach(SERVO);
Serial.begin(9600);
s.write(0); // Inicia motor posição zero
}

void loop()
{
for(pos = 0; pos < 90; pos++)
{
s.write(pos);
delay(15);
}
delay(1000);
for(pos = 90; pos >= 0; pos--)
{
s.write(pos);
delay(15);
}
}

Controlando lâmpadas com Módulo Relé Arduino

Neste tutorial vamos explicar como usar o Módulo Relé Arduino e montar 2 circuitos: um
circuito com acionamento temporizado de 2 lâmpadas e outro circuito com acionamento
por botões de uma lâmpada e um ventilador (pode substituir por outro eletrodoméstico
por exemplo).

Este relé 5V pode ser também usado com AVR, PIC, Raspberry, 8051, ARM ou até
mesmo o seu circuito eletrônico personalizado. Usando dois pinos do módulo relé
arduino, você controla cargas como lâmpadas, motores, fechaduras e eletrodomésticos,
desde que a corrente de operação não ultrapasse 10 A (ampéres).
Cada relé desse módulo suporta cargas de até 10 A, em 125 VAC, 250 VAC ou 30 VDC.
Leds indicadores mostram o estado do relé (ligado/desligado) em cada canal. O módulo
já contém todo o circuito de proteção para evitar danos ao microcontrolador, e
possui baixa corrente de operação.

Pinagem Módulo Relé 5v

Na imagem abaixo você pode observar a pinagem do módulo relé arduino. No lado
esquerdo superior os pinos JD-Vcc, Vcc e GND, que permitem que seja conectada uma
fonte externa de 5V. Abaixo, os pinos GND, IN1 (aciona o relé 1), IN2 (aciona o relé 2),
e o Vcc. Ao lado dos relés, os contatos NC (Normal Fechado), C (Comum), e NA (normal
aberto):

Acionar os dois relés é muito simples e para isso você deve apenas mudar o estado das
portas digitais ligadas aos pinos IN1 e IN2. Um detalhe importante desse módulo é que
os relés são ativados em nível baixo, ou seja, quando o estado da porta estiver em LOW,
o relé será acionado.

Módulo Relé com Arduino: Circuito 2 Lâmpadas

No exemplo abaixo, vamos acionar duas lâmpadas alternadamente. Os dois relés irão
funcionar como chaves eletrônicas, fechando o contato NA (Normal Aberto), e
acendendo as lâmpadas a cada 2 segundos. Recomendamos muito cuidado tanto no
manuseio como na ordem de ligação dos fios, pois estamos trabalhando com 110 V (ou
220 v) da rede elétrica.
O controle do relé 1 é feito pela porta 7 do Arduino Uno, e o relé 2 é controlado pela
porta 8. As duas portas são definidas como saídas e alternam os estados LOW e HIGH,
lembrando que o estado baixo (LOW ), é que aciona o relé:

//Programa : Teste Modulo Rele Arduino 2 canais - Lampadas

//Autor : FILIPEFLOP

//Porta ligada ao pino IN1 do modulo

int porta_rele1 = 7;
//Porta ligada ao pino IN2 do modulo
int porta_rele2 = 8;

void setup()
{
//Define pinos para o rele como saida
pinMode(porta_rele1, OUTPUT);
pinMode(porta_rele2, OUTPUT);
}

void loop()
{
digitalWrite(porta_rele1, LOW); //Liga rele 1
digitalWrite(porta_rele2, HIGH); //Desliga rele 2
delay(2000);
digitalWrite(porta_rele1, HIGH); //Desliga rele 1
digitalWrite(porta_rele2, LOW); //Liga rele 2
delay(2000);
}
Controle remoto IR com Arduino

Existem várias maneiras práticas e baratas de controlar uma placa Arduino à distância,
e uma delas é usando infravermelho. Usar o controle remoto IR com Arduino permite
que você acione os mais variados equipamentos.

Hoje vou apresentar um outro método para controle remoto das portas do Arduino
Uno R3 , desta vez usando um Kit Controle Remoto IR , mostrado na foto abaixo:

O kit é composto por 1 módulo receptor IR, 1 led infravermelho, 1 cabo de conexão e 1
controle remoto (com bateria CR2025).

No exemplo de hoje, vou focar na recepção do sinal do controle remoto, acendendo e

apagando leds, conforme a sequência abaixo:

 Tecla 1 : Acende led vermelho.

Tecla 2 : Apaga led vermelho
 Tecla 4 : Acende led verde.
Tecla 5 : Apaga led verde
 Tecla 9 : Apaga os 2 leds

Entendendo o principio de funcionamento do receptor IR, fica fácil controlar qualquer

porta do Arduino e partir para o acionamento de relés, motores e outros dispositivos.

Circuito Arduino e módulo IR infravermelho

A ligação do módulo receptor IR segue o esquema mostrado na imagem abaixo, à

esquerda, que consiste na ligação dos pinos do módulo à porta 11 do Arduino (sinal), 5v
e GND. Na imagem da direita, podemos ver o módulo em funcionamento, com um led
que pisca quando o módulo está recebendo sinais infravermelhos:
Para o circuito, vamos utilizar 2 leds, 2 resistores de 330 ohms e o receptor IR, tomando
o cuidado de observar a ligação correta dos pinos do módulo, evitando a queima do
componente:

Criei um programa que faz a leitura do sinal IR recebido, e com base no valor lido, aciona
as portas 5 e 7, onde estão ligados os leds. Esse programa também apresenta no
monitor serial os valores lidos pelo receptor IR:

Desta forma consigo descobrir os valores, em hexadecimal, do sinal recebido por todas
as teclas do controle remoto. No programa, usei os valores FF30CF (Tecla 1),
FF18E7 (tecla 2), FF10EF (tecla 4), FF38C7 (tecla 5), e FF52AD (tecla 9) .

Finalmente, no loop, eu testo o valor recebido pelo receptor IR, e com alguns
comandos IF eu verifico qual tecla foi acionada, acendendo e apagando o led
correspondente. Usei a tecla 9 para apagar os 2 leds de uma só vez.

Programa controle remoto IR com Arduino

// Program a : T es te Controle R em ot o IR
#include <IRremote.h>
int RECV_PIN = 11;
float armazenavalor;
int pinoledvermelho = 5;
int pinoledverde = 7 ;

IRrecv irrec v(RECV_PIN);

decode_results results;

v oid s etup()
{
pinMod e(pinoledvermelho, OUTPUT);
pinMod e(pinoledverde, OUTPUT);
Serial.b egin(9600);
irrecv.en abl eIRIn(); // Inic ializa o rec eptor IR
}

v oid loop()
{
if (irrecv.d ec od e(&results))
{
Serial.print("Valor lid o : " );
Serial.println(results.valu e, HEX);
armazenavalor = (results.valu e);
if (armazenavalor == 0 xFF30CF) //Verif ic a s e a t ec la 1 f oi ac ion ad a
{
digitalW rite(pinoledvermelho, HIGH); //Ac end e o l ed verm elh o
}
if (armazenavalor == 0 xFF18E7) //Verif ic a s e a tec la 2 f oi ac ion ad a
{
digitalW rite(pinoledvermelho, LOW ); //Apaga o l ed verm elh o
}
if (armazenavalor == 0 xFF10EF) //Verific a s e a tec la 4 f oi ac ion ad a
{
digitalW rite(pinoledverde, HIGH); //Ac ende o l ed verde
}
if (armazenavalor == 0 xFF38C7) //Verif ic a s e a tec la 5 f oi ac ion ad a
{
digitalW rite(pinoledverde, LOW); //Apaga o led verd e
}
if (armazenavalor == 0 xFF52AD ) //Verif ic a s e a t ec la 9 f oi ac ion ad a
{
digitalW rite(pinoledvermelho, LOW ); //Apaga t od os os leds
digitalW rite(pinoledverde, LOW);
}
irrecv.res um e(); //Le o pr óxim o val or
}
}
Controlando um LCD 16×2 com Arduino

Neste post você vai encontrar alguns testes básicos do display LCD 16×2 com arduino,
um display muito comum com controlador HD44780, que se adapta aos mais diversos
projetos, podendo ser usado com vários modelos de placas e microcontroladores como
Arduino, Raspberry Pi, PIC, etc.

Esse display LCD tem 16 colunas e 2 linhas, com backlight (luz de fundo) azul e letras
na cor branca. Para conexão, são 16 pinos, dos quais usamos 12 para uma conexão
básica, já incluindo as conexões de alimentação (pinos 1 e 2), backlight (pinos 15 e 16)
e contraste (pino 3).
Conexão display LCD 16×2 com Arduino
Na conexão do display ao Arduino Uno vamos utilizar apenas 4 pinos de dados (pinos
digitais 2, 3, 4 e 5), e 2 pinos de controle (pinos digitais 11 e 12).

Para o ajuste do contraste, usamos um potenciômetro de 100K, mas você pode testar
com outros valores como 10K ou 50K, por exemplo.

Se preferir, você também pode utilizar um potenciômetro para regular a luz de fundo,
nos pinos 15 e 16 do display. Outra opção é usar um resistor em um desses pinos.

Programa de controle LCD

O controle desse display pode ser feito utilizando-se a biblioteca LiquidCrystal, já
embutida na IDE do Arduino.

No início do programa (linha 8), definimos os pinos que serão utilizados pelo displays,
nesse formato:

LiquidCrystal lcd(<pino RS>, <pino enable>, <pino D4>, <pino D5>, <pino D6>, <pino
D7>)

No setup, inicializamos o display definindo o número de colunas e linhas com o

comando lcd.begin(16,2).

//Programa: Teste de Display LCD 16 x 2

//Autor: FILIPEFLOP

//Carrega a biblioteca LiquidCrystal

#include <LiquidCrystal.h>

//Define os pinos que serão utilizados para ligação ao display

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()
{
 //Define o número de colunas e linhas do LCD
lcd.begin(16, 2);
}

void loop()
{
//Limpa a tela
lcd.clear();
//Posiciona o cursor na coluna 3, linha 0;
lcd.setCursor(3, 0);
//Envia o texto entre aspas para o LCD
lcd.print("FILIPEFLOP");
lcd.setCursor(3, 1);
lcd.print(" LCD 16x2");
delay(5000);

//Rolagem para a esquerda

for (int posicao = 0; posicao < 3; posicao++)
{
lcd.scrollDisplayLeft();
delay(300);
}

//Rolagem para a direita

for (int posicao = 0; posicao < 6; posicao++)
{
lcd.scrollDisplayRight();
delay(300);
}
}

O programa acima posiciona o texto na posição desejada utilizando o

comando lcd.setCursor(), e imprime a string na tela usando lcd.print(“Texto”). Depois
de 5 segundos, são utilizados os
comandos scrollDisplayLeft() e scrollDisplayRight() para “mover” os caracteres para a
esquerda e para a direita, respectivamente.

Controle de Acesso usando Leitor RFID com Arduino

Tag e leitor RFID (Radio Frequency Identification, ou Identificação por Radiofrequência)

costumam ser utilizados para controle de acesso e identificação de pessoas e
equipamentos, seja por meio de crachás ou etiquetas aplicadas à produtos. No nosso
dia-a-dia, podemos encontrar a tecnologia RFID nos pedágios (no popular “Sem
Parar”), ou em cartões tipo Bilhete Único, utilizados em várias cidades brasileiras para
acesso ao transporte coletivo.
As etiquetas (ou tags) RFID, podem conter vários dados sobre o proprietário do cartão,
como nome e endereço e, no caso de produtos, informações sobre procedência e data
de validade, apenas para citar alguns exemplos. Como são compostas apenas por um
pequeno circuito, as tags RFID podem ser embutidas facilmente em vários objetos,
nos mais variados tamanhos e formatos.

Cada etiqueta/tag do leitor RFID tem a sua própria identificação (UID), e é com essa
identificação que vamos montar um controle de acesso que irá ler o UID do cartão e
exibir as informações de acesso num display LCD 16×2. Com pequenas alterações no
programa é possível acionar as outras portas do Arduino e ligar motores, sensores,
luzes e outros dispositivos.

Pinagem Leitor RFID:

O leitor RFID tem 8 pinos que seguem a seguinte sequência de ligação. Atenção à tensão de
alimentação, que neste caso é de 3.3 volts

 Pino SDA ligado na porta 10 do Arduino

 Pino SCK ligado na porta 13 do Arduino
 Pino MOSI ligado na porta 11 do Arduino
 Pino MISO ligado na porta 12 do Arduino
 Pino NC – Não conectado
 Pino GND ligado no pino GND do Arduino
 Pino RST ligado na porta 9 do Arduino
 Pino 3.3 – ligado ao pino 3.3 V do Arduino
Montagem Leitor RFID com Arduino:

Utilizamos no circuito o Display 16×2 HD44780 com ligação semelhante ao do

artigo Mostrando informações de temperatura no LCD 16×2 com o DHT11. Trocamos apenas
os pinos 12 do Arduino Uno pelo pino 6, e o 11 pelo 7, pois os mesmos já estão sendo
utilizados pelo leitor RFID. O potenciômetro é utilizado para controlar o contraste do LCD, e
no circuito foi usado um de 10 K :

Programando Arduino com Leitor RFID:

Para o programa, baixe a biblioteca MFRC522 nesse link. Descompacte o arquivo e

renomeie a pasta rfid-master para MFRC522, colocando-a dentro da pasta LIBRARIES
da IDE do seu Arduino.

O programa exibe na tela mensagens referentes ao cartão utilizado, sendo que no nosso
caso, o display apresenta mensagem de “Acesso Liberado” para a tag no estilo chaveiro,
e “Acesso Negado” para a tag no estilo cartão.

Adapte o programa às tags que você possui, alterando as linhas com “UID 1 – Chaveiro”
e “UID 2 – Cartao” (Linhas 54 e 67), lembrando que o formato da UID deve ser mantido
(XX YY ZZ WW).

Para descobrir o número da tag do seu dispositivo, aproxime-o do leitor RFID e verifique
o serial monitor :
//Programa : RFID - Controle de Acesso leitor RFID

//Autor : FILIPEFLOP

#include <SPI.h>

#include <MFRC522.h>

#include <LiquidCrystal.h>

#define SS_PIN 10

#define RST_PIN 9

MFRC522 mfrc522(SS_PIN, RST_PIN); // Create MFRC522 instance.

LiquidCrystal lcd(6, 7, 5, 4, 3, 2);

char st[20];

void setup()

Serial.begin(9600); // Inicia a serial

SPI.begin(); // Inicia SPI bus

mfrc522.PCD_Init(); // Inicia MFRC522

Serial.println("Aproxime o seu cartao do leitor...");

Serial.println();

//Define o número de colunas e linhas do LCD:

 lcd.begin(16, 2);

mensageminicial();

void loop()

// Look for new cards

if ( ! mfrc522.PICC_IsNewCardPresent())

return;

// Select one of the cards

if ( ! mfrc522.PICC_ReadCardSerial())

return;

//Mostra UID na serial

Serial.print("UID da tag :");

String conteudo= "";

byte letra;

for (byte i = 0; i < mfrc522.uid.size; i++)

Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ");

Serial.print(mfrc522.uid.uidByte[i], HEX);

conteudo.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "));

conteudo.concat(String(mfrc522.uid.uidByte[i], HEX));

Serial.println();

Serial.print("Mensagem : ");

conteudo.toUpperCase();

if (conteudo.substring(1) == "ED 78 03 CA") //UID 1 - Chaveiro

Serial.println("Ola FILIPEFLOP !");

Serial.println();

lcd.clear();
 lcd.setCursor(0,0);

lcd.print("Ola FILIPEFLOP !");

lcd.setCursor(0,1);

lcd.print("Acesso liberado!");

delay(3000);

mensageminicial();

if (conteudo.substring(1) == "BD 9B 06 7D") //UID 2 - Cartao

Serial.println("Ola Cartao !");

Serial.println();

lcd.clear();

lcd.setCursor(0,0);

lcd.print("Ola Cartao !");

lcd.setCursor(0,1);

lcd.print("Acesso Negado !");

delay(3000);

mensageminicial();

void mensageminicial()

lcd.clear();

lcd.print(" Aproxime o seu");

lcd.setCursor(0,1);

lcd.print("cartao do leitor");

Monitorando Temperatura e Umidade com o sensor DHT11

Em um país tropical como o nosso o clima em boa parte do Brasil é quente e úmido.
Logo creio que este projeto irá te ajudar a monitorar com apenas 1 sensor a temperatura
e umidade de seu clima local com este Sensor DHT11.
Este sensor inclui um componente medidor de umidade e um componente NTC para
temperatura, ambos conectados a um controlador de 8-bits. O interessante neste
componente é o protocolo usado para transferir dados entre o MCDU e DHT11, pois as
leituras do sensor são enviadas usando apena um único fio de barramento.

Formato dos dados: 8bit integral RH data + 8bit decimal RH data + 8bit integral T data
+ 8bit decimal T data + 8bit check sum = 40 bits.

Conectando o sensor DHT11 ao Arduino:

O DHT11 possui 4 terminais sendo que somente 3 são usados: GND, VCC e Dados. Se
desejar, pode-se adicionar um resistor pull up de 10K entre o VCC e o pino de dados.
Conecte o pino de dados do DHT11 ao pino 2 do seu Arduino Uno como mostra o código
exemplo abaixo, mas você poderá alterar por outro se desejar.

Comunicação Arduino com DHT11:

Para facilitar o seu trabalho já existe uma bilioteca que pode ser baixada. Após o
download descompacte o arquivo .zip e mova-o para a pasta
arduinosketchfolder/libraries/ e reinicie a IDE do Arduino. Não retire o arquivo dht.cpp. e
não esqueça de renomear a pasta para “DHT”. Talvez será necessário criar uma sub-
pasta da biblioteca caso não exista.

Agora acesse Examples->DHT->DHTtester em sua IDE Arduino.

#include "DHT.h"

#define DHTPIN A1 // pino que estamos conectado

#define DHTTYPE DHT11 // DHT 11

// Conecte pino 1 do sensor (esquerda) ao +5V

// Conecte pino 2 do sensor ao pino de dados definido em seu Arduino

// Conecte pino 4 do sensor ao GND

// Conecte o resistor de 10K entre pin 2 (dados)

// e ao pino 1 (VCC) do sensor

DHT dht(DHTPIN, DHTTYPE);

void setup()

Serial.begin(9600);

Serial.println("DHTxx test!");

dht.begin();

void loop()

// A leitura da temperatura e umidade pode levar 250ms!

// O atraso do sensor pode chegar a 2 segundos.

float h = dht.readHumidity();

float t = dht.readTemperature();

// testa se retorno é valido, caso contrário algo está errado.

 if (isnan(t) || isnan(h))

Serial.println("Failed to read from DHT");

else

Serial.print("Umidade: ");

Serial.print(h);

Serial.print(" %t");

Serial.print("Temperatura: ");

Serial.print(t);

Serial.println(" *C");

Relógio com o módulo RTC DS1307

Com o módulo RTC DS1307 você tem um componente muito útil para montar algum
tipo de relógio com o Arduino, setar alarmes e assim executar ações em horários
predeterminados. Neste post vamos apresentar um tutorial de como conectar este
módulo RTC DS1307 com um Arduino Uno, mostrando as informações de data e hora
no Serial Monitor da IDE Arduino.
A sigla RTC significa Real Time Clock, ou seja, um Relógio de Tempo Real (RTC). Esse
módulo tem 56 bytes de memória não-volátil disponível para uso, é capaz de armazenar
e fornecer informações completas de data como dia da semana, dia do mês, mês, ano
e além é claro, das funções de horas, minutos e segundos, nos formatos de 12 ou 24
horas. Meses com menos de 31 dias e anos bissextos são ajustados automaticamente.

Uma bateria de lítio garante que os dados sejam preservados mesmo sem alimentação
externa, e é acionada automaticamente em caso de falta de energia no módulo.

Uma outra característica desse módulo é que você pode utilizar um sensor de
temperatura DS18B20 (não incluso), e ler as informações do sensor à partir do pino DS
do módulo, o que faz com que seja possível montar um relógio completo com data, hora,
dia da semana e temperatura, sem a necessidade de outros componentes.

CONECTANDO RTC DS1307 AO ARDUINO:

Neste post vamos mostrar um breve tutorial de como ligar esse módulo RTC DS1307
ao Arduino e exibir todas essas informações no serial monitor.

Olhando o módulo pela parte inferior, podemos ver na parte esquerda os pinos GND,
Vcc, SDA e SCL, utilizados para cascatear dispositivos I2C, e também o pino DS, que
fornece os dados do sensor de temperatura, se o mesmo estiver instalado. No lado
direito, vamos utilizar apenas os pinos SCL, SDA, Vcc e GND para ligação ao Arduino.

Conecte o módulo RTC DS1307 ao Arduino, tomando cuidado para não inverter as
ligações, pois como vimos acima existem pinos com o mesmo nome dos dois lados do
módulo :
No programa, a parte do código que contém os comandos

rtc.setDOW(MONDAY);
rtc.setTime(16, 30, 47);
rtc.setDate(5, 6, 2014);

só deve ser utilizada para setar a hora e data do RTC DS1307. Depois disso, essas
linhas podem ser comentadas ou excluídas e o programa deve ser novamente
carregado no Arduino.

//Programa : Relogio com modulo RTC DS1307

//Autor : FILIPEFLOP

//Carrega a biblioteca do RTC DS1307

#include <DS1307.h>

//Modulo RTC DS1307 ligado as portas A4 e A5 do Arduino

DS1307 rtc(A4, A5);

void setup()

//Aciona o relogio

rtc.halt(false);

//As linhas abaixo setam a data e hora do modulo

//e podem ser comentada apos a primeira utilizacao

 rtc.setDOW(FRIDAY); //Define o dia da semana

rtc.setTime(20, 37, 0); //Define o horario

rtc.setDate(6, 6, 2014); //Define o dia, mes e ano

//Definicoes do pino SQW/Out

rtc.setSQWRate(SQW_RATE_1);

rtc.enableSQW(true);

Serial.begin(9600);

void loop()

//Mostra as informações no Serial Monitor

Serial.print("Hora : ");

Serial.print(rtc.getTimeStr());

Serial.print(" ");

Serial.print("Data : ");

Serial.print(rtc.getDateStr(FORMAT_SHORT));

Serial.print(" ");

Serial.println(rtc.getDOWStr(FORMAT_SHORT));

//Aguarda 1 segundo e repete o processo

delay (1000);

Execute o programa, abra o Serial Monitor e você terá as informações do RTC DS1307
dessa maneira :
Sensor de chuva YL-83

Se você já montou ou vai montar uma estação de monitoração climática, usando

sensores de temperatura, umidade e pressão, precisa conhecer todo o
potencial do Sensor de chuva YL-83. Este conjunto é formado por uma placa que forma
o sensor propriamente dito, com várias trilhas nos dois lados e material resistente à
oxidação , que se encarrega de detectar o nível de chuva/umidade do ambiente. Esta
placa, por sua vez, é ligada por meio de 2 fios ao módulo principal, que contém o
circuito de controle que vai se comunicar com o microcontrolador. No caso deste post, o
Arduino.

O módulo de controle, como podemos ver acima, tem 2 pinos que vão se comunicar
com a placa do sensor, e na outra extremidade, 4 pinos de sinal e alimentação : A0
(sinal analógico), D0 (sinal digital), GND e Vcc. A alimentação vai de 3.3 à 5 volts.

A placa também possui, logo acima dos pinos, 2 leds. O da esquerda (verde) permanece
apagado quando não há sinal no sensor, e começa a piscar ou permanece aceso
quando o sensor é acionado. O led da direita (vermelho), indica que o módulo está ligado
:
Existem 2 formas bem simples de se trabalhar com esse sensor de chuva. Uma delas é
utilizando a saída digital, que simplesmente informa se foi detectada chuva/líquido
(saída em nível baixo / low) ou se o sensor está seco (saída em nível alto / high).

Outra maneira, que permite maiores variações, é utilizar a saída analógica, cujo valor
vai de 0 a 1023, e dessa maneira dimensionar o que você quer fazer com esse valor,
indicando em um painel, por exemplo, se não há chuva, ou se ela está fraca, forte,
moderada, etc.

Mas chega de teoria e vamos à prática, mostrando a ligação do sensor de chuva e do

módulo de controle ao Arduino, juntamente com um display LCD 16×2 :

O programa abaixo lê as informações tanto da saída digital D0 do módulo, ligada

ao pino 7 do Arduino, como da saída analógica A0 , ligada ao pino A5 :

//Programa : Teste sensor de chuva YL-83

//Autor : FILIPEFLOP

#include <LiquidCrystal.h> //Carrega a biblioteca LiquidCrystal

int pino_d = 7; //Pino ligado ao D0 do sensor

int pino_a = A5; //Pino ligado ao A0 do sensor

int val_d = 0; //Armazena o valor lido do pino digital

int val_a = 0; //Armazena o valor lido do pino analogico

//Define os pinos que serão utilizados para ligação ao display

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

void setup()

lcd.begin(16, 2);

pinMode(pino_d, INPUT);

pinMode(pino_a, INPUT);

Serial.begin(9600);

lcd.setCursor(0,0);

lcd.print("Chuva : ");

lcd.setCursor(0,1);

lcd.print("Intens.: ");

void loop()

//Le e arnazena o valor do pino digital

val_d = digitalRead(pino_d);

//Le e armazena o valor do pino analogico

val_a = analogRead(pino_a);

//Envia as informacoes para o serial monitor

Serial.print("Valor digital : ");

Serial.print(val_d);

Serial.print(" - Valor analogico : ");

Serial.println(val_a);

//Mostra no display se ha chuva ou nao

if (val_d == 1)

lcd.setCursor(10,0);

lcd.print("Nao");
}

else

lcd.setCursor(10,0);

lcd.print("Sim");

//Mostra no display o nivel de intensidade

//da chuva

if (val_a >900 && val_a <1023)

lcd.setCursor(10,1);

lcd.print(" ");

lcd.setCursor(10,1);

lcd.print("----");

else if (val_a >600 && val_a <900)

lcd.setCursor(10,1);

lcd.print(" ");

lcd.setCursor(10,1);

lcd.print("Fraca");

else if (val_a >400 && val_a <600)

lcd.setCursor(10,1);

lcd.print(" ");

lcd.setCursor(10,1);

lcd.print("Moder.");

else if (val_a <400)

lcd.setCursor(10,1);

lcd.print(" ");

lcd.setCursor(10,1);
 lcd.print("Forte");

delay(1000);

No display, é mostrada a indicação de chuva, e se a mesma é fraca, moderada ou

intensa :

Monitore sua planta usando Arduino

Não seria ótimo se a sua planta pudesse avisar você quando está precisando de água
? Com o sensor de umidade do solo higrômetro e um Arduino, isso é possível. Monte
um sistema para monitorar sua planta usando Arduino com as instruções deste post,
que utiliza poucos componentes para criar um indicador visual de nível de umidade do
solo e saúde da sua plantinha.

Neste projeto, temos três leds que acendem conforme o nível detectado pelo sensor de
umidade: vermelho para solo seco, amarelo para umidade moderada e verde para solo
úmido.
O sensor de umidade do solo higrômetro

O sensor de umidade do solo consiste em 2 partes: uma sonda que entra em contato com
o solo, e um pequeno módulo contendo um chip comparador LM393 (datasheet), que vai
ler os dados que vêm do sensor e enviá-los para o microcontrolador, no nosso caso, um
Arduino Uno. Como saída, temos um pino D0, que fica em nível 0 ou 1 dependendo da
umidade, e um pino de saída analógica ( A0), que possibilita monitorar com maior
precisão usando uma porta analógica do microcontrolador.

O módulo tem um led que indica quando a placa está sendo alimentada corretamente,
e outro que acende quando a saída digital for acionada. A sensibilidade do módulo é
ajustada por meio do potenciômetro existente na placa.

Conexão do sensor ao Arduino

No nosso exemplo vamos usar a porta analógica A0 do Arduino para ler os valores do
pino A0 do módulo. Os leds serão ligados às portas digitais 5, 6 e 7.

Usamos resistores de 10K nos leds, mas você pode utilizar outros valores de resistores
no circuito.
Programa de monitoração de planta usando Arduino

O programa abaixo faz a leitura da porta analógica a cada 2 segundos, e de acordo com
o valor lido acende o led correspondente à solo seco (led vermelho), solo com umidade
moderada (led amarelo), ou solo úmido (led verde). O valor da porta analógica e a
condição de umidade também são mostrados no serial monitor.

//Programa: Monitoracao de planta usando Arduino

//Autor: FILIPEFLOP

#define pino_sinal_analogico A0
#define pino_led_vermelho 5
#define pino_led_amarelo 6
#define pino_led_verde 7

int valor_analogico;

void setup()
{
Serial.begin(9600);
pinMode(pino_sinal_analogico, INPUT);
pinMode(pino_led_vermelho, OUTPUT);
pinMode(pino_led_amarelo, OUTPUT);
pinMode(pino_led_verde, OUTPUT);
}

void loop()
{
//Le o valor do pino A0 do sensor
valor_analogico = analogRead(pino_sinal_analogico);

//Mostra o valor da porta analogica no serial monitor

Serial.print("Porta analogica: ");
Serial.print(valor_analogico);

//Solo umido, acende o led verde

if (valor_analogico > 0 && valor_analogico < 400)
{
Serial.println(" Status: Solo umido");
apagaleds();
digitalWrite(pino_led_verde, HIGH);
}

//Solo com umidade moderada, acende led amarelo

if (valor_analogico > 400 && valor_analogico < 800)
{
Serial.println(" Status: Umidade moderada");
apagaleds();
digitalWrite(pino_led_amarelo, HIGH);
 }

//Solo seco, acende led vermelho

if (valor_analogico > 800 && valor_analogico < 1024)
{
Serial.println(" Status: Solo seco");
apagaleds();
digitalWrite(pino_led_vermelho, HIGH);
}
delay(100);
}

void apagaleds()
{
digitalWrite(pino_led_vermelho, LOW);
digitalWrite(pino_led_amarelo, LOW);
digitalWrite(pino_led_verde, LOW);
}

Uma boa sugestão de “upgrade” nesse circuito é a utilização do NodeMCU, enviando

os avisos para o seu celular ou tablet ou mostrando esses valores em uma página web.
Você também pode usar esse sensor como base para montar um sistema de irrigação
com Arduino.

Como comunicar com o Arduino Ethernet Shield W5100

Controlar sensores ou enviar informações remotamente é um dos grandes objetivos de

quem mexe com Arduino. O Arduino Ethernet Shield W5100 é outro dispositivo dessa
família, que além de possibilitar o acesso às informações na sua rede local, ainda pode
ser conectado à internet e permitir o seu monitoramento de qualquer lugar do mundo.
CONFIGURE O ETHERNET SHIELD W5100

Acoplando o Arduino Ethernet Shield W5100 ao seu Arduino, basta um simples cabo de
rede para que, em poucos minutos, você passe a monitorar o estado de sensores,
chaves e outros dispositivos à partir do browser do seu computador ou celular. Este
Shield é baseado no ethernet chip Wiznet W5100 (datasheet) e fornece um endereço IP
compatível com os protocolos TCP e UDP.

O primeiro passo deste tutorial para setar corretamente o seu shield ethernet é
configurá-lo com um endereço IP válido da sua rede. Vamos mostrar como obter as
informações de rede no Windows 7, mas você pode usar o mesmo princípio para outros
sistemas operacionais.

Configuração IP:

Clique em INICIAR e, na caixa de diálogo, digite CMD. Em seguida pressione a

tecla ENTER :

Na janela de prompt de comando, digite “ipconfig /all” (sem as aspas) e aperte ENTER :
O comando será executado e várias informações aparecerão na tela. Procure pela
informação referente à sua placa de rede principal, semelhante à esta destacada na
imagem, pois são essas informações que você irá precisar para configurar o shield
: Endereço IP, Máscara de sub-rede e Gateway Padrão :

Esses três parâmetros são definidos logo no início do programa, e devem ser alterados
de acordo com a configuração da sua rede :

IPAddress ip(192,168,1,88) : Troque por um endereço IP no mesmo formato daquele que

você copiou na janela de prompt de comando, mas o último número deve ser diferente.
Exemplo : o IP do nosso equipamento é 192.168.1.120, e no programa utilizamos o
192.168.1.88. Antes de usar qualquer endereço da rede, certifique-se que o mesmo
ainda não está em uso por nenhum outro equipamento.

IPAddress gateway(192,168,1,1) : Utilize o mesmo endereço do Gateway Padrão que

você obteve na janela de prompt de comando. No nosso caso, 192.168.1.1

IPAddress subnet(255,255,255,0) : Utilize o mesmo endereço referente à máscara de

sub-rede, que você obteve na janela de prompt de comando : 255.255.255.0

Programando o Arduino:

Altere esses parâmetros citados acima de acordo com a sua configuração de rede, salve
o programa e carregue-o no seu Arduino.

//Programa : Arduino Ethernet Shield W5100 e HC-SR04

//Alteracoes e adaptacoes : FILIPEFLOP

//

//Baseado no programa exemplo de

//by David A. Mellis e Tom Igoe

#include <Ultrasonic.h>

#include <SPI.h>

#include <Ethernet.h>

//Define os parametros para o sensor ultrasonico HC-SR04

#define PINO_TRIGGER 6 //Porta ligada ao pino Trigger do sensor

#define PINO_ECHO 7 //Porta ligada ao pino Echo do sensor

//Inicializa o sensor ultrasonico

Ultrasonic ultrasonic(PINO_TRIGGER, PINO_ECHO);

//Definicoes de IP, mascara de rede e gateway

byte mac[] = {

0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

IPAddress ip(192,168,1,88); //Define o endereco IP

IPAddress gateway(192,168,1,1); //Define o gateway

IPAddress subnet(255, 255, 255, 0); //Define a máscara de rede

//Inicializa o servidor web na porta 80

EthernetServer server(80);

void setup()

//Inicializa a interface de rede

Ethernet.begin(mac, ip, gateway, subnet);

server.begin();

void loop() {

float cmMsec;

long microsec = ultrasonic.timing();

//Le e armazena as informacoes do sensor ultrasonico

cmMsec = ultrasonic.convert(microsec, Ultrasonic::CM);

//Aguarda conexao do browser

EthernetClient client = server.available();

if (client) {

Serial.println("new client");

// an http request ends with a blank line

boolean currentLineIsBlank = true;

while (client.connected()) {

if (client.available()) {

char c = client.read();

Serial.write(c);

// if you've gotten to the end of the line (received a newline

// character) and the line is blank, the http request has ended,

// so you can send a reply

if (c == 'n' && currentLineIsBlank) {

// send a standard http response header

client.println("HTTP/1.1 200 OK");

client.println("Content-Type: text/html");

client.println("Connection: close");

client.println("Refresh: 2"); //Recarrega a pagina a cada 2seg

client.println();

client.println("<!DOCTYPE HTML>");

client.println("<html>");

//Configura o texto e imprime o titulo no browser

client.print("<font color=#FF0000><b><u>");

client.print("Envio de informacoes pela rede utilizando Arduino");

client.print("</u></b></font>");

client.println("<br />");

client.println("<br />");

//Mostra o estado da porta digital 3

int porta_digital = digitalRead(3);

client.print("Porta Digital 3 : ");

client.print("<b>");
 client.print(porta_digital);

client.println("</b>");

client.print(" (0 = Desligada, 1 = Ligada)");

client.println("<br />");

//Mostra as informacoes lidas pelo sensor ultrasonico

client.print("Sensor Ultrasonico : ");

client.print("<b>");

client.print(cmMsec);

client.print(" cm");

client.println("</b></html>");

break;

if (c == 'n') {

// you're starting a new line

currentLineIsBlank = true;

else if (c != 'r') {

// you've gotten a character on the current line

currentLineIsBlank = false;

// give the web browser time to receive the data

delay(1);

// close the connection:

client.stop();

Enviando Informações pela Rede:

Encaixe o Arduino Ethernet Shield W5100 ao seu Arduino e ligue-o à um roteador ou

hub usando um cabo de rede comum. Vamos usar o webserver embutido na placa para
enviar ao browser duas informações sobre as portas do Arduino, uma informando sobre
o estado (ligado/desligado) de um botão ligado à porta 3, e outro com informações sobre
o Sensor Ultrasonico HC-SR04, ligado às portas 6 (pino trigger do sensor) e 7 (pino echo
do sensor) :
Para testar o funcionamento, abra o browser no seu computador e digite na barra de
endereços o IP que você configurou no programa. No nosso caso 192.168.1.88 :

Você também pode acessar pelo celular :

As informações serão enviadas pelo webserver da placa ethernet à cada 2 segundos

(veja no programa que esse tempo é configurável). Também podemos configurar no
programa os comandos html para formatação, como por exemplo <font> para exibir o
texto do título na cor vermelha, <b> para negrito e <u> para sublinhado. Você também
pode utilizar outros comandos HTML.