Páginas

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.***






- 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;





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.




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.



Exemplo de ligações com relés: 
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.








Arduino Uno R3.








Módulo Bluetooth HC-06 ou JY-MCU:












Módulo de Relés:













Resistores de 220 ohms e Leds.









Protoboard.












Jumper Wire - Cabos para ligações:


Macho - Fêmea.







Macho - Macho












Nenhum comentário:

Postar um comentário