Control Climático Inteligente por Zonas con MediaTek LinkIt™ Smart 7688

Componentes y Suministros

Componente	Cantidad	Notas
Espressif ESP8266 ESP-01	1	WiFi para sensores remotos
Arduino Nano R3	1	Nodo sensor temperatura
Microchip ATtiny85	1	Nodo sensor bajo consumo
DHT22 Sensor Temperatura/Humedad	1	Medición precisa
Servo Tower Pro MG996R	1	Actuador compuerta conducto

Aplicaciones y Servicios Online

• Arduino IDE

Sobre el Proyecto

Llega el Invierno

Cuando nació nuestra hija el invierno pasado, compramos un calefactor eléctrico para mantener caliente su zona. Lo movíamos de habitación en habitación creyendo que era eficiente. Un mes después, la factura eléctrica se duplicó: habría sido más barato calentar toda la casa con la caldera de gas las 24h.

Este invierno instalé un termostato WiFi para encender la calefacción desde el sofá o la cama. Más cómodo, pero seguimos calentando toda la casa aunque pasemos la mayor parte del tiempo en una zona.

Trabajar de Forma Inteligente

Los registros de sensores de movimiento (que controlan luces) muestran patrón claro: 4-5 horas en planta baja tras el trabajo, luego subimos a dormitorios ~21h hasta la mañana siguiente. Lunes-viernes es reloj (especialmente con bebé de 10 meses con horario estricto). Fines de semana varían.

Los sistemas HVAC multi-zona con compuertas controladas inalámbricamente son caros y su software parece una ocurrencia tardía (poco soporte/actualizaciones). Ya tengo sensores WiFi de temperatura para control de AC puntual y quería usar servos pequeños. Solo necesito servos WiFi que abran/cierren rejillas de conductos... debería ser fácil.

MediaTek LinkIt™ Smart 7688

El LinkIt Smart 7688 Duo HDK es un microprocesador WiFi con OpenWRT y microcontrolador Arduino-compatible integrado. Perfecto: pines I/O para múltiples sensores y servos + WiFi para hablar con mis sensores de temperatura existentes. Además, al tener OpenWRT con uHTTPd, puedo ejecutar la WebApp directamente en el LinkIt para paquete autocontenido.

Configuración del LinkIt Smart 7688 HDK

Primera vez con WiFi integrado, esperaba curva de aprendizaje empinada. Configuración en 3 pasos:

1. Encender LinkIt y conectar a su punto de acceso WiFi desde PC
2. Entrar a interfaz web y configurar credenciales de tu WiFi
3. Añadir placa "LinkIt Smart 7688 Duo" en Arduino IDE

¡Listo! Al seleccionar la placa en Arduino IDE puedes subir sketch por serie o por WiFi (muy útil después). Guías de inicio y desarrollador de LinkIt Smart 7688 son útiles.

Para que el microcontrolador use WiFi directamente en sketch Arduino, hacer SSH al HDK y activar compatibilidad con librería Arduino Yun (cambiar un bit).

Cliente WiFi y Controlador Servo

Gracias a compatibilidad con librería Bridge de Yun y Arduino IDE, es fácil adaptar código existente. Con Bridge, el HDK consulta al servidor web embarcado la configuración de rejillas (planta alta, baja, o toda casa) y ajusta los dos servos. En video anterior corría en Raspberry Pi 2, pero porté la WebApp al LinkIt para mayor eficiencia (código al final).

La WebApp usa PHP, así que instalé via opkg (gestor paquetes OpenWRT en LinkIt):

opkg update
opkg install php7 php7-cgi

Actualizar /etc/config/uhttpd para interpretar PHP añadiendo línea:

list interpreter ".php=/usr/bin/php-cgi"

Reiniciar uHTTPd: /etc/init.d/uhttpd restart

Hardware

Conecté el brazo del servo directamente a la rejilla y fabricé soporte de aluminio con separadores de acero inoxidable. Aún hay algo de juego, añadiré bridas para hacerlo permanente.

Software

Tres componentes:

1. Sensores temperatura por la casa envían actualizaciones periódicas al servidor uHTTPd en LinkIt Smart 7688.
2. WebApp en LinkIt muestra estado actual y permite reconfigurar rejillas manualmente.
3. MCU en LinkIt controla rejillas para dirigir aire caliente arriba/abajo según hora del día.

Sensores de temperatura: ATtiny85 o Arduino Nano + DHT11/DHT22, envían datos a servidor web vía ESP8266 por SoftwareSerial. Tengo artículo completo sobre estos sensores (fase II de mi proyecto AC puntual - opcional pero da métricas para afinar y automatizar).

LinkIt Smart 7688 HDK en buhardilla conectado a rejillas. En OpenWRT, un cronjob actualiza archivo de estado de rejillas. Lado MCU (sketch Arduino) lee este archivo periódicamente y mueve servos.

Para consultar estado y reconfigurar manualmente, creé WebApp alojada en el propio LinkIt. Con dyndns y port forwarding, acceso y control desde fuera de casa.

Margen de Mejora

Con noches ya frías, necesitaba funcionamiento ASAP, así que hice concesiones por despliegue rápido.

• Hardware: imprimiré en 3D soportes proper para servos (los actuales tienen juego). Servo RC de plástico no durará años; lo cambiaré por servos mayores con engranajes metálicos para no volver a subir al tejado.
• Futuro: añadir más servos WiFi a rejillas de cada habitación, todos conectados al mismo LinkIt.
• Sondas temperatura solo vuelcan lecturas a CSV para gráficas. Sería útil encender calefacción antes si la casa está muy fría, pero mi termostato WiFi no tiene API aún.
• Integrar con domótica para que rejillas se ajusten según ocupación en tiempo real (sensores movimiento) en lugar de solo horario (clave para fines de semana con horarios dinámicos).

Código

LinkIt Smart Duo WiFi Vent (C/C++)

Sketch usa librerías Bridge y HTTP Client de Arduino Yun para consultar servidor web y abrir/cerrar rejillas HVAC según necesidad.

/* Adaptado de ejemplo Sweep servo por BARRAGAN y ejemplo Yun HTTP Client por Tom Igoe (dominio público).
   Adaptado para HAI (Home Automation w/ Intelligence) por Buddy Crotty.
   Este sketch confía en servidor web para lógica pesada (puede ser RPi aparte o lado MPU de LinkIt en OpenWRT).
   Servidor recoge lecturas temp de toda la casa y decide dónde enviar aire según hora, clima exterior (pronóstico), ocupación.
   Devuelve 'upstairs', 'downstairs', o 'wholehouse'. */

#include <Servo.h>
#include <Bridge.h>
#include <HttpClient.h>

Servo upservo;    // servo rejilla planta alta
Servo downservo;  // servo rejilla planta baja
int uppos = 0, downpos = 0;
const char* host = "192.168.1.80"; // IP servidor domótica
int dopenangle = 80, dcloseangle = 0;
int uopenangle = 140, ucloseangle = 0;

void setup() {
  upservo.attach(9);
  downservo.attach(10);
  pinMode(13, OUTPUT);
  digitalWrite(13, LOW);
  Bridge.begin();
  digitalWrite(13, HIGH);
}

void wholehouse() {
  if (downpos <= dcloseangle) {
    for (downpos = dcloseangle; downpos <= dopenangle; downpos++) {
      downservo.write(downpos); delay(20);
    }
  }
  if (uppos <= uopenangle) {
    for (uppos = ucloseangle; uppos <= uopenangle; uppos++) {
      upservo.write(uppos); delay(20);
    }
  }
}

void downstairs() {
  if (downpos <= dopenangle) {
    for (downpos = dcloseangle; downpos <= dopenangle; downpos++) {
      downservo.write(downpos); delay(20);
    }
  }
  if (uppos >= ucloseangle) {
    for (uppos = uopenangle; uppos >= ucloseangle; uppos--) {
      upservo.write(uppos); delay(20);
    }
  }
}

void upstairs() {
  if (uppos <= uopenangle) {
    for (uppos = ucloseangle; uppos <= uopenangle; uppos++) {
      upservo.write(uppos); delay(20);
    }
  }
  if (downpos >= dcloseangle) {
    for (downpos = dopenangle; downpos >= dcloseangle; downpos--) {
      downservo.write(downpos); delay(20);
    }
  }
}

void loop() {
  HttpClient client;
  String cmd = "https://"; cmd += host; cmd += "/vent.txt";
  client.get(cmd);
  while (client.available()) {
    int c = client.read();
    if (c == '2') upstairs();
    if (c == '1') downstairs();
    if (c == '0') wholehouse();
  }
  delay(60000); // consultar cada minuto
}

Sensor Temperatura WiFi (C/C++)

Sensor temperatura/humedad conectado. Envía datos a servidor domótica central.

/* Adaptado para HAI por Buddy Crotty.
   Envía datos vía HTTP GET a servidor HAI.
   Conectividad vía SoftwareSerial a ESP8266 ya configurado para tu WiFi.
   (Descomenta líneas WiFi para resetear SSID/password) */

const char* host = "192.168.1.80";
const char* devID = "downstairs"; // ID dispositivo (una palabra, sin espacios/caracteres especiales)
#include <SoftwareSerial.h>
SoftwareSerial ser(10, 11); // RX, TX para ESP8266
long utime = 300000; // intervalo actualizaciones: 300000=5min (red), 900000=15min (batería/solar), 5000=5seg (test)

#include <DHT.h>
#define DHTPIN 2
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  ser.begin(9600);
  /* // Descomenta para resetear WiFi
  delay(1000);
  ser.println("AT+CWMODE=1");
  ser.println("AT+CWJAP=\"SSID\",\"Password\"");
  */
  ser.println("AT+RST"); // Reset ESP8266 tras reset Arduino
  delay(10);
  dht.begin();
  Serial.println("Dando tiempo a calentar...");
  Serial.print("|-------------------------|");
  Serial.print("|");
  for(int x=0; x<25; x++){ Serial.print("#"); delay(1000); }
  Serial.println("|"); Serial.println("Listo");
}

void loop() {
  float t = dht.readTemperature(true); // Fahrenheit
  int h = dht.readHumidity();
  float hi = dht.computeHeatIndex(t, h);

  Serial.println();
  Serial.print("Temp: "); Serial.print(t); Serial.print(" *F\t");
  Serial.print("Heat Index: "); Serial.print(hi); Serial.println(" *F");
  Serial.print("Humedad: "); Serial.print(h); Serial.println("%\t");
  Serial.print("Conectando a "); Serial.println(host);

  // Conexión TCP
  String cmd = "AT+CIPSTART=\"TCP\",\""; cmd += host; cmd += "\",80";
  ser.println(cmd); delay(1000);
  if(ser.find("Error")){ Serial.println("Error AT+CIPSTART"); return; }

  // Preparar GET
  String getStr = "GET /tempupdate.php?ID="; getStr += devID;
  getStr += "&field1="; getStr += t; // Temp
  getStr += "&field2="; getStr += h; // Humedad
  getStr += "&field3="; getStr += hi; // Heat Index
  getStr += "\r\n\r\n";

  Serial.print("URL envío: "); Serial.println(getStr);

  // Enviar longitud
  cmd = "AT+CIPSEND="; cmd += String(getStr.length());
  ser.println(cmd);
  if(ser.find(">")){ ser.print(getStr); Serial.println("Éxito!"); }
  else{ ser.println("AT+CIPCLOSE"); Serial.println("Conexión Fallida"); }

  Serial.print("Próxima actualización en "); Serial.print(utime/1000); Serial.println(" segundos");
  delay(utime);
}

Vent.php (PHP)

Comprobar estado y anular manualmente configuración de rejillas.

<html> <head> <style>
.myButton { /* estilos botones grandes */ }
</style> <link rel="manifest" href="manifest.json"> </head> <body>
<div align="center">
<a href="vent.php?zone=2" class="myButton">Solo Planta Alta</a><br><br>
<a href="vent.php?zone=0" class="myButton">Toda la Casa</a><br><br>
<a href="vent.php?zone=1" class="myButton">Solo Planta Baja</a><br><br>
<?php
$myfile = fopen("vent.txt", "r") or die("No se puede abrir archivo!");
$status = fgets($myfile);
if ($status != "") print "<h1>Rejillas abiertas para ";
if ($status === "0") print "Toda la Casa";
if ($status === "1") print "Solo Planta Baja";
if ($status === "2") print "Solo Planta Alta";
print "<br>"; fclose($myfile);
if ($_GET["zone"] != "") {
  $myfile = fopen("vent.txt", "w+") or die("No se puede abrir archivo!");
  print "<h1>Enviando orden para abrir rejillas para ";
  if ($_GET["zone"] === "0") print "Toda la Casa";
  if ($_GET["zone"] === "1") print "Solo Planta Baja";
  if ($_GET["zone"] === "2") print "Solo Planta Alta";
  print "</h1>";
  fwrite($myfile, $_GET['zone']);
  fclose($myfile);
}
?>
</div> </body> </html>

LinkIt Smart Vent Android WebApp (JSON Manifest)

Archivo manifest para que Chrome en Android abra el controlador como WebApp.

{
  "name": "LinkIt Smart Vent",
  "icons": [
    { "src": "LinkIt_icon_36.png", "sizes": "36x36", "type": "image/png", "density": 0.75 },
    { "src": "LinkIt_icon_48.png", "sizes": "48x48", "type": "image/png", "density": 1.0 },
    { "src": "LinkIt_icon_128.png", "sizes": "128x128", "type": "image/png", "density": 1.0 },
    { "src": "LinkIt_icon_192.png", "sizes": "192x192", "type": "image/png", "density": 1.0 }
  ],
  "start_url": "vent.php",
  "display": "standalone",
  "orientation": "portrait"
}

Esquemáticos

ATtiny85 o Arduino Nano leyendo DHT11/22 y conectado WiFi con ESP8266.