Prender y apagar luces con Windows Phone

Hace tiempo publiqué un artículo que llevaba un video mostrando como utilizar un pequeño circuito electrónico para que desde un Windows Phone pudieras prender y apagar luces, el video fue simplemente demostrativo y ahora con este nuevo artículo te guiaré hacia como crear una aplicación (mejor dicho aplicaciones) para que tu lo puedas realizar.

Para comenzar como se debe, desde el inicio, veremos lo que necesitas para poder realizar esta aplicación, que es muy importante en este caso.

1.- Lo indispensable, un dispositivo físico, podrás hacer pruebas en el emulador,pero al hacerlo es muy posible que la aplicación no responda de manera adecuada por conflictos con las IP, dado que el emulador automáticamente toma la ip de la máquina.

2.- En segundo lugar, obviamente la máquina que necesitarás para crear la aplicación tanto del teléfono como el servidor, esta máquina será la que se conecte con el dispositivo siguiente.

3.- Un dispositivo Phidget 1014, este dispositivo es el que te muestro en la imagen siguiente, aclaro que hay muchos de su tipo, incluso si sabes algo de electrónica lo podrías hacer, pero si lo recomiendo y lo usé en este caso fue por una sencilla razón, este dispositivo viene con muchas librerías de respaldo, una de ellas está hecha en C#, así que eso nos alivianará muchísimo las cosas, además de que será indispensable tenerla para poder continuar.

Antes de continuar, quiero aclarar que en este artículo no explicaré la instalación del dispositivo en la pc, es algo sencillo y tan intuitivo como instalar una simple memoria USB, solo debes instalar sus drivers y aún así, si ves que puedes trabarte, hay una guía de usuario que puedes descargar aquí.

También es mi deber mencionarte que el dispositivo es de origen canadiense, así que debes ser paciente y dar tus datos exactos, de lo contrario lo regresarán a una oficina de ellos y el costo de ir por el sube, así como que deberás pagar tu traslado hacía ahí, entonces lo mejor es ser cauteloso en ese aspecto.

Bueno, con las debidas precauciones y mensajes correspondientes ya podemos continuar con la configuración y ensamblado de todas las partes necesarias para poder trabajar, para esta parte creo que un diagrama será mucho mas útil, así que aquí tienes.

Deberás conectar los focos hacia el Phidget, bueno, una sola parte del cable, la otra parte irá conectada a la corriente eléctrica, el cable USB del Phidget irá conectado vía USB a tu máquina, que será quien funcione como servidor. Por otra parte estará el teléfono, que será el cliente y será quien mande la señal vía sockets a la máquina para que esta a su vez la mande al dispositivo para permitir o no el paso de corriente para así terminar prendiendo o no los focos.

Ahora comenzamos con la parte de la programación, comienza creando una solución Windows Phone ordinaria.

Ya que tienes tu aplicación Windows Phone puedes car clic derecho en tu solución y añadir un nuevo proyecto de tipo Windows Forms, aclaro que igualmente puedes hacerlo usando WPF, pero para fines didácticos y considerando que la mayoría de sus ejemplos están hechos de esta forma, nos podremos quedar con ese entorno.

En el proyecto Windows Forms, debes agregar la referencia a un ensamblado que se llama Phidget21.NET, lo encuentras en la carpeta C:\Program Files\Phidgets (debiste haber ya instalado los drivers de la página).

Ya con el nuevo ensamblado en el proyecto, comienza por crear una interfaz similar a esta en Windows Forms.

De hecho si quieres hacerte la vida mas fácil e incluso ver como funciona el código fuente de ejemplo, puedes descargar una solución en donde la interfaz será muy similar (la diferencia es que la aplicación de ejemplo tiene muchos mas ejemplos y funcionalidad de la que necesitamos).

Continuando con el ejemplo, la interfaz de la aplicación de Windows Phone, deberá quedar de la siguiente manera.

Una parte muy importante a mencionar es que por facilidad y estética dentro de la aplicación, opté por utilizar el control ToggleSwitch que no es un control nativo de los que se instalan con las Windows Phone Tools, sino que pertenece al Windows Phone Toolkit, el cual puedes descargar desde aquí.

Ya con la interfaz del teléfono creada, se me hace mas prudente comenzar desde aquí, así que veamos.

private void Interruptores_Click(object sender, System.Windows.RoutedEventArgs e)
{
ToggleSwitch elementoSeleccionado = sender as ToggleSwitch;
 
if (elementoSeleccionado.IsChecked == true)
elementoSeleccionado.Content = "Prendido";
else
elementoSeleccionado.Content = "Apagado";
 
switch (elementoSeleccionado.Name)
{
case "interruptor1":
if (interruptor1.IsChecked == true)
cadena1 = "true";
else
cadena1 = "false";
break;
 
case "interruptor2":
if (interruptor2.IsChecked == true)
cadena2 = "true";
else
cadena2 = "false";
break;
 
case "interruptor3":
if (interruptor3.IsChecked == true)
cadena3 = "true";
else
cadena3 = "false";
break;
 
case "interruptor4":
if (interruptor4.IsChecked == true)
cadena4 = "true";
else
cadena4 = "false";
break;
}
 
focosEncendidos = cadena1 + "," + cadena2 + "," + cadena3 + "," + cadena4;
EnviarInformacion();
}

Lo único que hace esta sentencia es identificar que botón fue el activado y dependiendo de su estado crearemos una cadena, ya por último solo ejecutamos el método de EnviarInformacion.

private void EnviarInformacion()
{
var ipAddress = IPAddress.Parse(txtIp.Text);
var endpoint = new IPEndPoint(ipAddress, 13001);
 
var mensajeEnviado = string.Format("{0}", focosEncendidos);
 
var buffer = Encoding.UTF8.GetBytes(mensajeEnviado);
 
var args = new SocketAsyncEventArgs();
args.RemoteEndPoint = endpoint;
args.Completed += SocketAsyncEventArgs_Completed;
args.SetBuffer(buffer, 0, buffer.Length);
 
var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
 
bool completesAsynchronously = socket.ConnectAsync(args);
 
if (!completesAsynchronously)
{
SocketAsyncEventArgs_Completed(args.ConnectSocket, args);
}
}

En esta función lo que hacemos es primero verificar en donde se encuentra nuestro punto de conexión por medio de su IP y su número de puerto, después enviamos la cadena que acabamos de crear en la función anterior, codificamos el mensaje y listo, solo enviamos un manejador de eventos para el evento Completed del socket y luego verificamos que todo haya sido realizado de manera exitosa.

private void SocketAsyncEventArgs_Completed(object sender, SocketAsyncEventArgs e)
{
// verifica cualquier error cometido al transmitir
if (e.SocketError != SocketError.Success)
{
Dispatcher.BeginInvoke(() => MessageBox.Show("Error durante la operación del socket: "+ e.SocketError));
 
// limpia los recursos consumidos
Limpieza(e);
return;
}
 
// checa que fue lo que se realizó si una conexión o un envío, para poder revisarlo
switch (e.LastOperation)
{
case SocketAsyncOperation.Connect:
ManejarConexion(e);
break;
case SocketAsyncOperation.Send:
ManejarEnvio(e);
break;
}
}

En el manejador de eventos, verificamos que un todo esté en orden al principio, después, recordando que el socket NO corre en el hilo de la UI, por ello si queremos, debemos enviar un mensaje a este hilo, para poder verlo, y después sin problemas podremos ejecutar la función Limpieza.

private void Limpieza(SocketAsyncEventArgs e)
{
//la limpieza consiste en "callar" la conexión y después cerrarla
if (e.ConnectSocket != null)
{
e.ConnectSocket.Shutdown(SocketShutdown.Both);
e.ConnectSocket.Close();
}
}

La función limpieza, como dice el comentario en la línea de código, para callar la conexión y después cerrarla. Así es como terminamos la funcionalidad de Windows Phone, ahora vamos por la aplicación de la PC. Aquí la cosa es un poco mas compleja, la teoría es que deberemos recibir la cadena de la aplicación Windows Phone y dependiendo del resultado de esta, poder enviar a nuestro Phidget para prender o apagar el puerto adecuado.

private void Form1_Load(object sender, EventArgs e)
{
PopularArregloDeSalidas();
Socket receptor = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint localEP = new IPEndPoint(IPAddress.Any, 13001);
 
try
{
ifKit = new InterfaceKit();
 
ifKit.Attach += new AttachEventHandler(ifKit_Attach);
ifKit.Detach += new DetachEventHandler(ifKit_Detach);
ifKit.Error += new ErrorEventHandler(ifKit_Error);
 
int serial = -1;
ifKit.open(serial);
 
receptor.Bind(localEP);
receptor.Listen(10);
 
while (true)
{
receptor.BeginAccept(AcceptCallback, receptor);
todoListoAutomatico.WaitOne();
}
}
catch (PhidgetException ex)
{
MessageBox.Show(ex.ToString());
}
 
receptor.Accept();
receptor.Listen(1);
}

En primer lugar mandamos llamar la función PopularArregloDeSalidas en donde preparamos nuestro entorno para recibir la información, ya después, configuramos el socket y su puerto de entrada por medio de un End Point así como el tipo de transmisión que utilizaremos, en este caso será por medio de TCP luego, nos seguimos con tres manejadores de eventos esenciales para el uso del dispositivo electrónico que son ifKit_Attach, ifKit_Detach e ifKit_Error,  simplemente colocamos un verificador que abrirá la función del socket para comenzar a escuchar, por último ejecutamos dos métodos, que son Accept y Listen.

private void AcceptCallback(IAsyncResult ar)
{
var listener = (Socket)ar.AsyncState;
var socket = listener.EndAccept(ar);
 
todoListoAutomatico.Set();
 
var state = new StateObject();
state.Socket = socket;
socket.BeginReceive(state.Buffer, 0, StateObject.BufferSize, 0, ReceiveCallback, state);
}

La función exclusiva del método AcepptCallback es la de estar abierto a recibir información cuando sea enviada, y mas aún que hacer con ella, para ello, invocará el método ReceiveCallback

private void ReceiveCallback(IAsyncResult ar)
{
StateObject datosObtenidos = (StateObject)ar.AsyncState;
Socket socket = datosObtenidos.Socket;
 
int read = socket.EndReceive(ar);
bool allRead = true;
 
if (read > 0)
{
string cadenaResultado = Encoding.UTF8.GetString(datosObtenidos.Buffer, 0, read);
datosObtenidos.StringBuilder.Append(cadenaResultado);
}
 
if (!allRead)
{
socket.BeginReceive(datosObtenidos.Buffer, 0, StateObject.BufferSize, 0, ReceiveCallback, datosObtenidos);
}
else
{
if (datosObtenidos.StringBuilder.Length > 0)
{
string result = datosObtenidos.StringBuilder.ToString();
result = result.Substring(result.IndexOf(delimitador) + 1);
 
try
{
Debug.WriteLine(result);
 
bool interruptor0 = Convert.ToBoolean(result.Split(',')[0]);
bool interruptor1 = Convert.ToBoolean(result.Split(',')[1]);
bool interruptor2 = Convert.ToBoolean(result.Split(',')[2]);
bool interruptor3 = Convert.ToBoolean(result.Split(',')[3]);
PrenderFocoDesdeSockets(interruptor0, interruptor1, interruptor2, interruptor3);
 
}
catch (Exception ex)
{ }
}
 
socket.Shutdown(SocketShutdown.Both);
socket.Close();
 
}
}

Esta es la función mas importante por el lado de la aplicación para la máquina, aquí es en donde ya recibiste la información del teléfono por medio del socket y la canalizas a una variable (result), con la cadena de datos recibida solo necesitamos fragmentarla y de acuerdo a los fragmentos recibidos simplemente ejecutar el método PrenderFocoDesdeSockets, para terminar este método es indispensable que cierres la escucha, de lo contrario te será imposible volver a recibir el siguiente dato.

private void PrenderFocoDesdeSockets(bool foco0, bool foco1, bool foco2, bool foco3)
{
ifKit.outputs[0] = foco0;
ifKit.outputs[1] = foco1;
ifKit.outputs[2] = foco2;
ifKit.outputs[3] = foco3;
}

Por último, el dispositivo deberá recibir de acuerdo a su arreglo de focos (o mejor dicho de puertos, recuerda que puedes cambiar el foco por cualquier dispositivo eléctrico) el estado en el que se encuentran, para que de esta manera sepa cuales prender y cuales no.

En el código de ejemplo que pongo a tu disposición al final de este artículo, hay algo mas de funcionalidad que sirve para poder controlar los puertos sin usar el teléfono, no la elimino para fines de comprensión de la funcionalidad del dispositivo electrónico, espero que te sea de utilidad.

NOTA: Para poder ejecutar ambas aplicaciones a la vez, deberás configurar tu solución, para ello da clic derecho en las propiedades de la solución, de la siguiente manera.

Ya en el cuadro de diálogo que aparece, solo configura la posibilidad de ejecutar dos soluciones de manera simultanea.

Para finalizar te dejo el video de como es que termina funcionando la aplicación ya completada.

Puedes descargar el código desde aquí.

Y no olvides que si tienes alguna duda escríbela en los comentarios y podremos irla resolviendo. ¡Nos vemos!