Sensor de Temperatura,Humedad y salida relé con ESP8266 compatible con HomeKit

Vamos a construir nuestro segundo accesorio compatible con HomeKit ( el primero está detallado en la primera entrada relacionada con el tema donde montamos el servidor para los accesorios), se trata de un sensor de temperatura ,de humedad y con una salida de relé para controlar alguna luz o enchufe.

 

home-kit-3

 

Vamos usar un solo módulo ESP8266 para crear los 3 accesorios, luego añadiremos los tres accesorios virtuales a nuestro servidor HomeKit y a funcionar…

El esquema de montaje es muy sencillo…

homekit_dht11rele

 

El sketch para el módulo ESP8266 lo descargáis de AQUI.

 

La librería necesaria para compilar el sketch, DESCARGAR.

 

Antes de cargar el sketch en el módulo, acordaos de modificar los siguientes datos:

IPAddress server ( ip ); Dirección IP del servidor HomeKit (Raspberri Pi)

const char* ssid = “SSID”;  SSID de vuestra red WIFI

const char* pass = “PASSWORD”; Password de vuestra red WIFI

LuzSensor1 ; Nombre del accesorio del relé , si hay más cambiad el numero .

Temperatura1 ; Nombre del accesorio de temperatura , si hay más cambiad el numero.

Humedad1 ; Nombre del accesorio de humedad, si hay más cambiad el numero.

 

 

Para aprender a cargar el sketch en el módulo, visitad esta entrada del blog.

Una vez que hemos creado nuestro accesorio, accederemos a nuestro servidor HomeKit ( Raspberry Pi) por ssh.

ssh pi@ip de la raspberry

navegaremos al directorio de accesrios del servidor… ( la ruta dependerá de la version de node )

 

cd node-v6.7.0-linux-armv7l/HAP-NodeJS/accessories/

una vez en el directorio, descargaremos los accesorios

sudo wget https://dl.dropboxusercontent.com/u/8783282/descargas/ficheros/ficheros%20homekit%20DHT11/humedad1_accessory.js

sudo wget https://dl.dropboxusercontent.com/u/8783282/descargas/ficheros/ficheros%20homekit%20DHT11/temperatura1_accessory.js

sudo wget https://dl.dropboxusercontent.com/u/8783282/descargas/ficheros/ficheros%20homekit%20DHT11/LuzSensor1_accessory.js


Ahora editaremos los accesorios para modificar el nombre, si fuese necesario al añadir más, la dirección ip del servidor y las direcciones MAC del accesorio ( como en la entrada anterior ), para ello usaremos el comando nano…

 

sudo nano temperatura1_accesory.js

sudo nano humedad1_accesory.js

sudo nano LuzSensor1_accesory.js

 

Reiniciamos el servidor para que arranquen los nuevos accesorios

 

sudo reboot

 

Y ya podemos añadir los nuevos accesorios a la aplicación HomeKit de nuestro iPhone/ipad .

 

img_0199

 

 

DonacionPayPal

Anuncios

23 Respuestas a “Sensor de Temperatura,Humedad y salida relé con ESP8266 compatible con HomeKit

  1. Pingback: Sensor de movimiento y salida de relé con ESP8266 para HomeKit |

  2. Boa tarde! otimos trabalhos seus projetos utlizando o homekit, sou seu fã, rrsrsrs,
    pode publicar ou colocar a biblioteca do DHT11 para download?

      • hola, al parecer era la versión de arduino con la 1.6.5 lo conseguí programar, ahora el problema viene con el rele no se desactiva la temperatura y la humedad la marca bien, se te ocurre de que puede ser?? como siempre gracias de antemano

      • correcto se activa pero se desactiva, adjunto los ficheros en el sket lo tengo programado asi:
        {
        if (WiFi.status() == WL_CONNECTED)
        get_temp();
        {
        if (!client.connected())
        {
        if (client.connect(“ESP8266: LuzSensor1”))
        {
        client.subscribe(“LuzSensor1″);
        }
        }
        if (client.connected())
        {
        Serial.println(String(temp)+”°”) ;
        client.publish(“Temperatura1″,String(temp));
        Serial.println(String(humi)+”%”) ;
        client.publish(“Humedad1”,String(humi));
        }
        y en el accesorio

        // MQTT Setup
        var mqtt = require(‘mqtt’);
        console.log(“Connecting to MQTT broker…”);
        var mqtt = require(‘mqtt’);
        var options = {
        port: 1883,
        host: ‘192.168.1.137’,
        clientId: ‘LuzSensor1’
        };
        var client = mqtt.connect(options);
        console.log(“LuzSensor1 Connected to MQTT broker”);

        var Accessory = require(‘../’).Accessory;
        var Service = require(‘../’).Service;
        var Characteristic = require(‘../’).Characteristic;
        var uuid = require(‘../’).uuid;

        // here’s a fake hardware device that we’ll expose to HomeKit
        var LUZSENSOR1 = {
        powerOn: false,

        setPowerOn: function(on) {
        console.log(“Turning the LuzSensor1 %s!”, on ? “on” : “off”);
        if (on) {
        client.publish(‘LuzSensor1’, ‘on’);
        LUZSENSOR1.powerOn = on;
        }
        else {
        client.publish(‘LuzSensor1′,’off’);
        LUZSENSOR1.powerOn = false;
        };

        },
        identify: function() {
        console.log(“Identify the light!”);
        }
        }

        // Generate a consistent UUID for our light Accessory that will remain the same even when
        // restarting our server. We use the `uuid.generate` helper function to create a deterministic
        // UUID based on an arbitrary “namespace” and the word “LuzSensor1”.
        var lightUUID = uuid.generate(‘hap-nodejs:accessories:LuzSensor11’);

        // This is the Accessory that we’ll return to HAP-NodeJS that represents our fake light.
        var light = exports.accessory = new Accessory(‘LuzSensor1’, lightUUID);

        // Add properties for publishing (in case we’re using Core.js and not BridgedCore.js)
        light.username = “22:1B:33:1D:55:4F”;
        light.pincode = “031-45-154”;

        // set some basic properties (these values are arbitrary and setting them is optional)
        light
        .getService(Service.AccessoryInformation)
        .setCharacteristic(Characteristic.Manufacturer, “Lisergio”)
        .setCharacteristic(Characteristic.Model, “Ver-1”)
        .setCharacteristic(Characteristic.SerialNumber, “00001”);

        // listen for the “identify” event for this Accessory
        light.on(‘identify’, function(paired, callback) {
        LUZSENSOR1.identify();
        callback(); // success
        });

        // Add the actual Lightbulb Service and listen for change events from iOS.
        // We can see the complete list of Services and Characteristics in `lib/gen/HomeKitTypes.js`
        light
        .addService(Service.Lightbulb, “LuzSensor1”) // services exposed to the user should have “names” like “Fake Light” for us
        .getCharacteristic(Characteristic.On)
        .on(‘set’, function(value, callback) {
        LUZSENSOR1.setPowerOn(value);
        callback(); // Our fake Light is synchronous – this value has been successfully set
        });

        // We want to intercept requests for our current power state so we can query the hardware itself instead of
        // allowing HAP-NodeJS to return the cached Characteristic.value.
        light
        .getService(Service.Lightbulb)
        .getCharacteristic(Characteristic.On)
        .on(‘get’, function(callback) {

        // this event is emitted when you ask Siri directly whether your light is on or not. you might query
        // the light hardware itself to find this out, then call the callback. But if you take longer than a
        // few seconds to respond, Siri will give up.

        var err = null; // in case there were any problems

        if (LUZSENSOR1.powerOn) {
        console.log(“Are we on? Yes.”);
        callback(err, true);
        }
        else {
        console.log(“Are we on? No.”);
        callback(err, false);
        }
        });

    • perdón quería decir que se queda activado el rele pero no se desactiva cuando le doy la orden en homekit (en homekit si apaga y enciende pero el rele no siempre esta activado)

      • Este es el código completo no te lo puse para no agrandar el tema 😀

        #include
        #include
        #include

        int err;
        float temp, humi;

        IPAddress server(192, 168, 1, 137); // IP de la raspberry Pi

        const char* ssid = “JAZZTEL_6411”; // Your ssid
        const char* pass = “Arowana228”; // Your Password

        int pin = 0;
        int relay = 2;

        #define BUFFER_SIZE 100

        DHT11 dht11(pin);

        WiFiClient wclient;
        PubSubClient client(wclient, server);
        #define BUFFER_SIZE 100

        void callback(const MQTT::Publish& pub) {
        if(pub.payload_string() == “on”)
        {
        digitalWrite(relay, LOW); // en caso de que el modulo rele funcione al reves, cambiarl LOW por HIGH
        }
        else
        {
        digitalWrite(relay, HIGH); // en caso de que el modulo rele funcione al reves, cambiarl HIGH por LOW
        }
        }

        void setup()
        {
        pinMode(relay,OUTPUT);
        digitalWrite(relay, HIGH);
        Serial.begin(115200);
        delay(10);
        Serial.println();
        Serial.println();
        client.set_callback(callback);
        if (WiFi.status() != WL_CONNECTED)
        {
        Serial.print(“Connecting to “);
        Serial.print(ssid);
        Serial.println(“…”);
        WiFi.mode(WIFI_STA);
        WiFi.begin(ssid, pass);
        if (WiFi.waitForConnectResult() != WL_CONNECTED)
        return;
        Serial.println(“WiFi connected”);
        }

        }

        void loop()
        {
        if (WiFi.status() == WL_CONNECTED)
        get_temp();
        {
        if (!client.connected())
        {
        if (client.connect(“ESP8266: LuzSensor1”))
        {
        client.subscribe(“LuzSensor1″);
        }
        }
        if (client.connected())
        {
        Serial.println(String(temp)+”°”) ;
        client.publish(“Temperatura1″,String(temp));
        Serial.println(String(humi)+”%”) ;
        client.publish(“Humedad1”,String(humi));
        }
        client.loop();
        }
        }

        void get_temp()
        {
        if ((err = dht11.read(humi, temp)) == 0)
        {
        Serial.print(“temperature:”);
        Serial.print(temp);
        Serial.print(” humidity:”);
        Serial.print(humi);
        Serial.println();
        }
        else
        {
        Serial.println();
        Serial.print(“Error No :”);
        Serial.print(err);
        Serial.println();
        }
        delay(DHT11_RETRY_DELAY); //delay for reread
        }

      • Que rele estas usando??
        Un modulo de 5v conectado a la raspberry??
        Comprueba que se activa y se desactiva con los 3,3v de la raspberry , algunos módulos de 5 v no funcionan con 3,3

      • gracias por tu interes ya esta funcionando bien era que el rele no atmitia los 5v poniendolo a 3,3v sin problemas.

  3. Hola, quiero probar hacer los módulos, pero tengo algunas dudas ¿Se puede hacer algún módulo sensor para cuando quiera encender La Luz manualmente? La idea es colocar un módulo en la lámpara de techo pero claro si le pongo el módulo tengo que anular la llave que tengo ahora mismo para encender La Luz, en esta llave colocar un sensor con el cual atraves de HomeKit lo relacione con el módulo de la lámpara, así no siempre depender del móvil y no dejar todos los interruptores de la casa inservibles.
    Otra duda es saber si el módulo rele hay alguna forma de configurarlo para que corte en 2o3 segundo lo pregunto con idea de ponerlos en los motores de los portones automáticos ya que la idea es colocarlo en la conexión que tiene estos motores para abrir desde un pulsador. El poder programar el tiempo de actuación sobre el rele vendría genial para poder poner el módulo en persianas y toldos ya que calculando el tiempo que tarda en abrirse entero se puede relacionar el dimmer con el tiempo de actuación, así si la persiana o toldo tarda 20 segundos en hacer todo el recorrido si queremos abrirla por la mitad el dimmer al 50% equivale a 10 segundos de actuación del rele. Seguramente me estoy emparanollando demasiado y lo que planteó es inviable, solo es algo que se me ocurre. Bueno espero respuestas. Enhorabuena por bloq.

    • Puedes poner los reles en paralelo al interruptor, si lo enciendes desde homekit tendrás que apagarlo desde homekit y si lo enciendes con el interruptor lo tendrás que apagar con el interruptor…
      En cuanto a lo de las persianas habría que probarlo… no se si se podrá hacer, ya que tienes que detectar como esta para saber hacia dónde quieres que vaya…

      • Ese es un esquema de conmutación básica de electricidad, los módulos de reles, en realidad son conmutadores , así que se puede hacer como dice Alejandro.

  4. hola me ha surgido una duda se podría hacer una especie de termostato para decirle a la caldera a tal temperatura salta o se apague??

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s