Electrónica-arduino

domingo, 4 de noviembre de 2018

Servidor web simple con ESP8266

Hola nuevamente, en esta publicación voy a explicar cómo hacer un servidor web muy simple que sólo muestra texto estático (mejor dicho html), si bien esto es básico, creo que hay que empezar por algo.
Aclaro, no voy a explicar cómo hacer páginas web, sólo voy a explicar cómo montar una en el micro ESP8266, para aprender pueden ir aquí.

Las librerías que vamos a usar son la "ESP8266WebServer", viene con las dependencias del ESP8266 para arduino por lo que no hace falta instalarlo aparte, "DNSServer" que sirve para administrar las conexiones de los clientes y la "ESP8266WiFi" que se encarga de configurar el micro para que funcione correctamente.

#include <ESP8266WiFi.h>
#include <DNSServer.h>
#include <ESP8266WebServer.h>

ESP8266WebServer servidorweb(80);

const char* red = "red"/*ingrese aquí el nombre de id*/;
const char* contra = "contra"/*ingrese aquí la contraseña*/;
String pagina = 

  "<!DOCTYPEhtml>"
  "<html>"
    "<head>"
      "<title>"
        "Tutorial de servidor web"
      "</title>"
    "</head>"
    "<h3>"
      "Esto es un servidor web (de ejemplo)"
      " con el micro ESP8266"
    "</h3>"
  "<html>";

void setup() {

  Serial.begin(115200);

  WiFi.begin(red, contra);

  while (WiFi.status() != WL_CONNECTED) 
  {
    delay(500);
    Serial.print(".");
  }
  
  Serial.println("");
  Serial.print("Conectado a: ");
  Serial.println(red);
  Serial.print("Direccion IP: ");
  Serial.println(WiFi.localIP());
  
  servidorweb.on("/", []()
  {
    servidorweb.send(200, "text/html", pagina);
  });

  servidorweb.begin();

}

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

Como podemos ver se debe declarar el objeto:

ESP8266WebServer servidorweb(80);

y es el que vamos a utilizar cuando hagamos referencia a la librería. Luego se define el nombre de la red a la que nos vamos a conectar, la contraseña y por último definimos lo que va a ser la página web en sí.

Como podemos observar la página está escrita de una forma poco convencional:

String pagina = 

  "<!DOCTYPEhtml>"
  "<html>"
    "<head>"
      "<title>"
        "Tutorial de servidor web"
      "</title>"
    "</head>"
    "<h3>"
      "Esto es un servidor web (de ejemplo)"
      " con el micro ESP8266"
    "</h3>"
  "<html>";

pero esto es equivalente a escribir todo en una sola línea (si bien acá aparece en 3, es por el formato de la página):

String pagina= "<!DOCTYPEhtml><html><head><title>Tutorial de

servidor web</title></head><h3>Esto es un servidor web (de ejemplo)

con el micro ESP8266</h3><html>";

Cuál de las dos formas se use va a quedar a su gusto, para mi se ve más claro de la primera forma porque tiene una estructura tabulada y ordenada, lo que lo hace más fácil de visualizar.

Luego de definir la página web, vamos a dar inicio al programa, inicializando el puerto serie (cambiar la velocidad acá no infiere en nada) e inicializar la conexión a la red wifi predefinida, esperamos a que se conecte y damos notificación por el puerto serie de que se conectó a la red deseada y dejamos la dirección IP que el router le asignó. Todo esto básico y ya lo hicimos en otro post.

A continuación tenemos la siguiente porción de código (cuya sintaxis no es la normal):

  servidorweb.on("/", []()
  {
    servidorweb.send(200, "text/html", pagina);
  });

acá lo que estamos haciendo es indicarle al servidor cómo responder ante el "llamado" del cliente bajo la ruta "/", en este caso el servidor va a ejectuar la línea:

servidorweb.send(200, "text/html", pagina);

y lo que va a hacer es enviar como respuesta la página que tenemos almacenada en la variable "pagina" (vale aclarar que en lugar de poner "/" podríamos poner "/encender" y vamos a usar esa otra ruta, incluso podríamos declarar ambas, más adelante hablaremos de ello en más detalle). Una vez indicado cómo tiene que respoder podemos dar inicio al servidor web bajo el comando:

servidorweb.begin();

En el loop lo que tenemos que hacer es revisar constantemente si hay algún cliente esperando, y esto lo vamos a hacer con la siguiente línea:

servidorweb.handleClient();

Esta última línea debemos llamarla constantemente para que se manejen los clientes de forma regular.

domingo, 28 de octubre de 2018

Módulo GSM con mqtt

Bueno, hoy (en continuación al post del módulo GSM) les traigo cómo utilizar mqtt con un módulo gsm, hay una librería que se encarga de hacer todo el manejo de gprs y las conexiones y nos da un sistema simplificado. El código es el siguiente:

/**************************************************************
 *
 * For this example, you need to install PubSubClient library:
 *   https://github.com/knolleary/pubsubclient/releases/latest
 *   or from http://librarymanager/all#PubSubClient
 *
 * TinyGSM Getting Started guide:
 *   http://tiny.cc/tiny-gsm-readme
 *
 **************************************************************
 * Use Mosquitto client tools to work with MQTT
 *   Ubuntu/Linux: sudo apt-get install mosquitto-clients
 *   Windows:      https://mosquitto.org/download/
 *
 * Subscribe for messages:
 *   mosquitto_sub -h test.mosquitto.org -t GsmClientTest/init -t

 *   GsmClientTest/ledStatus -q 1
 * Toggle led:
 *   mosquitto_pub -h test.mosquitto.org -t GsmClientTest/led -q 1 -m

 *   "toggle"
 *
 * You can use Node-RED for wiring together MQTT-enabled devices
 *   https://nodered.org/
 * Also, take a look at these additional Node-RED modules:
 *   node-red-contrib-blynk-websockets
 *   node-red-dashboard
 *
 **************************************************************/

// elegimos el modem:
#define TINY_GSM_MODEM_SIM800
// #define TINY_GSM_MODEM_SIM808
// #define TINY_GSM_MODEM_SIM900
// #define TINY_GSM_MODEM_A6
// #define TINY_GSM_MODEM_A7
// #define TINY_GSM_MODEM_M590
// #define TINY_GSM_MODEM_ESP8266
// #define TINY_GSM_MODEM_XBEE

#include <TinyGsmClient.h>
#include <PubSubClient.h>

// credenciales de gprs
// en caso de no tener usuario y contraseña no llenar
const char apn[]  = "tuapn";
const char user[] = "";
const char pass[] = "";

// para las placas Mega, Leonardo, Micro utilizar el serie por hardware
#define SerialAT Serial1

// o Software Serial para Uno y Nano
//#include <SoftwareSerial.h>
//SoftwareSerial SerialAT(2, 3); // RX, TX

TinyGsm modem(SerialAT);
TinyGsmClient client(modem);
PubSubClient mqtt(client);

const char* broker = "test.mosquitto.org";

const char* topicLed = "GsmClientTest/led";
const char* topicInit = "GsmClientTest/init";
const char* topicLedStatus = "GsmClientTest/ledStatus";

#define LED_PIN 13
int ledStatus = LOW;

long lastReconnectAttempt = 0;

void setup() {
  pinMode(LED_PIN, OUTPUT);

  // elegimos una velocidad de datos
  Serial.begin(115200);
  delay(10);

  // elegimos la velocidad para el módulo
  SerialAT.begin(115200);
  delay(3000);

  // reiniciamos el módulo, demora mucho
  Serial.println("inicializando modem...");
  modem.restart();

  String modemInfo = modem.getModemInfo();
  Serial.print("Modem: ");
  Serial.println(modemInfo);

  // si la sim tiene contraseña ponerla acá
  //modem.simUnlock("1234");

  Serial.print("esperando por red...");
  if (!modem.waitForNetwork()) {
    Serial.println(" fallo");
    while (true);
  }
  Serial.println(" OK");

  Serial.print("conectando a ");
  Serial.print(apn);
  if (!modem.gprsConnect(apn, user, pass)) {
    Serial.println(" fallo");
    while (true);
  }
  Serial.println(" OK");

  // MQTT Broker setup
  mqtt.setServer(broker, 1883);
  mqtt.setCallback(mqttCallback);
}

boolean mqttConnect() {
  Serial.print("conectando a ");
  Serial.print(broker);
  if (!mqtt.connect("GsmClientTest")) {
    Serial.println(" fallo");
    return false;
  }
  Serial.println(" OK");
  mqtt.publish(topicInit, "GsmClientTest iniciado");
  mqtt.subscribe(topicLed);
  return mqtt.connected();
}

void loop() {

  if (mqtt.connected()) {
    mqtt.loop();
  } else {
    // Reconnect every 10 seconds
    unsigned long t = millis();
    if (t - lastReconnectAttempt > 10000L) {
      lastReconnectAttempt = t;
      if (mqttConnect()) {
        lastReconnectAttempt = 0;
      }
    }
  }

}

void mqttCallback(char* topic, byte* payload, unsigned int len) {
  Serial.print("mensaje recibido [");
  Serial.print(topic);
  Serial.print("]: ");
  Serial.write(payload, len);
  Serial.println();

  // solo lo ejecutamos si coinciden los tópicos
  if (String(topic) == topicLed) {
    ledStatus = !ledStatus;
    digitalWrite(LED_PIN, ledStatus);
    mqtt.publish(topicLedStatus, ledStatus ? "1" : "0");
  }
}

En donde dice "tuapn" en la línea 43, tendremos que ingresar el APN de nuestro proveedor de telefonía, a continuación les dejo los apn de las compañías de argentina:

CLARO: igprs.claro.com.ar

MOVISTAR: wap.gprs.unifon.com.ar usuario: wap contraseña: wap

PERSONAL: datos.personal.com usuario: datos contraseña: datos

TUENTI: internet.movil usuario:internet contraseña: internet

Para otros países solamente hay que googlear: apn nombre_compañia de nombre_país (en mi caso busqué "apn de todas las compañias de argentina").

Esto código sirve para encender un led a través de mqtt por internet (las aplicaciones podrían llegar a ser increíbles, como encender algo a distancia), para hacerlo funcionar tendremos que subscribirnos a los tópicos "GsmClientTest/init" y "GsmClientTest/ledStatus", en el primer tópico el equipo va a notificar cuando se conecte y en el segundo nos va a notificar el estado del led (encendido o apagado). Si publicamos en el tópico "GsmClientTest/led" podremos cambiar el estado del led mandando un mensaje cualquiera en ese tópico.

domingo, 21 de octubre de 2018

LDR

Hoy les traigo un post corto sobre LDR, o resistencias variables por luz. Estas resistencias van a variar según sea la cantidad de luz que reciben y las hay de dos tipos, las que aumentan la resistencia con la luz y las que disminuyen su resistencia con la luz. Estas resistencias son (o al menos eran) muy usadas para hacer lúces automáticas (las que se prenden automáticamente cuando oscurece), aunque el funcionamiento para esas aplicaciones es comparando con un valor de resistencia fijo (cuando el valor de la LDR está por debajo o por encima del valor con el cuál se compara enciende o apaga la luz), nosotros vamos a darle un uso un poco más amplio y vamos a intentar medir la cantidad de lúmenes en luxes. Esto nos va a permitir (saber si es de día o de noche) ampliar nuestra estación meteorológica y conocer las variaciones lumínicas en el tiempo.

Vamos a utilizar la librería "LightDependenResistor" que nos simplifica muchísimo el cálculo de todo. Esta librería se "alimenta" del valor de una resistencia en serie con la LDR y el modelo de la misma. Acá nos topamos con la primer barrera, como saber el modelo de nuestra resistencia variable por luz, esto es un poco difícil, en mi caso empecé a buscar imágenes que coincidieran con mi LDR y luego comencé a buscar los modelos asociados a esas imágenes, en mi caso era la GL5528 (justo coincide con el modelo del ejemplo). Una vez solucionado el tema del modelo realizamos el siguiente circuito:

Esta imágen la saqué del repositorio de github de la librería

y utilizamos el código de ejemplo de la librería, si abrimos el monitor serie de arduino, vamos a ver que nos entrega el valor en lux y en "foot candle" que es otra forma de medir la intensidad de la luz.

En el post de la semana que viene vamos a utilizar este nuevo sensor y la base de datos para realizarle una mejora a nuestra estación meteorológica.

domingo, 23 de julio de 2017

Fin de publicación

Esta vez vengo a comentar el fin de la tanda de publicaciones, espero el año que viene poder subir nuevo contenido. Hasta entonces, espero sus sugerencias.

domingo, 9 de julio de 2017

Sensor de humedad HIH-4000

Hoy les traigo el sensor de humedad HIH-4000, cuenta con una resolución de 31.483 mV por cada porcentaje de humedad relativa. Sus aplicaciones van desde la meteorología hasta (según la hoja de datos) equipamientos médicos.
Si se mira de frente (con la parte expuesta hacia nosotros) tenemos a la izquierda masa, en el centro la tensión de salida y a la derecha vcc. Se alimenta con 5V y entre el pin que va a masa y el de salida deberíamos agregarle una resistencia de 80Kohms.

El sensor recuadrado en rojo es la parte expuesta, y de
izquierda a derecha tenemos: GND, Salida, VCC

Este sensor tiene una respuesta bastante lineal, por lo que podemos tomar desde 0% hasta el 100% de humedad el incremento de la tensión que mencioné más arriba, pero para una humedad relativa de 0% tenemos 0,826V
A continuación les dejo un breve programa capaz de manejar los datos.

void setup()

{
  Serial.begin(9600);
}

void loop() 
{
  int humedad = 0, vout = 0;
  vout = analogRead(a0);
  humedad = ((vout - 0.826)/0.0315);
  Serial.println(humedad);  
}

Como el sensor se alimenta con 5V y tiene una tensión de salida que varía entre 0V y casi 4V es difícil implementarlo de forma directa (es decir sin ningún circuito adicional) con el microcontrolador ESP8266, recordemos que este micro se alimenta con 3,3V y es capaz de "leer" tensiones analógicas de hasta 1V. Con esto en mente, si alimentamos nuestro ESP8266 con 5V que luego regulamos, podríamos tomar esa tensión sin regular para alimentar el sensor de humedad, y si al pin de salida le agregamos un divisor resistivo con una atenuación de 1 a 4 podríamos usarlo sin ningún problema en ese microcontrolador. De más está decir que este sensor es de muchísima mejor calidad que la familia DHT.

domingo, 2 de julio de 2017

Cómo mantener las gráficas en node-red

Hoy les voy a explicar, como indica el título, cómo mantener las gráficas en node-red incluso si éste se detiene o se corta la luz.

Si realizaron la estación meteorológica simple (la versión que les dejé en el link de mega) quizá les pasó que las gráficas históricas se perdieron si se desconectaba el servidor o si detenían los servicios (hay algunos casos más en los que se pueden perder los datos, pero no los voy a mencionar porque el resultado siempre es el mismo, la pérdida de los datos), sin lugar a dudas a mi me pasó varias veces y tenía que mantener el servidor funcionando 24/7 si no quería perder esos datos, lo que hacía que la raspberry pi se me tildase o funcionase erráticamente luego de estar encendida por un par de meses (no me ejecutaba las funciones correctamente por lo que no filtraba los datos que se mostraban). Luego del último corte de luz me puse a pensar en cómo corregir eso, y decidí guardar los datos en un archivo, simplemente conectando los nodos de la siguiente forma

Así no perdía los datos, pero seguía sin poder mostrarlos nuevamente, revisando los datos que se guardaban, quedaba un objeto como el siguiente:

[{"key":"Series 1","values":[[1492920133027,32],[1492920135027, 33]...]}]

Si analizamos este objeto nos quedan las propiedades "Key" que guarda el valor "Series 1" y "values" que es un array de arrays (o un array de dos dimensiones) que contiene los milisegundos desde el año 1970 y la temperatura (o la humedad, si analizamos el otro archivo) correspondiente a esa fecha exacta.
Mi primera prueba fue crear una función que devuelva un objeto similar y mandarlo directo al graficador, pero no sirvió (lo más probable es que haya echo algo mal dado que no tengo experiencia trabajando con objetos), por lo que probé mandar el mismo objeto que guardo de la siguiente forma

Cuando presionaba el botón que inyecta el "timestamp" debería mandar los datos del archivo, de más está decir que esto no funciona porque lo que se guarda dentro del archivo es procesado como texto plano y no como un objeto, pero esto se resuelve poniendo el nodo json de la siguiente forma

Este nodo lo que hace es tomar el texto plano y lo transforma en lo que es (en este caso un objeto). Esto sí es tomado de forma correcta por el nodo "chart" y nos muestra los datos subidos, entonces ahora nos faltaría hacer que se guarde en ese mismo archivo y la solución que se me ocurrió es la siguiente (sé que el tamaño de la imágen es bastante chico)

Cada tres horas mando el promedio de la humedad (en este caso) al nodo "chart" el cual me devuelve todos los puntos graficados, en la función siguiente verifico si lo que me manda está vacío, si lo está no devuelve nada y si no lo está guarda en el archivo todos los datos. Cada vez que se enciende el servidor el nodo "inject" manda una señal que hace que se lea el archivo donde se guardan los datos, estos se convierten a objeto y se mandan al nodo "chart" que los grafica.
Esta solución sigue teniendo el problema de que se muestra el último año de datos, y luego se van a ir descartando los datos más antiguos al año, por lo que no podríamos almacenar más que eso (si modificamos cuántos días queremos mostrar en el pasado podríamos hacer que se muestre, pero como el espacio para graficar es reducido llegaría un punto en el cuál no se podría apreciar ningún detalle).
La solución a esto podría ser crear un archivo por año y que se muestren todos los datos del año actual (del primero de enero al 31 de diciembre), y esto se podría implementar en la última función (la que está a la salida de la gráfica). Vamos a obtener el año actual y lo vamos a usar como nombre del archivo (o al menos como parte del nombre del archivo) y luego le vamos a pasar el nombre del archivo al nodo que guarda los datos para que los guarde en dicho archivo o cree el archivo si el mismo no existe. Un ejemplo de esto sería lo siguiente, los nodos función obtienen el año, le agregan la ruta y pasan ese string como nombre de archivo, el nodo que maneja archivos crea el archivo y guarda el dato, si ya está creado solo guarda el dato, el otro nodo de manejo de archivos sólo lo abre y lo muestra por consola.

El resultado final nos quedaría algo similar a la imágen anterior, pero con un nodo de función extra, deberíamos crear los archivos iniciales por como está planteado el sistema.

Acá les dejo el código de la versión actualizada de la estación meteorológica para que puedan importar y ver el código, o la configuración, de cada nodo. Vale aclarar que el sistema de archivos que estoy usando es el de linux que es el sistema operativo recomendado para la raspberry pi 3, si tienen montado este servidor en windows hay que cambiar la ruta de los archivos.

https://mega.nz/#!W5g1UBII!Xwh1HVaIYwi6lRhlVImE--tZM8qVIy2kR73KcwNCgDM

domingo, 25 de junio de 2017

Estación meteorológica simple

En esta ocasión les traigo una forma de hacer una estación meteorológica simple con node-red, mqtt, esp8266, un dth11 y una raspberry pi 3 haciendo las veces de servidor. La idea es dejar este equipo en el exterior y que se comunique con el servidor a través de la red wifi, y que a través de un servicio web podamos consultar los datos actuales y atrás en el tiempo.

Primero y principal deberíamos tener los componentes mínimos para montar el sistema, por lo que vamos a necesitar un par de cargadores de celular (para alimentación de las dos placas), una vez realizado esto tendríamos que establecer una conexión vnc, que lo vamos a conseguir ingresando al terminal (de la raspberry pi 3) y ponemos los siguientes comandos:

sudo apt-get update

sudo apt-get install realvnc-vnc-server realvnc-vnc-viewer

esto nos va a instalar el real vnc, una vez puesto todo eso vamos a descargar el vnc viewer y a instalarlo. una vez echo esto vamos a conectarnos (es posible que haya que configurar una contraseña además de darle permiso desde la rbpi 3, no pongo todos los pasos por acá porque se va a hacer muy largo el post y esto tampoco es tan necesario para tener andando todo, directamente se podría realizar desde la rbpi 3 y dejarlo andando sin problemas, pero me resulta más práctico tener acceso a la computadora de forma remota) a la dirección que nos indique en la rbpi3. Esto nos va a "simular" lo que aparecería por pantalla de la computadora, y debería ser algo como lo siguiente:

Luego deberíamos bajar el mqtt broker mosca en la rbpi 3, para poder crear el servicio. Para ello abriremos el terminal e ingresar el siguiente comando (quizá sea bastante molesto, pero poner la palabra "sudo" antes de cualquier comando, le da atributos root y nos evita perder el tiempo, aunque hay que tener cuidado porque justamente estamos ejecutando cosas como root):

sudo npm install mosca bunyan -g

y debería aparecer lo siguiente:

El proceso de instalación demora bastante, sobre todo si la tarjeta SD sobre la cual montamos el SO es medio lenta o si están ejecutando otras cosas como el navegador.

Una vez terminado el proceso de instalación, solo hay que iniciar el servidor mqtt con el comando:

mosca -v | bunyan

y debería iniciar de la siguiente forma:

Hay que recordar que también hay que iniciar el node-red para este proyecto. Una vez todo configurado vamos a abrir en nuestro navegador el node-red (con la ip de la rbpi 3) y vamos a colocar los siguientes nodos:

El código para estos nodos lo dejo al final del post.

Le damos "deploy" y ya deberíamos tener esa parte lista, si queremos guardar los dato o si queremos graficar más tiempo solo tenemos que cambiar las bases de las gráficas. Si nos vamos a la página del node-red (que es agregando a la dirección que termina en 1880, /ui) tendremos lo siguiente:

Ahora vamos a arrancar con la parte del sensor (dht11) y el esp8266. Los componentes que estoy usando son los de las fotos (sé que no queda bien usar el flash, pero se veía tan poco que decidí cometer el pecado):

Los tengo conectados con un cable que me vino con mi modelo del esp.
El cable no era el ideal, porque tenía la separación de los pines muy
corta y los cables no me coincidían con el sensor, pero lo invertí y
"forcé" los pines del dht para que todo quedase bien (creo).

Según mi placa (el modelo es "crowtail- ESP8266 NodeMCU") lo tengo conectado sobre el pin "D1" que según la web es el GPIO5, por lo que si ustedes tienen otra placa deberían corroborar cuál es el pin adecuado.

El código que le cargué es el siguiente:

/*
 * Este programa es una estación meteorológica que verifica los niveles de 
 * temperatura y humedad del ambiente con el sensor DTH11. Se alimenta con 
 * una celda fotovoltáica, y posee un cargador de baterías y alimentación 
 * para el equipo.
 */


#include <ESP8266WiFi.h>
#include <PubSubClient.h>

//---------------------------------------------------------------------------

#include "DHT.h"

#define DHTPIN            5         // Pin de datos
#define DHTTYPE           DHT11     // DHT 11

// El tercer parámetro va en función de la velocidad
// del microprocesador, cuanto más rápido sea, más 
// grande el valor (6 es para un micro de 16Mhz).

DHT dht(DHTPIN, DHTTYPE, 11);

//---------------------------------------------------------------------------

// Las siguientes tres constantes definen, nombre
// de red wifi y su contraseña.

const char* ssid = "Fibertel WiFi999";
const char* password = "0043546735";
const char* mqtt_server = "192.168.1.23";

// Acá definimos los pines.

const int d1 = 5, d2 = 4, d3 = 0, pin_led = 2;

long tiempo = 0;

// A continuación declaramos el nombre del cliente 
// que se va a conectar.

WiFiClient espClient;
PubSubClient client(espClient);

// En esta variable se almacena el mensaje recibido
// notar que tiene un máximo de 50 (en realidad son
// 49) caracteres.

char msg[50];

void setup() {
  pinMode(pin_led, OUTPUT);   //Pin del LED 2
  digitalWrite(pin_led, LOW);
  pinMode(d1, INPUT);         //Pin D1
  pinMode(d2, INPUT);         //Pin D2
  pinMode(d3, INPUT);         //Pin D3
  
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);

  dht.begin();
}

void setup_wifi() {

    Serial.println();
    Serial.print("Conectando a: ");
    Serial.println(ssid);
  
    WiFi.begin(ssid, password);

    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(500);
      Serial.print(".");
    }
  
    digitalWrite(pin_led, HIGH);
  
    Serial.println("");
    Serial.println("WiFi conectado");
    Serial.println("IP: ");
    Serial.println(WiFi.localIP());

}

// En esta función se administra la llegada de 
// mensajes, nos avisa en qué tópico llegó y 
// cuál es el mensaje.

void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensaje recibido [");
  Serial.print(topic);
  Serial.print("] ");

  if ((char)payload[0] == 'O') {  // si recibo como primer caracter una O
    if ((char)payload[1] == 'N'){  // si recibo como segundo caracter una N
      Serial.println("El boton esta apagado"); 
      digitalWrite(pin_led, LOW);
    } 
    else {
      Serial.println("El boton esta encendido");  
      digitalWrite(pin_led, HIGH);
    }
  }

}

// Esta función se encarga de conectar con el 
// mqtt broker, si lo consigue se subscribe a
// los tópicos que definamos (no es necesario
// subscribirnos en esta función, pero si lo
// recomiendo para organizar mejor el código.
// Prueba reconectarse cada cinco segundos si
// no lo consigue.

void reconnect() {
  // Loop hasta lograr la conexión
  while (!client.connected()) {
    Serial.print("Intentando conectar al servicio MQTT...");
    
    if (client.connect("ESP8266Client")) {
      Serial.println("Conectado!");
      client.publish("temperatura", "0");    //envío dato
      client.publish("humedad", "0");    //envío dato
    } 
    else 
    {
      Serial.print("Fallo, Resultado=");
      Serial.print(client.state());
      Serial.println("Intetando nuevamente en 5 segundos");
      delay(5000);
    }
  }
}

// En el loop principal no hacemos nada más 
// que verificar si perdimos la conexión con
// el servicio mqtt, que lleguen mensajes y
// actualizamos la temperatura y humedad. 
// El "client.loop();" se encarga de revisar 
// si llegaron mensajes, por lo que habría
// que invocar esta función regularmente.

void loop() {

  if (WiFi.status() != WL_CONNECTED)
  {
    setup_wifi();
  }
  if (!client.connected()) 
  {
    reconnect();
  }
  
  //-------------------------------------------------------
  if ((millis() - tiempo) > 2000)
  {
    tiempo = millis();
    float humedad = dht.readHumidity();
    float temperatura = dht.readTemperature();
    client.publish("temperatura", String(temperatura).c_str(),true);
    delay(250);
    client.publish("humedad", String(humedad).c_str(),true);
    delay(250);
    Serial.print(temperatura);
    Serial.print(" ");
    Serial.println(humedad);
  }

  //-------------------------------------------------------
}

Bueno, el resultado final va a ser similar al siguiente (mi sensor no anda del todo bien y me tira picos de 66º C, pero por suerte eso no pasa jaja)

Acá les dejo el código fuente del programa del node-red (recuerden modificar las direcciones ip para que se ajusten a su red, aunque si está todo montado de forma local, poniendo localhost debería bastar) para que puedan importarlo a sus servidores (con algunos extra):

https://mega.nz/#!z9pVQY5K!UbAhz9WpzZzg1AXPkpskjLP9lIkeax5fp_dCDyoldTc

Páginas