Controlador de piscina

Código

• Bosquejo 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
• Mapa del sitio de OpenHAB
• Elementos de OpenHAB

Arduino Sketch para sensores de temperatura usando I2C Java

 #include  #include  #include  #define SLAVE_ADDRESS 0x40 // Define el pin GPIO constantsconst int POOL_PIN =3; const int SOLAR_PIN =5; const int OUTSIDE_PIN =7; // Defina la longitud de nuestro búfer para la interfaz I2Cconst int I2C_BUFFER_LEN =24; // ¡¡¡IMPORTANTE MÁXIMO es 32 !!! // Cargar OneWire:protocolo de sensor de semiconductores de dallas patentado:no se requiere licencia OneWire poolTemp (POOL_PIN); OneWire solarTemp (SOLAR_PIN); OneWire outsideTemp (OUTSIDE_PIN); // Load Dallas:protocolo de sensor de dallas propietario que utiliza onewire - no se requiere licenciaDallasTemperature poolSensor (&poolTemp); DallasTemperature solarSensor (&solarTemp); DallasTemperature outsideSensor (&outsideTemp); // Definir I2C bufferchar data [I2C_BUFFER_LEN]; String temperatureData; // Definir variable para temporizadorlong prevMillis =0; void setup (void) {// Conectarse a los buses del sensor de temperatura poolSensor.begin (); solarSensor.begin (); outsideSensor.begin (); // Inicie la interfaz I2C Wire.begin (SLAVE_ADDRESS); Wire.onRequest (requestEvent);} void loop (void) {// Controle el tiempo para leer los sensores de temperatura una vez en cada intervalo definido // No los lea más rápido que cada segundo. no pueden responder tan rápido sin firmar currMillis =millis (); if (currMillis - prevMillis> intervalo) {prevMillis =currMillis; readTemperatures (); }} void readTemperatures () {// Leer los tres sensores de temperatura poolSensor.requestTemperatures (); solarSensor.requestTemperatures (); outsideSensor.requestTemperatures (); // Almacenamos los datos de temperatura en una cadena // Acumulamos hasta la longitud total del búfer para asegurarnos de sobrescribir los datos antiguos // Los datos tienen el 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 ()  
 PoolWebServer - BackgroundTask.cs  C #  
 Define el servidor HTTP que responde a las solicitudes HTTP POST y GET 
 // Copyright (c) Microsoft. Todos los derechos reservados.usando System; usando System.Collections.Generic; usando System.Linq; usando System.Text; usando System.Net.Http; usando Windows.Foundation.Collections; usando Windows.ApplicationModel.Background; usando Windows.ApplicationModel. AppService; usando Windows.System.Threading; usando Windows.Networking.Sockets; usando System.IO; usando Windows.Storage.Streams; usando System.Threading.Tasks; usando System.Runtime.InteropServices.WindowsRuntime; usando Windows.Foundation; usando Windows.Devices.Gpio; namespace WebServerTask {clase pública sellada WebServerBGTask:IBackgroundTask {public void Run (IBackgroundTaskInstance taskInstance) {// Asocia un controlador de cancelación con la tarea en segundo plano. taskInstance.Canceled + =OnCanceled; // Obtener el objeto de aplazamiento de la instancia de tarea serviceDeferral =taskInstance.GetDeferral (); var appService =taskInstance.TriggerDetails como AppServiceTriggerDetails; if (appService! =null &&appService.Name =="App2AppComService") {appServiceConnection =appService.AppServiceConnection; appServiceConnection.RequestReceived + =OnRequestReceived; }} // Procesa las solicitudes de mensajes enviadas desde la aplicación PoolWebService private async void OnRequestReceived (AppServiceConnection sender, AppServiceRequestReceivedEventArgs args) {var message =args.Request.Message; comando de cadena =mensaje ["Comando"] como cadena; cambiar (comando) {caso "Inicializar":{Sensores.InitSensors (); Devices.InitDevices (); var messageDeferral =args.GetDeferral (); // Establecer un resultado para devolver al llamador var returnMessage =new ValueSet (); // Definir una nueva instancia de nuestro HTTPServer en el puerto 8888 HttpServer server =new HttpServer (8888, appServiceConnection); IAsyncAction asyncAction =Windows.System.Threading.ThreadPool.RunAsync ((workItem) => {// Inicie el servidor Servidor.StartServer ();}); // Responde a PoolWebService con un estado de éxito returnMessage.Add ("Status", "Success"); var responseStatus =await args.Request.SendResponseAsync (returnMessage); messageDeferral.Complete (); descanso; } case "Quit":{// Se solicitó el cierre del servicio. Danos el aplazamiento del servicio // para que la plataforma pueda finalizar la tarea en segundo plano serviceDeferral.Complete (); descanso; }}} private void OnCanceled (remitente de IBackgroundTaskInstance, motivo BackgroundTaskCancellationReason) {// Limpia y prepárate para salir} BackgroundTaskDeferral serviceDeferral; AppServiceConnection appServiceConnection; } // Clase para definir la clase sellada pública HTTP WebServer HttpServer:IDisposable {// Crear un búfer para leer datos HTTP const uint privado BufferSize =8192; // Puerto para escuchar en el puerto int privado =8888; // Oyente al oyente StreamSocketListener privado de solo lectura; // Conexión para enviar información de estado a PoolControllerWebService private AppServiceConnection appServiceConnection; HttpServer público (int serverPort, conexión AppServiceConnection) {listener =new StreamSocketListener (); puerto =servidorPort; appServiceConnection =conexión; // Agregue un controlador de eventos para el detector de conexiones HTTP.ConnectionReceived + =(s, e) => ProcessRequestAsync (e.Socket); } // Llamar para iniciar el listner public void StartServer () {#pragma warning disable CS4014 listener.BindServiceNameAsync (port.ToString ()); # pragma warning restore CS4014} public void Dispose () {listener.Dispose (); } privado async void ProcessRequestAsync (conector StreamSocket) {prueba {solicitud de StringBuilder =new StringBuilder (); // Obtener los datos entrantes usando (IInputStream input =socket.InputStream) {byte [] data =new byte [BufferSize]; IBuffer buffer =data.AsBuffer (); uint dataRead =BufferSize; // Leer todos los datos entrantes while (dataRead ==BufferSize) {await input.ReadAsync (buffer, BufferSize, InputStreamOptions.Partial); request.Append (Encoding.UTF8.GetString (data, 0, data.Length)); dataRead =buffer.Length; }} // Obtuve los datos, comience a procesar una respuesta usando (IOutputStream output =socket.OutputStream) {string requestMethod =request.ToString (); string [] requestParts ={""}; if (requestMethod! =null) {// Transmitir la solicitud en sus partes requestMethod =requestMethod.Split ('\ n') [0]; requestParts =requestMethod.Split (''); } // Solo respondemos los métodos HTTP GETS y POST si (requestParts [0] =="GET") await WriteGetResponseAsync (requestParts [1], salida); else if (requestParts [0] =="POST") await WritePostResponseAsync (requestParts [1], salida); si no, aguarda WriteMethodNotSupportedResponseAsync (requestParts [1], salida); }} catch (Exception) {}} // Maneja todas las tareas asincrónicas privadas de HTTP GET WriteGetResponseAsync (solicitud de cadena, IOutputStream os) {bool urlFound =false; byte [] bodyArray =null; string responseMsg =""; // Vea si la solicitud coincide con alguna de las URL de solicitudes válidas y cree el interruptor de mensaje de respuesta (request.ToUpper ()) {case "/ SENSORS / POOLTEMP":responseMsg =Sensors.PoolTemperature; urlFound =verdadero; descanso; case "/ SENSORS / SOLARTEMP":responseMsg =Sensors.SolarTemperature; urlFound =verdadero; descanso; case "/ SENSORS / OUTSIDETEMP":responseMsg =Sensors.OutsideTemperature; urlFound =verdadero; descanso; case "/ DEVICES / POOLPUMP / STATE":responseMsg =Devices.PoolPumpState; urlFound =verdadero; descanso; case "/ DEVICES / WATERFALLPUMP / STATE":responseMsg =Devices.PoolWaterfallState; urlFound =verdadero; descanso; case "/ DEVICES / POOLLIGHTS / STATE":responseMsg =Devices.PoolLightsState; urlFound =verdadero; descanso; case "/ DEVICES / YARDLIGHTS / STATE":responseMsg =Devices.YardLightsState; urlFound =verdadero; descanso; case "/ DEVICES / POOLSOLAR / STATE":responseMsg =Devices.PoolSolarValveState; urlFound =verdadero; descanso; predeterminado:urlFound =false; descanso; } bodyArray =Encoding.UTF8.GetBytes (responseMsg); esperar WriteResponseAsync (request.ToUpper (), responseMsg, urlFound, bodyArray, os); } // Maneja todas las tareas asíncronas privadas de HTTP POST WritePostResponseAsync (solicitud de cadena, IOutputStream os) {bool urlFound =false; byte [] bodyArray =null; string responseMsg =""; // Vea si la solicitud coincide con alguna de las URL de solicitudes válidas y cree el mensaje de respuesta switch (request.ToUpper ()) {case "/ DEVICES / POOLPUMP / OFF":Devices.PoolPumpPinValue =GpioPinValue.Low; bodyArray =Encoding.UTF8.GetBytes ("APAGADO"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / POOLPUMP / ON":Devices.PoolPumpPinValue =GpioPinValue.High; bodyArray =Encoding.UTF8.GetBytes ("ON"); responseMsg ="ENCENDIDO"; urlFound =verdadero; descanso; case "/ DEVICES / WATERFALLPUMP / OFF":Devices.PoolWaterfallPinValue =GpioPinValue.Low; bodyArray =Encoding.UTF8.GetBytes ("APAGADO"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / WATERFALLPUMP / ON":Devices.PoolWaterfallPinValue =GpioPinValue.High; bodyArray =Encoding.UTF8.GetBytes ("ON"); responseMsg ="ENCENDIDO"; urlFound =verdadero; descanso; case "/ DEVICES / POOLLIGHTS / OFF":Devices.PoolLightsPinValue =GpioPinValue.Low; bodyArray =Encoding.UTF8.GetBytes ("APAGADO"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / POOLLIGHTS / ON":Devices.PoolLightsPinValue =GpioPinValue.High; bodyArray =Encoding.UTF8.GetBytes ("ON"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / YARDLIGHTS / OFF":Devices.YardLightsPinValue =GpioPinValue.Low; bodyArray =Encoding.UTF8.GetBytes ("APAGADO"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / YARDLIGHTS / ON":Devices.YardLightsPinValue =GpioPinValue.High; bodyArray =Encoding.UTF8.GetBytes ("ON"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / POOLSOLAR / OFF":Devices.PoolSolarValvePinValue =GpioPinValue.Low; bodyArray =Encoding.UTF8.GetBytes ("APAGADO"); responseMsg ="APAGADO"; urlFound =verdadero; descanso; case "/ DEVICES / POOLSOLAR / ON":Devices.PoolSolarValvePinValue =GpioPinValue.High; bodyArray =Encoding.UTF8.GetBytes ("ON"); responseMsg ="ENCENDIDO"; urlFound =verdadero; descanso; predeterminado:bodyArray =Encoding.UTF8.GetBytes (""); urlFound =falso; descanso; } await WriteResponseAsync (request.ToUpper (), responseMsg, urlFound, bodyArray, os); } // Escribe la respuesta para métodos HTTP no admitidos private async Task WriteMethodNotSupportedResponseAsync (solicitud de cadena, IOutputStream os) {bool urlFound =false; byte [] bodyArray =null; bodyArray =Encoding.UTF8.GetBytes (""); aguardar WriteResponseAsync (request.ToUpper (), "NO SOPORTADO", urlFound, bodyArray, os); } // Escribe la respuesta para HTTP GET's y POST's private async Task WriteResponseAsync (string RequestMsg, string ResponseMsg, bool urlFound, byte [] bodyArray, IOutputStream os) {try // El appService morirá después de un día más o menos. Intentemos capturarlo por separado para que el servidor http todavía responda {var updateMessage =new ValueSet (); updateMessage.Add ("Solicitud", RequestMsg); updateMessage.Add ("Respuesta", ResponseMsg); var responseStatus =aguardar appServiceConnection.SendMessageAsync (updateMessage); } catch (Exception) {} try {MemoryStream bodyStream =new MemoryStream (bodyArray); usando (Respuesta de secuencia =os.AsStreamForWrite ()) {encabezado de cadena =GetHeader (urlFound, bodyStream.Length.ToString ()); byte [] headerArray =Encoding.UTF8.GetBytes (encabezado); aguardar respuesta.WriteAsync (headerArray, 0, headerArray.Length); si (urlFound) aguarda bodyStream.CopyToAsync (respuesta); aguardar respuesta.FlushAsync (); }} catch (Exception) {}} // Crea el texto del encabezado HTTP para las URL encontradas y no encontradas string GetHeader (bool urlFound, string bodyStreamLength) {string header; if (urlFound) {header ="HTTP / 1.1 200 OK \ r \ n" + "Access-Control-Allow-Origin:* \ r \ n" + "Content-Type:text / plain \ r \ n" + " Longitud del contenido:"+ bodyStreamLength +" \ r \ n "+" Conexión:cerrar \ r \ n \ r \ n "; } else {header ="HTTP / 1.1 404 Not Found \ r \ n" + "Access-Control-Allow-Origin:* \ r \ n" + "Content-Type:text / plain \ r \ n" + "Content -Longitud:0 \ r \ n "+" Cierre de conexión \ r \ n \ r \ n "; } encabezado de retorno; }}} 
 
 PoolWebServer - Devices.cs  C #  
 La clase define todos los dispositivos y a qué pines GPIO están conectados 
 usando System; usando System.Collections.Generic; usando System.Linq; usando System.Text; usando System.Threading.Tasks; usando Windows.Devices.Gpio; namespace WebServerTask {// Class the define todos los dispositivos y los pines GPIO a los que están conectados. Dispositivos de clase estática pública {// Defina los números de los pines GPIO. private const int POOL_PUMP_PIN =12; const privado int POOL_WATERFALL_PIN =13; const privado int POOL_LIGHTS_PIN =16; const privado int YARD_LIGHTS_PIN =18; const privado int POOL_SOLAR_VALVE_PIN =22; // Definir los pines GPIO private static GpioPin poolPumpPin; poolWaterfallPin estático privado de GpioPin; poolLightsPin estático privado de GpioPin; GpioPin yardLightsPin estático privado; poolSolarValvePin estático privado de GpioPin; // Propiedad para el Pin GPIO asignado a Pool Pump public static GpioPinValue PoolPumpPinValue {get {return poolPumpPin.Read (); // Leer el Pin devuelve Alto o Bajo} set {if (poolPumpPin.Read ()! =Value) // Solo establece el pin si está cambiando poolPumpPin.Write (value); } } //Property to read status of the Pool Pump ON or OFF public static string PoolPumpState { get { return GetState(PoolPumpPinValue, GpioPinValue.High); //Get the state } } //Property for GPIO Pin assigned to the Waterfall Pump public static GpioPinValue PoolWaterfallPinValue { get { return poolWaterfallPin.Read(); } set { if (poolWaterfallPin.Read() !=value) poolWaterfallPin.Write(value); } } //Property to read status of the Waterfall Pump ON or OFF public static string PoolWaterfallState { get { return GetState(PoolWaterfallPinValue, GpioPinValue.High); } } //Property for GPIO Pin assigned to the Pool Lights public static GpioPinValue PoolLightsPinValue { get { return poolLightsPin.Read(); } set { if (poolLightsPin.Read() !=value) poolLightsPin.Write(value); } } //Property to read status of the Pool Lights ON or OFF public static string PoolLightsState { get { return GetState(PoolLightsPinValue, GpioPinValue.High); } } //Property for GPIO Pin assigned to the valve to turn Solar on and off public static GpioPinValue PoolSolarValvePinValue { get { return poolSolarValvePin.Read(); } set { if (poolSolarValvePin.Read() !=value) poolSolarValvePin.Write(value); } } //Property to read status of the Solar valve ON or OFF public static string PoolSolarValveState { get { return GetState(PoolSolarValvePinValue, GpioPinValue.High); } } //Property for GPIO Pin assigned to the Yard Lights public static GpioPinValue YardLightsPinValue { get { return yardLightsPin.Read(); } set { if (yardLightsPin.Read() !=value) yardLightsPin.Write(value); } } //Property to read status of the Yard Lights ON or OFF public static string YardLightsState { get { return GetState(YardLightsPinValue, GpioPinValue.High); } } //Intialize all GPIO pin used public static void InitDevices() { var gpio =GpioController.GetDefault(); if (gpio !=null) { //These pins are on an active high relay. We set everything to OFF when we start poolPumpPin =gpio.OpenPin(POOL_PUMP_PIN); poolPumpPin.Write(GpioPinValue.Low); poolPumpPin.SetDriveMode(GpioPinDriveMode.Output); poolWaterfallPin =gpio.OpenPin(POOL_WATERFALL_PIN); poolWaterfallPin.Write(GpioPinValue.Low); poolWaterfallPin.SetDriveMode(GpioPinDriveMode.Output); poolLightsPin =gpio.OpenPin(POOL_LIGHTS_PIN); poolLightsPin.Write(GpioPinValue.Low); poolLightsPin.SetDriveMode(GpioPinDriveMode.Output); yardLightsPin =gpio.OpenPin(YARD_LIGHTS_PIN); yardLightsPin.Write(GpioPinValue.Low); yardLightsPin.SetDriveMode(GpioPinDriveMode.Output); poolSolarValvePin =gpio.OpenPin(POOL_SOLAR_VALVE_PIN); poolSolarValvePin.Write(GpioPinValue.Low); poolSolarValvePin.SetDriveMode(GpioPinDriveMode.Output); } } //Gets the state of a device based upon it ActiveState //ActiveState means what required to turn the device on High or Low on the GPIO pin private static string GetState(GpioPinValue value, GpioPinValue ActiveState) { string state ="OFF"; if (value ==ActiveState) state ="ON"; return state; }}} 
 
PoolWebServer - Sensors.csC# 
 Class that defines all temperature sensors and the I2C interface used to read them
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{ //Class that defines all temperature sensors and the I2C interface used to read them them public static class Sensors { private static I2cDevice Device; private static Timer periodicTimer; //How often to read temperature data from the Arduino Mini Pro private static int ReadInterval =4000; //4000 =4 seconds //Variables to hold temperature data private static string poolTemperature ="--.--"; private static string solarTemperature ="--.--"; private static string outsideTemperature ="--.--"; //Property to expose the Temperature Data public static string PoolTemperature { get { //Lock the variable incase the timer is tring to write to it lock (poolTemperature) { return poolTemperature; } } set { //Lock the variable incase the HTTP Server is tring to read from it lock (poolTemperature) { poolTemperature =value; } } } //Property to expose the Temperature Data public static string SolarTemperature { get { //Lock the variable incase the timer is tring to write to it lock (solarTemperature) { return solarTemperature; } } set { //Lock the variable incase the HTTP Server is tring to read from it lock (solarTemperature) { solarTemperature =value; } } } //Property to expose the Temperature Data public static string OutsideTemperature { get { //Lock the variable incase the timer is tring to write to it lock (outsideTemperature) { return outsideTemperature; } } set { //Lock the variable incase the HTTP Server is tring to read from it lock (outsideTemperature) { outsideTemperature =value; } } } //Initilizes the I2C connection and starts the timer to read I2C Data async public static void InitSensors() { //Set up the I2C connection the Arduino var settings =new I2cConnectionSettings(0x40); // Arduino address settings.BusSpeed =I2cBusSpeed.StandardMode; string aqs =I2cDevice.GetDeviceSelector("I2C1"); var dis =await DeviceInformation.FindAllAsync(aqs); Device =await I2cDevice.FromIdAsync(dis[0].Id, settings); //Create a timer to periodicly read the temps from the Arduino periodicTimer =new Timer(Sensors.TimerCallback, null, 0, ReadInterval); } //Handle the time call back private static void TimerCallback(object state) { byte[] RegAddrBuf =new byte[] { 0x40 }; byte[] ReadBuf =new byte[24]; //Read the I2C connection try { Device.Read(ReadBuf); // read the data } catch (Exception) { } //Parse the response //Data is in the format "88.99|78.12|100.00" where "PoolTemp|SolarTemp|OutsideTemp" char[] cArray =System.Text.Encoding.UTF8.GetString(ReadBuf, 0, 23).ToCharArray(); // Converte Byte to Char String c =new String(cArray).Trim(); string[] data =c.Split('|'); //Write the data to temperature variables try { if (data[0].Trim() !="") PoolTemperature =data[0]; if (data[1].Trim() !="") SolarTemperature =data[1]; if (data[2].Trim() !="") OutsideTemperature =data[2]; } catch (Exception) { } } }}
 
PoolWebService- MainPage.xaml.csC# 
 Main page of app that starts the 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 { AppServiceConnection appServiceConnection; public MainPage() { InitializeComponent(); InitializeAppSvc(); } private async void InitializeAppSvc() { string WebServerStatus ="PoolWebServer failed to start. AppServiceConnectionStatus was not successful."; // Initialize the AppServiceConnection appServiceConnection =new AppServiceConnection(); appServiceConnection.PackageFamilyName ="PoolWebServer_hz258y3tkez3a"; appServiceConnection.AppServiceName ="App2AppComService"; // Send a initialize request var res =await appServiceConnection.OpenAsync(); if (res ==AppServiceConnectionStatus.Success) { var message =new ValueSet(); message.Add("Command", "Initialize"); var response =await appServiceConnection.SendMessageAsync(message); if (response.Status !=AppServiceResponseStatus.Success) { WebServerStatus ="PoolWebServer failed to start."; throw new Exception("Failed to send message"); } appServiceConnection.RequestReceived +=OnMessageReceived; WebServerStatus ="PoolWebServer started."; } await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { txtWebServerStatus.Text =WebServerStatus; }); } private async void OnMessageReceived(AppServiceConnection sender, AppServiceRequestReceivedEventArgs args) { var message =args.Request.Message; string msgRequest =message["Request"] as string; string msgResponse =message["Response"] as string; await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () => { txtRequest.Text =msgRequest; txtResponse.Text =msgResponse; }); }}} 
 
PoolWebService - App.xaml.csC# 
 
// 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{ /// 
 /// Provides application-specific behavior to supplement the default Application class. /// 
 sealed partial class App :Application { /// 
 /// Initializes the singleton application object. This is the first line of authored code /// executed, and as such is the logical equivalent of main() or WinMain(). /// 
 public App() { InitializeComponent(); Suspending +=OnSuspending; } /// 
 /// Invoked when the application is launched normally by the end user. Other entry points /// will be used such as when the application is launched to open a specific file. /// 
 /// Details about the launch request and process. protected override void OnLaunched(LaunchActivatedEventArgs e) {#if DEBUG if (System.Diagnostics.Debugger.IsAttached) { DebugSettings.EnableFrameRateCounter =true; }#endif Frame rootFrame =Window.Current.Content as Frame; // Do not repeat app initialization when the Window already has content, // just ensure that the window is active if (rootFrame ==null) { // Create a Frame to act as the navigation context and navigate to the first page rootFrame =new Frame(); // Set the default language rootFrame.Language =Windows.Globalization.ApplicationLanguages.Languages[0]; rootFrame.NavigationFailed +=OnNavigationFailed; if (e.PreviousExecutionState ==ApplicationExecutionState.Terminated) { //TODO:Load state from previously suspended application } // Place the frame in the current Window Window.Current.Content =rootFrame; } if (rootFrame.Content ==null) { // When the navigation stack isn't restored navigate to the first page, // configuring the new page by passing required information as a navigation // parameter rootFrame.Navigate(typeof(MainPage), e.Arguments); } // Ensure the current window is active Window.Current.Activate(); } /// 
 /// Invoked when Navigation to a certain page fails /// 
 /// The Frame which failed navigation /// Details about the navigation failure void OnNavigationFailed(object sender, NavigationFailedEventArgs e) { throw new Exception("Failed to load Page " + e.SourcePageType.FullName); } /// 
 /// Invoked when application execution is being suspended. Application state is saved /// without knowing whether the application will be terminated or resumed with the contents /// of memory still intact. /// 
 /// The source of the suspend request. /// Details about the suspend request. private void OnSuspending(object sender, SuspendingEventArgs e) { var deferral =e.SuspendingOperation.GetDeferral(); //TODO:Save application state and stop any background activity deferral.Complete(); }}} 
 
OpenHAB SitemapJavaScript 
 Sample sitemap used in openHAB configuration
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 ItemsPlain text 
 Sample items openHAB configuration
Switch PoolPump "Pool Pump"  (grp1) {http=">[ON:POST:http:///DEVICES/POOLPUMP/ON]>[OFF:POST:http:///DEVICES/POOLPUMP/OFF] <[http:///DEVICES/POOLPUMP/STATE:1500:REGEX((.*?))]", autoupdate="true"}Switch WaterFall "Water Fall"  (grp1) {http=">[ON:POST:http:///DEVICES/WATERFALLPUMP/ON]>[OFF:POST:http:///DEVICES/WATERFALLPUMP/OFF] <[http:///DEVICES/WATERFALLPUMP/STATE:1500:REGEX((.*?))]", autoupdate="true"}Switch PoolLights "Pool Lights" (grp1) {http=">[ON:POST:http:///DEVICES/POOLLIGHTS/ON]>[OFF:POST:http:///DEVICES/POOLLIGHTS/OFF] <[http:///DEVICES/POOLLIGHTS/STATE:1500:REGEX((.*?))]", autoupdate="true"}Number pooltemp "Pool Water Temp [%.2f F]"  (grp1) {http="<[http:///SENSORS/POOLTEMP:30000:REGEX((.*?))]"}Number solartemp "Solar Water Temp [%.2f F]"  (grp1) {http="<[http:///SENSORS/SOLARTEMP:30000:REGEX((.*?))]"}Number outsidetemp "Outside Air Temp [%.2f F]"  (grp1) {http="<[http:///SENSORS/OUTSIDETEMP:30000:REGEX((.*?))]"}
 
GitHub project repository
 Full Visual Studio 2015 Pool Controller projecthttps://github.com/mmackes/Windows-10-IoT-PoolController

Piezas y carcasas personalizadas

Esquemas