Kit Completo de Controlador de Piscina – Raspberry Pi 2 + Arduino, Placas de Relés, Sensores de Temperatura y Accesorios

Componentes y Suministros

Componente	Cantidad
Raspberry Pi 2 Model B	1
Tarjeta MicroSD PNY 16GB Turbo CL10	1
SparkFun Arduino Pro Mini 328 - 5V/16MHz	1
Placa de Relés de Estado Sólido SainSmart 5V 4 Canales	1
Módulo de Relé Tolako 5V para Arduino	1
Sensores de Temperatura Impermeables DS18b20	1
Resistencias 4.7k Ohm 1/4 Watt 5% (10 unidades)	1
Adaptador USB WiFi para Raspberry Pi	1
Cable de Extensión USB Macho-Hembra 1 Pie	1
Abrazaderas American Valve CL40PK6 Número 40 (Paquete de 6)	1
Epoxi Marino J-B Weld 8272 MarineWeld - 2 oz	1
Arandela de Asiento	2
Fuente de Alimentación Micro USB (Cargador de Pared AC)	1

Herramientas y Máquinas Necesarias

• Printrbot Simple – Utilizada para crear la carcasa y soportes de sensores mediante impresión 3D.
• Adaptador Serie FTDI USB a TTL – Necesario para cargar el sketch en el Arduino Pro Mini.

Aplicaciones y Servicios en Línea

• Microsoft Windows 10 IoT Core
• Microsoft Visual Studio 2015
• Microsoft IIS
• Arduino IDE
• Biblioteca OneWire
• Biblioteca Dallas Temperature
• openHAB (Software de Automatización del Hogar de Código Abierto)

Sobre el Proyecto

Controlador Automatizado de Piscina

En tres meses, el temporizador de la bomba de mi piscina falló dos veces. El costo de reemplazo superó los $120 y solo obtuve un temporizador con poco control y alta tasa de fallos. Además, falló el sensor de temperatura de mi calentador solar, costando $30 adicionales.

Decidí crear un controlador automatizado rentable que me diera mayor control sobre la bomba. Quería usar variables como temperatura del aire, agua de la piscina y calentador solar, no solo hora y día. También buscaba monitorear el entorno de la piscina y controlarlo todo remotamente desde cualquier dispositivo.

El proyecto utiliza una Raspberry Pi con Windows 10 IoT Core, relés, Arduino Pro Mini, sensores de temperatura, cableado e impresiones 3D. El costo total fue inferior al de los dos temporizadores y el sensor solar anteriores.

Control de la Bomba de Piscina (Componentes AC)

Comencé controlando relés de estado sólido desde la Raspberry Pi con Windows 10 IoT Core. Estos relés permiten controlar componentes de CA (corriente alterna) como la bomba de la piscina. Los relés de estado sólido controlan los relés de CA de 30A que usaba el temporizador anterior. Tras diseñar y probar el circuito de la bomba, agregué control para la cascada, luces de la piscina y luces del jardín. Ahora puedo controlar todo remotamente sin abrir la caja de control.

Carcasa del Controlador de Piscina

Mi hijo diseñó la carcasa e la imprimió en 3D, asegurando un ajuste seguro para la Raspberry Pi y los relés de estado sólido.

Sensores de Temperatura

Un objetivo clave era controlar la bomba basándose en variables adicionales: temperatura del aire exterior, agua del calentador solar y agua de la piscina. Por ejemplo, si la temperatura exterior está cerca de congelación y el agua de la piscina también, debo activar las bombas para evitar que las tuberías se congelen y dañen el sistema. Esto es posible incluso fuera de casa.

Incorporé sensores de temperatura leídos por un Arduino Pro Mini que envía los datos a la Raspberry Pi mediante interfaz I2C.

Sensor de Temperatura del Aire Exterior

Fue el primer sensor integrado. Mi hijo diseñó e imprimió el soporte en 3D. Probó PLA y ABS; el ABS funciona mejor por su mayor resistencia a la intemperie y temperatura de transición vítrea más alta. Imprime con al menos 75% de relleno (infill). El sensor se conecta según el esquema.

Sensores de Temperatura del Agua

Luego integré sensores de agua de la piscina y del calentador solar. Esto permite recopilar datos de temperatura para mostrar al usuario y usarlos como variables de control. Se diseñó e imprimió un soporte para los sensores. De nuevo, usa al menos 75% de infill y prefiere ABS.

Construcción e Instalación del Sensor de Temperatura del Agua

Tras imprimir el soporte, usé una broca avellanadora de 45° alrededor del orificio del sensor para aumentar la superficie de adhesión del JB Weld. Preferí taladrar en lugar de modificar el diseño 3D, ya que el corte rugoso mejora la adherencia.

Inserta el sensor hasta que sobresalga aprox. 19 mm (3/4") por la base. Coloca la arandela de asiento para fijarlo.

Rellena la parte superior del soporte con JB Weld y deja secar 24 horas.

NOTA IMPORTANTE: ¡Asegúrate de que todas las bombas estén APAGADAS antes de instalar los sensores de temperatura del agua!

Tras apagar las bombas, abre válvulas para liberar presión en la zona de instalación. Perfora un orificio de 8 mm (5/16") en la tubería de la piscina. Instala el sensor y fíjalo con 2 abrazaderas firmemente, sin apretar demasiado para no aplastar el soporte. Cierra válvulas, enciende bombas y verifica fugas.

Control de Válvula del Calentador Solar

Con los sensores en su lugar, diseñé e instalé el control de la válvula del calentador solar. Este usa voltaje CC (corriente continua) a diferencia de los componentes de CA anteriores, requiriendo un relé de CC. El concepto es similar pero los relés difieren. Asegúrate de usar relés adecuados para el tipo de voltaje de tu dispositivo.

Este control desvía agua de la piscina a los paneles solares en el techo. Solo quiero desviar agua cuando la temperatura exterior supera 15°C (60°F). Una vez desviada, el agua de retorno debe ser al menos 2°C más cálida que el agua de la piscina; de lo contrario, es un desperdicio de energía bombear agua a los paneles.

El cableado y conexiones se muestran en el esquema de Componentes CC del Controlador de Piscina.

Desarrollo de la Aplicación

Tras instalar Windows 10 IoT Core en la Raspberry Pi, descubrí que tiene un servidor web integrado para su gestión. Me pregunté si era una versión reducida de IIS; de ser así, podría escribir servicios RESTful en IIS. Tras investigar, no parecía factible en ese momento.

Tomé otro enfoque: revisé el ejemplo "Blinky Web Server" y un artículo del "Druss Blog". Decidí construir una Aplicación en Segundo Plano (Background Application) sin interfaz gráfica (headless) para Windows 10 IoT Core que actúe como un servidor HTTP simple respondiendo a peticiones GET y POST.

En pocos días tenía un prototipo funcional, lo que me dio confianza. Tras probar exhaustivamente el código con el depurador de Visual Studio 2015, creí que el despliegue sería sencillo.

Despliegue de la Aplicación

Este punto me causó dificultades, así que explico cómo evitarlas. Como la aplicación funcionaba perfectamente en modo depuración, pensé que bastaba cambiar a modo Release para desplegar. Se desplegaba e iniciaba en modo depuración, pero al detener la depuración e intentar ejecutar desde el Administrador AppX, fallaba con un error genérico: "Application failed to initialize".

La solución: eliminar el despliegue actual e instalar la aplicación desde el Administrador AppX. Esto me costó mucho tiempo; espero que te ayude a evitarlo.

Incluso funcionando bien en depuración, la aplicación moría tras recibir la primera petición HTTP. Pasé mucho tiempo solucionándolo sin éxito.Bajo presión por completar el proyecto, cambié la arquitectura al modelo "Blinky Web Server". En mi implementación original no veía la necesidad de una aplicación de pantalla (screen application) porque planeaba que el servidor web controlara los pines GPIO y leyera la interfaz I2C. Lo que hice fue que la aplicación de pantalla inicie el servidor web, y este envíe mensajes de vuelta a la aplicación de pantalla para ver qué petición HTTP recibió. Este enfoque es sólido y usa exactamente el mismo código.

Interfaz de Usuario

Finalmente, construí un programa de control HTML que funciona en prácticamente cualquier dispositivo. Permite no solo controlar la bomba, cascada y luces, sino también monitorear los sensores adicionales desde cualquier lugar.

Posteriormente, usé OpenHAB y creé un sitemap que proporcionó esta interfaz adicional.

Espero que hayas disfrutado leyendo sobre mi proyecto tanto como yo creándolo. ¡Gracias!

Código

• Sketch de Arduino para Sensores de Temperatura usando I2C
• PoolWebServer - BackgroundTask.cs
• PoolWebServer - Devices.cs
• PoolWebServer - Sensors.cs
• PoolWebService - MainPage.xaml.cs
• PoolWebService - App.xaml.cs
• Sitemap de OpenHAB
• Items de OpenHAB

Sketch de Arduino para Sensores de Temperatura usando I2C C++

Código para leer sensores DS18b20 y enviar datos cuando se solicitan mediante interfaz I2C.

#include <OneWire.h> 
#include <DallasTemperature.h> 
#include <Wire.h> 
#define SLAVE_ADDRESS 0x40 
// Definir constantes de pines GPIO
const int POOL_PIN = 3;
const int SOLAR_PIN = 5;
const int OUTSIDE_PIN = 7;
// Longitud del buffer I2C
const int I2C_BUFFER_LEN = 24; // IMPORTANTE: MÁXIMO 32!!!
// Cargar OneWire - protocolo propietario de Dallas Semiconductor - sin licencia requerida
OneWire poolTemp(POOL_PIN);
OneWire solarTemp(SOLAR_PIN);
OneWire outsideTemp(OUTSIDE_PIN);
// Cargar Dallas - protocolo propietario de sensor Dallas usando onewire - sin licencia requerida
DallasTemperature poolSensor(&poolTemp);
DallasTemperature solarSensor(&solarTemp);
DallasTemperature outsideSensor(&outsideTemp);
// Definir buffer I2C
char data[I2C_BUFFER_LEN];
String temperatureData;
// Variable para temporizador
long prevMillis = 0;
long interval = 1000;

void setup(void) {
  // Conectar a buses de sensores de temperatura
  poolSensor.begin();
  solarSensor.begin();
  outsideSensor.begin();
  // Iniciar interfaz I2C
  Wire.begin(SLAVE_ADDRESS);
  Wire.onRequest(requestEvent);
}

void loop(void) {
  // Monitorear tiempo para leer sensores cada intervalo definido
  // No leer más rápido de 1 segundo; no responden tan rápido
  unsigned long currMillis = millis();
  if (currMillis - prevMillis > interval) {
    prevMillis = currMillis;
    readTemperatures();
  }
}

void readTemperatures() {
  // Leer los tres sensores de temperatura
  poolSensor.requestTemperatures();
  solarSensor.requestTemperatures();
  outsideSensor.requestTemperatures();
  // Almacenar datos de temperatura en una cadena
  // Rellenar a la derecha hasta la longitud completa del buffer para sobrescribir datos antiguos
  // Formato: "88.99|78.12|100.00" donde "PoolTemp|SolarTemp|OutsideTemp"
  temperatureData = padRight(String(poolSensor.getTempFByIndex(0)) + "|" + String(solarSensor.getTempFByIndex(0)) + "|" + String(outsideSensor.getTempFByIndex(0)), I2C_BUFFER_LEN);
}

String padRight(String inStr, int inLen) {
  while (inStr.length() < inLen) inStr = inStr + " ";
  return inStr;
}

void requestEvent() {
  // Enviar datos por I2C en formato "88.99|78.12|100.00" donde "PoolTemp|SolarTemp|OutsideTemp"
  temperatureData.toCharArray(data, I2C_BUFFER_LEN);
  Wire.write(data);
}

PoolWebServer - BackgroundTask.cs C#

Define el Servidor HTTP que responde a peticiones HTTP POST y GET.

// Copyright (c) Microsoft. All rights reserved.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net.Http;
using Windows.Foundation.Collections;
using Windows.ApplicationModel.Background;
using Windows.ApplicationModel.AppService;
using Windows.System.Threading;
using Windows.Networking.Sockets;
using System.IO;
using Windows.Storage.Streams;
using System.Threading.Tasks;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.Foundation;
using Windows.Devices.Gpio;

namespace WebServerTask {
  public sealed class WebServerBGTask : IBackgroundTask {
    public void Run(IBackgroundTaskInstance taskInstance) {
      taskInstance.Canceled += OnCanceled;
      serviceDeferral = taskInstance.GetDeferral();
      var appService = taskInstance.TriggerDetails as AppServiceTriggerDetails;
      if (appService != null && appService.Name == "App2AppComService") {
        appServiceConnection = appService.AppServiceConnection;
        appServiceConnection.RequestReceived += OnRequestReceived;
      }
    }
    // ... (código completo en el repositorio GitHub)
  }
}

PoolWebServer - Devices.cs C#

Clase que define todos los dispositivos y los pines GPIO a los que están conectados.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Windows.Devices.Gpio;

namespace WebServerTask {
  public static class Devices {
    // Definir números de pines GPIO
    private const int POOL_PUMP_PIN = 12;
    private const int POOL_WATERFALL_PIN = 13;
    private const int POOL_LIGHTS_PIN = 16;
    private const int YARD_LIGHTS_PIN = 18;
    private const int POOL_SOLAR_VALVE_PIN = 22;
    // ... (código completo en el repositorio GitHub)
  }
}

PoolWebServer - Sensors.cs C#

Clase que define todos los sensores de temperatura y la interfaz I2C usada para leerlos.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Windows.Devices.Enumeration;
using Windows.Devices.I2c;

namespace WebServerTask {
  public static class Sensors {
    private static I2cDevice Device;
    private static Timer periodicTimer;
    private static int ReadInterval = 4000; // 4000 = 4 segundos
    // ... (código completo en el repositorio GitHub)
  }
}

PoolWebService - MainPage.xaml.cs C#

Página principal de la app que inicia el WebServer.

// Copyright (c) Microsoft. All rights reserved.
using System;
using Windows.ApplicationModel.AppService;
using Windows.Devices.Gpio;
using Windows.Foundation.Collections;
using Windows.UI.Core;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Media;

namespace PoolWebService {
  public sealed partial class MainPage : Page {
    // ... (código completo en el repositorio GitHub)
  }
}

PoolWebService - App.xaml.cs C#

// Copyright (c) Microsoft. All rights reserved.
// ... (código estándar de aplicación UWP)

Sitemap de OpenHAB JavaScript

Sitemap de ejemplo usado en la configuración de openHAB.

sitemap default label="Windows 10 IoT" {
  Frame label="" {
    Text label="Pool" icon="swimmingpool" {
      Switch item=PoolPump mappings=[ON="ON", OFF="OFF"]
      Switch item=WaterFall mappings=[ON="ON", OFF="OFF"]
      Switch item=PoolLights mappings=[ON="ON", OFF="OFF"]
      Text item=pooltemp
      Text item=solartemp
      Text item=outsidetemp
    }
  }
}

Items de OpenHAB Texto plano

Configuración de items de ejemplo para openHAB.

Switch PoolPump "Pool Pump" <swimmingpool> (grp1) {http=">[ON:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLPUMP/ON] >[OFF:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLPUMP/OFF] <[https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLPUMP/STATE:1500:REGEX((.*?))]", autoupdate="true"}
Switch WaterFall "Water Fall" <waterfall> (grp1) {http=">[ON:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/WATERFALLPUMP/ON] >[OFF:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/WATERFALLPUMP/OFF] <[https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/WATERFALLPUMP/STATE:1500:REGEX((.*?))]", autoupdate="true"}
Switch PoolLights "Pool Lights" (grp1) {http=">[ON:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLLIGHTS/ON] >[OFF:POST:https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLLIGHTS/OFF] <[https://<YOUR_IP_ADDRESS_AND_PORT>/DEVICES/POOLLIGHTS/STATE:1500:REGEX((.*?))]", autoupdate="true"}
Number pooltemp "Pool Water Temp [%.2f F]" <temperature> (grp1) {http="<[https://<YOUR_IP_ADDRESS_AND_PORT>/SENSORS/POOLTEMP:30000:REGEX((.*?))]"}
Number solartemp "Solar Water Temp [%.2f F]" <temperature> (grp1) {http="<[https://<YOUR_IP_ADDRESS_AND_PORT>/SENSORS/SOLARTEMP:30000:REGEX((.*?))]"}
Number outsidetemp "Outside Air Temp [%.2f F]" <temperature> (grp1) {http="<[https://<YOUR_IP_ADDRESS_AND_PORT>/SENSORS/OUTSIDETEMP:30000:REGEX((.*?))]"}

Repositorio del Proyecto en GitHub

Proyecto completo de Visual Studio 2015 para el Controlador de Piscina:
https://github.com/mmackes/Windows-10-IoT-PoolController

Piezas Personalizadas y Carcasas

• Soporte para sensor DS18B20 impermeable para monitorizar temperatura del aire
• Soporte para sensor DS18B20 impermeable en tubería estándar de piscina
• Carcasa para Raspberry Pi y Relés
• Carcasa para Raspberry Pi y Relés (variante)

Esquemáticos