Arduino Android WI-FI Bluetooth: Arduino IP Camera WI-FI 18 CHs BT

Câmera IP WI-FI e controle com 18 canais Bluetooth no mesmo aplicativo.

Funciona com WI-FI sem acesso à internet!

***Utilize seu celular velho como câmera de vigilância - Baixo custo e mais simples.***

Funciona com WI-FI sem acesso à internet!

Método 1: Funciona com wi-fi do Roteador - Não é necessário configurar roteador;

Obs1.: Em campo aberto sem obstáculos ~100 metros e para ambiente interno com obstáculos 30 metros, dependendo da potência de transmissão do sinal wi-fi.

***Utilize seu celular velho como câmera de vigilância - Baixo custo e mais simples.***

Google Play: https://play.google.com/store/apps/details?id=appinventor.ai_antoniosergiosouzaalmeida.Arduino_IP_Camera_WI_FI_18_CHs_BT

- Este App. controla até 18 dispositivos Switches ON/OFF com Camera IP, conectados ao Arduino Uno, utilizando até 18 relés conectados à rede 110V/220V.

- Automação residencial: Monitorar e visualizar(câmera) o acionamento dos dispositivos(switches ON/OFF) à distância.

Apresentação do aplicativo: Arduino IP Camera WI-FI 18 CHs BT

Botão Monitor:
Visualiza a imagem da câmera do celular em tempo real;

Botão Bluetooth:
- Seleciona o dispositivo Bluetooth de uma lista;

Botão Atualizar:
- Atualiza o status dos Botões - Chaves ON/OFF;

- Botão Cadeado:
Abre cadeado, Modo Edição dos dispositivos, total de 18 dispositivos editáveis e numero de IP da câmera do celular;
Fecha cadeado, bloqueia modo de edição;

-Botão Rede:
Editar o numero de IP da câmera do celular e salvar no banco e dados do App;

- Botão Salvar:
Salva os nomes dos dispositivos e numero do IP da câmera do celular no banco de dados do App;

- Botão Sair:
Sai do App;

Botões ou Chaves ON/OFF:

- Total de 18 Botões - Chaves ON/OFF Modo Relé 110V/220V;
- Todos os Botões com seus nomes Editáveis;
- 02 Botões são de Pulso ON/OFF Modo Relé 110V/220V, Timer 2000ms, utilizados em Portas com Trava Elétrica.

*** Código Arduino Gratuíto!***

Google Play: https://play.google.com/store/apps/details?id=appinventor.ai_antoniosergiosouzaalmeida.Arduino_IP_Camera_WI_FI_18_CHs_BT

Imagens do Aplicativo - Arduino IP Camera WI-FI 18 CHs BT:

Veja também:

1- Programa código Arduino completo para o App.: Arduino IP Camera WI-FI 18 CHs BT;
2- Esquema de ligações com galeria de fotos;
3- Descrição de funcionamento e instalações.
4- Como montar e configurar corretamente o App;
5- Lista de Materiais.

Como funciona:

- Iniciar o App. Arduino IP Camera WI-FI 18 CHs BT, neste momento será pedido para ligar o Bluetooth de seu celular;
- Então após esta ação pressionamos o botão para escolher um dispositivo Bluetooth de uma lista;
- Note que neste momento o bluetooth para de piscar e fica aceso continuamente, representando que o Bluetooth está conectado;
Obs.: Veja como fazer as ligações necessárias, como alimentação, bluetooth, leds ou relés, e outros;
- Todos os botões e IP são editáveis;
- Neste momento já podemos testar os acionamentos ON/OFF, mesmo sem a montagem dos leds ou relés, apenas com o módulo Bluetooth conectado;
- Podemos ligar Leds nas saídas do Arduino para representar todos os 18 canais de acionamentos;
- Devemos ligar relés nas saídas do Arduino para fazermos os acionamentos ON/OFF em uma rede elétrica 110/220V;
- Através destes relés podemos controlar(liga/desliga) lâmpadas, abatjours, luminárias, ventiladores, travas elétricas de portas, motores, contatores, forno elétrico, TV, som, torradeira, aparelhos eletrodomésticos, etc;

O Arduino também transmite de volta via wi-fi o Status das portas acionadas, de forma que qualquer modificação de acionamento dos relés possa ser visualizada através da câmera e alteração de status dos botões - chaves são mostradas instantaneamente no smartphone Android;

Automação residencial: Monitorar e visualizar imagens da câmera todos os acionamento dos dispositivos(botões-chaves ON/OFF) à distância.

Neste projeto utilizaremos a câmera de um celular "velho" e o sistema de controle e visualização das imagens da câmera fica por conta do App. Arduino IP Camera WI-FI 18 CHs BT, instalado em outro celular.

Então o primeiro celular "velho" será usado apenas como câmera de vigilância e o segundo celular será usado para controle dos dispositivos ON/OFF e Monitoramento das imagens em tempo real.

Instalar o App. Arduino IP Camera WI-FI 18 CHs BT
Google Play:

Veja como é facil, abra o App e clique no botão cadeado para editar o IP de sua câmera(celular velho):

Procedimento:

Instalar o App. IP WebCam no celular velho;
Google Play: https://play.google.com/store/apps/details?id=appinventor.ai_antoniosergiosouzaalmeida.Arduino_IP_Camera_WI_FI_18_CHs_BT

Configurações básicas do App. IP WebCam no celular velho:

- Ligar o WI-FI;

Escolher uma rede WI-FI de seu roteador;

Entrar no App.IP WebCam;

Selecionar Vídeo preferences;

Selecionar Vídeo resolution;
Para retornar, clique no ícone IP Webcam;

Selecionar 640x480;

Para retornar, clique no ícone IP Webcam;

Clique agora em Local broadcasting;

Selecione Login/password;

Para retornar, clique no ícone IP Webcam;

Escolha um login e senha, estes dados serão utilizados apenas para câmera;

Dê OK e para retornar clique no ícone IP Webcam;

Finalizando, clique em Start server;

Pronto agora você já tem a câmera funcionando e basta copiar o numero do IP que será utilizado no segundo celular com o App. Arduino IP Camera WI-FI 18 CHs BT;

Neste exemplo fica assim: http://192.168.1.50:8080

O App. fornece este IP; Quando o celular faz a conexão WI-FI com o seu roteador, o App. captura e mostra este este IP que será utilizado mais tarde.

Porta para utilização da câmera " :8080 "; Esta é a porta de acesso à nossa câmera do celular;

Instalação do App. Arduino IP Camera WI-FI 18 CHs BT no segundo celular:

Google Play:

Instalar o App. Arduino IP Camera WI-FI 18 CHs BT
Google Play:

Passo a passo:

Ligar o Bluetooth do smartphone, entrar em configurações e parear o dispositivo bluetooth.

Será pedido uma senha para parear o BT, normalmente "0000" ou "1234" e pressione OK.

Neste exemplo meu HC-6 está pareado.

O celular Android e o Arduino conectam-se através do Bluetooth HC6, nos pinos de saída do Arduino, temos ligado uma placa de relés(TOTAL ATÉ 18 RELÉS)que por sua vez está ligada à rede elétrica(110/220V) ligados aos dispositivos que se deseja controlar. Exemplo de acionamento dispositivos ON/OFF: Lâmpadas de leds(sala, cozinha, quarto, quintal, jardim...), Ventilador, Ar condicionado, TV, Rádio, Cafeteira, Torradeira, Aquário... Exemplo de acionamento BOTÕES de PULSO ON/OFF(2 segundos): Porta ou portão com trava elétrica; Quando por exemplo pressionarmos um botão para ligarmos um dispositivo, o APP. Android envia dados à placa ESP8266, esta recebe estes dados processa e toma decisão de enviar comandos para ligar/desligar o relé correspondente; O Arduino retorna os dados das portas analógicas e digitais para o APP. Android que irá mostrar as chaves e botões de pulso com a indicação do status correspondente.

Agora vamos preparar para visualizar a câmera do celular velho; Primeiro vamos inserir o IP neste campo de Rede.

Veja como é facil, abra o App e clique no botão cadeado para editar o IP de sua câmera(celular velho);
Neste exemplo: http://192.168.1.50:8080

Clique no botão cadeado para encerrar o modo de edição.

Clique no botão disquete para salvar sua edição de IP da câmera.

Clique no botão monitor para abrir o browser do IP Webcam;
CLIQUE NO BOTÃO JAVASCRIPT.

Clique no botão FRONT CAMERA se preferir(seleciona entre câmera frontal ou traseira).

E...pronto! Você já pode visualizar sua câmera via WI-FI através do IP(http://192.168.1.50) e porta(:8080) que foram obtidos através de seu roteador WI-FI.

Aqui veja que como já estou com um módulo Bluetooth ligado;

Clicar no botão bluetooth, selecionar o BT de uma lista para conectar; Os acionamentos são via bluetooth, independente da câmera WI-FI.

Selecionar o MAC correspondente ao seu Bluetooth, no exemplo HC-06.

Na sequencia a tela retorna para a tela principal do App.
Será mostrado uma notificação dizendo que o MAC foi selecionado e o bluetooth está conectado.

Use a barra de rolagem tanto para a câmera quanto para os botões.

Veja todos os 18 canais de acionamento via bluetooth; Sendo que os 2 últimos canais são para acionamentos de trava elétrica de portões.

Obs.:1 A câmera funciona com WI-FI e os botões de acionamentos funcionam via bluetooth, então não se esqueça de ligar o WI-FI e bluetooth de seu smatphone.

Neste primeiro exemplo veja que:

- Não precisamos configurar o roteador;

- Nossa conexão é WI-FI(rede interna) e bluetooth, sem o uso de internet;

A atuação da Câmera e dos botões de acionamento dependem do alcance do WI-FI que em campo aberto pode atingir cerca de 100 metros e local fechado ou com obstáculos 30 metros.

Atenção:

Para os mais experientes, sabem que também podemos controlar a câmera de qualquer lugar independente da distância;

Através de qualquer outro ponto de WI-FI ou 3G, basta inserir o IP real, aquele IP que está chegando na rede WAN de seu roteador ou computador e se necessário entrar nas configurações de seu roteador para abrir a Porta:8080(public port) que está direcionada para este IP de exemplo do roteador(192.168.1.50). Então no campo de edição de rede ficaria exemplo: http://193.203.168.121:8080 veja que este tem que ser um IP real que está entrando na WAN de seu roteador.

Obs.:

A câmera é opcional;

A câmera funciona via WI-FI, independente do sistema de controle que funciona via bluetooth.

O App. Arduino IP Camera WI-FI 18 CHs BT também funciona no modo bluetooth e sem a câmera.

Conectando o App. Arduino IP Camera WI-FI 18 CHs BT com o Arduino mais o módulo bluetooth e câmera do celular velho.

Pronto agora você já pode acionar todos os 18 canais e visualizar a câmera, para isso monte o circuito proposto.

EDIÇÃO dos nomes dos dispositivos:

Pressionar o botão cadeado verde para desbloquear e entrar no modo de edição, um cadeado vermelho aparece(modo e edição desbloqueado) então clique no Device que deseja editar; Um teclado aparece, digite o novo nome do dispositivo e clique em ok.

Clique no botão cadeado vermelho para bloquear o modo de edição.

Agora vamos salvar a edição do banco de dados do APP., para isso pressione o botão disquete azul e pronto!

Imagem do circuito montado, acompanhe os testes de bancada!

Diagrama de Conexões(Pinagem Arduino - Led/Relé e HC-06):

pinA0 = Led/Relé1
pinA1 = Led/Relé2
pinA2 = Led/Relé3
pinA3 = Led/Relé4
pinA4 = Led/Relé5
pinA5 = Led/Relé6
pinD0 = Bluetooth HC-06 - TX
pinD1 = Bluetooth HC-06 - RX
pinD2 = Led/Relé7
pinD3 = Led/Relé8
pinD4 = Led/Relé9
pinD5 = Led/Relé10
pinD6 = Led/Relé11
pinD7 = Led/Relé12
pinD8 = Led/Relé13
pinD9 = Led/Relé14
pinD10 = Led/Relé15
pinD11 = Led/Relé16
pinD12 = Led/Relé17
pinD13 = Led/Relé18

Obs.: Atenção evitar conflito entre as seriais(Arduino e HC-06) carregar o programa Arduino sem o módulo bluetooth HC-06 pois a conexão RX -TX do HC-06 está na mesma pinagem RX - TX do Arduino(D0 e D1).

Após carregar o programa ligar o bluetooth HC-06(Vcc, GND, RX e TX), evitando conflito com a serial.

Esquema de ligações utilizando Leds:

Utilizamos o mesmo programa Arduino que foi utilizado para acionamento com relés.

Veja que montei os catodos dos leds voltados para as portas do Arduino, asim quando enviarmos sinal 0V o led acende e 5V apaga; Assim quando utilizarmos os módulos de relés, estes já estarão prontos para receberem o sinal.

A maioria dos módulos de relés possuem lógica invertida ou seja acionam em 0V e desligam em 5V.

Utilizamos o mesmo programa Arduino que foi utilizado para acionamento com leds.

Repetir estas ligações utilizando 18 Relés entre os terminais Arduino:

A0, A1,A2, A3, A4, A5, D2, D3, D4, D5, D6, D7, D8, D9, D10, D11, D12, D13.

Obs.: Se necessário utilizar 2 fontes de alimentação:

Uma fonte de 12V/1000mA para o Arduino e outra fonte de alimentação de 5VDC/2000mA para alimentação dos relés, conectar os "GND´s" em comum(GND do Arduino com GND da Fonte e GND do Bluetooth) e aplicar a alimentação 5V diretamente na placa módulo de relé.

Desta forma não estaremos sobrecarregando o regulador de tensão de 5V do Arduino, então desfaça a ligação de 5V entre o Arduino e módulo relé e ligue apenas o 5V da fonte no módulo relé.

*** Se preferir utilize uma fonte de 5V/1000mA saída USB para o Arduino.

Exemplo de ligações utilizando módulo de relés na rede elétrica:

O módulo relé possui uma lógica invertida quando desejamos acionar ou energizar a bobina no relé precisamos colocar nível "0V' na entrada do módulo relé(lógica invertida) com isso um contato normalmente aberto é fechado de forma correta.

Exemplo ligação com uma Lâmpada em rede de 110V:

Obs.: Atenção evitar conflito entre as seriais(Arduino e HC-06) carregar o programa Arduino sem a placa(desconectada) de bluetooth HC-06 pois a conexão RX -TX do HC-06 está na mesma pinagem RX - TX do Arduino(D0 e D1).

Após carregar o programa ligar o bluetooth HC-06(Vcc, GND, RX e TX), evitando conflito com a serial.

Obs.: Atenção evitar conflito entre as seriais(Arduino e HC-06) carregar o programa Arduino sem a placa(desconectada) de bluetooth HC-06 pois a conexão RX -TX do HC-06 está na mesma pinagem RX - TX do Arduino(D0 e D1).

Após carregar o programa ligar o bluetooth HC-06(Vcc, GND, RX e TX), evitando conflito com a serial.

Programa - Arduino IP Camera WI-FI 18 CHs BT :

#include <SoftwareSerial.h>//Biblioteca Serial--------------------------
SoftwareSerial mySerial(0, 1);//Biblioteca para serial bluetooth
//Arduino D0(Bluetooth-TX), Arduino D1(Bluetooth-RX)--------------------

//------Declaração das variáveis para os pinos A0--A5 e D2--D13 Arduino-
int pinA0 = A0;//A0
int pinA1 = A1;//A1
int pinA2 = A2;//A2
int pinA3 = A3;//A3
int pinA4 = A4;//A4
int pinA5 = A5;//A5
int pinD2 = 2;//D2
int pinD3 = 3;//D3
int pinD4 = 4;//D4
int pinD5 = 5;//D5
int pinD6 = 6;//D6
int pinD7 = 7;//D7
int pinD8 = 8;//D8
int pinD9 = 9;//D9
int pinD10 = 10;//D10
int pinD11 = 11;//D11
int pinD12 = 12;//D12
int pinD13 = 13;//D13
//----------------------------------------

void setup() {

mySerial.begin(9600);//Velocidade da serial em 9600bps-----------
//Obs.: Bluetooth também deve estar na mesma veloc. 9600bps;

//-----------------Pinos Arduino, saída para acionamentos----------
pinMode(pinA0, OUTPUT);
pinMode(pinA1, OUTPUT);
pinMode(pinA2, OUTPUT);
pinMode(pinA3, OUTPUT);
pinMode(pinA4, OUTPUT);
pinMode(pinA5, OUTPUT);
pinMode(pinD2, OUTPUT);
pinMode(pinD3, OUTPUT);
pinMode(pinD4, OUTPUT);
pinMode(pinD5, OUTPUT);
pinMode(pinD6, OUTPUT);
pinMode(pinD7, OUTPUT);
pinMode(pinD8, OUTPUT);
pinMode(pinD9, OUTPUT);
pinMode(pinD10, OUTPUT);
pinMode(pinD11, OUTPUT);
pinMode(pinD12, OUTPUT);
pinMode(pinD13, OUTPUT);

//-----------------Pinos Arduino, inicia em nível alto(desligado)--------
//Obs.: Desliga em nível alto(HIGH==OFF) e Liga em nível baixo(LOW==ON)--
digitalWrite(pinA0, HIGH);
digitalWrite(pinA1, HIGH);
digitalWrite(pinA2, HIGH);
digitalWrite(pinA3, HIGH);
digitalWrite(pinA4, HIGH);
digitalWrite(pinA5, HIGH);
digitalWrite(pinD2, HIGH);
digitalWrite(pinD3, HIGH);
digitalWrite(pinD4, HIGH);
digitalWrite(pinD5, HIGH);
digitalWrite(pinD6, HIGH);
digitalWrite(pinD7, HIGH);
digitalWrite(pinD8, HIGH);
digitalWrite(pinD9, HIGH);
digitalWrite(pinD10, HIGH);
digitalWrite(pinD11, HIGH);
digitalWrite(pinD12, HIGH);
digitalWrite(pinD13, HIGH);
}

//---------------------------
void loop() {
char caracter = mySerial.read();//Variavel para leitura da serial;
delay(3);
/*************************************************************************************
Acionamento dos 18 canais(ON/OFF);
APP envia caracteres(via Bluetooth) correspondentes aos pinos de saída do Arduino;
Arduino faz uma leitura da serial e compara o caracter recebido e
liga ou desliga a saída correspondente;
*************************************************************************************/
if (caracter == 'A')
{
digitalWrite(pinA0, LOW);
}
if (caracter == 'a')
{
digitalWrite(pinA0, HIGH);
}
//----------------------------
if (caracter == 'B')
{
digitalWrite(pinA1, LOW);
}
if (caracter == 'b')
{
digitalWrite(pinA1, HIGH);
}
//---------------------------
if (caracter == 'C')
{
digitalWrite(pinA2, LOW);
}
if (caracter == 'c')
{
digitalWrite(pinA2, HIGH);
}
//---------------------------
if (caracter == 'D')
{
digitalWrite(pinA3, LOW);
}
if (caracter == 'd')
{
digitalWrite(pinA3, HIGH);
}
//---------------------------
if (caracter == 'E')
{
digitalWrite(pinA4, LOW);
}
if (caracter == 'e')
{
digitalWrite(pinA4, HIGH);
}
//---------------------------
if (caracter == 'F')
{
digitalWrite(pinA5, LOW);
}
if (caracter == 'f')
{
digitalWrite(pinA5, HIGH);
}
//---------------------------
if (caracter == 'G')
{
digitalWrite(pinD2, LOW);
}
if (caracter == 'g')
{
digitalWrite(pinD2, HIGH);
}
//---------------------------
if (caracter == 'H')
{
digitalWrite(pinD3, LOW);
}
if (caracter == 'h')
{
digitalWrite(pinD3, HIGH);
}
//---------------------------
if (caracter == 'I')
{
digitalWrite(pinD4, LOW);
}
if (caracter == 'i')
{
digitalWrite(pinD4, HIGH);
}
//---------------------------
if (caracter == 'J')
{
digitalWrite(pinD5, LOW);
}
if (caracter == 'j')
{
digitalWrite(pinD5, HIGH);
}
//---------------------------
if (caracter == 'K')
{
digitalWrite(pinD6, LOW);
}
if (caracter == 'k')
{
digitalWrite(pinD6, HIGH);
}
//---------------------------
if (caracter == 'L')
{
digitalWrite(pinD7, LOW);
}
if (caracter == 'l')
{
digitalWrite(pinD7, HIGH);
}
//---------------------------
if (caracter == 'M')
{
digitalWrite(pinD8, LOW);
}
if (caracter == 'm')
{
digitalWrite(pinD8, HIGH);
}
//---------------------------
if (caracter == 'N')
{
digitalWrite(pinD9, LOW);
}
if (caracter == 'n')
{
digitalWrite(pinD9, HIGH);
}
//---------------------------
if (caracter == 'O')
{
digitalWrite(pinD10, LOW);
}
if (caracter == 'o')
{
digitalWrite(pinD10, HIGH);
}
//---------------------------
if (caracter == 'P')
{
digitalWrite(pinD11, LOW);
}
if (caracter == 'p')
{
digitalWrite(pinD11, HIGH);
}
//---------------------------
if (caracter == 'Q')
{
digitalWrite(pinD12, LOW);
delay(2000);
digitalWrite(pinD12, HIGH);
}
//---------------------------
if (caracter == 'T')
{
digitalWrite(pinD13, LOW);
delay(2000);
digitalWrite(pinD13, HIGH);
}
//---------------------------

/*******************************************************************************************
Aualização da pagina do APP(Status ON/OFF));
APP envia para o Arduino uma string caracter"S";
Arduino recebe(via bluetooth serial) uma solicitação para leituradas portas;
Arduino retorna para o APP o novo status(leitura atualizada do estado das portas ON/OFF)
******************************************************************************************/
if(caracter == 'S'){

if(digitalRead(pinA0)==LOW){
mySerial.println("LA");
}
if(digitalRead(pinA0)==HIGH){
mySerial.println("La");
}
delay(25);
//--------------------------------------
if(digitalRead(pinA1)==LOW){
mySerial.println("LB");
}
if(digitalRead(pinA1)==HIGH){
mySerial.println("Lb");
}
delay(25);
//--------------------------------------
if(digitalRead(pinA2)==LOW){
mySerial.println("LC");
}
if(digitalRead(pinA2)==HIGH){
mySerial.println("Lc");
}
delay(25);
//--------------------------------------
if(digitalRead(pinA3)==LOW){
mySerial.println("LD");
}
if(digitalRead(pinA3)==HIGH){
mySerial.println("Ld");
}
delay(25);
//--------------------------------------
if(digitalRead(pinA4)==LOW){
mySerial.println("LE");
}
if(digitalRead(pinA4)==HIGH){
mySerial.println("Le");
}
delay(25);
//--------------------------------------
if(digitalRead(pinA5)==LOW){
mySerial.println("LF");
}
if(digitalRead(pinA5)==HIGH){
mySerial.println("Lf");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD2)==LOW){
mySerial.println("LG");
}
if(digitalRead(pinD2)==HIGH){
mySerial.println("Lg");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD3)==LOW){
mySerial.println("LH");
}
if(digitalRead(pinD3)==HIGH){
mySerial.println("Lh");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD4)==LOW){
mySerial.println("LI");
}
if(digitalRead(pinD4)==HIGH){
mySerial.println("Li");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD5)==LOW){
mySerial.println("LJ");
}
if(digitalRead(pinD5)==HIGH){
mySerial.println("Lj");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD6)==LOW){
mySerial.println("LK");
}
if(digitalRead(pinD6)==HIGH){
mySerial.println("Lk");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD7)==LOW){
mySerial.println("LL");
}
if(digitalRead(pinD7)==HIGH){
mySerial.println("Ll");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD8)==LOW){
mySerial.println("LM");
}
if(digitalRead(pinD8)==HIGH){
mySerial.println("Lm");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD9)==LOW){
mySerial.println("LN");
}
if(digitalRead(pinD9)==HIGH){
mySerial.println("Ln");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD10)==LOW){
mySerial.println("LO");
}
if(digitalRead(pinD10)==HIGH){
mySerial.println("Lo");
}
delay(25);
//--------------------------------------
if(digitalRead(pinD11)==LOW){
mySerial.println("LP");
}
if(digitalRead(pinD11)==HIGH){
mySerial.println("Lp");
}
delay(25);

}//if
delay(10);
}//loop

Lista de Materiais:

1 X Fonte de Alimentação 12VDC/1000mA com saída P4 para o Arduino;
1 X Fonte de Alimentação 5VDC/2000mA com saída P4(ou fios - jumpers) para o Módulo de Relés;

Atenção:

Devido a alimentação de 18 Relés, sujerimos uma fonte com 2A para suprir essa demanda de corrente.