Tutorial: Sistema de alarmística de temperatura com NodeMCU

É cada vez mais comum ter sistemas automatizados que recolhem informação para posteriormente nos darem orientações. O tutorial que preparamos para hoje é um estilo de sistema de alarmística básico.
O cliente faz a recolha da temperatura ambiente e envia-a para um servidor que por sua vez passa para um servidor na Cloud. Sempre que a temperatura ultrapasse um determinado valor, o servidor emite um alerta.

Para este tutorial vamos usar o já popular microcontrolador ESP8266 NodeMCU (c/ o módulo ESP-12E).

Arquitetura

A seguinte arquitetura dá uma ideia do sistema a implementar. É de salientar apenas teremos um cliente, mas a arquitetura pode ter N clientes.

Hardware – Lista de material

Para este projeto foram utilizados os seguintes recursos:

• 2x Node MCU ESP 8266;
• 2x Cabo micro USB
• 1x DS18B20 (sensor de temperatura);
• 1x LED;
• Resistências;
• Fios de cobre.

A NodeMCU é uma pequena plataforma de desenvolvimento open source direcionada para o desenvolvimento de projetos no mundo da Internet das Coisas. Esta pequena mas poderosa placa vem com um microcontrolador ESP8266 (da Espressif Systems) que oferece suporte nativo para redes Wi-fi com as normas 802.11 b/g/n. Saber mais aqui.

Características da placa NodeMCU

• Wi-fi 2,4 Ghz com suporte para as normas 802.11 b/g/n>
  • WPA/WPA2
  • Wi-Fi Direct (P2p), Soft Access Point
  • Antena integrada
• Power: 5V via porta micro USB
• Processador Tensilica LX106 – até 160MHz
• Pilha protocolar TCP/IP (apenas IPv4)
• Botão de Reset e Flash
• Memória RAM: 96kBytes
• Memória ROM boot: 64 KBytes
• Memória flash: 4 MB
• Potência de saída: 0,15 (W); +19.5dBm em modo 802.11b
• Consumo em modo de baixa energia: > 10 uA
• GPIO com funções de PWM, I2C, SPI, etc
• Conversor analógico digital (ADC)
• Dimensões:49 x 24.5 x 13mm

DS18B20 – Sensor de Temperatura

O DS18B20 é um sensor de temperatura da Maxim Integrated que mede temperatura entre -55ºC e +125ºC utilizando o protocolo 1-Wire batizado e registado pela DALLAS Semiconductors. Este tipo de sensores, enviam os dados da temperatura em série, transmitidos por uma única linha de transmissão, ou seja, é possível ligar múltiplos sensores numa única porta do microcontrolador pois cada sensor tem um número de série único de 64-bit permitindo economizar recursos.

Por causa do 1-Wire, foi necessário adicionar uma resistência de 4.7KΩ entre o 5V e a pino de dados do sensor, que serve de pull-up para manter o nível lógico a 1.
Por fim utilizámos um LED para simular o alerta de temperatura elevada.

Software

• Arduino IDE
• Plataforma ThingSpeak

Plataforma Thingspeak

Thingspeak é uma plataforma de análise IoT (Internet of Things) que permite agregar, visualizar e analisar streams de dados, de uma forma muito simples. Uma das grandes vantagens da plataforma Thingspeak é que nos permite visualizar os dados enviados pelos nossos dispositivos, em tempo real, mas também a possibilidade de analisar os mesmo recorrendo ao poderoso Matlab. Saber mais aqui.

Com uma conta gratuita temos a possibilidade de guardar e analisar dados de até 8 sensores (canais). Assim, o Thingspeak é ideal para projetos numa pequena escala. Para projetos maiores, temos a opção de fazer o upgrade da conta com um fluxo de dados maior e mais rápido (a conta gratuita limita o envio de dados a cada 15 segundos).

No nosso caso, o protótipo só envia dados de apenas um sensor para o Thingspeak, através de um URL com envio dos valores pela query string. O registo de alguns dados no Thingspeak, resultou no seguinte gráfico:

Este gráfico é o resultado de um teste feito ao sistema a funcionar com todos os seus módulos. O sensor foi aquecido, que resultou no pico do gráfico quase aos 40º graus e demonstrou sucesso do nosso projeto.

Circuito

O seguinte circuito representa a ligação do sensor de temperatura ao microcontrolador cliente.

O seguinte circuito representa a ligação do LED (alerta) ao servidor.

Implementação

Bibliotecas

Para facilitar a implementação deste projeto, recorremos a algumas bibliotecas. A animação seguinte pretende demonstrar a falha no upload do código por falta de uma biblioteca e como a incluir.

Cliente

O ESP8266 cliente será o microcontrolador que faz a medição da temperatura e envia os valores para o ESP8266 servidor.
Não esquecer de alterar a variável ssid e password com as suas respetivas credenciais de acesso à sua Internet. Também é necessário ajustar o endereço IP do servidor que pode ser obtido através da consola após ligação à rede.
Ex.: url=”http://192.168.0.168/t?temp=”+String(temp);

Código principal do cliente

#include
#include
#include
#include

const char* ssid = ““;
const char* password = ““;

WiFiServer server(80);

String url = “”;
bool httpFunction = false;

#define ONE_WIRE_BUS 13 // DS18B20 pin
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);
void setup() {
Serial.begin(115200);
delay(10);
// Connect to WiFi network
Serial.println();
Serial.println();
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”);
// Start the server
server.begin();
Serial.println(“Server started”);
// Print the IP address
Serial.print(“Use this URL to connect: “);
Serial.print(“http://”);
Serial.print(WiFi.localIP());
Serial.println(“/”);
}

void loop() {
float temp;
DS18B20.requestTemperatures();
temp = DS18B20.getTempCByIndex(0);
Serial.print(“Temperature: “);
Serial.println(temp);

url=”http:///t?temp=”+String(temp);
httpConnect(url);
delay(1000);
}

Função httpConnect()
bool httpConnect(String url) {
HTTPClient http; // Declare an object of class HTTPClient
http.begin(url); // Specify request destination
int httpCode = http.GET(); //Send the request
if (httpCode > 0) { // Check the returning code
String payload = http.getString(); //Get the request response payload
}
http.end(); // Close connection
return true;
}

Servidor

Em relação ao servidor também é necessário alterar as credenciais da sua ligação à Internet. Para simplificar a implementação do projeto, o cliente e o servidor deve estar na mesma rede.
De forma a enviar os dados para o ThingSpeak, é necessário definir o token e o nome do campo (ex.: String p = String(“http://api.thingspeak.com/update?api_key=2ABCKNTSH25MUYTE&field1=”)+temp;)

Código do servidor

#include
#include
#include

const char* ssid = “TESTES”;
const char* password = “TEnkust5l54#$”;

WiFiClient client;
HTTPClient http;
ESP8266WebServer server(80);
const int input2 = 13;
const int led = 13;
String ip = “”;
int data = 0;
long startTime = 0;
long endTime = 0;
long times = 0;
boolean device1 = false;
boolean device2 = false;
boolean device3 = false;
boolean device4 = false;

void handleRoot() {
String cmd;
cmd = “{\”Tempo\”:\””;
cmd += (endTime – startTime);
cmd += “\”}”;
server.send(200, “text/plain”, cmd);
}

void handleNotFound() {
String message = “File Not Found\n\n”;
message += “URI: “;
message += server.uri();
message += “\nMethod: “;
message += (server.method() == HTTP_GET) ? “GET” : “POST”;
message += “\nArguments: “;
message += server.args();
message += “\n”;
for (uint8_t i = 0; i < server.args(); i++) { message += ” ” + server.argName(i) + “: ” + server.arg(i) + “\n”; } server.send(404, “text/plain”, message); } void setup(void) { pinMode(led, OUTPUT); Serial.begin(115200); WiFi.begin(ssid, password); Serial.println(“”); // Wait for connection while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print(“.”); } Serial.println(“”); Serial.print(“Connected to “); Serial.println(ssid); Serial.print(“IP address: “); Serial.println(WiFi.localIP()); if (MDNS.begin(“esp8266”)) { Serial.println(“MDNS responder started”); } server.on(“/”, handleRoot); server.on(“/s”, []() { startTime = millis(); server.send(200, “text/plain”, “s”); }); server.on(“/e”, []() { endTime = millis(); server.send(200, “text/plain”, “e”); }); server.on(“/t”, []() { String temp = “”; temp += server.arg(0); long lint = temp.toInt(); if (lint >= 30.0) {
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
String p = String(“http://api.thingspeak.com/update?api_key=&=”) + temp;
http.begin(p);
int httpcode = http.GET();
Serial.printf(“httpcode: ” + httpcode);
http.end();
Serial.println(temp);
server.send(200, “text/plain”, temp);
});

server.onNotFound(handleNotFound);
server.begin();
Serial.println(“HTTP server started”);
}

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

Este é um tutorial simples mas que pode servir de base a muitos outros projetos. Se têm todo o hardware, experimentem. Caso tenham alguma dúvida, deixem nos comentários