Complete Pool Controller Kit – Raspberry Pi 2 + Arduino, Relaisborden, Temperatuursensoren & Accessoires

Onderdelen en benodigdheden

Onderdeel	Aantal
Raspberry Pi 2 Model B	1
PNY 16GB Turbo MicroSDXC CL10	1
SparkFun Arduino Pro Mini 328 - 5V/16MHz	1
SainSmart 5V 4-kanaals Solid State Relaisbord	1
Tolako 5V Relaismodule voor Arduino	1
DS18B20 Waterdichte Temperatuursensoren	1
4,7k Ohm Weerstanden - 1/4 Watt - 5% - 4K7 (10 stuks)	1
Raspberry Pi USB WiFi Dongle	1
A Male To A Female Extension 1-Feet USB	1
American Valve CL40PK6 Nummer 40 Klem, 6-pack	1
J-B Weld 8272 MarineWeld Marine Epoxy - 2 oz	1
Zitring	2
Micro USB Voeding Wandlader AC Adapter	1

Benodigde tools en machines

• Printrbot Simple – Gebruikt voor het maken van de behuizing en sensorsteunen
• FTDI USB naar TTL Serial Adapter Module voor Arduino Mini Port – Gebruikt om de sketch naar de Arduino Mini Pro te uploaden

Apps en online diensten

• Microsoft Windows 10 IoT Core
• Microsoft Visual Studio 2015
• Microsoft IIS
• Arduino IDE
• OneWire Library
• Dallas Temperature Library
• openHAB open source home automation software

Over dit project

Geautomatiseerde Pool Controller

Twee keer in drie maanden tijd faalde de timer voor mijn zwembadpomp. Dit inspireerde me om dit project te creëren. De kosten voor het vervangen van die timers bedroegen meer dan $120 en alles wat ik had was een timer die me zeer weinig controle bood en een hoge uitvalkans had. Ik had ook een storing van de temperatuursensor op mijn zonneboiler die nog eens $30 kostte.

Ik wist dat ik een kosteneffectieve geautomatiseerde poolcontroller kon bouwen die me veel meer controle gaf over wanneer mijn zwembadpomp draaide. Ik wilde meer variabelen hebben om te bepalen wanneer de pomp draait, in plaats van de simpele tijd en dag van de bestaande timer. Ik wilde ook niet alleen mijn zwembadpomp automatiseren, maar ook de status van verschillende aspecten van mijn zwembadomgeving monitoren. Een verder doel was om deze taken van overal uit te kunnen voeren met elk apparaat.

Het project dat ik heb gemaakt is zeer kosteneffectief omdat het een Raspberry Pi gebruikt met Windows 10 IoT Core, relais, een Arduino Mini Pro en temperatuursensoren, bedrading en 3D-geprinte onderdelen. Ik heb dit project voltooid voor veel minder geld dan ik had betaald voor de twee eerdere timers en de zonne-temperatuursensor.

Zwembadpomp Besturing (AC Componenten)

Ik startte mijn project met het besturen van solid-state relais vanaf mijn Raspberry Pi met Windows 10 IoT Core. Deze relais laten me mijn AC-componenten (wisselstroom) besturen zoals de zwembadpomp. De solid-state relais besturen de bestaande 30 Amp AC relais die de oude timer gebruikte. Na het ontwerpen en testen van het circuit voor de zwembadpomp, voegde ik extra functionaliteit toe om andere AC-componenten te besturen zoals mijn zwembadwaterval, en mijn zwembad- en tuinverlichting. Met dit deel van het project kon ik al deze elementen op afstand besturen. Geen van mijn gezinsleden of ik hoefde nog de besturingsbox fysiek te openen om de waterval aan te zetten, de zwembad- of tuinverlichting aan te zetten of de timer voor de zwembadpomp in te stellen.

Pool Controller Behuizing

Mijn zoon ontwierp de Pool Controller behuizing en maakte deze met onze 3D-printer, en zorgde ervoor dat zowel de Raspberry Pi als de solid-state relais veilig in de controllerbox paste.

Temperatuursensoren

Eén van de ontwerpdoelen voor mijn project was om besturing mogelijk te maken op basis van variabelen naast dag en tijd. Ik wilde de buitentemperatuur, de zonneboiler- en zwembadwatertemperatuur kunnen meenemen om te bepalen wanneer de pomp moet draaien en wanneer hij in rust moet zijn. Een voorbeeld van wanneer dit cruciaal is: wanneer de buitentemperatuur erg koud is en dicht bij het vriespunt. Als de zwembadwatertemperatuur ook dicht bij het vriespunt is, moet ik ervoor zorgen dat mijn zwembad- en watervalpompen draaien om te voorkomen dat pijpen bevriezen en de systemen beschadigen. Met dit project kan ik dit bereiken zelfs wanneer ik niet thuis ben. Om dit te implementeren, heb ik temperatuursensoren in mijn project geïntegreerd. Ik lees die sensoren uit met een Arduino Mini Pro die die data naar dezelfde Raspberry Pi stuurt die de zwembad- en watervalpompen bestuurt via de I2C-interface.

Buitentemperatuursensor

De buitentemperatuursensor was de eerste sensor die ik incorporeerde. Opnieuw ontwierp en printte mijn zoon de sensorsteun op onze 3D-printer. Hij probeerde zowel PLA als ABS; ABS werkt eigenlijk beter omdat het weerbestendiger is en een hogere glasovergangstemperatuur heeft, wat het meer hittebestendig maakt. Zorg ervoor dat je met ten minste 75% invulling print. De sensor werd aangesloten zoals beschreven in het schema.

Watertemperatuursensoren

Ik incorporeerde vervolgens de zwembadwater- en zonneboilertemperatuursensoren. Dit stelt het project in staat om watertemperatuurgegevens te verzamelen die aan een gebruiker getoond worden en verdere variabelen bieden om te bepalen wanneer bepaalde componenten draaien of in rust zijn. Eerst werd een sensorsteun ontworpen en 3D-geprint. Zoals eerder vermeld, werkt ABS beter vanwege betere weer- en hittebestendigheid. Ook zorg ervoor dat je ten minste 75% invulling gebruikt.

Bouwen en Installeren van de Watertemperatuursensor

Na het printen van de watertemperatuursensorsteun, gebruikte ik een afzettboor om een 45 graden gebied rond het sensorgat te creëren. Dit zou het JB Weld meer oppervlakte geven om aan te hechten. Ik verkies een boorbom hiervoor boven het wijzigen van het 3D-ontwerp, omdat de ruwe snede van de boorbom het JB Weld betere hechtkracht leek te geven.

De volgende stap was het invoegen van de temperatuursensor in de steun tot hij ongeveer 3/4 inch uit de onderkant van de steun uitsteekt. Voeg de zitring toe om het op zijn plaats te houden.

Vervolgens vulde ik de bovenkant van de steun met JB Weld en liet het 24 uur drogen.

Na minstens 24 uur wachten tot het JB Weld was gedroogd, was het tijd om de watertemperatuursensoren te installeren.

BELANGRIJKE Let op: Zorg ervoor dat alle pompen UIT staan voordat je probeert de watertemperatuursensoren te installeren!

Na controle dat alle waterpompen uitstaan, is het een goed idee om alle kleppen te openen die waterdruk uit het gebied halen waar je de watertemperatuursensoren installeert. Dit vergemakkelijkt de installatie enorm (en houdt je ook droog).

Boor een 5/16 inch gat in de zwembadpijpleiding. Installeer de watertemperatuursensor en gebruik 2 klemmen om hem stevig op zijn plaats te houden. Maak niet dezelfde fout als ik en draai de klemmen te vast; te vast aandraaien zal de sensorsteun vervormen. Sluit kleppen en zet pompen aan. Controleer op lekkages.

Zonneboiler Klepbesturing

Na het plaatsen van de temperatuursensoren kon ik de zonneboiler klepbesturing ontwerpen en installeren. De zonneboiler gebruikt DC-spanning in tegenstelling tot de AC-spanningen die gebruikt worden met de andere zwembadcomponenten. Dit vereiste dat ik een DC-relais bestuurde in plaats van een AC-relais. Het concept is vergelijkbaar, maar de benodigde relais zijn anders. Zorg ervoor dat de relais die je voor je project gebruikt de juiste spanningstypen kunnen schakelen die het apparaat gebruikt dat je bestuurt.

Deze besturing stelt me in staat om zwembadwater naar de zonnepanelen op mijn dak te leiden. Ik wil water alleen naar de panelen leiden wanneer de buitentemperatuur boven de 60 graden Fahrenheit (ongeveer 15,5°C) is. Zodra water naar de panelen wordt geleid, zorg ervoor dat het terugkerende water ten minste 2 graden warmer is dan het zwembadwater. Anders is het energieverspilling om het water naar de panelen te pompen.

De bedrading en verbindingen van deze besturing zijn te vinden in het Pool Controller DC Componenten schema.

Applicatie Ontwikkeling

Na het installeren van Windows 10 IoT Core op mijn Raspberry Pi, ontdekte ik dat het een ingebouwde webserver heeft die gebruikt wordt om het te beheren. Ik vroeg me af of dit een uitgestreepte versie van IIS was? Zo ja, kon ik gewoon enkele RESTful services op IIS schrijven en ze voor dit project aanroepen. Na veel zoekopdrachten en onderzoek leek dit niet mogelijk. Die benadering zou mijn voorkeur hebben, maar lijkt op dit moment niet haalbaar.

Ik nam een andere aanpak: ik bekeek het voorbeeld "Blinky Web Server" en een artikel op "Druss Blog". Ik besloot een headless Windows 10 IoT Core Background Application te bouwen die fungeert als een simpele HTTP-webserver die reageert op HTTP GET en POST verzoeken.

Binnen een paar dagen had ik een werkend prototype. Dit gaf me veel vertrouwen dat mijn project succesvol kon zijn. Dus besloot ik door te gaan met deze architectuur. Na grondig testen van mijn code via de Visual Studio 2015 debugger, was ik onder de indruk dat ik mijn applicatie gemakkelijk kon deployen.

De Applicatie Deployen

Dit is een punt waar ik worstelde, dus ik hoop je te laten zien hoe je dergelijke moeilijkheden kunt vermijden. Omdat mijn applicatie grondig getest was in de Visual Studio 2015 debugger, was ik onder de indruk dat ik de modus kon veranderen van Debug naar Release om mijn applicatie te deployen. Ik probeerde deze aanpak en het deployde inderdaad mijn applicatie en startte deze in Debug-modus. Ik stopte dan de debugger en probeerde de applicatie te draaien vanuit AppX Manager. Ik had geen succes, ik kreeg alleen een generieke fout die stelde: "Applicatie kon niet initialiseren."

De oplossing is om de huidige deployment te verwijderen en vervolgens de applicatie te installeren vanuit de AppX Manager. Dit kostte me veel tijd, dus ik hoop dat dit je helpt om dat probleem te vermijden.

Hoewel de applicatie feilloos draaide in Visual Studio 2015 debug-modus, stopte hij na het ontvangen van de eerste HTTP-verzoek. Ik besteedde veel tijd aan het oplossen hiervan en weet nog steeds niet waarom dit gebeurt.

Omdat ik druk voelde om het project af te maken, besloot ik mijn project te veranderen zodat het precies werd als het "Blinky Web Server" voorbeeld. In mijn implementatie zag ik geen noodzaak voor een Windows 10 IoT Core schermapplicatie omdat ik van plan was de webserver de GPIO-pinnen te laten besturen en de I2C-interface te laten lezen (geen schermapplicatie). Wat ik in mijn project deed was de schermapplicatie de webserver laten starten. De webserver stuurt dan berichten terug naar de schermapplicatie zodat ik kan zien welk HTTP-verzoek mijn server ontving. Deze aanpak blijkt rotsvaste en het is precies dezelfde code die ik in mijn oorspronkelijke poging gebruikte.

Gebruikersinterface

Ten slotte bouwde ik een HTML-besturingsprogramma dat op vrijwel elk apparaat draait. Hierdoor kan ik niet alleen de zwembadpomp, waterval en zwembadverlichting besturen, maar ook de extra sensoren van overal monitoren.

Later gebruikte ik OpenHAB en creëerde een sitemap die me deze extra interface gaf.

Ik hoop dat je evenveel plezier hebt beleefd aan het lezen over mijn project als ik aan het maken ervan. Dank je wel.

Code

Arduino Sketch voor Temperatuursensoren met I2C

Code om de DS18B20 temperatuursensoren uit te lezen en data te sturen wanneer daarom wordt gevraagd via de I2C-interface.

#include <OneWire.h> 
#include <DallasTemperature.h> 
#include <Wire.h> 
#define SLAVE_ADDRESS 0x40 
// GPIO pin constanten
const int POOL_PIN = 3; 
const int SOLAR_PIN = 5; 
const int OUTSIDE_PIN = 7; 
// Buffer lengte voor I2C interface
const int I2C_BUFFER_LEN = 24; 
// IMPORTANT MAX is 32!!! 
// OneWire - Dallas semiconductor sensor protocol
OneWire poolTemp(POOL_PIN); 
OneWire solarTemp(SOLAR_PIN); 
OneWire outsideTemp(OUTSIDE_PIN); 
// Dallas Temperature - sensor protocol via OneWire
DallasTemperature poolSensor(&poolTemp); 
DallasTemperature solarSensor(&solarTemp); 
DallasTemperature outsideSensor(&outsideTemp); 
// I2C buffer
char data[I2C_BUFFER_LEN]; 
String temperatureData; 
// Timer variabele
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

Definieert de HTTP-server die reageert op HTTP POST en GET verzoeken.

// 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;
            }
        }
        // ... (rest of code omitted for brevity)
    }
}

PoolWebServer - Devices.cs

Klasse die alle apparaten definieert en welke GPIO-pinnen ze gebruiken.

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;
        // ... (rest of code omitted for brevity)
    }
}

PoolWebServer - Sensors.cs

Klasse die alle temperatuursensoren en de I2C-interface definieert om ze uit te lezen.

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; // 4 seconden
        // ... (rest of code omitted for brevity)
    }
}

PoolWebService - MainPage.xaml.cs

Hoofdpagina van de app die de webserver start.

// 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 {
        // ... (code omitted for brevity)
    }
}

PoolWebService - App.xaml.cs

// Copyright (c) Microsoft. All rights reserved.
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices.WindowsRuntime;
using Windows.ApplicationModel;
using Windows.ApplicationModel.Activation;
using Windows.Foundation;
using Windows.Foundation.Collections;
using Windows.UI.Xaml;
using Windows.UI.Xaml.Controls;
using Windows.UI.Xaml.Controls.Primitives;
using Windows.UI.Xaml.Data;
using Windows.UI.Xaml.Input;
using Windows.UI.Xaml.Media;
using Windows.UI.Xaml.Navigation;

namespace PoolWebService {
    sealed partial class App : Application {
        // ... (code omitted for brevity)
    }
}

OpenHAB Sitemap

Voorbeeld sitemap gebruikt in openHAB configuratie.

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

OpenHAB Items

Voorbeeld items openHAB configuratie.

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((.*?))]"}

GitHub project repository

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

Aangepaste onderdelen en behuizingen

• Steun om DS18B20 waterdichte sensor te houden voor luchtemperatuur monitoring
• Steun om DS18B20 waterdichte sensor op standaard zwembadpijpleiding te monteren
• Behuizing voor Raspberry Pi en relais

Schema's