Colocando os Dados em uma plataforma IoT

Salve galera, beleza?

Esse é o último post sobre do nosso projeto do ESP32 com o sensor DHT11 (Aaaahhhhh 😭). Esse último post é sobre como podemos enviar os dados que coletamos do sensor DHT11 para alguma plataforma IoT.

*Para entender esse post é de extrema importância que de uma olhada nessa publicação: 

https://iobrtools.blogspot.com/2019/05/banco-de-dados-com-esp32.html

Partindo da premissa que vocês já tenham os dados em uma Google Planilha, vamos exportar o arquivo CSV com as informações para a plataforma ThingSpeak:

https://thingspeak.com/

** É necessário criar uma conta

Com a conta criada Cliquem em "New Channel" coloquem um nome para esse canal, uma descrição e os campos de Umidade e Temperatura.

Feito isso basta importar o arquivo CSV da planilha do Google para lá.

*** Dentro do arquivo CSV deverá ser alterado a primeira linha para que a plataforma reconheça os campos, o meu ficou assim: 

datetime,field2,field1

E é isso aí, bem fácil né?

Existe uma outra maneira para enviar os dados para a plataforma, porém, na programação do ESP32 os dados não devem ser enviados para a Google planilhas, mas sim, direto para o ThingSpeak.

Como fazer isso?

Também é simples, pegue o mesmo código que está nesse post:

https://iobrtools.blogspot.com/2019/05/banco-de-dados-com-esp32.html

E altere os seguintes campos:

1° Onde estiver o host do Google coloque: "api.thingspeak.com";

2° No caminho do seu forms você coloca: "/update?api_key=SUA_CHAVE";

3° Nos campos de entrada basta colocar: "&field1=" "&field2=".

**** Para pegar a tal chave, no próprio canal do ThingSpeak é possível pegar essa chave clicando no menu Keys.

Bom, é isso pessoal!!!

 Divirtam-se! 

Banco de Dados com ESP32

Fala aí pessoal!

Tudo beleza?

Nesse post vou mostrar como podemos montar um banco de dados usando o ESP32 e coletando os dados do DHT11

Para começar é necessário que você crie um formulário do Google e uma planilha do Google.

Primeiro passo crie uma planilha e coloque o nome como coleta de dados ou algo do tipo.

Após isso crie um formulário, coloque um título e crie duas perguntas, uma pra temperatura e uma para umidade. Coloque as duas como respostas curtas.
Ainda no formulário, vá na aba respostas e vincule sua planilha com o formulário.

Perfeito! A conexão entre planilha e formulário está feita. Se quiser preencha os resultados e envie uma resposta como teste.

Esse é o código que usaremos no ESP32:

**AVISO: NÃO COPIE E COLE ESSE CÓDIGO DIRETO, POIS, É NECESSÁRIO QUE ALTEREM ALGO**

#include <WiFi.h>
#include <DHT.h>
#include <WiFiClientSecure.h>

#define DHTPIN 23 // pino de dados do DHT11
#define DHTTYPE DHT11 // define o tipo de sensor, no caso DHT11

DHT dht(DHTPIN, DHTTYPE);

float umidade;
float temperatura;


WiFiClientSecure client;//Cria um cliente seguro (para ter acesso ao HTTPS)
String textFix = "GET /forms/d/e/1FAIpQLSct2cvJhOekJ_IjGsDujEln1H6EYdm0qbkU_3p9Kfrv4-ZGQ/formResponse?ifq";
//Essa String sera uma auxiliar contendo o link utilizado pelo GET, para nao precisar ficar re-escrevendo toda hora

void setup()
{
    Serial.begin(115200);//Inicia a comunicacao serial
    dht.begin();
    WiFi.mode(WIFI_STA);//Habilita o modo estaçao
    WiFi.begin("SUA REDE", "SENHA DA SUA REDE");//Conecta na rede
   
    delay(2000);//Espera um tempo para se conectar no WiFi
}
void loop()
{
   umidade = dht.readHumidity();
  temperatura = dht.readTemperature();

  if (isnan(temperatura) || isnan(umidade))
  {
    Serial.println("Failed ao ler DHT");
  }
  else
  {
    if (client.connect("docs.google.com", 443) == 1)//Tenta se conectar ao servidor do Google docs na porta 443 (HTTPS)
    {
        String toSend = textFix+"&entry.250814549="+umidade+"&entry.179559370="+temperatura;
//Atribuimos a String auxiliar na nova String que sera enviada
      
        toSend += "&submit=Submit HTTP/1.1";//Completamos o metodo GET para nosso formulario.

        client.println(toSend);//Enviamos o GET ao servidor-
        client.println("Host: docs.google.com");//-
        client.println();//-
        client.stop();//Encerramos a conexao com o servidor
        Serial.println("Dados enviados.");//Mostra no monitor que foi enviado
    }
    else
    {
        Serial.println("Erro ao se conectar");//Se nao for possivel conectar no servidor, ira avisar no monitor.
    }
  }
    delay(5000);
}

As partes que estão Vermelhas é necessário adaptar.

Para conseguir essas informações faça o seguinte:

Abra seu formulário e pegue o endereço dele todo entre “docs.google.com” e “/viewform” e substitua onde está a função GET.

Para pegar o campo de referencia das respostas é necessário pegar o nome do campo na programação fonte do formulário.

Clique com o botão direito e de um inspecionar elemento, abrirá uma janela com o código HTML do form. Procure o campo das respostas e cole na programação do ESP.

Pronto! Está feito nosso Banco de Dados para coletas.

Se deixar o código rodando com a planilha aberta você verá que as linhas serão inseridas manualmente.

Faça um teste, coloque um isqueiro próximo do DHT11 (Cuidado para não se queimar ou queimar o sensor).

E é isso! Caso tenha alguma dúvida dê uma olhada nas postagens anteriores, caso não encontre a resposta, deixe um comentário.

Divirtam-se!

Enviando Dados para o WebServices

Fala ai pessoal, beleza?

Nesse post vou mostrar como enviar os dados do DHT11 usando o WebServices.

Para começar é necessário ter a biblioteca do DHT11 e do Adafruit (Se der uma olhada nas postagens antigas eu mostro como instalar essas bibliotecas)

Após colocar essas bibliotecas, adicione esse código no ESP32:

#include <WiFi.h>
#include <WebServer.h>
#include "DHT.h"

// TIPOS DE DHT QUE É POSSÍVEL USAR
#define DHTTYPE DHT11   // DHT 11
//#define DHTTYPE DHT21   // DHT 21 (AM2301)
//#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321

/*Put your SSID & Password*/
const char* ssid = "NOME DA SUA REDE"; 
const char* password = "SENHA DA SUA REDE";
WebServer server(80);

// PINO DO SENSOR
uint8_t DHTPin = 23;
              
DHT dht(DHTPin, DHTTYPE);               

float Temperature;
float Humidity;

void setup() {
  Serial.begin(115200);
  delay(100);
 
  pinMode(DHTPin, INPUT);

  dht.begin();             

  Serial.println("Connecting to ");
  Serial.println(ssid);

  //connect to your local wi-fi network
  WiFi.begin(ssid, password);

  //check wi-fi is connected to wi-fi network
  while (WiFi.status() != WL_CONNECTED) {
  delay(1000);
  Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected..!");
  Serial.print("Got IP: ");  Serial.println(WiFi.localIP());

  server.on("/", handle_OnConnect);
  server.onNotFound(handle_NotFound);

  server.begin();
  Serial.println("HTTP server started");

}
void loop() {
 
  server.handleClient();
 
}

void handle_OnConnect() {

 Temperature = dht.readTemperature(); // Gets the values of the temperature
  Humidity = dht.readHumidity(); // Gets the values of the humidity
  server.send(200, "text/html", SendHTML(Temperature,Humidity));
}

void handle_NotFound(){
  server.send(404, "text/plain", "Not found");
}

//CONFIGURAÇÃO DA PÁGINA
String SendHTML(float Temperaturestat,float Humiditystat){
  String ptr = "<!DOCTYPE html> <html>\n";
  ptr +="<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0, user-scalable=no\">\n";
  ptr +="<title>ESP32 Weather Report</title>\n";
  ptr +="<style>html { font-family: Helvetica; display: inline-block; margin: 0px auto; text-align: center;}\n";
  ptr +="body{margin-top: 50px;} h1 {color: #444444;margin: 50px auto 30px;}\n";
  ptr +="p {font-size: 24px;color: #444444;margin-bottom: 10px;}\n";
  ptr +="</style>\n";
  ptr +="</head>\n";
  ptr +="<body>\n";
  ptr +="<div id=\"webpage\">\n";
  ptr +="<h1>ESP32 Weather Report</h1>\n";
  ptr +="<p>Temperature: ";
  ptr +=(int)Temperaturestat;
  ptr +="°C</p>";
  ptr +="<p>Humidity: ";
  ptr +=(int)Humiditystat;
  ptr +="%</p>";
  ptr +="</div>\n";
  ptr +="</body>\n";
  ptr +="</html>\n";
  return ptr;
}

Ao compilar esse código, abra o monitor serial e ele retornará o IP, digite esse IP em algum navegador e pronto aparecerá os dados na página.

* No código, é possível alterar configurações de layout da sua página.

É possível também acrescentar um refresh na página para atualizar os dados:

ptr +="<meta http-equiv=refresh content=TEMPO EM SEGUNDOS, http:ENDEREÇO DE RETORNO>\n";

** Se você assoprar no seu sensor e atualizar a página, a umidade aumentará, o que confirma que o código está funcionando  .

Conectando ESP32 no WiFi

Fala pessoal! Beleza?

Vou mostrar nesse post como conectar a placa ESP32 em um uma rede WiFi.

Para começar é necessário colocar a biblioteca NTPClient na IDE do Arduino. Esse é o link do zip:

https://github.com/taranais/NTPClient/archive/master.zip

Após baixar o ZIP, instale a biblioteca seguindo esse caminho:

Sketch -> Incluir Biblioteca -> Adicionar Biblioteca ZIP

Depois de adicionar a biblioteca, insira o código:

#include <WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <time.h>


const char* ssid = "NOME DA REDE";
const char* password = "SENHA DA REDE";


WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

String formattedDate;
String dayStamp;
String timeStamp;


void setup(){
  Serial.begin(115200);
  Serial.print("Connecting to ");
  Serial.println(ssid);
  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());

  timeClient.begin();
  timeClient.setTimeOffset(3600);
}
void loop(){
  while(!timeClient.update()){
    timeClient.forceUpdate();
  }
  formattedDate = timeClient.getFormattedDate();
  Serial.println(formattedDate);
  int splitT = formattedDate.indexOf("T");
  dayStamp = formattedDate.substring(0, splitT);
  Serial.print("DATE: ");
  Serial.println(dayStamp);
  timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);
  Serial.print("HOUR: ");
  Serial.println(timeStamp);
  delay(1000);
}

Quando compilar abra o Monitor Serial

Divrtam-se!!

Sensor DHT11 no ESP32.

Fala pessoal, tudo bem?

Nesse post irei mostrar como usar um sensor DHT11 (Umidade e Temperatura) no ESP32.

Primeiramente, esse post foi baseado no artigo da Página do Filipe Flop. Caso queiram ver a publicação original, segue o link:

https://www.filipeflop.com/blog/bluetooth-low-energy-com-esp32-e-dht11/

Para começar, é importante ter a biblioteca do DHT11 instalado na IDE do Arduino.

Para instalar, é necessário baixar a biblioteca que está nesse link: 

https://github.com/adafruit/DHT-sensor-library

Após baixar o ZIP, instale a biblioteca seguindo esse caminho:

Sketch -> Incluir Biblioteca -> Adicionar Biblioteca ZIP

Com a biblioteca instalada é necessário fazer mais um ajuste no AdaFruit.

Vá em Ferramentas -> Gerenciar Biblioteca

Instale esse componente (no meu caso, já está instalado).

Pronto! Agora podemos brincar com o sensor.

Primeiro monte esse circuito:

Após montar esse circuito coloque esse código na placa:

/*
 *  Programa baseado no programa original desenvolvido por Timothy Woo
 *  Tutorial do projeto original; https://www.hackster.io/botletics/esp32-ble-android-arduino-ide-awesome-81c67d
 *  Modificado para ler dados do sensor DHT11 - Bluetooth Low Energy com ESP32
 */
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>

#include <DHT.h>

#include <iostream>
#include <string>

BLECharacteristic *pCharacteristic;

bool deviceConnected = false;
const int LED = 2; // Could be different depending on the dev board. I used the DOIT ESP32 dev board.

/*
 * Definição do DHT11
 */
#define DHTPIN 23 // pino de dados do DHT11
#define DHTTYPE DHT11 // define o tipo de sensor, no caso DHT11

DHT dht(DHTPIN, DHTTYPE);

float humidity;
float temperature;

// Veja o link seguinte se quiser gerar seus próprios UUIDs:
// https://www.uuidgenerator.net/

#define SERVICE_UUID           "6E400001-B5A3-F393-E0A9-E50E24DCCA9E" // UART service UUID
#define CHARACTERISTIC_UUID_RX "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"
#define DHTDATA_CHAR_UUID "6E400003-B5A3-F393-E0A9-E50E24DCCA9E"


class MyServerCallbacks: public BLEServerCallbacks {
    void onConnect(BLEServer* pServer) {
      deviceConnected = true;
    };

    void onDisconnect(BLEServer* pServer) {
      deviceConnected = false;
    }
};

class MyCallbacks: public BLECharacteristicCallbacks {
    void onWrite(BLECharacteristic *pCharacteristic) {
      std::string rxValue = pCharacteristic->getValue();
      Serial.println(rxValue[0]);

      if (rxValue.length() > 0) {
        Serial.println("*********");
        Serial.print("Received Value: ");

        for (int i = 0; i < rxValue.length(); i++) {
          Serial.print(rxValue[i]);
        }
        Serial.println();
        Serial.println("*********");
      }

      // Processa o caracter recebido do aplicativo. Se for A acende o LED. B apaga o LED
      if (rxValue.find("A") != -1) {
        Serial.println("Turning ON!");
        digitalWrite(LED, HIGH);
      }
      else if (rxValue.find("B") != -1) {
        Serial.println("Turning OFF!");
        digitalWrite(LED, LOW);
      }
    }
};

void setup() {
  Serial.begin(115200);

  pinMode(LED, OUTPUT);

  // Create the BLE Device
  BLEDevice::init("IOBR"); // Aqui é o nome para o Bluetooth

  // Configura o dispositivo como Servidor BLE
  BLEServer *pServer = BLEDevice::createServer();
  pServer->setCallbacks(new MyServerCallbacks());

  // Cria o servico UART
  BLEService *pService = pServer->createService(SERVICE_UUID);

  // Cria uma Característica BLE para envio dos dados
  pCharacteristic = pService->createCharacteristic(
                      DHTDATA_CHAR_UUID,
                      BLECharacteristic::PROPERTY_NOTIFY
                    );
                      
  pCharacteristic->addDescriptor(new BLE2902());

  // cria uma característica BLE para recebimento dos dados
  BLECharacteristic *pCharacteristic = pService->createCharacteristic(
                                         CHARACTERISTIC_UUID_RX,
                                         BLECharacteristic::PROPERTY_WRITE
                                       );

  pCharacteristic->setCallbacks(new MyCallbacks());

  // Inicia o serviço
  pService->start();

  // Inicia a descoberta do ESP32
  pServer->getAdvertising()->start();
  Serial.println("Esperando um cliente se conectar...");
}

void loop() {
  if (deviceConnected) {

    humidity = dht.readHumidity();
    temperature = dht.readTemperature();
    // testa se retorno é valido, caso contrário algo está errado.
    if (isnan(temperature) || isnan(humidity))
    {
      Serial.println("Failed to read from DHT");
    }
    else
    {
      Serial.print("Umidade: ");
      Serial.print(humidity);
      Serial.print(" %\t");
      Serial.print("Temperatura: ");
      Serial.print(temperature);
      Serial.println(" *C");
    }
    
    char humidityString[2];
    char temperatureString[2];
    dtostrf(humidity, 1, 2, humidityString);
    dtostrf(temperature, 1, 2, temperatureString);

    char dhtDataString[16];
    sprintf(dhtDataString, "%d,%d", temperature, humidity);
    
    pCharacteristic->setValue(dhtDataString);
    
    pCharacteristic->notify(); // Envia o valor para o aplicativo!
    Serial.print("*** Dado enviado: ");
    Serial.print(dhtDataString);
    Serial.println(" ***");
  }
  delay(1000);
}


Depois de compilar esse código, instale o APP que está no site do Filipe Flop e conecte com o Bluetooth.

Esse será o resultado. O bluetooth e o app estão funcionando.

*** Esses números estão esquisitos devido a uma possível falha no sensor. Verificarei e posto uma atualização em breve.

Abraços!

Acendendo um LED com o ESP32

E aí pessoal, tudo bem com vocês? 👍😜

Nesse post vou mostrar como acender um LED com o ESP32 (sim o ESP32 faz isso também, tipo Arduino né?!).

Bom pra começar, esse são os materiais necessários:

• Placa ESP32;
• Protoboard;
• Cabo USB (aqueles de carregadores de celulares);
• LED (qualquer cor);
• Dois cabos Jumpers;
• Resistor de pelo menos 100Ω. 

Esse aí são os materiais

Comece encaixando a placa na Protoboard (Peça a ajuda deu um adulto, porque tem que forçar muito pra encaixar kkkkkkk).
Feito isso, coloque uma das pontas dos cabos Jumpers no GND (no meu caso, azul) e outro no D5 (no meu caso, vermelho). A outra ponta do vermelho pode encaixar no espaços a baixo, no cabo azul coloque no negativo da protoboard.

Na linha do vermelho coloque o resistor e o LED com o lado negativo na frente do cabo azul e ligue sua placa no no computador.

Não, não acendeu né? kkkkk

Para fazer funcionar, abra a IDE e coloque esse código:


const int ledPin = 5;

void setup() {
  pinMode (ledPin, OUTPUT);
}

void loop() {
  digitalWrite (ledPin, HIGH);

  delay(500);
  //LED Acendendo em 0,5 segundos)
  
  digitalWrite (ledPin, LOW);

  delay(500);
  //LED Apagando em 0,5 segundos)
}


Compile o código e pronto. O LED piscará de acordo com o tempo que você inseriu.

* Não esqueçam de ver as postagens anteriores e se tiverem dúvidas deixem nos comentários, ou entre em contato!

Divirtam-se

Configurando a IDE para Utilizar o ESP32

E aí pessoal, tudo certo?

Nessa postagem, vou ensinar como utilizar a Arduino IDE para programar no ESP32. Acompanha comigo que é bem simples:

O primeiro passo a se fazer é instalar a Arduino IDE em seu computador. Para fazer isso acesse o site:
https://www.arduino.cc/en/Main/Software

*Caso seu sistema operacional seja Windows 8.1 ou Windows 10 é possível encurtar o caminho e baixar direto pela Microsoft Store (é de grátis).

Com a IDE instalada, só falta configurá-la, simples não? kkkk


Para começar a configuração vá em Arquivo -> Preferência (Ou aperte Ctrl + , direto).





No final da janela de configuração, terá uma TextBox "URLs Adicionais para Gerenciadores de Placas". Nessa opção coloque o seguinte link:
https://dl.espressif.com/dl/package_esp32_index.json

Basta instalar e pronto, as bibliotecas do ESP32 já estarão disponíveis na IDE.

Após esse passo vá em Ferramentas e na opção de Placa selecione a "ESP32 Dev Module" e em upload speed coloque a 115200.

 

Já era! Está feito a configuração e agora é só brincar com o ESP32 (Falei que era simples?!).