Monitoramento Residencial Inteligente com Alexa

Componentes e Materiais

Arduino UNO	×	1
Espressif ESP8266 ESP-01	×	1
Sensor de Temperatura e Umidade DHT11 (4 pinos)	×	1
ControlEverything.com Controlador de Relé 4 Canais I2C	×	1
Sensor de obstáculo IR	×	1
Câmera	×	1
Jumpers (genéricos)	×	1

Aplicativos e Serviços Online

Arduino IDE
Amazon Alexa Skills Kit
Amazon Alexa echosim.io
ThingSpeak API
Backendless
PushingBox

Sobre o Projeto

Introdução

No mundo atual, as pessoas passam mais tempo no local de trabalho do que em casa. Daí a necessidade de um sistema de monitoramento residencial onde as pessoas possam saber as condições da casa enquanto estão no trabalho. Seria ainda melhor se pudessem apenas perguntar a "alguém" sobre sua casa durante o horário de trabalho. Isso pode ser realizado usando o Amazon Alexa como assistente que pode fornecer ao usuário as informações necessárias sobre sua casa.

Não apenas no local de trabalho: os usuários podem saber as condições da casa em qualquer lugar do mundo, desde que tenham conexão com internet e um dispositivo Amazon Alexa.

As seguintes funções são implementadas neste projeto:

Controlar dispositivos domésticos como ventilador e luz
Informar o status dos dispositivos
Informar as condições climáticas da casa (temperatura e umidade)
Enviar foto do interior da casa para o usuário via Gmail quando solicitado
Enviar notificações em caso de:
- Intruso (também envia foto)
- Incêndio
- Visita (também envia foto)

Passo 1: Programando o Arduino e ESP8266

Baixe a Arduino IDE do site oficial: https://www.arduino.cc/en/Main/Software

Abra a Arduino IDE e vá em Arquivo → Preferências → em URL Adicional do Gerenciador de Placas digite: https://arduino.esp8266.com/stable/package_esp8266com_index.json

Vá em Ferramentas → Placas → Gerenciador de Placas → e instale o pacote esp8266 encontrado por último.

Para programar o Arduino, basta conectar o cabo USB do Arduino ao computador e selecionar Arduino/Genuino UNO em Ferramentas → Placas. Certifique-se também de selecionar a porta COM correta em Ferramentas (o número da porta COM pode ser encontrado no Gerenciador de Dispositivos). Escreva o programa necessário, compile e clique em upload se não houver erros.

Para programar o ESP8266, faça a conexão conforme mostrado no diagrama:

Monitoramento Residencial Inteligente com Alexa

Conecte o USB do Arduino ao Computador. Em Ferramentas → Placa → selecione Generic ESP8266 e também selecione a porta COM correta. Escreva o programa necessário, compile e clique em upload se não houver erros. Certifique-se de conectar o RST do Arduino ao GND (o Arduino atua como programador para o ESP8266).

Neste Projeto, primeiro o ESP8266 é programado e depois as conexões do circuito são removidas. Então o circuito é reconectado conforme mostrado na Figura chamada "Conexões do Circuito". E então o Arduino é programado.

Passo 2: Configurando thingspeak.com

Crie uma conta no thingspeak.com.

Fazemos uso de canais no ThingSpeak para armazenar informações de controle de dispositivos e roteá-las para Arduino/Alexa. Também armazenamos os valores de temperatura e umidade nos canais. É como um local de armazenamento para as informações.

Vá em Canais → Meus Canais e crie novo canal. Dê nome e descrição aos seus canais.

No nosso projeto precisamos de 8 canais (você pode fazer o trabalho usando menos canais, mas será um pouco mais complicado na programação). O ThingSpeak tem uma restrição de tempo ao atualizar um canal. Deve haver um intervalo de 10-15 segundos entre atualizações sucessivas de um canal específico.

Oito canais com seus valores e significados são dados abaixo:

Nome do canal (valor1-significado, valor2-significado, etc):

Controle de Dispositivo (0 - luzLIGADA, 1 - luzDESLIGADA, 2 - ventiladorLIGADO, 3 - ventiladorDESLIGADO)
Status da luz (0 - luz desligada, 1 - luz ligada)
Status do ventilador (0 - ventilador desligado, 1 - ventilador ligado)
Umidade (valor da umidade)
Temperatura (valor da temperatura)
Notificação de intruso (1 - alerta de intruso)
Notificação de incêndio (1 - alerta de incêndio)
Notificação de visita (1 - alerta de visita)

Ao clicar em qualquer canal, você pode ver seu Channel ID e Write API Keys na aba API Keys. O Channel ID é necessário para obter a informação/valor no canal. E a write key é necessária para armazenar um valor no canal.

Requisição HTTP para atualizar um canal é:

https://api.thingspeak.com/update?api_key=<write key>&field1=<value>

<write key> é substituído pela write key correspondente do canal e value pode ser (0/1 no caso de controle de dispositivo ou valores de temp/umidade).

Requisição HTTP para ler valor de um canal é:

https://api.thingspeak.com/channels/<channel id>/field/field1/last.html

<channel id> é substituído pelo channel id particular do canal que queremos ler.

Passo 3: O Programa

O programa é dividido em 3 partes:

A) Programa para Arduino: o programa para Arduino é muito simples. Ele recebe os dados do ESP8266 serialmente e, com base nos dados recebidos, os dispositivos são controlados. Mais informações sobre o programa estão nos comentários no próprio programa.

B) Programa para ESP8266: o programa para ESP8266 envolve 3 coisas:

Atualizar temperatura e umidade usando requisição HTTP:

client.print(String("GET ") + "/update?key=<write key>&field1=" + humidity + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // atualiza umidade
client.print(String("GET ") + "/update?key=<write key>&field1=" + temperature + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n"); // atualiza temperatura

O <write key> é substituído pela write key correspondente encontrada no canal ThingSpeak para umidade e temperatura respectivamente. E host é api.thingspeak.com.

Baixe a biblioteca DHT em: https://github.com/adafruit/DHT-sensor-library

Ler dos canais correspondentes do ThingSpeak e controlar dispositivo baseado nos valores obtidos:

client.print(String("GET ") + "/channels/<channel id>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");

Onde <channel id> é substituído pelo channel id correspondente encontrado no ThingSpeak.

Enviar alerta em caso de temperatura alta via PushingBox:

String host1="api.pushingbox.com";
client.print(String("GET ") + "/pushingbox?devid=<your dev id> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");

Onde <your dev id> é substituído pelo seu device id no PushingBox.

Passo 4: Configurando LinkIt Smart 7688 Duo e Webcam

Neste projeto, webcam e LinkIt Smart 7688 Duo são usados para capturar a foto necessária e enviá-la ao usuário. Você também pode usar módulo de câmera Arduino e interfaciá-lo com Arduino ou usar qualquer câmera IP.

Pressione e segure o botão WiFi no LinkIt Smart 7688 por 20 segundos para resetar a placa. Então, após o reset das configurações WiFi, você poderá ver o nome do ponto de acesso nas conexões de rede sem fio. Agora conecte o computador a essa rede.

Após conectar, abra o navegador e digite 192.168.100.1 na barra de endereços. Você verá o portal.

Defina uma senha para fazer login no portal.

Após fazer login, vá na aba Rede e selecione Modo Estação (precisamos que ele acesse a internet) e conecte-o à sua rede WiFi e pressione Configurar e Reiniciar.

Após a reinicialização, a placa receberá um endereço IP local. Descubra o endereço usando qualquer ferramenta de IP ou portal do seu roteador. No meu caso era 192.168.1.4.

Agora digite o endereço IP local na barra de endereços do navegador. Certifique-se de que o computador está conectado à mesma rede que o LinkIt Smart. Você será solicitado a fazer login novamente.

Para habilitar streaming da webcam, você deve habilitar o MJPG Streamer (mjpg-streamer é uma aplicação de linha de comando que copia frames JPEG de um ou mais plugins de entrada para múltiplos plugins de saída). Para fazer isso no portal, vá em OpenWrt no canto superior direito. Você precisará fazer login novamente.

Após fazer login, vá na aba Serviços e marque habilitar MJPG Streamer e atribua um número de porta para este serviço. Atribuí 4440. Clique em Salvar e Aplicar.

Após a configuração, você pode conectar sua webcam ao LinkIt Smart 7688 Duo host USB através de um cabo OTG.

Agora para ver o Stream, abra o navegador e digite <IP local>:<porta> na barra de endereços. No meu caso é 192.168.1.4:4400

Para tirar a foto (snapshot), digite o comando <IP local>:<porta>?action=snapshot

Agora esta imagem está disponível localmente, mas precisamos torná-la disponível para o serviço PushingBox. Para isso, precisamos fazer Port Forwarding (Redirecionamento de Porta). O redirecionamento de porta pode ser feito no portal do roteador. O processo é diferente para diferentes roteadores. Pesquise no Google para saber como fazer port forwarding para seu roteador específico. Geralmente está disponível sob serviço NAT.

Após fazer o port forwarding, você pode acessar esta porta (ex: 4440) a partir do seu IP externo. O IP externo pode ser encontrado digitando "whats my ip" no Google.

Você precisa colocar este endereço, ou seja, https://<IP externo>:<porta>?action=snapshot no PushingBox (explicado no próximo passo) para que o PushingBox possa acessar esta imagem e anexá-la ao e-mail e enviá-la a você quando necessário.

Você também pode armazenar a imagem no cartão SD, pois o LinkIt Smart 7688 Duo também vem com slot para cartão SD para armazenar informações.

Mais informações sobre isso em: Documentação LinkIt Smart 7688

Passo 5: Configurando PushingBox

O PushingBox é usado para enviar notificações sobre diferentes alertas do projeto para o Gmail.

Faça login no PushingBox usando conta Google: https://www.pushingbox.com/

Vá em Meus Serviços → Adicionar Serviço. Há muitos serviços para escolher como Gmail, Twitter, push notification para Android, etc...

Selecione Gmail (pois precisamos enviar foto como anexo) e preencha a configuração apropriada do nome do Gmail e o Gmail ID do usuário para quem o alerta deve ser enviado.

Vá em Meus Cenários e crie um novo cenário. Dê nome ao cenário (ex: ALERTA) e adicione o serviço criado anteriormente.

Escreva assunto e corpo do e-mail adequados e insira a URL para capturar o screenshot da webcam para anexar a foto. Crie cenários diferentes para alertas diferentes.

API para executar um cenário do PushingBox é: https://api.pushingbox.com/pushingbox?devid=<device id>

Passo 6: Criando Skill Alexa usando Backendless

O Backendless é usado para criar a skill Alexa. É uma programação simples de arrastar e soltar usada para criar skill Alexa (ou qualquer programa) que pode ser acessada pela API Backendless.

Crie uma conta no Backendless: https://backendless.com/

Faça login na sua conta Backendless. Clique em Criar App e dê um nome ao seu app.
Clique no ícone Lógica de Negócios na barra de ícones à esquerda. Você verá a tela SERVIÇOS API.
Clique no ícone "+" para criar um novo serviço. Certifique-se de selecionar CODELESS no popup "Novo Serviço". Digite "AlexaService" para o nome do serviço. Clique em SALVAR:

O Backendless cria o Serviço API e solicitará que você crie um método para o serviço. Este será o método que processará requisições da Alexa. Digite "handleRequest" para o nome do método. Certifique-se de selecionar POST para a operação REST, e declare um argumento com nome "req" e tipo "Any Object" como mostrado abaixo:

O Backendless cria um placeholder para a lógica codeless do método. Clique no botão EDITAR para começar a alternar para o Designer de Lógica Codeless.

No bloco de placeholder da função criada, clique na área que diz "doSomething" e mude para "sendAlexaResponse". Esta função é usada para fazer a Alexa dizer algo que pode ser passado como argumento. Clique no botão SALVAR para que a função seja salva:

Clique no ícone de engrenagem no bloco roxo ao lado da palavra "Function". Adicione dois argumentos arrastando os blocos de entrada como mostrado na imagem abaixo. Atribua os nomes dos argumentos como "whatToSay" e "waitForResponse". Note que conforme você adiciona argumentos, a área Blocos de Contexto é automaticamente populada com os blocos representando valores dos argumentos:

Modifique a lógica da função para ficar como na imagem abaixo. Para os blocos "Create Objects", use o ícone de engrenagem para mudar o nome das propriedades do objeto. Não esqueça de salvar seu trabalho clicando no botão SALVAR.

Agora que a função personalizada está construída, volte ao método handleRequest do serviço AlexaService. Clique na categoria Funções Personalizadas na barra de ferramentas à esquerda e arraste o bloco sendAlexaResponse para conectar com o conector de retorno do seu método de serviço:

Os passos acima também podem ser encontrados no site deles: Parte 1 e Parte 2

Clique no nó "Add New" sob Functions na seção BROWSER. No bloco de placeholder da função criada, clique na área que diz "doSomething" e mude para "getIntentName"

Modifique os blocos para que a função fique assim:

Isso obterá o nome da intent baseado nas sample utterances. Volte para API Services → → handle request na seção BROWSER. Variáveis e lógica são criadas da seção System. Crie as seguintes variáveis:

Em seguida, armazenamos o nome da intent na variável request. E então comparamos com as intents. Por exemplo, se a request for "introduction", a variável respond é definida como "oi! Eu posso controlar..." e esta resposta é lida em voz alta pela Alexa por último.

Modifique o bloco como mostrado abaixo:

Se a request for intent LightsOn, atualizamos o canal ThingSpeak para '0' usando requisição HTTP GET e ao mesmo tempo atualizamos o status do dispositivo (1/0 dependendo de On/Off). A mesma coisa é repetida para LightsOff, FanOn e FanOff.

Para clima, lemos dos canais Temperatura e Umidade e armazenamos o resultado na variável respond. Como o canal só dá valores, anexamos textos para tornar a resposta significativa:

Para snapshot da sala de estar, executamos cenário do PushingBox:

Para status do dispositivo, lemos informação do canal de status do ThingSpeak:

Para notificações e alertas, lemos dos canais de alerta (incêndio, intruso e visita):

Baseado nos valores que obtemos do campo de notificação, as mensagens de alerta correspondentes são armazenadas na variável respond0. Se não houver notificações, nenhuma mensagem de notificação é armazenada.

Uma vez que a notificação é lida em voz alta, '0' é atualizado nos canais de notificação para que a Alexa não leia a mesma notificação novamente. Então, por último, baseado na request, a variável respond0/respond é lida em voz alta.

PS: Após criar o modelo necessário no Backendless, clique em Deploy Model no canto superior direito da tela codeless para implantar o modelo.

Passo 7: Configurando Skill Alexa no Amazon Developer Console

Vá ao Amazon Developer Console e faça login usando conta Amazon. https://developer.amazon.com/

Vá ao Developer Console e clique na aba ALEXA. Clique em Alexa Skills Kit Get Started.

Crie skill do tipo custom, dê nome e invocation name à skill.

As respectivas intents e sample utterances são dadas no código abaixo.

{
  "languageModel": {
    "intents": [
      { "name": "AMAZON.CancelIntent", "samples": [] },
      { "name": "AMAZON.HelpIntent", "samples": [] },
      { "name": "AMAZON.StopIntent", "samples": [] },
      { "name": "Camera", "samples": [
        "please send a snapshot of my living room",
        "please send a snapshot of my home",
        "please send a photo of my living room",
        "please send a photo of my home"
      ], "slots": [] },
      { "name": "FanOff", "samples": [
        "turn off Fan", "switch off Fan", "turn off the Fan", "switch off the Fan"
      ], "slots": [] },
      { "name": "FanOn", "samples": [
        "turn on Fan", "switch on Fan", "turn on the Fan", "switch on the Fan"
      ], "slots": [] },
      { "name": "Introduction", "samples": [
        "what you can do", "what can you do", "what can you do for me"
      ], "slots": [] },
      { "name": "LightsOff", "samples": [
        "turn off lights", "switch off lights", "turn off the lights", "switch off the lights"
      ], "slots": [] },
      { "name": "LightsOn", "samples": [
        "turn on lights", "switch on lights", "turn on the lights", "switch on the lights"
      ], "slots": [] },
      { "name": "Notification", "samples": [
        "what are my notifications", "is there any notifications", "is there any updates", "read out my notifications"
      ], "slots": [] },
      { "name": "Status", "samples": [
        "what is my device status", "what is the status of my devices"
      ], "slots": [] },
      { "name": "Weather", "samples": [
        "what is the weather condition of my home",
        "what is the weather of my home",
        "what is the weather",
        "what is the temperature of my home",
        "what is the temperature"
      ], "slots": [] }
    ],
    "invocationName": "my home"
  }
}

Na aba Configuração, selecione HTTPS como tipo de endpoint de serviço. Preencha a URL padrão com a URL da API do Backendless.

Selecione a 2ª opção em Certificado para endpoint padrão em SSL Certificate. Você também pode testar a skill usando o simulador de teste.

Após o teste estar completo, você pode publicar a skill com as informações de publicação necessárias.

Passo 8: Configuração Final e Finalização!

Faça a conexão do circuito conforme mostrado abaixo:

Às vezes o ESP8266 pode funcionar mal devido a corrente insuficiente. Portanto, embora não mencionado no circuito, é recomendado alimentar o ESP8266 de uma fonte separada de 3.3V. Se você estiver usando um power bank, certifique-se de reduzir a tensão de 5V para 3.3V usando um regulador de tensão 3.3V.

Faça upload do programa para ESP8266 e Arduino. Mostrei a conexão com lâmpada; a mesma coisa pode ser estendida para ventilador ou qualquer dispositivo.

Finalmente use Amazon Echo ou echosim.io para testar sua skill.

Você deve ativar a skill usando o invocation name (no meu caso - "my home"). Às vezes não funcionará se usado sem invocation name, como mostrei algumas vezes no meu vídeo.

Espero que tenha gostado do tutorial!

Obrigado!

Código

Smart_bell_ESP8266.ino Arduino

Código para ESP8266 obter alerta sobre intruso e visita

/* * This sketch is implementation of smart bell and home security * */
#include <ESP8266WiFi.h>
#include<String.h>
//------------------------------------------
// variáveis
//------------------------------------------
int intruder=0,guest=2; // pino 0 como alerta de intruso e pino2 como alerta de visita
const char* ssid = "SSID"; // seu SSID do WIFI
const char* password = "password"; // senha do Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
  Serial.begin(115200);
  delay(10);
  // Iniciamos conectando a uma rede WiFi
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Defina explicitamente o ESP8266 como cliente WiFi, caso contrário, por padrão,
     tentaria atuar como cliente e access-point e poderia causar problemas de rede
     com seus outros dispositivos WiFi na sua rede WiFi. */
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
int value = 0;
int x,y=0,z,k=0;
void loop() {
  delay(1000);
  ++value;
  Serial.print("connecting to ");
  Serial.println(host);
  // Use classe WiFiClient para criar conexões TCP
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  Serial.print("Requesting URL: ");
  //============================================================================================================
  // alerta de intruso
  //============================================================================================================
  x=digitalRead(intruder);
  //Serial.println(x);
  if(x==0) { y=0; }
  if(x==1&&y==0) {
    Serial.println("Sending Alert Pls Wait.....");
    delay(1000);
    String host1="api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_intruderAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");
    client.print(String("GET ") + "/update?api_key=<write_key_intruderAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
    delay(1000);
    y=1;
  }
  //============================================================================================================
  // Fim do alerta de intruso
  //============================================================================================================
  //============================================================================================================
  // alerta de visita
  //============================================================================================================
  long t1;
  z=digitalRead(guest);
  if(z==0 && (millis()>=t1+300000)) // espera 5 min para evitar envio múltiplo de alerta devido a múltiplas pressionadas da campainha
  { k=0; }
  if(x==1&&k==0) {
    t1=millis(); // armazenando timestamp atual em t1
    Serial.println("Sending Alert Pls Wait.....");
    delay(1000); // delay para envio de alerta e debounce do switch
    String host1="api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_guestAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");
    client.print(String("GET ") + "/update?api_key=<write_key_guestAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
    delay(1000);
    k=1;
  }
  //============================================================================================================
  // Fim do alerta de visita
  //============================================================================================================
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }
  //Serial.println("closing connection");
}

Home_monitor_arduino.ino Arduino

Código para Arduino controlar eletrodomésticos

//This sketch in the implementation of home automation
#include <SoftwareSerial.h> // importa a biblioteca serial
#include<String.h>
//-----------------------------------------
// definições de pinos
//-----------------------------------------
#define Light 2 // pino 2 para controlar luz
#define fan 3 // pino 3 para controlar ventilador
//------------------------------------------
// variáveis
//------------------------------------------
char e;
int p=0,q=0; // estas variáveis evitam ligar/desligar dispositivos já LIGADOS/DESLIGADOS
SoftwareSerial home_monitor(10, 11); // RX, TX
char control_data; // o dado transmitido via Bluetooth
void setup() {
  home_monitor.begin(115200);
  Serial.begin(9600);
  pinMode(13,OUTPUT);
}
void loop() {
  if (home_monitor.available()){
    control_data=home_monitor.read(); // obtendo informação de controle do ESP8266 serialmente
    e=control_data;
    Serial.print(control_data);
    //============================================================================================================
    // Controle de Dispositivo
    //============================================================================================================
    // Realizando operações necessárias baseadas no valor do canal
    //-------------------------------------------------------------
    // LUZ
    //-------------------------------------------------------------
    if(e=='0'&&p==0) // Luz LIGADA
    {
      digitalWrite(Light,LOW);
      p=1;
    }
    if(e=='1'&&p==1) // Luz desligada
    {
      digitalWrite(Light,HIGH);
      p=0;
    }
    //-------------------------------------------------------------
    // Aquecedor/Ventilador
    //-------------------------------------------------------------
    if(e=='2'&&q==0)
    {
      digitalWrite(fan,HIGH);
      q=1;
    }
    if(e=='3'&&q==1)
    {
      digitalWrite(fan,LOW);
      q=0;
    }
  }
}

Home_Monitor_ESP8266.ino Arduino

Código para ESP8266 atualizar umidade e temperatura no ThingSpeak e também recuperar informação de controle do ThingSpeak

/* * This sketch updates wheather information in thingspeak.com and also retrieve control information from thingspeak.com * It send the control information to arduino serially */
#include <ESP8266WiFi.h>
#include<String.h>
#include "DHT.h" // incluindo a biblioteca do sensor de temperatura e umidade DHT11
#define DHTTYPE DHT11 // DHT 11
#define dht_dpin 2 // define GPIO2 como entrada de dados
DHT dht(dht_dpin, DHTTYPE);
//------------------------------------------
// variáveis
//------------------------------------------
//dht DHT;
char c,e; // armazena os bytes vindos do servidor
float temp,h; // armazena valor float de temp e umidade
String humidity,temperature,line; // armazena valor string de temp e umidade
int co=0; // controla o envio de Alerta
const char* ssid = "SSID"; // seu SSID do WIFI
const char* password = "password"; // senha do Wifi
//--------------------------------------------
const char* host = "api.thingspeak.com";
void setup() {
  dht.begin();
  Serial.begin(115200);
  delay(10);
  // Iniciamos conectando a uma rede WiFi
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);
  /* Defina explicitamente o ESP8266 como cliente WiFi, caso contrário, por padrão,
     tentaria atuar como cliente e access-point e poderia causar problemas de rede
     com seus outros dispositivos WiFi na sua rede WiFi. */
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}
int value = 0;
void loop() {
  delay(1000);
  ++value;
  Serial.print("connecting to ");
  Serial.println(host);
  // Use classe WiFiClient para criar conexões TCP
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }
  Serial.print("Requesting URL: ");
  //============================================================================================================
  // Mini Estação Meteorológica
  //============================================================================================================
  h = dht.readHumidity(); // lê umidade e temperatura
  temp = dht.readTemperature();
  if(temp<50.0) { co=0; }
  if(temp>=50.0&&co==0) // envia alerta se temperatura acima de 50 graus e co usado para evitar alertas múltiplos
  {
    Serial.println("Sending Alert please wait.......");
    delay(1000);
    String host1="api.pushingbox.com";
    client.print(String("GET ") + "/pushingbox?devid=<deviceID_fireAlert> HTTP/1.1\r\n" + "Host: " + host1 + "\r\n" + "Connection: close\r\n\r\n");
    delay(1000);
    client.print(String("GET ") + "/update?key=<write_key_fireAlert>&field1=1 HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
    co=1;
  }
  humidity=String(h);
  temperature=String(temp);
  Serial.println(h);
  Serial.println(temp);
  client.print(String("GET ") + "/update?key=<write_key_humidity>&field1=" + humidity + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
  client.print(String("GET ") + "/update?key=<write_key_temperature>&field1=" + temperature + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
  //============================================================================================================
  // Fim da Estação Meteorológica
  //============================================================================================================
  //============================================================================================================
  // Enviando info de controle para Arduino Serialmente
  //============================================================================================================
  // Isto enviará a requisição ao servidor
  client.print(String("GET ") + "/channels/<channelID_control>/field/field1/last.html HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
  // obtém informação sobre controle de dispositivo
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Client Timeout !");
      client.stop();
      return;
    }
  }
  // Lê todas as linhas da resposta do servidor e imprime no Serial
  while(client.available()){
    String line = client.readStringUntil('\r');
  }
  Serial.print(line); // recebido pelo Arduino serialmente
  //Serial.println("closing connection");
}

Esquemáticos

Iluminação Inteligente: Acenda as Luzes ao Chegar em Casa com Arduino e iPhone Carregador Solar Portátil com Rastreador Solar Arduino e Controle por Servo

Processo de manufatura

impressao 3D

Sistema de controle de automação

Tecnologia industrial