Kit Completo de Controlador de Piscina – Raspberry Pi 2 + Arduino, Placas de Relé, Sensores de Temperatura e Acessórios

Componentes e Materiais

Raspberry Pi 2 Model B	1
Cartão MicroSD PNY 16GB Turbo CL10	1
SparkFun Arduino Pro Mini 328 - 5V/16MHz	1
Placa de Relé de Estado Sólido 4 Canais 5V SainSmart	1
Módulo Relé 5v Tolako para Arduino	1
Sensores de Temperatura DS18b20 à Prova d'Água	1
Resistores 4.7k Ohm 1/4 Watt 5% (10 unidades)	1
Adaptador USB WiFi para Raspberry Pi	1
Cabo Extensor USB Macho-Fêmea 30cm	1
Abrazadeiras American Valve CL40PK6 nº40 (pacote com 6)	1
Epóxi Marinho J-B Weld 8272 MarineWeld - 56g	1
Arruela de Assento	2
Carregador Fonte Micro USB AC	1

Ferramentas e Máquinas Necessárias

• Impressora 3D Printrbot Simple – para criar gabinete e suportes dos sensores
• Adaptador Serial FTDI USB para TTL – para carregar sketch no Arduino Pro Mini

Aplicativos e Serviços Online

• Microsoft Windows 10 IoT Core
• Microsoft Visual Studio 2015
• Microsoft IIS
• Arduino IDE
• Biblioteca OneWire
• Biblioteca Dallas Temperature
• openHAB – software de automação residencial open source

Sobre o Projeto

Controlador Automatizado de Piscina

Duas vezes em três meses o temporizador da bomba da minha piscina falhou. Isso me inspirou a criar este projeto. O custo de substituição desses temporizadores ultrapassou $120 e tudo que eu tinha era um temporizador com pouco controle e alta taxa de falha. Também sofri uma falha no sensor de temperatura do meu aquecedor solar que custou mais $30.

Sabia que poderia criar um controlador automatizado de piscina econômico que me desse muito mais controle sobre quando a bomba funciona. Queria mais variáveis além de simples horário e dia da semana. Também queria monitorar vários aspectos do ambiente da piscina e controlar tudo remotamente de qualquer dispositivo.

O projeto utiliza um Raspberry Pi rodando Windows 10 IoT Core, relés, Arduino Pro Mini, sensores de temperatura, fiação e componentes impressos em 3D. Completei por muito menos do que gastei nos dois temporizadores anteriores e no sensor solar.

Controle da Bomba da Piscina (Componentes AC)

Comecei controlando relés de estado sólido a partir do Raspberry Pi com Windows 10 IoT Core. Esses relés permitem controlar componentes AC (corrente alternada) como a bomba da piscina. Os relés de estado sólido controlam os relés AC de 30Amp que o temporizador antigo utilizava. Após projetar e testar o circuito da bomba, adicionei funcionalidade para controlar cascata, luzes da piscina e do jardim. Agora posso controlar tudo remotamente, sem precisar abrir a caixa de controle fisicamente.

Gabinete do Controlador

Meu filho projetou o gabinete e o imprimiu em 3D, garantindo encaixe seguro para o Raspberry Pi e relés de estado sólido.

Sensores de Temperatura

Um dos objetivos era permitir controle baseado em variáveis além de dia e hora: temperatura do ar externo, água do aquecedor solar e água da piscina. Exemplo crucial: quando a temperatura externa está perto de zero e a água da piscina também, preciso garantir que as bombas funcionem para evitar congelamento e danos aos canos. Mesmo longe de casa, consigo fazer isso.

Incorporei sensores de temperatura lidos por um Arduino Pro Mini que envia dados ao Raspberry Pi via interface I2C.

Sensor de Temperatura do Ar Externo

Primeiro sensor incorporado. Meu filho projetou e imprimiu o suporte em 3D. Testou PLA e ABS; o ABS funciona melhor por ser mais resistente à intempérie e ter temperatura de transição vítrea mais alta. Imprima com pelo menos 75% de preenchimento. O sensor foi conectado conforme o esquemático.

Sensores de Temperatura da Água

Incorporei sensores da água da piscina e do aquecedor solar. Permitem coletar dados de temperatura exibidos ao usuário e fornecer variáveis para decidir quando componentes ligam/desligam. Projetamos e imprimimos suportes em 3D. Novamente, ABS é melhor pela resistência a intempéries e calor. Use pelo menos 75% de preenchimento.

Construção e Instalação do Sensor de Temperatura da Água

Após imprimir o suporte, usei broca escareadora para criar área de 45° ao redor do furo do sensor, aumentando a área de adesão do JB Weld. Preferi broca a alterar o design 3D pois o corte rugoso dá melhor aderência.

Insira o sensor até protruir ~19mm pela base. Adicione a arruela de assento para fixar.

Preencha o topo do suporte com JB Weld e deixe secar 24 horas.

NOTA IMPORTANTE: Certifique-se que todas as bombas estão desligadas antes de instalar os sensores de temperatura da água!

Após confirmar bombas desligadas, abra válvulas para aliviar pressão na área de instalação. Isso facilita muito e mantém você seco.

Fure um orifício de 8mm (5/16") na tubulação. Instale o sensor e use 2 abraçadeiras para fixar firmemente. Não cometa meu erro de apertar demais – isso esmaga o suporte. Feche válvulas, ligue bombas e verifique vazamentos.

Controle da Válvula do Aquecedor Solar

Com sensores no lugar, projetei e instalei o controle da válvula do aquecedor solar. Este usa tensão DC (diferente dos componentes AC anteriores), exigindo relé DC. O conceito é similar, mas os relés diferem. Certifique-se que os relés controlam o tipo correto de tensão do dispositivo.

Este controle direciona água da piscina para painéis solares no telhado. Só desvio água quando a temperatura externa está acima de 15°C (60°F). Uma vez desviada, a água de retorno deve ser pelo menos 2°C mais quente que a da piscina; caso contrário, é desperdício de energia bombear.

A fiação e conexões estão no esquemático "Pool Controller DC Components".

Desenvolvimento da Aplicação

Após instalar Windows 10 IoT Core no Raspberry Pi, notei que ele tem servidor web embutido para gerenciamento. Pensei se era uma versão reduzida do IIS – se sim, poderia escrever serviços REST no IIS. Após muita pesquisa, não parecia viável na época.

Adotei outra abordagem: revisei o exemplo "Blinky Web Server" e artigo no "Druss Blog". Decidi construir uma aplicação Background headless Windows 10 IoT Core que atua como servidor HTTP simples respondendo a GET e POST.

Em poucos dias tinha protótipo funcional, o que me deu confiança. Após testar profundamente no depurador do Visual Studio 2015, achei que implantação seria fácil.

Implantação da Aplicação

Ponto onde tive dificuldade, então compartilho para evitar o mesmo. Como a aplicação testou bem no depurador, pensei que bastava mudar de Debug para Release. Implantou e iniciou em modo Debug, mas parou o debug e tentei rodar pelo AppX Manager – falhou com erro genérico "Application failed to initialize".

Solução: excluir a implantação atual e instalar a aplicação pelo AppX Manager. Isso me custou muito tempo.

Mesmo rodando perfeitamente no modo debug, a aplicação morria após a primeira requisição HTTP. Gastei tempo troubleshooting sem descobrir a causa.

Sob pressão para finalizar, mudei para arquitetura igual ao exemplo "Blinky Web Server". No meu original, não via necessidade de aplicação de tela (planejava servidor web controlando GPIO e lendo I2C). O que fiz: aplicação de tela inicia o servidor web, que envia mensagens de volta para a tela mostrando qual chamada HTTP foi recebida. Essa abordagem é sólida e usa o mesmo código da tentativa original.

Interface do Usuário

Por fim, construí um programa de controle HTML que roda em praticamente qualquer dispositivo. Permite controlar bomba, cascata, luzes e monitorar sensores de qualquer lugar.

Depois, usei OpenHAB e criei um sitemap para interface adicional.

Espero que tenha gostado de ler sobre meu projeto tanto quanto eu gostei de criá-lo. Obrigado.

Código

• Sketch 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 OpenHAB
• Itens OpenHAB

Sketch Arduino para Sensores de Temperatura usando I2C Java

Código para ler sensores DS18b20 e enviar dados quando solicitado via I2C.

#include <OneWire.h> 
#include <DallasTemperature.h> 
#include <Wire.h> 
#define SLAVE_ADDRESS 0x40 
const int POOL_PIN = 3; 
const int SOLAR_PIN = 5; 
const int OUTSIDE_PIN = 7; 
const int I2C_BUFFER_LEN = 24; 
OneWire poolTemp(POOL_PIN); 
OneWire solarTemp(SOLAR_PIN); 
OneWire outsideTemp(OUTSIDE_PIN); 
DallasTemperature poolSensor(&poolTemp); 
DallasTemperature solarSensor(&solarTemp); 
DallasTemperature outsideSensor(&outsideTemp); 
char data[I2C_BUFFER_LEN]; 
String temperatureData; 
long prevMillis = 0; 
long interval = 1000; 

void setup(void) { 
  poolSensor.begin(); 
  solarSensor.begin(); 
  outsideSensor.begin(); 
  Wire.begin(SLAVE_ADDRESS); 
  Wire.onRequest(requestEvent); 
} 

void loop(void) { 
  unsigned long currMillis = millis(); 
  if (currMillis - prevMillis > interval) { 
    prevMillis = currMillis; 
    readTemperatures(); 
  } 
} 

void readTemperatures() { 
  poolSensor.requestTemperatures(); 
  solarSensor.requestTemperatures(); 
  outsideSensor.requestTemperatures(); 
  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() { 
  temperatureData.toCharArray(data, I2C_BUFFER_LEN); 
  Wire.write(data); 
}

PoolWebServer - BackgroundTask.cs C#

Define o servidor HTTP que responde a requisições POST e 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 omitido para brevidade, disponível no repositório GitHub)
  } 
}

PoolWebServer - Devices.cs C#

Classe que define todos os dispositivos e pinos GPIO.

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 { 
    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; 
    // ... propriedades e métodos de inicialização
  } 
}

PoolWebServer - Sensors.cs C#

Classe que define sensores de temperatura e interface I2C.

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; 
    // ... propriedades e métodos de leitura I2C
  } 
}

PoolWebService - MainPage.xaml.cs C#

Página principal que inicia o 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 { 
    // ... inicialização e comunicação com AppService
  } 
}

PoolWebService - App.xaml.cs C#

// Copyright (c) Microsoft. All rights reserved.
// ... código padrão de aplicação UWP

Sitemap OpenHAB JavaScript

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 
    } 
  } 
}

Itens OpenHAB Texto simples

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

Repositório GitHub do Projeto

Projeto completo Visual Studio 2015 Pool Controller: https://github.com/mmackes/Windows-10-IoT-PoolController

Peças Personalizadas e Gabinetes

• Suporte para sensor DS18B20 à prova d'água monitorar temperatura do ar
• Suporte para sensor DS18B20 à prova d'água em tubulação padrão de piscina
• Gabinete para Raspberry Pi e Relés

Esquemáticos

Esquemático mostrando conexão Raspberry Pi a relés AC. Controla bomba, cascata, luzes da piscina e luzes AC do jardim.

Esquemático mostrando conexão Raspberry Pi a relé DC. Controla válvula de água solar.

Esquemático mostrando conexão Raspberry Pi a Arduino Pro Mini e sensores de temperatura. Monitora água da piscina, água do aquecedor solar e temperatura do ar externo.