Gerenciamento de uma estufa ou estufa de qualquer lugar do mundo (exemplo de implementação)

O objetivo deste desenvolvimento é coletar dados de sensores locais, enviar esses dados para a Internet. O usuário poderá visualizar dados provenientes dos sensores em qualquer lugar do mundo e tomar uma decisão remota sobre a ativação de determinados atuadores que estarão localizados localmente, próximo aos sensores

O projeto usa Arduino Módulo UNO e WiFi ESP8266-01. Os dados serão transmitidos para a nuvem através do serviço web ThingSpeak.com, e os dispositivos serão ativados através do aplicativo Android desenvolvido usando o MIT AppInventor.





O foco principal deste projeto de IoT será o serviço ThingSpeak.com. O dispositivo local UNO / ESP-01 recebe dados de sensores e dados sobre o status dos atuadores, envia-os para a Internet "gravando" por meio de um canal de status específico do ThingSpeak.com (ThingSpeak.com Status Channel), o mesmo dispositivo local recebe dados ", lendo-os de outro canal de dados - “o canal de dispositivos executivos” (ThingSpeak.com Actuator Channels).



Os dados serão coletados usando um sensor de temperatura e umidade relativa, temperatura e umidade do solo e um sensor de luz ambiente. Esses dados serão enviados para a nuvem de serviço do ThingSpeak.

Haverá dois dispositivos executivos - esta é uma bomba elétrica de água e uma lâmpada. O status ON / OFF também será enviado para a nuvem. Dados de sensores, por exemplo, podem exibir o estado atual de uma estufa ou estufa. O usuário controlará os dispositivos executivos usando o aplicativo Android.




Todos os links são apenas para fins informativos.






2 x LEDs (vermelho e verde)
1 x
- $3.00
Lâmpada 220V
Resistor de 2 x 330 ohm (usado com LEDs)
Resistor de 2 x 10K ohm (usado com DHT22 e LDR)
1 x resistor de 4K7 ohm (usado com DS18B20)
Breadboard
Jumpers
Fonte de alimentação externa para o relé 5V DC



Agora você precisa conectar todos os sensores, conforme mostrado no diagrama.



A solução ideal seria montar e testar o projeto em partes.

Na seguinte sequência:
1. Instale e teste todos os sensores
2)Instale e configure no mínimo o ESP-01
3. Altere a instalação do ESP-01 para a configuração final e teste
4. Configure o canal de status do ThingSpeak
5. Instale o código ThingSpeak no Arduino e verifique o status dos sensores na nuvem
6. Desenvolva a primeira versão do programa no android para verificar as mensagens de status dos sensores
7. Instale atuadores
8. Configure os canais dos atuadores do ThingSpeak
9. Instale e teste o código para dispositivos executivos no Arduino
10. Faça a segunda versão do programa no android para todo o conjunto do dispositivo.



O projeto usa algumas bibliotecas incluídas no. É necessário verificar sua disponibilidade. A configuração inicial dessas bibliotecas é a seguinte:

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 no pino D5
OneWire oneWire (ONE_WIRE_BUS);
Temperatura Dallas DS18B20 (& oneWire);
int soloTemp = 0;

// DHT
#include "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (leve)
#define ldrPIN 1
int light = 0;

// Humidade do solo
#define soloHumPIN 0
int soloHum = 0;

Agora, inicializamos nossos sensores e os exibimos no terminal:

configuração nula ()
{
  Serial.begin (9600);
  DS18B20.begin ();
  dht.begin ();
}

loop vazio ()
{
  readSensors ();
  displaySensors ();
  atraso (10000);
}

E, finalmente, escreveremos duas funções: uma lê as leituras dos sensores e a outra as exibe na tela:

/ ********* Valor dos sensores de leitura ************* /
void readSensors (vazio)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soloTemp = DS18B20.getTempCByIndex (0); // O sensor 0 captura a temperatura do solo em Celcius
  
  soloHum = mapa (leitura analógica (soloHumPIN), 1023, 0, 0, 100);
 
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> luz 100%

}

/ ********* Valor dos sensores de exibição ************* /
void displaySensors (void)
{
  Serial.print ("airTemp (oC):");
  Serial.println (airTemp);
  Serial.print ("airHum (%):");
  Serial.println (airHum);
  Serial.print ("groundTemp (oC):");
  Serial.println (groundTemp);
  Serial.print ("soloHum (%):");
  Serial.println (soloHum);
  Serial.print ("light (%):");
  Serial.println (claro);
  Serial.println ("");
}

A foto mostra como os dados são exibidos na tela.


O código-fonte pode ser baixado do autor.



A maneira mais rápida de "conversar" com o módulo é o comando AT. O processador já possui um processador de comando AT. Por padrão, o módulo vem com configurações de fábrica de 115200 bauds, você precisa definir 9600 bauds nas configurações.

Em primeiro lugar, você precisa conectar o módulo, como mostra a foto



( Observe que o terminal Tx do ESP-01 está conectado ao terminal Tx do UNO, assim como os terminais Rx estão conectados um ao outro. Esta conexão será alterada mais tarde. ).

Em seguida, conecte o UNO ao computador, abra o IDE e faça o download do exemplo localizado. Este é um código vazio, para que não haja conflitos entre o ESP-01 e o UNO. Esse código foi carregado no Ardunio antes de conectar o ESP-01 a ele, para garantir que o Ardunio não use os pinos Tx e Rx para qualquer outra coisa.
Agora você precisa abrir o IDE Serial Monitor, defina a taxa de transmissão para 115200 nas configurações e envie o comando AT para o IDE Serial Monitor. ESP-01 deve enviar uma resposta OK

Agora você precisa alterar a taxa de dados no módulo ESP-01. Para fazer isso, no IDE, dê o comando

AT + CIOBAUD = 9600

Pode acontecer que o ESP-01 retorne às configurações de fábrica, então você precisará usar outro comando:

AT + UART_DEF = , , , , 

Por exemplo 9600 baud / 8 bits de dados / 1 bit de parada e nenhum controle de paridade e fluxo

AT + UART_DEF = 9600,8,1,0,0

Agora altere a taxa de transferência de dados nas configurações do IDE para 9600 e envie o comando AT, a resposta OK deve vir.
Em seguida, você precisa alternar o módulo para o modo STA para que ele possa se conectar ao ponto de acesso da sua rede.

AT + CWMODE = 1

Para que o módulo se conecte à rede, digite o comando AT + CWJAP = "nome da rede", "nome da rede_1"onde network_name É o nome da sua rede e network_name_1 - senha para sua rede (a senha e o nome da rede devem estar entre aspas)
Se você vir a resposta WIFI CONECTADO WIFI OBTIDO IP, a conexão é estabelecida. Verifique o endereço IP com o comando

AT + CIFSR

.

O endereço que aparece no seu monitor, você pode usar no futuro. Depois de configurar o módulo, você pode conectá-lo permanentemente, mas para isso é necessário alterar o circuito de comutação, conforme mostrado na figura.


• ESP-01 RX (Amarelo) -> UNO Pin D7
• ESP-01 TX (Laranja) -> UNO Pin D6
• ESP-01 Ch-Pd (Marrom) -> Vcc (3,3V)
• Reset ESP-01 (Azul) -> UNO Pin D8
• ESP-01 Vcc (vermelho) -> 3,3V
• ESP-01 Gnd (preto) -> UNO GND

Observe que a biblioteca Serial de software usa o pino UNO Pin D7 como tx e se conecta à saída do ESP-01 Rxenquanto UNO Pin D6 como rxconectado ao ESP-01 TX.

Digite um código pequeno para verificar a conexão e a configuração corretas do módulo ESP-01

#include 
SoftwareSerial esp8266 (6.7); // Rx ==> Pino 6; TX ==> Pin7

#define speed8266 9600

configuração nula ()
{
  esp8266.begin (speed8266);
  Serial.begin (speed8266);
  Serial.println ("ESP8266 Setup test - use AT coomands");
}

loop vazio ()
{
  while (esp8266.available ())
  {
    Serial.write (esp8266.read ());
  }
  while (Serial.available ())
  {
    esp8266.write (Serial.read ());
  }
}

Agora, algumas equipes da AT. Veja os resultados no Monitor serial.



* AT =====> ESP8266 retorna OK
* AT + RST =====> ESP8266 reinicia e retorna OK
* AT + GMR =====> ESP8266 retorna a versão AT; Versão do SDK; id; Ok
* AT + CWMODE? => ESP8266 retorna o tipo de modo
* AT + CWLAP ===> ESP8266 retorna pontos de acesso próximos
* AT + CIFSR ===> ESP8266 retorna IP designado

O código do programa pode ser baixado em

6 conexão de sensores e ESP-01

Depois que todos os sensores estão conectados e verificados, assim como o módulo ESP-01 é verificado, é necessário preparar os dados para o envio à Internet.





Uma das partes mais importantes do projeto é a plataforma IoT aberta, que permitirá coletar dados de sensores, processar e analisá-los. Para fazer isso, acesse e crie sua conta. Em seguida, você precisa criar um canal onde haverá 2 atuadores, 5 sensores e um campo de backup.
• Campo 1: Atuador 1 (dispositivo 1)
• Campo 2: Atuador 2 (dispositivo 2)
• Campo 3: Temperatura do ar em oC (temperatura do ar em graus Celsius)
• Arquivado 4: Umidade relativa do ar em% (umidade relativa do ar em%)
• Campo 5: Temperatura do solo em oC (temperatura do solo em gramas Celsius)
• Campo 6: umidade do solo em% (umidade do solo em%)
• Campo 7: Luminosidade em% (iluminação em%)
• Campo 8: Sobressalente

O campo 8 está reservado para expansão futura ou para depuração. Neste projeto, é usado como um contador de erros de comunicação entre o Arduino / ESP-01 e o ThingSpeak.com.

Depois de criar o canal de status, você precisa gravar as teclas, conforme mostrado na foto.



No momento, temos um serviço de nuvem configurado e nossos sensores coletam dados localmente. Agora você precisa pegar esses dados e enviá-los para a nuvem no ThingSpeak.com.

Para gravar dados no canal ThingSpeak, você precisa enviar uma string GET. Isso será feito em três etapas.
Envie o comando "Iniciar cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Comprimento da corda adicional

AT + CIPSEND = 116

E, finalmente, uma string GET que gravará nossos dados nos campos reservados do Status Channel.

GET / update? Api_key = sua_saved_key_aqui & campo1 = bomba & luz de campo = 0 & campo3 = arTemp & campo4 = arHum & campo5 = soloTemp & campo6 = soloHum & campo7 = luz e campo8 = reposição

Observe que não devemos gravar dados no canal mais de uma vez em 16 segundos.

O código enviado fará tudo isso.

// Thingspeak
String statusChWriteKey = "SUA CHAVE DE ESCRITA AQUI"; // ID do canal de status: 385184

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// DS18B20
#include 
#include 
#define ONE_WIRE_BUS 5 // DS18B20 no pino D5
OneWire oneWire (ONE_WIRE_BUS);
Temperatura Dallas DS18B20 (& oneWire);
int soloTemp = 0;

// DHT
#include "DHT.h"
#include 
int pinoDHT = 11;
int tipoDHT = DHT22;
DHT dht (pinoDHT, tipoDHT);
int airTemp = 0;
int airHum = 0;

// LDR (leve)
#define ldrPIN 1
int light = 0;

// Humidade do solo
#define soloHumPIN 0
int soloHum = 0;

// Variáveis ​​a serem usadas com temporizadores
writeTimingSeconds longo = 17; // ==> Defina o tempo da amostra em segundos para enviar dados
long startWriteTiming = 0;
long elapsedWriteTime = 0;

// Variáveis ​​a serem usadas com atuadores
bomba booleana = 0;
lâmpada booleana = 0;

int sobressalente = 0;
erro booleano;

configuração nula ()
{
  Serial.begin (9600);
  
  pinMode (HARDWARE_RESET, OUTPUT);
  
  digitalWrite (HARDWARE_RESET, HIGH);
  
  DS18B20.begin ();
  dht.begin ();

  EspSerial.begin (9600); // Comunicação com Módulo WiFi
  EspHardwareReset (); // Redefinir WiFi do módulo
  startWriteTiming = millis (); // iniciando o "relógio do programa"
}

loop vazio ()
{
  start: // label
  erro = 0;
  
  elapsedWriteTime = millis () - startWriteTiming;
  
  if (elapsedWriteTime> (writeTimingSeconds * 1000))
  {
    readSensors ();
    writeThingSpeak ();
    startWriteTiming = millis ();
  }
  
  if (error == 1) // Reenviar se a transmissão não estiver concluída
  {
    Serial.println ("<<<< ERRO >>>>");
    atraso (2000);
    goto start; // vá para o rótulo "start"
  }
}

/ ********* Valor dos sensores de leitura ************* /
void readSensors (vazio)
{
  airTemp = dht.readTemperature ();
  airHum = dht.readHumidity ();

  DS18B20.requestTemperatures ();
  soloTemp = DS18B20.getTempCByIndex (0); // O sensor 0 captura a temperatura do solo em Celcius
             
  light = map (analogRead (ldrPIN), 1023, 0, 0, 100); // LDRDark: 0 ==> luz 100%
  soloHum = mapa (leitura analógica (soloHumPIN), 1023, 0, 0, 100);

}

/ ********* Conexão com TCP com Thingspeak ******* /
void writeThingSpeak (void)
{

  startThingSpeakCmd ();

  // preparação da string GET
  String getStr = "GET / update? Api_key =";
  getStr + = statusChWriteKey;
  getStr + = "& campo1 =";
  getStr + = String (bomba);
  getStr + = "& field2 =";
  getStr + = String (lâmpada);
  getStr + = "& field3 =";
  getStr + = String (airTemp);
  getStr + = "& field4 =";
  getStr + = String (airHum);
  getStr + = "& field5 =";
  getStr + = String (soloTemp);
  getStr + = "& field6 =";
  getStr + = String (soloHum);
  getStr + = "& field7 =";
  getStr + = String (leve);
  getStr + = "& field8 =";
  getStr + = String (sobressalente);
  getStr + = "\ r \ n \ r \ n";

  sendThingSpeakGetCmd (getStr);
}

/ ********* Redefinir ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Redefinindo .......");
  digitalWrite (HARDWARE_RESET, LOW);
  atraso (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Inicie a comunicação com o ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Iniciar cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Erro"))
  {
    Serial.println ("erro AT + CIPSTART");
    retornar
  }
}

/ ********* envia um cmd GET para ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> comprimento cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo para processar o GET, sem este atraso apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Linha de seqüência de caracteres = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// o conteúdo real inicia após a linha vazia (que possui o comprimento 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody recebeu:");
    Serial.println (messageBody);
    retornar messageBody;
  }
  mais
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerta usuário
    Serial.println ("ESP8266 ERRO CIPSEND: ENVIANDO"); // Reenviar ...
    sobressalente = sobressalente + 1;
    erro = 1;
    retornar "erro";
  }
}

Você pode ver o progresso no Serial Monitor.

O código-fonte pode ser baixado em



Primeiro você precisa criar uma interface de usuário. A imagem mostra os principais elementos visíveis e invisíveis.



Depois disso, você precisa criar blocos. Os itens de menu correspondem aos números da captura de tela.

1 Variáveis ​​de estado que devem ser declaradas como globais

2 A cada dois segundos (dependendo do Clock1), um procedimento é chamado "readArduino"


O procedimento retorna o valor das variáveis ​​que devem ser exibidas na tela. Nesse caso, o valor do estado (0 e 1) para os atuadores é convertido em "ON" e "OFF" para uma melhor percepção.

Esses valores (Status) serão exibidos nos "Atalhos" correspondentes

3 A rotina readArduino essencialmente lê o canal de status no ThingSpeak. Portanto, você precisa determinar o URL que será enviado ao Thingspeak. Para fazer isso, três variáveis ​​globais devem ser declaradas e combinadas para criar a URL que será enviada ao ThingSpeak. GET deve ser enviado para um componente da web chamado "ArduFarmBotStatusCh"

4 O texto recebido do comando anterior chegará no formato JSon. Este texto precisa ser processado para que cada campo seja lido e armazenado na variável global correspondente.

5 A última coisa a fazer é chamar o procedimento "Alarme", que analisará o estado de dois sensores de solo. Se a temperatura estiver muito baixa (no nosso caso, 10oC), uma mensagem deve ser exibida. O mesmo para a umidade se estiver abaixo de 60%.

Observe que definimos outro timer (Clock2), programado para que ele funcione a cada segundo. Só é necessário "alternar" a cor do texto da mensagem (de branco para vermelho). A mensagem irá piscar.

O código do aplicativo pode ser baixado em




Os comandos para ligar e desligar a bomba e a lâmpada serão recebidos remotamente. A saída do Ardunio ativará o relé e o LED, executando estes comandos. A imagem mostra como os atuadores devem ser conectados. Observe que a saída do relé GND NÃO CONECTADO para saída GNDUNO. Dessa forma, haverá menos interferência de energia quando o relé estiver funcionando.




Todas as ações repetem o procedimento para configurar o canal Status. É necessário criar dois canais para cada um dos dispositivos. Para cada canal, escreva as teclas ID do canal, Leitura e Gravação. Vamos escrever apenas no primeiro campo de cada canal. Por exemplo:
ID do canal 375598 ==> LED vermelho (bomba)
1 Campo1 = 0 ==> Bomba DESLIGADA
1 Campo1 = 1 ==> Bomba LIGADA
2. ID do canal 375599 ==> LED verde (lâmpada)
1 Campo1 = 0 ==> Lâmpada apagada
1 Campo1 = 1 ==> Lâmpada acesa



Quando enviamos dados para a nuvem, "escrevemos" esses dados no ThingSpeak, canal de status, "transmitindo" (enviando) esses dados. Agora temos que "ler" os dados do canal do atuador, "aceitando" (baixando) esses dados.

Para fazer isso, envie uma string GET e este procedimento consiste em 3 estágios.
"Iniciar cmd"

AT + CIPSTART = "TCP", "184.106.153.149", 80

Comprimento da linha

AT + CIPSEND = 36

E a própria string GET

GET / canais / 375598 / campos / 1 / último

Os canais serão "lidos" a cada 10 segundos

Depois de enviar o GET, devemos aceitar a resposta do ThingSpeak. A resposta deve ser 0 ou 1, para cada canal. Se houver outros valores, simplesmente os ignoramos.

A principal diferença entre esta parte e a anterior é apenas na função readThingSpeak (String channelID)
Abaixo está o código que executa as ações descritas.

// Thingspeak
String canalID1 = "999999"; // Atuador1
CanalID2 da string = "999999"; // Atuador2

#include 
SoftwareSerial EspSerial (6, 7); // Rx, Tx
#define HARDWARE_RESET 8

// Variáveis ​​a serem usadas com temporizadores
long readTimingSeconds = 10; // ==> Defina o tempo da amostra em segundos para receber dados
long startReadTiming = 0;
long elapsedReadTime = 0;

// Relés
#define ACTUATOR1 10 // LED VERMELHO ==> Bomba
#define ACTUATOR2 12 // LED VERDE ==> Lâmpada
bomba booleana = 0;
lâmpada booleana = 0;

int sobressalente = 0;
erro booleano;

configuração nula ()
{
  Serial.begin (9600);
  
  pinMode (ATUADOR1, SAÍDA);
  pinMode (ATUADOR2, SAÍDA);
  pinMode (HARDWARE_RESET, OUTPUT);

  digitalWrite (ATUADOR1, ALTO); // o módulo está ativo em LOW
  digitalWrite (ATUADOR2, ALTO); // o módulo está ativo em LOW
  digitalWrite (HARDWARE_RESET, HIGH);

  EspSerial.begin (9600); // Comunicação com Módulo WiFi
  EspHardwareReset (); // Redefinir WiFi do módulo
  startReadTiming = millis (); // iniciando o "relógio do programa"
}

loop vazio ()
{
  start: // label
  erro = 0;
  
  elapsedReadTime = millis () - startReadTiming;

  if (elapsedReadTime> (readTimingSeconds * 1000))
  {
    comando int = readThingSpeak (canalID1);
    if (comando! = 9) bomba = comando;
    atraso (5000);
    comando = readThingSpeak (canalID2);
    if (comando! = 9) lâmpada = comando;
    takeActions ();
    startReadTiming = millis ();
  }
  
  if (error == 1) // Reenviar se a transmissão não estiver concluída
  {
    Serial.println ("<<<< ERRO >>>>");
    atraso (2000);
    goto start; // vá para o rótulo "start"
  }
}

/ ********* Execute ações com base nos comandos do ThingSpeak ************* /
void takeActions (vazio)
{
  Serial.print ("Pump:");
  Serial.println (bomba);
  Serial.print ("Lâmpada:");
  Serial.println (lâmpada);
  if (pump == 1) digitalWrite (ATUADOR1, BAIXO);
  caso contrário, digitalWrite (ATUADOR1, ALTO);
  if (lâmpada == 1) digitalWrite (ATUADOR2, BAIXO);
  caso contrário, digitalWrite (ATUADOR2, ALTO);
}

/ ********* Leia o comando Atuadores do ThingSpeak ************* /
int readThingSpeak (String channelID)
{
  startThingSpeakCmd ();
  comando int;
  // preparação da string GET
  String getStr = "GET / channels /";
  getStr + = channelID;
  getStr + = "/ campos / 1 / último";
  getStr + = "\ r \ n";

  String messageDown = sendThingSpeakGetCmd (getStr);
  if (messageDown [5] == 49)
  {
    comando = messageDown [7] -48;
    Serial.print ("Comando recebido:");
    Serial.println (comando);
  }
  comando else = 9;
  comando de retorno;
}

/ ********* Redefinir ESP ************* /
void EspHardwareReset (void)
{
  Serial.println ("Redefinindo .......");
  digitalWrite (HARDWARE_RESET, LOW);
  atraso (500);
  digitalWrite (HARDWARE_RESET, HIGH);
  delay (8000); // Tempo necessário para começar a ler
  Serial.println ("RESET");
}

/ ********* Inicie a comunicação com o ThingSpeak ************* /
void startThingSpeakCmd (void)
{
  EspSerial.flush (); // limpa o buffer antes de começar a gravar
  
  String cmd = "AT + CIPSTART = \" TCP \ ", \" ";
  cmd + = "184.106.153.149"; // Endereco IP de api.thingspeak.com
  cmd + = "\", 80 ";
  EspSerial.println (cmd);
  Serial.print ("enviado ==> Iniciar cmd:");
  Serial.println (cmd);

  if (EspSerial.find ("Erro"))
  {
    Serial.println ("erro AT + CIPSTART");
    retornar
  }
}

/ ********* envia um cmd GET para ThingSpeak ************* /
String sendThingSpeakGetCmd (String getStr)
{
  String cmd = "AT + CIPSEND =";
  cmd + = String (getStr.length ());
  EspSerial.println (cmd);
  Serial.print ("enviado ==> comprimento cmd:");
  Serial.println (cmd);

  if (EspSerial.find ((char *) ">"))
  {
    EspSerial.print (getStr);
    Serial.print ("enviado ==> getStr:");
    Serial.println (getStr);
    delay (500); // tempo para processar o GET, sem este atraso apresenta busy no próximo comando

    String messageBody = "";
    while (EspSerial.available ())
    {
      Linha de seqüência de caracteres = EspSerial.readStringUntil ('\ n');
      if (line.length () == 1)
      {// o conteúdo real inicia após a linha vazia (que possui o comprimento 1)
        messageBody = EspSerial.readStringUntil ('\ n');
      }
    }
    Serial.print ("MessageBody recebeu:");
    Serial.println (messageBody);
    retornar messageBody;
  }
  mais
  {
    EspSerial.println ("AT + CIPCLOSE"); // alerta usuário
    Serial.println ("ESP8266 ERRO CIPSEND: ENVIANDO"); // Reenviar ...
    sobressalente = sobressalente + 1;
    erro = 1;
    retornar "erro";
  }
}

Você pode baixá-lo em



Nesta fase, temos um canal de atuador configurado alterando o valor do campo 1 para cada dispositivo. Devemos verificar se os dispositivos executam os comandos corretamente. No final do projeto, um aplicativo Android será usado para isso, mas também pode ser feito através de um navegador.

Ligue a bomba (LED vermelho aceso)

https://api.thingspeak.com/update?api_key=Saved_channel_key_1&field1=1

Bomba desligada (LED vermelho apagado)

https://api.thingspeak.com/update?api_key=Saved Channel_key_1 & field1 = 0

Ligue a lâmpada (o LED verde está aceso)

https://api.thingspeak.com/update?api_key=Saved Channel_key_2 & field1 = 1

Desligue a lâmpada (LED verde apagado)

https://api.thingspeak.com/update?api_key=Saved Channel_key_2 & field1 = 0

Na parte anterior, havia um programa simples que "lia" os dados do canal e os exibia na tela. Agora precisamos fazer o programa "escrever" os comandos no Atuador Channal, para que esses comandos possam ser lidos pelo controlador e a lâmpada com a bomba funcione de acordo.

Para que o usuário possa enviar comandos, o aplicativo terá dois botões para cada dispositivo. Se ligado, azul; se desligado, vermelho.

Ao clicar nos botões do aplicativo, você pode ver o resultado no Serial Monitor.

O código pode ser baixado em



Nesse estágio, há um aplicativo Android totalmente concluído, uma peça de hardware totalmente montada, mas não há código no controlador que lesse dados constantemente e enviasse comandos para a nuvem. Você só precisa combinar todos os fragmentos do código escrito anteriormente.Claro, o código possui opções de verificação adicionais (por exemplo, se o ESP-01 congelar). Para fazer isso, periodicamente, antes de cada comando de leitura ou gravação, um comando AT é enviado.E se a resposta OK não veio do módulo, o módulo é forçado a reiniciar programaticamente.

O código completo do projeto pode ser baixado em

No endereço, você pode obter atualizações para os arquivos de programa.

Você também pode ler comentários no link para a fonte, se algo não estiver claro.