Jarvis – Feedback / Confirmação das ações executadas no Arduino

Por padrão o Jarvis não tem a capacidade de dar feedback ou confirmar se uma ação foi de fato executada na plataforma microcontrolada. Por exemplo: enviamos o comando ao Jarvis para que através do Arduino ele acione um relé com o intuito de apagar ou acender a lâmpada. O comando vai ser enviado ao Arduino pela serial, contudo, o Jarvis não consegue confirmar se a lâmpada está acesa ou apagada. Mas será que é possível implementar alguma solução para que o Jarvis possa dar feedback ou confirmar as ações executadas pelo Arduino?! A resposta é SIM e hoje você vai aprender!

– Introdução

Na primeira postagem sobre o Jarvis que saiu aqui no blog, foi falado um pouco sobre a ferramenta, suas capacidades, compatibilidade e foi implementado uma prática com o intuito de demonstrar a integração entre o Jarvis e o Arduino. Acesse a postagem Jarvis – Controlando o seu Arduino por Comandos de Voz e veja todos os detalhes.

O DJ.JARVIS.AM ou simplesmente Jarvis, é um programa de computador que tem como papel ser um assistente de voz. O Jarvis pode ser instalado e executado em dispositivos com Windows, e além disso, reconhece os comandos de voz em português do Brasil. Além de ser capaz de interagir com as pessoas e executar tarefas do nosso cotidiano, o Jarvis pode ser integrado com qualquer plataforma embarcada / microcontrolada que possua comunicação serial. Desta forma, podemos interagir o Jarvis com o Arduino, Raspberry Pi, ESP8266 e ESP32, por exemplo. Com isto, temos infinitas possibilidades de projetos, principalmente na área de automação residencial e robótica.

Para conhecer todos os detalhes do Jarvis, recomendo que acesse o site oficial e faça o download da versão free para que você possa fazer testes com a ferramenta. Lembrando que o Jarvis está disponível também na versão PRO:

Site Oficial do Jarvis

Download Jarvis

Tutoriais de Instalação e Configuração

– Feedback e confirmação através do Jarvis

Conforme mencionado anteriormente, o Jarvis não tem a capacidade de dar retorno ou confirmar se uma ação foi de fato executada. Na integração com Arduino, por exemplo, nós falamos o comando para o Jarvis, ele dá uma resposta (se estiver configurada), processa o comando e envia ao Arduino através da serial o caractere correspondente. O Arduino recebe o comando e executa a ação, contudo, o Jarvis não consegue receber um retorno do Arduino e dar uma segunda resposta informando se a ação foi realmente executada.

A vantagem do Jarvis poder dar feedback é que a interação com a ferramenta fica muito mais completa, pois torna-se possível fazer perguntas e receber respostas com base no retorno dado pelo Arduino e o Jarvis pode fazer perguntas e aguardar confirmações (respostas) com base nos eventos ou alterações que ocorrerem nos sensores, módulos, shields e componentes eletrônicos conectados ao Arduino. Além disso, tem várias pessoas implementando projetos com o Jarvis com a finalidade de ajudar pessoas com problema de mobilidade, logo, o uso do feedback e confirmação das ações executadas permite que os projetos possam ser melhorados e consequentemente trazer mais funcionalidades.

– Solução para o feedback e confirmação

Para enviar comandos ao Jarvis, falamos o comando, o microfone capta a voz, o Jarvis interpreta, dá uma resposta e executa uma ação. Portanto, o que precisamos fazer é permitir que o Arduino também possa conversar com o Jarvis, ou seja, reproduzir a nossa voz, de forma que o Jarvis possa captar esta reprodução e dar uma resposta em correspondência, que no nosso caso é confirmar as ações executadas pelo Arduino ou fazer perguntas com base nas alterações que ocorrerem nos dispositivos que estiverem conectados a placa.

A forma mais simples que encontrei para fazer com que o Arduino converse com o Jarvis e possa reproduzir os comandos de voz e direcioná-los ao programa, é através do Módulo YX6300 Leitor de Cartão com Saída de Áudio P2 ou simplesmente Módulo YX6300 (Serial MP3 Player v1.0 YX5300):

Este módulo aceita micro cartão sd formatado em FAT32 / FAT16 e as faixas de áudio podem ser em formato MP3 ou WAV com taxa de amostragem na faixa de 8kHz a 48kHz. A saída de áudio do módulo é estéreo e aceita conexão de um fone de ouvido ou alto falante, por exemplo. O controle do módulo é feito utilizando comandos seriais, logo, fica fácil conectá-lo ao Arduino ou a qualquer outra plataforma embarcada que possua comunicação serial.

Pelo fato deste módulo possuir uma saída de áudio com conector P2 fêmea, torna-se possível conectá-lo a uma entrada de microfone do computador. Desta forma, podemos gravar os comandos de voz no cartão de memória, programar o Arduino para reproduzir cada um dos comandos gravados no cartão e como a saída do módulo vai estar conectada ao computador, o Jarvis vai estar escutando os comandos e poderá dar uma resposta correspondente a cada comando reconhecido.

Com esta solução para o Arduino dar comandos de voz ao Jarvis, o diagrama de comunicação fica conforme a imagem abaixo:

Geralmente computadores desktop possuem duas conexões de microfone, uma na parte de trás da máquina e outra na parte frontal. Logo, fica fácil conectar o microfone em uma das entradas e conectar o Módulo YX6300 na entrada que sobrar. No caso de notebooks, há somente uma entrada de microfone, logo, precisamos conectar o microfone e o módulo nesta mesma entrada através de um Cabo 2X1.

OBS: se o computador que você utiliza o Jarvis possuir duas entradas de microfone e não pretende confeccionar o Cabo 2X1, pule para ESTA etapa.

– Cabo 2X1 para a entrada de microfone

O conector de microfone do computador / notebook é estéreo, logo, possui dois canais de áudio separados. O que precisamos fazer é construir um Cabo 2X1, sendo duas entradas P2 fêmea e uma saída P2 macho.

Se o seu computador ou notebook possuir apenas um conector de microfone e você pretende construir o Cabo 2X1, irá precisar de:

02 – Conector P2 Estéreo Fêmea
01 – Conector P2 Estéreo Macho
01 – Cabo Microfone Estéreo com Malha 2×0.20 mm² (1 metro)
01 – Ferro de solda
01 – Estanho

OBS: dê preferência para utilizar conector P2 do tipo metálico, pois ele reduz consideravelmente o ruído do sinal de áudio.

Na imagem abaixo você pode ver como serão feitas as conexões para que cada entrada (P2 fêmea) utilize apenas um canal de áudio da saída (P2 macho):

Observe que um dos fios de cada um dos cabos de entrada foi ignorado. Utilize um ferro de solda para fazer as conexões e se possível, dê acabamento com espaguete termo retrátil.

Você pode usar como referência a sequência de imagens abaixo que mostra a confecção do Cabo 2X1 que eu fiz:

Terminado a confecção do cabo, basta conectá-lo ao computador através da entrada de microfone para fazer um teste rápido. Acesse o “Painel de Controle” do Windows e em seguida clique na opção “Som”:

Com a janela aberta, clique na aba “Gravação” e em seguida dê dois cliques sobre o microfone (entrada em que o Cabo 2X1 está conectado):

Na janela que for aberta, clique na aba “Níveis” e deixe configurado conforme a imagem abaixo:

Clique na aba “Aperfeiçoamentos”, deixe marcado somente a opção “Modo imediato” e clique no botão “OK”. Não marque mais nenhuma opção, pois isto pode comprometer o funcionamento de uma das entradas do cabo:

Com o Cabo 2X1 conectado ao computador e a janela “Som” aberta, conecte o microfone em um dos canais de entrada dele e fale próximo ao microfone. Se tudo estiver correto, o nível de sinal irá variar conforme a imagem abaixo:

Agora conecte o microfone no outro canal de entrada do Cabo 2X1, fale próximo ao microfone e se tudo estiver correto, o nível de sinal irá variar.

Quando o microfone estiver conectado em um dos canais de entrada do Cabo 2X1 e o Módulo YX6300 estiver conectado no outro canal, o funcionamento deles será de forma separada e não haverá interferência (elétrica) entre eles.

– Propostas práticas

Para demonstrar esta integração entre o Jarvis e o Arduino com feedback e confirmação das ações executadas, optei por implementar:

Acionamento de uma bomba d’água e monitoramento de um recipiente com água: o acionamento da bomba d’água para encher o recipiente vai ser feito pelo Jarvis através do comando de voz e o nível do recipiente também vai poder ser consultado. O nível máximo do recipiente vai ser monitorado e quando for atingido, o Jarvis vai informar que o recipiente está cheio e vai desligar a bomba d’água. Na consulta ao Jarvis perguntando qual o nível do recipiente, caso o nível esteja abaixo do máximo, o Jarvis vai perguntar se deseja que a bomba d’água seja ligada.

Para esta prática serão necessários os itens abaixo:

01 – Arduino com Cabo USB
01 – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2
01 – Micro Cartão de Memória
01 – Mini Motor DC – Bomba de Água Submersível
01 – Sensor Óptico Infravermelho Detector de Nível de Líquido
01 – Módulo Relé 5V de 1 Canal
01 – Resistor de 330Ω
01 – Resistor de 4,7KΩ
01 – Protoboard
05 – Cabos Jumper macho-macho
07 – Cabos Jumper macho-fêmea
01 – Cabo 2X1 (para computador com apenas uma entrada de microfone)
01 – Cabo P2 Macho (em ambas as pontas)
01 – Fonte 5V (no mínimo 1A)
02 – Recipiente (para água)
01 – Mangueira de 1/2” para a mini bomba d’água

Simulador de segurança com sensor de movimento: o alarme poderá ser ativado ou desativado por comando enviado ao Jarvis e quando o sensor estiver ativo, se houver detecção de movimento, o Jarvis irá avisar que identificou um movimento no ambiente.

Para esta prática serão necessários os itens abaixo:

01 – Arduino com Cabo USB
01 – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2
01 – Micro Cartão de Memória
01 – Sensor Microondas RCWL-0516 (Detector) de Movimento
07 – Cabos Jumper macho-fêmea
01 – Cabo 2X1 (para computador com apenas uma entrada de microfone)
01 – Cabo P2 Macho (em ambas as pontas)

Acionamento de um ventilador com base na temperatura medida por um sensor: além de poder ligar ou desligar o ventilador por comando de voz, quando a temperatura ultrapassar um determinado valor, o Jarvis irá perguntar se o ventilador pode ser ligado.

Para esta prática serão necessários os itens abaixo:

01 – Arduino com Cabo USB
01 – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2
01 – Micro Cartão de Memória
01 – Sensor de Temperatura DS18B20 – Prova D’água do Tipo Sonda
01 – Módulo Relé 5V de 1 Canal
01 – Resistor de 4,7KΩ
01 – Protoboard
03 – Cabos Jumper macho-macho
07 – Cabos Jumper macho-fêmea
01 – Cabo 2X1 (para computador com apenas uma entrada de microfone)
01 – Cabo P2 Macho (em ambas as pontas)
01 – Fonte 5V (no mínimo 1A)
01 – Mini Ventilador USB

Acionamento de uma lâmpada e controle de luminosidade: o acionamento da lâmpada será feito pelo Jarvis e o estado atual (acesa ou apagada) também será informado por ele. Se a lâmpada já estiver acesa e for dado o comando para liga-la, o Jarvis irá informar que ela já está acesa e se for dado o comando para apaga-la e a mesma já estiver apagada, o Jarvis vai informar que ela já está apagada. Além de poder apagar e acender a lâmpada, vai ser possível controlar a luminosidade dela (dimerização) e consultar o Jarvis sobre qual o percentual atual de luminosidade que está definido nela.

Para esta prática serão necessários os itens abaixo:

01 – Arduino com Cabo USB
01 – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2
01 – Micro Cartão de Memória
01 – Módulo Dimmer de 1 Canal Bivolt com RF 433MHz para Automação
01 – Módulo Transmissor Wireless RF 433MHz
01 – Controle Remoto (Transmissor) para RF 433 MHz
01 – Sensor de Corrente (AC e DC) ACS712-30A
01 – Chave Gangorra KCD1-101 NA Preta 2T (Pulsante)
03 – Cabos Jumper macho-macho
07 – Cabos Jumper macho-fêmea
01 – Cabo 2X1 (para computador com apenas uma entrada de microfone)
01 – Cabo P2 Macho (em ambas as pontas)
01 – Lâmpada (dimerizável)
01 – Receptáculo (boquilha)
01 – Cabo paralelo de 1,5mm ou 2,5mm
01 – Tomada (Rede alternada de 127V)

OBS: se você quiser conhecer os detalhes do Módulo Dimmer de 1 Canal Bivolt com RF 433MHz para Automação, acesse a postagem Conhecendo o Módulo Dimmer AC Bivolt com RF 433MHz para Automação .

– Configurando o Jarvis

Considerando que você já tenha o Jarvis instalado e configurado em seu computador, execute o programa e aguarde o carregamento da interface.

OBS: o Jarvis que está instalado no meu computador é a versão PRO e está com o tema Dark Edition.

Com o Jarvis aberto, acesse a opção de “Comandos” para que o menu de opções seja aberto.

Clique na opção “Controles de automação”:

Na janela que for aberta, clique em “Comandos Arduino”:

Nesta janela, em “Portas seriais” selecione a porta COM em que seu Arduino está conectado e clique em “Salvar porta”. Em “Baud rate” selecione 9600 e clique em “Setar Baud Rate”:

OBS: a porta COM1 é nativa do Windows e não corresponde ao Arduino.

Na parte de “COMANDOS” deve ser inserido em cada linha o comando de voz (palavra ou frase), em “RESPOSTAS” deve ser inserido em cada linha a resposta correspondente ao comando e em “ENVIAR” deve ser inserido o caractere que será enviado via serial para o Arduino. Estes serão os comandos falados ao Jarvis através do microfone.

Para criar o comando, basta colocar o cursor na linha 1, digitar a frase e pressionar enter para que o cursor vá para a segunda linha. Use este mesmo procedimento para inserir as respostas e os caracteres a serem enviados ao Arduino.

Após preenchimento das informações, minhas configurações ficaram conforme a imagem abaixo:

Clique em “Salvar” para efetivar as modificações.

OBS: veja que nas linhas 1, 8, e 10 coloquei mais de um comando e os separei por uma barra vertical. Desta forma, qualquer um destes comandos que eu falar, ele vai dar a mesma resposta (se existir resposta configurada) e vai enviar ao Arduino o caractere definido. Na resposta de um comando você também pode inserir mais de uma resposta, respeitando o uso da barra vertical para separá-los.

Agora será necessário informar ao Jarvis que há novos comandos disponíveis. Para isto, aproxime-se do microfone e diga “Atualizar comandos”. Aguarde o Jarvis responder “Todos os comandos foram atualizados”.

Terminado esta configuração, basta fechar a janela de comandos.

Clique na opção “Criar comandos”:

Nesta parte serão inseridos os comandos de voz que o Arduino vai falar para o Jarvis através do Módulo YX6300. Para cada comando será criado uma resposta.

Após preenchimento das informações, minhas configurações ficaram com 16 comandos de voz:

O comando da linha 4 “Não precisa” é o único que não será executado pelo Arduino, pois é um comando de resposta que é falado no microfone sempre que o Jarvis questionar e eu NÃO optar pela execução de algum acionamento.

É importante ressaltar que cada um destes comandos é referente a um arquivo de áudio que ficará salvo no cartão de memória do Módulo YX6300. Esses arquivos de áudio são os comandos de voz que serão gravados dizendo exatamente a palavra ou frase de cada um dos comandos que foram configurados nesta parte de “Criar Comandos”.

Exemplo:

O alarme foi ativado através do comando de voz “Ativar alarme” que foi falado no microfone, o Jarvis responde “OK, alarme ativado. A partir de agora vou monitorar o ambiente” e ele envia ao Arduino o comando serial para ativação do alarme. Quando houver detecção de movimento por parte do sensor que está conectado ao Arduino, o arquivo de áudio que pronuncia “Alarme violado” será executado através do Módulo YX6300 e como a saída de áudio do módulo vai estar conectada a entrada de microfone do computador através do cabo 2X1, o Jarvis vai escutar o comando de voz “Alarme violado” e vai dar como resposta “Identifiquei um movimento no ambiente”.

Veja que em “Criar Comandos” eu configurei o comando “Alarme violado” e a respectiva resposta “Identifiquei um movimento no ambiente”. Para os demais comandos e respostas (exceto o da linha 4) que configurei, o funcionamento será da mesma forma que expliquei no exemplo acima.

Clique em “SALVAR ALTERAÇÕES” para efetivar as modificações.

Novamente será necessário informar ao Jarvis que há novos comandos disponíveis. Para isto, aproxime-se do microfone e diga “Atualizar comandos”. Aguarde o Jarvis responder “Todos os comandos foram atualizados”.

Terminado esta configuração, basta fechar a janela de comandos.

– Gravando os comandos de voz

Conforme mencionei e mostrei anteriormente, configurei no Jarvis 16 comandos de voz na opção “Criar Comandos”, sendo que 15 deles serão executados pelo Arduino. Portanto, é necessário gravar 15 arquivos de áudio dizendo exatamente o texto contido em cada comando configurado no Jarvis.

Recomendo que faça as gravações em um ambiente silencioso e com o mínimo possível de ruído. Defina palavras ou frases curtas e grave mais de um áudio falando o mesmo comando para depois você filtrar e definir qual deles está com melhor qualidade.

Para gravar os comandos de voz optei por utilizar o smartphone, pois achei que ficou com uma qualidade bem melhor que gravar pelo microfone no computador. Utilizei o gravador de voz que pode ser baixado na Google Play a partir do link abaixo:

Gravador de voz

Após gravar os comandos de voz e filtrar, separe os que serão utilizados e exclua o restante.

Agora será necessário carregar os arquivos de áudio no cartão de memória para inserir no Módulo YX6300, contudo, existe alguns detalhes a serem seguidos.

Formate o cartão de memória em FAT32 e em seguida crie na raiz do cartão uma pasta chamada 01:

Cada arquivo de áudio deverá iniciar com a numeração de três dígitos, por exemplo, 001 002 003 004… 010 011… 026 027 e assim sucessivamente. O requisito principal é que cada arquivo inicie com um número de três dígitos. Se após a numeração você quiser colocar uma palavra para identificar cada gravação, fique à vontade.

Depois que fiz as gravações e separei os áudios que seriam utilizados, fiz as nomeações de cada um deles conforme explicado anteriormente e copiei os arquivos para a pasta 01 do cartão de memória:

Um outro detalhe importante é que a biblioteca responsável por fazer as execuções do áudio através do Módulo YX6300, utiliza como padrão a numeração em base octal. Portanto, no código final para executar o áudio 008, por exemplo, teríamos que passar como parâmetro o número 010 (8 decimal convertido em octal é igual a 10), para o áudio 009 passaríamos o número 011 (9 decimal convertido em octal é igual a 11), para o áudio 015 passaríamos o número 017 (15 decimal convertido em octal é igual a 17) e assim sucessivamente. Para os áudios de 001 a 007 não é preciso fazer nenhuma conversão de base. No link abaixo você pode fazer as conversões de decimal para octal:

Binary Hex Converter

– Downloads necessários

Para execução das práticas propostas será necessário instalar algumas bibliotecas.

Faça o download das bibliotecas abaixo e em seguida instale na IDE do Arduino:

Download MD_YX6300

Download EmonLib

Download OneWire

Download DallasTemperature

Se você não sabe como instalar bibliotecas na IDE do Arduino, basta clicar no link abaixo, seguir os passos, importar a biblioteca e retornar para continuar:

Arduino – Importando bibliotecas para a ID

– Esquema de ligação e código

Para cada uma das Propostas práticas foi feito um esquema de ligação separado. Desta forma, você poderá executar apenas algumas das práticas ou todas elas. O código para cada uma das práticas está abaixo de cada um dos esquema de ligação.

Se o computador que você utiliza o Jarvis possuir duas entradas de microfone, ignore a parte do esquema de ligação em que é utilizado o Cabo 2X1 e conecte o microfone em uma entrada e o Módulo YX6300 na entrada que sobrar.

Esquema (Acionamento de uma bomba d’água e monitoramento de um recipiente com água):

Código (Acionamento de uma bomba d’água e monitoramento de um recipiente com água):

  #include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)
  
  //INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX
  #define modLeitorRX 5  //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)
  #define modLeitorTX 6  //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)
  
  #define pinoReleCh2 9 //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ (BOMBA D'ÁGUA)
    
  #define pinoSensorIR A3 //PINO ANALÓGICO UTILIZADO PELO SENSOR INFRAVERMELHO DETECTOR DE NÍVEL
  
  int leituraSensorIR = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO PINO DIGITAL
    
  MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO
  
  int estadoBomba = 0; //VARIÁVEL QUE CONTROLA O ESTADO DA BOMBA D'ÁGUA (LIGADA / DESLIGADA)

void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO
  mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO
  pinMode(pinoReleCh2, OUTPUT); //DEFINE O PINO COMO SAÍDA
  digitalWrite(pinoReleCh2, HIGH); //MÓDULO RELÉ INICIA DESLIGADO
  pinMode(pinoSensorIR, INPUT); //DEFINE O PINO COMO ENTRADA
  }
  
void loop(){
  
  leituraSensorIR = analogRead(pinoSensorIR); //VARIÁVEL ARMAZENA A LEITURA DO PINO

  //CONDIÇÕES PARA QUE A BOMBA D'ÁGUA SEJA / SE MANTENHA DESLIGADA
  if((leituraSensorIR < 100) && (estadoBomba == 1)){ //SE LEITURA FOR MENOR QUE 100 E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
      digitalWrite(pinoReleCh2, HIGH); //DESLIGA A BOMBA D'ÁGUA
      mp3.playSpecific(01, 014); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ CHEIO (PASTA 01 / ARQUIVO 012 = 014 OCTAL)
      estadoBomba = 0; //VARIÁVEL RECEBE 0
  }
  
  char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

   if(c == 'J'){ //SE CARACTERE RECEBIDO FOR IGUAL a "J", FAZ
       digitalWrite(pinoReleCh2, LOW); //LIGA A BOMBA D'ÁGUA
       estadoBomba = 1; //VARIÁVEL RECEBE 1
   }
   if(c == 'K'){ //SE CARACTERE RECEBIDO FOR IGUAL a "K", FAZ
       digitalWrite(pinoReleCh2, HIGH); //DESLIGA A BOMBA D'ÁGUA
       estadoBomba = 0; //VARIÁVEL RECEBE 0
   }
   if(c == 'L'){ //SE CARACTERE RECEBIDO FOR IGUAL a "L", FAZ
       delay(3000); //INTERVALO DE 3 SEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)
       verificaRecipiente(); //EXECUTA A FUNÇÃO QUE VERIFICA O NÍVEL DO RECIPIENTE
   }
}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR O NÍVEL DE ÁGUA DO RECIPIENTE (CHEIO / ABAIXO DO NÍVEL MÁXIMO)
void verificaRecipiente(){
  if(leituraSensorIR < 100){ //SE A LEITURA NO PINO FOR MENOR QUE 100, FAZ
      mp3.playSpecific(01, 014); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ CHEIO(PASTA 01 / ARQUIVO 012 = 014 OCTAL)
  }else{ //SENÃO, FAZ
     if(leituraSensorIR > 100){ //SE A LEITURA NO PINO FOR MAIOR QUE 100, FAZ
         mp3.playSpecific(01, 015); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ ABAIXO DO NÍVEL MÁXIMO(PASTA 01 / ARQUIVO 013 = 015 OCTAL)
     }
  } 
}

#include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)

//INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX

#define modLeitorRX 5 //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)

#define modLeitorTX 6 //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)

#define pinoReleCh2 9 //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ (BOMBA D'ÁGUA)

#define pinoSensorIR A3 //PINO ANALÓGICO UTILIZADO PELO SENSOR INFRAVERMELHO DETECTOR DE NÍVEL

int leituraSensorIR = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO PINO DIGITAL

MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

int estadoBomba = 0; //VARIÁVEL QUE CONTROLA O ESTADO DA BOMBA D'ÁGUA (LIGADA / DESLIGADA)

void setup(){

Serial.begin(9600); //INICIALIZA A SERIAL

mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO

mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO

pinMode(pinoReleCh2, OUTPUT); //DEFINE O PINO COMO SAÍDA

digitalWrite(pinoReleCh2, HIGH); //MÓDULO RELÉ INICIA DESLIGADO

pinMode(pinoSensorIR, INPUT); //DEFINE O PINO COMO ENTRADA

}

void loop(){

leituraSensorIR = analogRead(pinoSensorIR); //VARIÁVEL ARMAZENA A LEITURA DO PINO

//CONDIÇÕES PARA QUE A BOMBA D'ÁGUA SEJA / SE MANTENHA DESLIGADA

if((leituraSensorIR < 100) && (estadoBomba == 1)){ //SE LEITURA FOR MENOR QUE 100 E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

digitalWrite(pinoReleCh2, HIGH); //DESLIGA A BOMBA D'ÁGUA

mp3.playSpecific(01, 014); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ CHEIO (PASTA 01 / ARQUIVO 012 = 014 OCTAL)

estadoBomba = 0; //VARIÁVEL RECEBE 0

}

char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

if(c == 'J'){ //SE CARACTERE RECEBIDO FOR IGUAL a "J", FAZ

digitalWrite(pinoReleCh2, LOW); //LIGA A BOMBA D'ÁGUA

estadoBomba = 1; //VARIÁVEL RECEBE 1

}

if(c == 'K'){ //SE CARACTERE RECEBIDO FOR IGUAL a "K", FAZ

digitalWrite(pinoReleCh2, HIGH); //DESLIGA A BOMBA D'ÁGUA

estadoBomba = 0; //VARIÁVEL RECEBE 0

}

if(c == 'L'){ //SE CARACTERE RECEBIDO FOR IGUAL a "L", FAZ

delay(3000); //INTERVALO DE 3 SEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)

verificaRecipiente(); //EXECUTA A FUNÇÃO QUE VERIFICA O NÍVEL DO RECIPIENTE

}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR O NÍVEL DE ÁGUA DO RECIPIENTE (CHEIO / ABAIXO DO NÍVEL MÁXIMO)

void verificaRecipiente(){

if(leituraSensorIR < 100){ //SE A LEITURA NO PINO FOR MENOR QUE 100, FAZ

mp3.playSpecific(01, 014); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ CHEIO(PASTA 01 / ARQUIVO 012 = 014 OCTAL)

}else{ //SENÃO, FAZ

if(leituraSensorIR > 100){ //SE A LEITURA NO PINO FOR MAIOR QUE 100, FAZ

mp3.playSpecific(01, 015); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O RECIPIENTE ESTÁ ABAIXO DO NÍVEL MÁXIMO(PASTA 01 / ARQUIVO 013 = 015 OCTAL)

}

Esquema (Simulador de segurança com sensor de movimento):

Código (Simulador de segurança com sensor de movimento):

  #include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)
  
  //INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX
  #define modLeitorRX 5  //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)
  #define modLeitorTX 6  //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)
  
  #define pinoSensorMov 10 //PINO DIGITAL UTILIZADO PELO SENSOR RCWL-0516
  
  int leituraSensorMov = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO PINO DIGITAL
  
  MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO
  
  int estadoAlarme = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO ALARME (ATIVADO / DESATIVADO)

void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO
  mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO
  pinMode (pinoSensorMov, INPUT); //DEFINE O PINO COMO ENTRADA
  }
  
void loop(){

  leituraSensorMov = digitalRead(pinoSensorMov); //VARIÁVEL ARMAZENA A LEITURA DO PINO

  if((leituraSensorMov == HIGH) && (estadoAlarme == 1)){ //SE A LEITURA FOR IGUAL A HIGH E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
      mp3.playSpecific(01, 016); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O ALARME FOI VIOLADO (PASTA 01 / ARQUIVO 014 = 016 OCTAL)
      estadoAlarme = 0; //VARIÁVEL RECEBE 0 (ALARME DESATIVADO)
  }
  
  char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)
  
   if(c == 'M'){ //SE CARACTERE RECEBIDO FOR IGUAL a "M", FAZ
       delay(4000); //INTERVALO DE 4 SEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)
       estadoAlarme = 1; //VARIÁVEL RECEBE 1 (ALARME ATIVADO)
   }
   if(c == 'N'){ //SE CARACTERE RECEBIDO FOR IGUAL a "N", FAZ
       estadoAlarme = 0; //VARIÁVEL RECEBE 0 (ALARME DESATIVADO)
   }
}

#include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)

//INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX

#define modLeitorRX 5 //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)

#define modLeitorTX 6 //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)

#define pinoSensorMov 10 //PINO DIGITAL UTILIZADO PELO SENSOR RCWL-0516

int leituraSensorMov = 0; //VARIÁVEL PARA ARMAZENAR LEITURA DO PINO DIGITAL

MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

int estadoAlarme = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO ALARME (ATIVADO / DESATIVADO)

void setup(){

Serial.begin(9600); //INICIALIZA A SERIAL

mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO

mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO

pinMode (pinoSensorMov, INPUT); //DEFINE O PINO COMO ENTRADA

}

void loop(){

leituraSensorMov = digitalRead(pinoSensorMov); //VARIÁVEL ARMAZENA A LEITURA DO PINO

if((leituraSensorMov == HIGH) && (estadoAlarme == 1)){ //SE A LEITURA FOR IGUAL A HIGH E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

mp3.playSpecific(01, 016); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE O ALARME FOI VIOLADO (PASTA 01 / ARQUIVO 014 = 016 OCTAL)

estadoAlarme = 0; //VARIÁVEL RECEBE 0 (ALARME DESATIVADO)

}

char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

if(c == 'M'){ //SE CARACTERE RECEBIDO FOR IGUAL a "M", FAZ

delay(4000); //INTERVALO DE 4 SEGUNDOS (TEMPO PARA O JARVIS CONCLUIR A RESPOSTA AO COMANDO RECEBIDO PELO MICROFONE)

estadoAlarme = 1; //VARIÁVEL RECEBE 1 (ALARME ATIVADO)

}

if(c == 'N'){ //SE CARACTERE RECEBIDO FOR IGUAL a "N", FAZ

estadoAlarme = 0; //VARIÁVEL RECEBE 0 (ALARME DESATIVADO)

}

Esquema (Acionamento de um ventilador com base na temperatura medida por um sensor):

Código (Acionamento de um ventilador com base na temperatura medida por um sensor):

  #include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)
  #include <OneWire.h> //INCLUSÃO DE BIBLIOTECA (DS18B20)
  #include <DallasTemperature.h> //INCLUSÃO DE BIBLIOTECA (DS18B20)
  
  //INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX
  #define modLeitorRX 5  //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)
  #define modLeitorTX 6  //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)
  
  #define pinoTemp 7 //PINO DIGITAL UTILIZADO PELO SENSOR DS18B20
  
  #define pinoReleCh1 8 //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ (VENTILADOR)
  
  OneWire ourWire(pinoTemp); //CONFIGURA UMA INSTÂNCIA ONEWIRE PARA SE COMUNICAR COM O SENSOR DE TEMPERATURA
  DallasTemperature sensors(&ourWire); //BIBLIOTECA DallasTemperature UTILIZA A OneWire
  MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO
  
  float temperatura = 0; //VARIÁVEL PARA ARMAZENAR O VALOR DE TEMPERATURA MEDIDO
  int estadoVent = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO VENTILADOR (LIGADO / DESLIGADO)
  int perguntaVent = 0; //VARIÁVEL QUE VERIFICA SE JÁ FOI SUGERIDO LIGAR O VENTILADOR

void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  sensors.begin(); //INICIALIZA O SENSOR DE TEMPERATURA
  mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO
  mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO
  pinMode(pinoReleCh1, OUTPUT); //DEFINE O PINO COMO SAÍDA
  digitalWrite(pinoReleCh1, HIGH); //MÓDULO RELÉ INICIA DESLIGADO
  }
  
void loop(){

  verificaTemperatura(); //EXECUTA CONSTANTEMENTE A FUNÇÃO QUE VERIFICA A TEMPERATURA AMBIENTE

  char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

   if(c == 'H'){ //SE CARACTERE RECEBIDO FOR IGUAL a "H", FAZ
        digitalWrite(pinoReleCh1, LOW); //LIGA O VENTILADOR
        estadoVent = 1; //VARIÁVEL RECEBE 1
   }
   if(c == 'I'){ //SE CARACTERE RECEBIDO FOR IGUAL a "I", FAZ
       digitalWrite(pinoReleCh1, HIGH); //DESLIGA O VENTILADOR
       estadoVent = 0; //VARIÁVEL RECEBE 0
       perguntaVent = 0; //VARIÁVEL RECEBE 0
   }
}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR A TEMPERATURA
void verificaTemperatura(){
  sensors.requestTemperatures();//SOLICITA QUE A FUNÇÃO INFORME A TEMPERATURA DO SENSOR
  temperatura = sensors.getTempCByIndex(0); //VARIÁVEL RECEBE O VALOR DE TEMPERATURA MEDIDO
  if((temperatura > 33) && (estadoVent == 0) && (perguntaVent == 0)){ //SE TEMPERATURA FOR MAIOR QUE 33 GRAUS CELCIUS E A SEGUNDA E TERCEIRA CONDIÇÃO FOR IGUAL A 0, FAZ
       mp3.playSpecific(01, 013); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A TEMPERATURA ESTÁ ALTA (PASTA 01 / ARQUIVO 011 = 013 OCTAL)
       perguntaVent = 1; //VARIÁVEL RECEBE 1
  }
}

#include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)

#include <OneWire.h> //INCLUSÃO DE BIBLIOTECA (DS18B20)

#include <DallasTemperature.h> //INCLUSÃO DE BIBLIOTECA (DS18B20)

//INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX

#define modLeitorRX 5 //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)

#define modLeitorTX 6 //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)

#define pinoTemp 7 //PINO DIGITAL UTILIZADO PELO SENSOR DS18B20

#define pinoReleCh1 8 //PINO DIGITAL UTILIZADO PELO MÓDULO RELÉ (VENTILADOR)

OneWire ourWire(pinoTemp); //CONFIGURA UMA INSTÂNCIA ONEWIRE PARA SE COMUNICAR COM O SENSOR DE TEMPERATURA

DallasTemperature sensors(&ourWire); //BIBLIOTECA DallasTemperature UTILIZA A OneWire

MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

float temperatura = 0; //VARIÁVEL PARA ARMAZENAR O VALOR DE TEMPERATURA MEDIDO

int estadoVent = 0; //VARIÁVEL QUE CONTROLA O ESTADO DO VENTILADOR (LIGADO / DESLIGADO)

int perguntaVent = 0; //VARIÁVEL QUE VERIFICA SE JÁ FOI SUGERIDO LIGAR O VENTILADOR

void setup(){

Serial.begin(9600); //INICIALIZA A SERIAL

sensors.begin(); //INICIALIZA O SENSOR DE TEMPERATURA

mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO

mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO

pinMode(pinoReleCh1, OUTPUT); //DEFINE O PINO COMO SAÍDA

digitalWrite(pinoReleCh1, HIGH); //MÓDULO RELÉ INICIA DESLIGADO

}

void loop(){

verificaTemperatura(); //EXECUTA CONSTANTEMENTE A FUNÇÃO QUE VERIFICA A TEMPERATURA AMBIENTE

char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

if(c == 'H'){ //SE CARACTERE RECEBIDO FOR IGUAL a "H", FAZ

digitalWrite(pinoReleCh1, LOW); //LIGA O VENTILADOR

estadoVent = 1; //VARIÁVEL RECEBE 1

}

if(c == 'I'){ //SE CARACTERE RECEBIDO FOR IGUAL a "I", FAZ

digitalWrite(pinoReleCh1, HIGH); //DESLIGA O VENTILADOR

estadoVent = 0; //VARIÁVEL RECEBE 0

perguntaVent = 0; //VARIÁVEL RECEBE 0

}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR A TEMPERATURA

void verificaTemperatura(){

sensors.requestTemperatures();//SOLICITA QUE A FUNÇÃO INFORME A TEMPERATURA DO SENSOR

temperatura = sensors.getTempCByIndex(0); //VARIÁVEL RECEBE O VALOR DE TEMPERATURA MEDIDO

if((temperatura > 33) && (estadoVent == 0) && (perguntaVent == 0)){ //SE TEMPERATURA FOR MAIOR QUE 33 GRAUS CELCIUS E A SEGUNDA E TERCEIRA CONDIÇÃO FOR IGUAL A 0, FAZ

mp3.playSpecific(01, 013); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A TEMPERATURA ESTÁ ALTA (PASTA 01 / ARQUIVO 011 = 013 OCTAL)

perguntaVent = 1; //VARIÁVEL RECEBE 1

}

Esquema (Acionamento de uma lâmpada e controle de luminosidade):

ATENÇÃO: MUITO CUIDADO AO EXECUTAR PRÁTICAS QUE ENVOLVAM TENSÃO / CORRENTE ALTERNADA! FAÇA TODAS AS LIGAÇÕES COM O CIRCUITO COMPLETAMENTE DESLIGADO E ANTES DE FAZER OS TESTES VERIFIQUE CADA UMA DAS LIGAÇÕES PARA ELIMINAR A POSSIBILIDADE DE CURTO ENTRE FASE / NEUTRO OU FASE / FASE.

Código (Acionamento de uma lâmpada e controle de luminosidade):

  #include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)
  #include "EmonLib.h" //INCLUSÃO DE BIBLIOTECA (SENSOR DE CORRENTE ACS-712)
    
  //INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX
  #define modLeitorRX 5  //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)
  #define modLeitorTX 6  //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)
  
  #define pinoSensorCor A2 //PINO ANALÓGICO UTILIZADO PELO SENSOR DE CORRENTE ACS712
  
  #define CURRENT_CAL 18.80 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO MEDINDO A CORRENTE DA CARGA)
  float ruido = 0.08; //VARIÁVEL QUE ARMAZENA O VALOR DO RUÍDO GERADO NO SENSOR ACS712
  double currentDraw = 0; //VARIÁVEL PARA ARMAZENAR A CORRNETE MEDIDA
  
  EnergyMonitor emon1; //CONFIGURA UMA INSTÂNCIA PARA SE COMUNICAR COM O SENSOR DE CORRENTE
  MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO
  
  int leituraSensorCor = 0; //VARIÁVEL PARA ARMAZENAR O VALOR DE CORRENTE MEDIDO
  int dimmerLampada = 0; //VARIÁVEL QUE CONTROLA O ESTADO DA DIMERIZAÇÃO (ATIVADO / DESATIVADO)
  
  byte out_rf = 12; //PINO CONECTADO AO DATA DO TRANSMISSOR RF
  byte address_l = 0xF1; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE BAIXA (LOW)
  byte address_h = 0xFE; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE ALTA (HIGH)
  byte loop_rf = 4; //QUANTIDADE DE VEZES QUE O PACOTE SERÁ TRANSMITIDO A CADA VEZ QUE EXECUTAR A ROTINA DE ENVIO
  unsigned int alpha = 370; //TEMPO DE DURAÇÃO EM MICROSEGUNDOS DE CADA CLOCK DA TRANSMISSÃO (PODE SER ALTERADO CASO
  //APRESENTE ERRO AO RECONHECER OS DADOS)
  byte aux1 = 0; //VARIÁVEL AUXILIAR
  byte aux2 = 0; //VARIÁVEL AUXILIAR

void setup(){
  Serial.begin(9600); //INICIALIZA A SERIAL
  emon1.current(pinoSensorCor, CURRENT_CAL); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO)
  mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO
  mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO
  pinMode(out_rf,OUTPUT); //PINO DEFINIDO COMO SAÍDA
  digitalWrite(out_rf, LOW); //PINO INICIA DESLIGADO
  }
  
void loop(){

  verificaStatusLamp(); //EXECUTA CONSTANTEMENTE A FUNÇÃO QUE VERIFICA O ESTADO ATUAL DA LÂMPADA (LIGADA / DESLIGADA)

  char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

   if((c == 'A') && (leituraSensorCor == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "A" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
        mp3.playSpecific(01, 003); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LÂMPADA "JÁ" ESTÁ ACESA (PASTA 01 / ARQUIVO 003 = 003 OCTAL)
   }else{ //SENÃO, FAZ
      if((c == 'A') && (leituraSensorCor == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "A" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ
           sendRF(0x03); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x03" (ACENDER A LÂMPADA)
           mp3.playSpecific(01, 001); //COMANDO DE VOZ PARA CONFIRMAR / INFORMAR AO JARVIS QUE A LÂMPADA ESTÁ ACESA (PASTA 01 / ARQUIVO 001 = 001 OCTAL)
      }
   }
   if((c == 'B') && (leituraSensorCor == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "B" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ
        mp3.playSpecific(01, 004); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LÂMPADA "JÁ" ESTÁ APAGADA (PASTA 01 / ARQUIVO 004 = 004 OCTAL)
   }else{ //SENÃO FAZ
      if((c == 'B') && (leituraSensorCor == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "B" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
            sendRF(0x04); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x04" (APAGAR A LÂMPADA)
            mp3.playSpecific(01, 002); //COMANDO DE VOZ PARA CONFIRMAR / INFORMAR AO JARVIS QUE A LÂMPADA ESTÁ APAGADA (PASTA 01 / ARQUIVO 002 = 002 OCTAL)
      }
   }

   if (c == 'C'){ //SE CARACTERE RECEBIDO FOR IGUAL a "C", FAZ
        if(currentDraw < 0.3){ //SE A CORRENTE MEDIDA FOR MENOR QUE 0.3, FAZ
            mp3.playSpecific(01, 005); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 0% / APAGADA (PASTA 01 / ARQUIVO 005 = 005 OCTAL)
        }
        if((currentDraw > 0.35) && (currentDraw <= 0.40)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.35 E 0.40, FAZ
             mp3.playSpecific(01, 006); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 20% (PASTA 01 / ARQUIVO 006 = 006 OCTAL)
        }
        if((currentDraw > 0.41) && (currentDraw <= 0.44)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.41 E 0.44, FAZ
             mp3.playSpecific(01, 007); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 40% (PASTA 01 / ARQUIVO 007 = 007 OCTAL)
        }
        if((currentDraw > 0.45) && (currentDraw <= 0.48)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.45 E 0.48, FAZ
             mp3.playSpecific(01, 010); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 60% (PASTA 01 / ARQUIVO 008 = 010 OCTAL)
        }
        if((currentDraw > 0.49) && (currentDraw <= 0.51)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.49 E 0.51, FAZ
             mp3.playSpecific(01, 011); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 80% (PASTA 01 / ARQUIVO 009 = 011 OCTAL)
        }
        if(currentDraw > 0.53){ //SE A CORRENTE MEDIDA FOR MAIOR QUE 0.53, FAZ
            mp3.playSpecific(01, 012); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 100% (PASTA 01 / ARQUIVO 010 = 012 OCTAL)
        }
   }
   if((c == 'D') && (dimmerLampada == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "D" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ
        dimmerLampada = 1; //VARIÁVEL RECEBE 1
   }
   if((c == 'E') && (dimmerLampada == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "E" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
        dimmerLampada = 0; //VARIÁVEL RECEBE 0
   }
   if((c == 'F') && (dimmerLampada == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "F" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ
         sendRF(0x03); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x03" (DIMINUI A LUMINOSIDADE DA LÂMPADA)
   }else{ //SENÃO, FAZ
      if((c == 'F') && (dimmerLampada == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "F" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ
           mp3.playSpecific(01, 017); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A DIMERIZAÇÃO ESTÁ DESATIVADA (PASTA 01 / ARQUIVO 015 = 017 OCTAL)
      }
   }
   if (c == 'G'){ //SE CARACTERE RECEBIDO FOR IGUAL a "G", FAZ
         dimmerLampada = 1; //VARIÁVEL RECEBE 1
   }
}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR O ESTADO DA LÂMPADA (ACESA / APAGADA)
void verificaStatusLamp(){
  emon1.calcVI(20,100); //FUNÇÃO DE CÁLCULO (20 SEMICICLOS / TEMPO LIMITE PARA FAZER A MEDIÇÃO)
  currentDraw = emon1.Irms; //VARIÁVEL RECEBE O VALOR DE CORRENTE RMS OBTIDO
  currentDraw = currentDraw-ruido; //VARIÁVEL RECEBER O RESULTADO DO VALOR MEDIDO MENOS O VALOR DO RUÍDO DO SENSOR
    
  if(currentDraw < 0){ //SE VARIÁVEL RESULTAR EM UM VALOR MENOR QUE 0, FAZ
      currentDraw = 0; //VARIÁVEL RECEBE 0
  }
  if(currentDraw > 0.3){ //SE VARIÁVEL RESULTAR EM UM VALOR MAIOR QUE 0.3, FAZ
      leituraSensorCor = 1; //VARIÁVEL RECEBE 1
  }else{ //SENÃO, FAZ
      leituraSensorCor = 0; //VARIÁVEL RECEBE 0
  }
}

/*INÍCIO - FUNÇÃO QUE ENVIA O PACOTE RF AO MÓDULO*/
void sendRF(byte dados){ //O PARÂMETRO "dados" É UM VALOR ENTRE 0 E 15 OU 0x00 e 0x0F QUE SÓ PERMITE OS 4 BITS MENOS SIGNIFICATIVOS E QUE RESULTA EM 16 POSSIBILIDADES
   digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
   delay(10); //INTERVALO DE 10 MILISSEGUNDOS
   aux1 = 0; //VARIÁVEL RECEBE 0
   while(aux1 < loop_rf){ //ENQUANTO "aux1" FOR MENOR QUE "loop_rf", FAZ

   digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
   delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"
   digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
   delayMicroseconds(alpha * 30); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
   sendBit(0);sendBit(0);sendBit(0);sendBit(0); //INICIA ENVIANDO O ENDEREÇO MAIS BAIXO, CONTUDO ENVIA 4 BIT ZERO
   
   //INÍCIO DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO
   aux2 = 0;
   while(aux2 < 8){
     sendBit(bitRead(address_l, aux2));       
     aux2 = aux2 + 1;
   }
   //FIM DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO
      
   //INÍCIO DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO
   aux2 = 0;
   while(aux2 < 8){
     sendBit(bitRead(address_h, aux2));       
     aux2 = aux2 + 1;
   }
   //FIM DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO
     
   //INÍCIO DO BLOCO QUE ENVIA O BYTE DE DADOS
   aux2 = 0;
   while(aux2 < 4){
     sendBit(bitRead(dados, aux2));       
     aux2 = aux2 + 1;
   }
   //FIM DO BLOCO QUE ENVIA O BYTE DE DADOS
     
   aux1 = aux1 + 1; //VARIÁVEL RECEBE "aux1" MAIS 1
   }
   digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO
   }
   /*FIM - FUNÇÃO QUE ENVIA O PACOTE RF AO MÓDULO*/
    
/*INÍCIO - FUNÇÃO QUE ENVIA UM BIT*/
void sendBit(byte _bit){
  if(_bit == 0){ //SE "_bit" IGUAL A 0, FAZ
      digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
      delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
      digitalWrite(out_rf, LOW);  //COLOCA O PINO EM NÍVEL BAIXO
      delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
  }else{//SENÃO, FAZ
      digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO
      delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
      digitalWrite(out_rf, LOW);  //COLOCA O PINO EM NÍVEL BAIXO
      delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha" 
    }
}
/*FIM - FUNÇÃO QUE ENVIA UM BIT*/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

#include <MD_YX5300.h> //INCLUSÃO DE BIBLIOTECA (MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO)

#include "EmonLib.h" //INCLUSÃO DE BIBLIOTECA (SENSOR DE CORRENTE ACS-712)

//INTERNAMENTE A BIBLIOTECA MD_YX5300 UTILIZA A BIBLIOTECA SoftwareSerial PARA EMULAR OS PINOS RX E TX

#define modLeitorRX 5 //PINO RX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO TX DO MÓDULO)

#define modLeitorTX 6 //PINO TX DO MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO (CONECTAR AO RX DO MÓDULO)

#define pinoSensorCor A2 //PINO ANALÓGICO UTILIZADO PELO SENSOR DE CORRENTE ACS712

#define CURRENT_CAL 18.80 //VALOR DE CALIBRAÇÃO (DEVE SER AJUSTADO EM PARALELO COM UM MULTÍMETRO MEDINDO A CORRENTE DA CARGA)

float ruido = 0.08; //VARIÁVEL QUE ARMAZENA O VALOR DO RUÍDO GERADO NO SENSOR ACS712

double currentDraw = 0; //VARIÁVEL PARA ARMAZENAR A CORRNETE MEDIDA

EnergyMonitor emon1; //CONFIGURA UMA INSTÂNCIA PARA SE COMUNICAR COM O SENSOR DE CORRENTE

MD_YX5300 mp3(modLeitorRX, modLeitorTX); //PASSA OS PARÂMETROS PARA A FUNÇÃO

int leituraSensorCor = 0; //VARIÁVEL PARA ARMAZENAR O VALOR DE CORRENTE MEDIDO

int dimmerLampada = 0; //VARIÁVEL QUE CONTROLA O ESTADO DA DIMERIZAÇÃO (ATIVADO / DESATIVADO)

byte out_rf = 12; //PINO CONECTADO AO DATA DO TRANSMISSOR RF

byte address_l = 0xF1; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE BAIXA (LOW)

byte address_h = 0xFE; //VALOR ENTRE 0 E 255 OU 0 E FF EM HEXADECIMAL PARA O ENDEREÇO NA PARTE ALTA (HIGH)

byte loop_rf = 4; //QUANTIDADE DE VEZES QUE O PACOTE SERÁ TRANSMITIDO A CADA VEZ QUE EXECUTAR A ROTINA DE ENVIO

unsigned int alpha = 370; //TEMPO DE DURAÇÃO EM MICROSEGUNDOS DE CADA CLOCK DA TRANSMISSÃO (PODE SER ALTERADO CASO

//APRESENTE ERRO AO RECONHECER OS DADOS)

byte aux1 = 0; //VARIÁVEL AUXILIAR

byte aux2 = 0; //VARIÁVEL AUXILIAR

void setup(){

Serial.begin(9600); //INICIALIZA A SERIAL

emon1.current(pinoSensorCor, CURRENT_CAL); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO)

mp3.begin(); //INICIALIZA O MÓDULO LEITOR DE SD CARD COM SAÍDA DE ÁUDIO

mp3.volume(30); //MÓDULO INICIA COM VOLUME MÁXIMO (30) NA SAÍDA DE ÁUDIO

pinMode(out_rf,OUTPUT); //PINO DEFINIDO COMO SAÍDA

digitalWrite(out_rf, LOW); //PINO INICIA DESLIGADO

}

void loop(){

verificaStatusLamp(); //EXECUTA CONSTANTEMENTE A FUNÇÃO QUE VERIFICA O ESTADO ATUAL DA LÂMPADA (LIGADA / DESLIGADA)

char c = Serial.read(); //VARIÁVEL RESPONSÁVEL POR RECEBER O CARACTERE NA SERIAL (ENVIADO PELO JARVIS)

if((c == 'A') && (leituraSensorCor == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "A" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

mp3.playSpecific(01, 003); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LÂMPADA "JÁ" ESTÁ ACESA (PASTA 01 / ARQUIVO 003 = 003 OCTAL)

}else{ //SENÃO, FAZ

if((c == 'A') && (leituraSensorCor == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "A" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ

sendRF(0x03); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x03" (ACENDER A LÂMPADA)

mp3.playSpecific(01, 001); //COMANDO DE VOZ PARA CONFIRMAR / INFORMAR AO JARVIS QUE A LÂMPADA ESTÁ ACESA (PASTA 01 / ARQUIVO 001 = 001 OCTAL)

}

if((c == 'B') && (leituraSensorCor == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "B" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ

mp3.playSpecific(01, 004); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LÂMPADA "JÁ" ESTÁ APAGADA (PASTA 01 / ARQUIVO 004 = 004 OCTAL)

}else{ //SENÃO FAZ

if((c == 'B') && (leituraSensorCor == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "B" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

sendRF(0x04); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x04" (APAGAR A LÂMPADA)

mp3.playSpecific(01, 002); //COMANDO DE VOZ PARA CONFIRMAR / INFORMAR AO JARVIS QUE A LÂMPADA ESTÁ APAGADA (PASTA 01 / ARQUIVO 002 = 002 OCTAL)

}

if (c == 'C'){ //SE CARACTERE RECEBIDO FOR IGUAL a "C", FAZ

if(currentDraw < 0.3){ //SE A CORRENTE MEDIDA FOR MENOR QUE 0.3, FAZ

mp3.playSpecific(01, 005); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 0% / APAGADA (PASTA 01 / ARQUIVO 005 = 005 OCTAL)

}

if((currentDraw > 0.35) && (currentDraw <= 0.40)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.35 E 0.40, FAZ

mp3.playSpecific(01, 006); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 20% (PASTA 01 / ARQUIVO 006 = 006 OCTAL)

}

if((currentDraw > 0.41) && (currentDraw <= 0.44)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.41 E 0.44, FAZ

mp3.playSpecific(01, 007); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 40% (PASTA 01 / ARQUIVO 007 = 007 OCTAL)

}

if((currentDraw > 0.45) && (currentDraw <= 0.48)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.45 E 0.48, FAZ

mp3.playSpecific(01, 010); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 60% (PASTA 01 / ARQUIVO 008 = 010 OCTAL)

}

if((currentDraw > 0.49) && (currentDraw <= 0.51)){ //SE A CORRENTE MEDIDA ESTIVER ENTRE 0.49 E 0.51, FAZ

mp3.playSpecific(01, 011); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 80% (PASTA 01 / ARQUIVO 009 = 011 OCTAL)

}

if(currentDraw > 0.53){ //SE A CORRENTE MEDIDA FOR MAIOR QUE 0.53, FAZ

mp3.playSpecific(01, 012); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A LUMINOSIDADE ESTÁ EM 100% (PASTA 01 / ARQUIVO 010 = 012 OCTAL)

}

if((c == 'D') && (dimmerLampada == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "D" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ

dimmerLampada = 1; //VARIÁVEL RECEBE 1

}

if((c == 'E') && (dimmerLampada == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "E" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

dimmerLampada = 0; //VARIÁVEL RECEBE 0

}

if((c == 'F') && (dimmerLampada == 1)){ //SE CARACTERE RECEBIDO FOR IGUAL a "F" E A SEGUNDA CONDIÇÃO FOR IGUAL A 1, FAZ

sendRF(0x03); //EXECUTA A FUNÇÃO "sendRF" E PASSA O PARÂMETRO "0x03" (DIMINUI A LUMINOSIDADE DA LÂMPADA)

}else{ //SENÃO, FAZ

if((c == 'F') && (dimmerLampada == 0)){ //SE CARACTERE RECEBIDO FOR IGUAL a "F" E A SEGUNDA CONDIÇÃO FOR IGUAL A 0, FAZ

mp3.playSpecific(01, 017); //COMANDO DE VOZ PARA INFORMAR AO JARVIS QUE A DIMERIZAÇÃO ESTÁ DESATIVADA (PASTA 01 / ARQUIVO 015 = 017 OCTAL)

}

if (c == 'G'){ //SE CARACTERE RECEBIDO FOR IGUAL a "G", FAZ

dimmerLampada = 1; //VARIÁVEL RECEBE 1

}

//FUNÇÃO RESPONSÁVEL POR VERIFICAR O ESTADO DA LÂMPADA (ACESA / APAGADA)

void verificaStatusLamp(){

emon1.calcVI(20,100); //FUNÇÃO DE CÁLCULO (20 SEMICICLOS / TEMPO LIMITE PARA FAZER A MEDIÇÃO)

currentDraw = emon1.Irms; //VARIÁVEL RECEBE O VALOR DE CORRENTE RMS OBTIDO

currentDraw = currentDraw-ruido; //VARIÁVEL RECEBER O RESULTADO DO VALOR MEDIDO MENOS O VALOR DO RUÍDO DO SENSOR

if(currentDraw < 0){ //SE VARIÁVEL RESULTAR EM UM VALOR MENOR QUE 0, FAZ

currentDraw = 0; //VARIÁVEL RECEBE 0

}

if(currentDraw > 0.3){ //SE VARIÁVEL RESULTAR EM UM VALOR MAIOR QUE 0.3, FAZ

leituraSensorCor = 1; //VARIÁVEL RECEBE 1

}else{ //SENÃO, FAZ

leituraSensorCor = 0; //VARIÁVEL RECEBE 0

}

/*INÍCIO - FUNÇÃO QUE ENVIA O PACOTE RF AO MÓDULO*/

void sendRF(byte dados){ //O PARÂMETRO "dados" É UM VALOR ENTRE 0 E 15 OU 0x00 e 0x0F QUE SÓ PERMITE OS 4 BITS MENOS SIGNIFICATIVOS E QUE RESULTA EM 16 POSSIBILIDADES

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delay(10); //INTERVALO DE 10 MILISSEGUNDOS

aux1 = 0; //VARIÁVEL RECEBE 0

while(aux1 < loop_rf){ //ENQUANTO "aux1" FOR MENOR QUE "loop_rf", FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha * 30); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

sendBit(0);sendBit(0);sendBit(0);sendBit(0); //INICIA ENVIANDO O ENDEREÇO MAIS BAIXO, CONTUDO ENVIA 4 BIT ZERO

//INÍCIO DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO

aux2 = 0;

while(aux2 < 8){

sendBit(bitRead(address_l, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE MENOS SIGNIFICATIVO DO ENDEREÇO

//INÍCIO DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO

aux2 = 0;

while(aux2 < 8){

sendBit(bitRead(address_h, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE MAIS SIGNIFICATIVO DO ENDEREÇO

//INÍCIO DO BLOCO QUE ENVIA O BYTE DE DADOS

aux2 = 0;

while(aux2 < 4){

sendBit(bitRead(dados, aux2));

aux2 = aux2 + 1;

}

//FIM DO BLOCO QUE ENVIA O BYTE DE DADOS

aux1 = aux1 + 1; //VARIÁVEL RECEBE "aux1" MAIS 1

}

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

}

/*FIM - FUNÇÃO QUE ENVIA O PACOTE RF AO MÓDULO*/

/*INÍCIO - FUNÇÃO QUE ENVIA UM BIT*/

void sendBit(byte _bit){

if(_bit == 0){ //SE "_bit" IGUAL A 0, FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

}else{//SENÃO, FAZ

digitalWrite(out_rf, HIGH); //COLOCA O PINO EM NÍVEL ALTO

delayMicroseconds(alpha * 3); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

digitalWrite(out_rf, LOW); //COLOCA O PINO EM NÍVEL BAIXO

delayMicroseconds(alpha); //INTERVALO COM O VALOR DA VARIÁVEL "alpha"

}

/*FIM - FUNÇÃO QUE ENVIA UM BIT*/

Monte cada um dos esquemas e em seguida carregue no Arduino o respectivo código.

Após o término do carregamento do código na placa, basta falar os comandos de voz ao Jarvis, ver as ações sendo executadas no Arduino e o feedback e confirmações sendo falados pelo Jarvis.

– Resultado final

No vídeo abaixo você pode ver o resultado final desta integração do Arduino com o Jarvis e o feedback e confirmação das ações executadas:

Escolhi implementar estas propostas práticas, pois elas demonstram bem algumas das aplicações reais em que o Jarvis pode ser utilizado.

Enquanto o Jarvis não possui recurso nativo para receber informações externas (que não seja por voz), a gente vai se virando através desta solução.

Agora que você já sabe como interagir o Arduino com o Jarvis para obter feedback e confirmação das ações executadas, basta usar a imaginação e implementar os mais diversos projetos.

OBS: para outros Blogs ou canais do Youtube que pretendam criar conteúdo baseado nesta publicação, favor mencionar a fonte original (Blog MasterWalker Shop).

Gostou desta postagem? Então deixa seu comentário, dúvida ou sugestão aí embaixo!

Loja online: https://www.masterwalkershop.com.br
Fan page no Facebook: https://www.facebook.com/masterwalkershop

Nos ajude a espalhar conhecimento clicando no botão de compartilhar (f Like) que está mais abaixo.

Obrigado e até a próxima!

Seu feedback é muito importante! Que tal dar uma nota para esta postagem?! Faça sua avaliação aqui embaixo.

Postagem anterior: Como usar com Arduino – Módulo Acelerômetro 3 Eixos MMA7361

Próxima postagem: Como usar com Arduino – Módulo YX6300 Leitor de Cartão com Saída de Áudio P2

Postagem feita por

Euler Oliveira

Formado em Engenharia da Computação, Técnico em Eletroeletrônica, Fundador e Diretor da MasterWalker Electronic Shop. Se preocupa com o aprendizado dos seus clientes e daqueles interessados em aprender sobre Arduino e plataformas embarcadas em geral.

Existem 19 comentários para esta postagem

Mauro D'Angeli 17 de outubro de 2021 às 12:58

Parabéns !

O percurso para realizar esta interface é descrito de um jeito assim claro e exaustivo, que é evidente a sua preparação técnica, junta com uma não comum capacidade didática.

Abraços …
Ademir Alves Borges 17 de junho de 2021 às 21:45

Ótimo conteúdo, muito didático. Tem tempo que queria fazer essa pesquisa, mas não sabia por onde começar. Vou fazer montar esse sistema, parabéns pelo incentivo.
Danilo Dorta 11 de junho de 2019 às 02:34

Sim sei que diz isso…não mudei nada no programa…e procurei ver se estava declarado…ao meu ver sim… Está declarado
- Euler Oliveira Autor 11 de junho de 2019 às 09:14
  
  Se copiou os códigos direto da postagem e instalou as devidas bibliotecas conforme orientações no texto, tudo deve funcionar sem acusar nenhum erro.
  
  Acabei de testar cada um dos códigos e nenhum deles acusou erro. Se copiou apenas parte de algum dos códigos, recomendo que você copie todo o código da postagem e em seguida vá removendo as partes que não precisa e adicionando os códigos que vai atender ao seu projeto.
  - Danilo Dorta 11 de junho de 2019 às 14:46
    
    Antes eu apenas compilei e deu erro, mas agora com o Arduíno conectado o erro sumiu…obrigado
    Outra coisa sobre o acendimento da lâmpada: No caso de eu usar uma lâmpada não dimerizavel, exemplo Lâmpada Led, eu posso usar um relê direto no lugar do dommer…ou o sensor de corrente faz isso no lugar do relê, ou ainda teria que mudar o esquema e o Sketch?
    Obrigado pela atenção e recebi hoje todos os sensores que encomendei , tudo certinho.
    - Euler Oliveira Autor 11 de junho de 2019 às 18:24
      
      Fazendo as modificações no código você pode sim usar um módulo relé para fazer o acionamento de uma lâmpada comum. O sensor de corrente não faz acionamento de cargas, apenas mede a corrente consumida pela carga.
      
      No tutorial abaixo você pode ver o funcionamento do módulo relé com Arduino e uma lâmpada, e com base no código disponibilizado na postagem, poderá fazer as alterações para atender ao que precisa.
      
      https://blogmasterwalkershop.com.br/arduino/como-usar-com-arduino-modulo-rele-5v-1-canal/
      - Danilo Dorta 13 de junho de 2019 às 13:14
        
        Muito Obrigado pela pronta atenção, meus parabéns pelas soluções inteligentes e de fácil execução.
Danilo Dorta 5 de junho de 2019 às 16:18

Euler ,,, eu copiei o programa da lâmpada para o IDEA do Arduino,,, deu o seguinte erro:

D:\Documents\Arduino\jarvisLamRetor\jarvisLamRetor.ino: In function ‘void setup()’:

jarvisLamRetor:31:17: error: ‘pinoSensorCor’ was not declared in this scope

emon1.current(pinoSensorCor , CURRENT_CAL); //PASSA PARA A FUNÇÃO OS PARÂMETROS (PINO ANALÓGIO / VALOR DE CALIBRAÇÃO)

^

exit status 1
‘pinoSensorCor’ was not declared in this scope

Por gentileza pode me ajudar? Só estou esperando os módulos chegarem da compra que fiz em sua loja virtual
Obrigado
- Euler Oliveira Autor 10 de junho de 2019 às 11:53
  
  Você declarou no código a variável pinoSensorCor? O erro diz que a variável não foi declarada.
Orlando 1 de maio de 2019 às 01:07

Hello, excellent work.
How you can automate the control of a minisplit through Jarvis
- Euler Oliveira Autor 5 de junho de 2019 às 10:27
  
  Hi, Orlando.
  
  In this case it is necessary to clone the keys of the remote control of the air conditioning and then make the settings in the Jarvis and the programming in the Arduino.
  - Orlando 6 de junho de 2019 às 01:52
    
    hello euler
    I see, then it is similar to the control of a tv?
    
    Thanks.
    Orlando
    - Euler Oliveira Autor 6 de junho de 2019 às 08:52
      
      Unfortunately remote control of air conditioning is very tricky to have the keys cloned.
      
      With Arduino, you will hardly be able to clone the keys.
Julio Silva 27 de janeiro de 2019 às 23:27

Download MD_YX6300 esta biblioteca não existe pode corrigir o erro?
- Euler Oliveira Autor 28 de janeiro de 2019 às 07:30
  
  Olá Julio.
  
  Os links já foram corrigidos.
DANIEL AMORIM 14 de janeiro de 2019 às 21:55

Muito bom este tutorial. Fiquei satisfeito com as informações. Já vou montar este projeto e depois digo os resultados.
- Euler Oliveira Autor 16 de janeiro de 2019 às 20:18
  
  Olá Daniel.
  
  Show de bola!
- Danilo 5 de junho de 2019 às 10:12
  
  Olá Euler… A tempo que eu procurava está interação do arduíno com o Jarvis, e você foi além usando o módulo de voz com tamanha inteligência… Quando puder…eu gostaria muito de ver estes sensores usados na casa em várias salas ou cômodos…porém para ficar viável…usar por exemplo módulos RF 433 que são baratos…e continuando a usar o Jarvis com o Arduíno off LINE…parabéns pela iniciativa!
  - Euler Oliveira Autor 5 de junho de 2019 às 10:18
    
    Olá Danilo.
    
    Agradeço pelo comentário!
    
    Utilizar RF para comunicação com os dispositivos espalhados pela casa, certamente é a opção mais viável. Procurei implementar simulações de uso real do Jarvis em uma residência e com o benefício do feedback de cada um dos dispositivos.
    
    Vlw!!!