Domotipi - Ingeniería Civil Telemática UTFSM

Ingeniería Civil Telemática
Domotipi
Servicio de domótica
Víctor Collio
Luis Castro
Alfonso Contreras
Luis Gálvez
Rodrigo Araya
01/09/2013
201330031-6
201330027-8
201330014-6
201330047-2
201330044-8
Índice.
Introducción……………………………......…………………………………..……..………..…………2
Procedimiento………………..…………………………………………………………….………………3
Programas………..………..……………………………………………………………………..……….…6
Electrónica…………………………………………………………….……………………………………..8
Conclusión………………………………………………………………………………………………….10
Referencias………………………………………………………………………………………….…..…10
Introducción
Sabemos que como vivimos hoy en día, en un siglo marcado por el avance tecnológico que
parece crecer de manera exponencial y cada vez más cercano a la mayoría de las personas alrededor
de todo el mundo, muchas ideas que hace tan sólo unas décadas parecían sueños utópicos hoy se han
hecho realidad y se han incorporado a la cultura y la sociedad de manera casi inherente, como es el
ejemplo de la telefonía móvil o el mismo acceso a internet, más aún ahora con dispositivos que
incorporan ambas cosas de manera simultánea y sin grandes limitaciones ya que existen equipos al
alcance del cualquier bolsillo, hasta dispositivos que son un verdadero lujo.
Es por esto que pensamos que para desarrollar ideas innovadoras debemos ser cada vez más
ambiciosos, en el sentido de proponer ideas que parezcan utópicas y proponernos desafíos cada vez
más interesantes, porque probablemente en el transcurso de llevar todo a cabo, ya se habrán
dispuesto herramientas para mejorar la idea aún más. Y es por esta razón que como grupo decidimos
proponer un proyecto enfocado a la domótica que nos permita seguir incluyendo ideas a largo plazo,
seguir desafiándonos a conseguir un producto - o bien, un servicio - cada vez más completo y que
pueda prestar más comodidad.
Sin mucho más que decir, describiremos a grandes rasgos nuestro proyecto, al cual hemos
llamado Domotipi, y procederemos a describir los pasos que seguimos para llevar a cabo el proyecto.
El proyecto consiste básicamente en poder tener control de las luces de una casa - o en su
defecto otro tipo de recinto - a larga distancia de manera cómoda, rápida y simple de usar, por medio
de un mini computador de bajo costo, llamado Raspberry Pi. Esto lo hicimos a través de una interfaz
web la cual se comunica con los archivos alojados dentro de la Raspberry Pi, los cuales controlan un
puerto físico llamado puerto GPIO (General Purpose Input/Output) que se encuentra en uno de los
extremos de la Raspberry Pi, estos transmiten impulsos eléctricos que podemos utilizar para un sinfín
de cosas, muy interesantes dependiendo de la idea y la utilidad que se le den. Dichos impulsos
eléctricos son los que nos permitirán encender las luces de a través de un circuito que considere los
voltajes y la intensidad necesarios para una red doméstica, sin causar ningún peligro de dañar la
Raspberry Pi, dando como resultado el control y la automatización del encendido de luces de manera
remota.
Las metas que nos propusimos fueron varias, ya que la domótica es un campo muy versátil.
Entre los objetivos cumplidos, se encuentran encender luces desde una página web creada por
nosotros, mecanismos de encendido por sensores de luminosidad, un pequeño sistema de seguridad
que utiliza luz infrarroja y encendido de luces mediante un aplauso. Cabe decir que queremos seguir
avanzando con este proyecto e incorporar comandos de voz para encender las luces, una base de
datos que registre todos los cambios efectuados, enviar un mail de alerta cuando se active el sensor de
movimiento entre otras cosas.
Procedimiento
Creemos que la manera más sencilla de explicar el procedimiento es partiendo desde lo que
tenemos a simple vista, es decir la página web, hasta el encendido de la luz. Cabe destacar que
nosotros utilizamos una maqueta con leds, dadas las limitaciones de tiempo y recursos; sin embargo el
proyecto es totalmente aplicable a una red doméstica tomando todas las precauciones de cambio de
voltaje e intensidad de la electricidad al momento de hacer la instalación, más adelante describiremos
con más detalle cómo logramos encender una ampolleta conectada al circuito principal para demostrar
lo que acabamos de decir.
Página Web
La página web está escrita en html básicamente, a pesar de que en su mayoría los elementos
visuales son javascript dado que utilizamos un framework para Jquery llamado Kickstart(1), Jquery es
una de las librerías más utilizadas para javascript por su sencillez, y dado que Kickstart es un framework
que utiliza Jquery, nos facilitó mucho más el trabajo ya que el uso de este framework es tan intuitivo
que hasta personas que no tengan muchos conocimientos de desarrollo web podrían utilizarlo, de
hecho nos consideramos dentro de este grupo, y como ustedes verán en las fotos el resultado final es
más que satisfactorio.
Eso es en cuanto a lo visual, sin embargo lo más importante dentro de la página es el método por el
cuál se envían los datos a la Raspberry; esto lo hacemos mediante AJAX(2), una forma de enviar datos al
servidor sin necesidad de recargar la página, esto resulta bastante eficiente cuando tenemos una
interfaz que interactúa de manera constante y dinámica con el cliente. Como dijimos anteriormente
utilizaremos la librería Jquery para hacer más sencilla la labor, para esto debemos incluir en el archivo
html la siguiente línea dentro del encabezado (<head>):
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
Hecho esto, podemos utilizar la librería Jquery, ahora agregamos un script con una función
javascript que capture las variables desde el html y las guarde en “parametros” y luego las envía
mediante Ajax al servidor, el cuál tiene un archivo “rptest.php” que recibe las variables mediante el
método POST:
<script>
function enviar(programa, variable){
var parametros = {
"programa" : programa,
"variable" : variable,
};
$.ajax({
data: parametros,
url: 'rptest.php',
type: 'post',
beforeSend: function () {
$("#resultado").html("Procesando, espere por favor...");
},
success: function (response) {
$("#resultado").html(response);
}
});
}
</script>
En beforeSend, escribimos lo que queramos que se vea mientras se están enviando los datos, y
en success escribimos la respuesta que dará el archivo php. Notar que #resultado hace referencia al
elemento con un id=”resultado”, donde se visualizará el mensaje escrito en beforeSend y en success, el
cual podemos incorporar en cualquier parte dentro del cuerpo del html (<body>) de la siguiente forma:
<span id="resultado"></span>
Ahora, la parte dinámica dependerá de los elementos que agregemos en el cuerpo del html,
esto pueden ser botones o cuadros de texto:
<button onclick="enviar('encender', 'd1');></button>
<input id='mail' type="text" placeholder="[email protected]"/>
<button onclick="enviar('mail', $('#mail').val());"></button>
Debemos notar que lo que se enviará como “programa” y “variable”, en el primer caso serán los
string “encender” y “d1” ; en el segundo caso serán “mail” y el valor del elemento con el id=“mail” el
cual corresponde a un cuadro de texto, así que lo enviado como “variable” dependerá de lo que el
usuario escriba en dicho cuadro de texto.
Ya hemos pasado la parte más difícil, para terminar la explicación del funcionamiento de la
página web sólo nos queda describir el archivo “rptest.php”. Para hacerlo sencillo diremos que el
archivo recibe los valores de ‘programa’ y ‘variable’ enviadas desde html, y guarda sus valores en una
$variable, mediante el método $_POST así:
<?php
$programa = $_POST['programa'];
$variable = $_POST['variable'];
…
Luego ejecutaremos el programa y le damos como parámetro la variable, mediante el comando
system(); de la siguiente forma:
…
system("/home/usuario/carpeta_programas/{$programa} {$variable}");
?>
Remplazando la ruta si es necesario por la carpeta donde se alojarán los programas. Eso es a
grandes rasgos, por ejemplo si el valor de $programa fuera “encender” y el valor de $variable fuera
“d1”, se ejecutará el programa llamado encender con el parámetro d1; así mismo si sus valores fueran
“mail” y “[email protected]”, se ejecutará el programa llamado mail con el mail ingresado por el
usuario como parámetro ([email protected]). Debemos destacar que hay que configurar los
programas para que reciban un parámetro y trabajen en base a ese parámetro de antemano y que el
comando system() de php devolverá como salida lo que retorne el programa alojado en la Raspberry.
Programas
La parte de los programas es la más importante, ya que esta es la que controla los impulsos
eléctricos que finalmente nos permitirán encender los leds. Para controlar el puerto GPIO utilizamos
una librería para C llamada wiringPi(3), es bastante utilizada y la página oficial provee una muy buena
documentación (en inglés solamente), para instalarla en nuestra Raspberry debemos ejecutar los
siguientes comandos en la terminal:
~$ sudo apt-get install git-core
~$ sudo apt-get update
~$ git clone git://git.drogon.net/wiringPi
~$ cd wiringPi
~$ git pull origin
~$ cd wiringPi
~$ ./build
Y para incluirla en nuestros archivos.c debemos escribir al principio:
#include <wiringPi.h>
Junto con las demás librería de C más usadas, y que por cierto, utilizaremos también nosotros
<stdio.h> y <string.h>. Es importante advertir que para compilar con esta librería debemos hacerlo
escribiendo –lwiringPi al final de la línea, por ejemplo:
~$ gcc archivo.c –o archivoEjecutable –lwiringPi
Ahora debemos tener en cuenta que para inicializar el sistema wiringPi, podemos escribir las
siguientes funciones dentro del archivo.c, que son equivalentes entre sí con algunas diferencias que
mencionaremos a continuación:
wiringPiSetup();
// Numeración de pines propia de wiringPi
wiringPiSetupGpio(); // Numeración de pines Broadcom GPIO (ver página oficial)
wiringPiSetupSys(); // Numeración de pines Broadcom GPIO
La diferencia radica en que con las primeras dos necesitaremos permisos de superusuario para
ejecutar los programas, mientras que con la tercera no será necesario; sin embargo sólo en la tercera
debemos haber exportado los pines que utilizaremos como salida o como entrada con anterioridad,
esto lo hacemos de la siguiente forma:
#include <stdio.h>
#include <string.h>
#include <wiringPi.h>
main(){
char comando[50];
strcpy(comando, "gpio export 9 in");
system(comando); …
Aquí ocupamos la función strcpy() para copiar el string “gpio export 9 in” y guardarlo en la
variable comando de tipo char, luego ejecutamos la función system() que es equivalente a escribir en la
terminal lo que esté guardado en la varible comando; por lo tanto podríamos escribir la siguiente línea
de comandos en la terminal y tendríamos el mismo resultado:
~$ gpio export 9 in
El resultado es el pin 9 (numeración Broadcom) exportado como entrada, análogamente
podemos escribir out en lugar de in y obtendremos el pin como salida. Dicho esto, podemos comenzar
con la parte electrónica.
En la parte electrónica tenemos las 8 luces controladas a través de la GPIO en modo OUTPUT
main(){
char comando[50];
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
strcpy(comando, "gpio
system(comando);
export 17 out"); //Luz Dormitorio 1
export 18 out"); //Luz Dormitorio 2
export 27 out"); //Luz Dormitorio 3
export 22 out"); //Luz Baño
export 23 out"); //Luz Cocina
export 24 out"); //Luz Living
export 25 out"); //Luz Pasillo
strcpy(comando, "gpio export 4 out"); //EMISOR de luz para seguridad en ventana;
system(comando);
…
Los primeros siete pines los exportamos en los programas correspondientes encender.c, apagar.c y
estado.c; el último lo exportaremos sólo en el programa mail.c; que será el encargado de ennviar un
mail al momento que sea interrumpida la luz.
También tenemos 3 sensores conectados al GPIO en modo INPUT:
strcpy(comando, "gpio export 10 in"); //Sonido (micrófono)
system(comando);
strcpy(comando, "gpio export 9 in"); //Fotodiodo receptor de luminosidad
system(comando);
strcpy(comando, "gpio export 11 in"); //Fotodiodo receptor de luz en ventana
system(comando);
El primero lo podemos exportar en un archivo llamada aplauso.c; el segundo en autoluces.c y el
tercero en el anterior mencionado mail.c.
Ahora para encender cada luz será cosa de algoritmos simples, con unos cuántos if, else if, etc.
Dependiendo del string ingresado como parámetro junto con el programa; recordar que para capturar
estos parámetros podemos utilizar argv y argc; y para comparar string usamos la función strncmp().
Electrónica
En cuanto a la parte electrónica procederemos a describir los componentes del circuito para
cada pin utilizado, exceptuando a los pines que salían hasta el led, ya que ellos no tienen mucha
elaboración más que conectarlos al pin correspondiente:
1) Sensor de luminosidad
Componentes:
-TR1=Transistor pn2222
-LDR
-VR1=Potenciómetro o Resistencia de 10k
El sensor de luminosidad funciona principalmente gracias a un LDR (light-dependent resistor) o
fotorresistencia, la cual disminuye la resistencia con el aumento de la luminosidad.
Link http://www.youtube.com/watch?v=WPXhlvpZVj4
2) Sensor emisor y receptor en ventana
Componentes:
-Fotodido (receptor)
-Led emisor
-R6= Resistencia de 50k
- R2=resistencia de 220
EL sensor funciona gracias al fotodiodo el cual recibe la luz del led emisor y este detecta la
interrupción de la luz.
3) Sensor de sonido
Componentes:
-Micrófono
-Transistor pn2222
-R3=Resistencia de 1k
-R2=Resistencia de 100k
-R4=Resistencia o potenciómetro de 50k
El sensor de sonido funciona principalmente gracias a un micrófono en el cual esta conectado al
circuito, lo que hace el micrófono es convertir ondas sonoras en energía eléctrica haciendo que envie
un pulso a al GPIO de la raspberry.
Link http://www.youtube.com/watch?v=u4lDJBxWSAc
Además le instalamos un circuito de potencia, en la cual en vez de hacer funcionar un motor
(como se muestra en el video), instalamos una ampolleta la que prende gracias al Relé, y el circuito de
control lo conectamos al pin 26 y a negativo de la GPIO de la Raspberry Pi, de esta manera podemos
ver que es posible implementarlo a la red doméstica.
Componentes:
-Relé 5vcc /250vac
-Ampolleta
Todos los diagramas los modificamos de acuerdo a lo que necesitábamos, en este caso pulsos 1
y 0 (1=3,3volts y 0=0volts), y así poder comunicar el sensor con los programas en C, ya que
investigamos y sabemos que la Raspberry no recibe señales análogas, sino sólo señales digitales (1 y 0).
Conclusión
Las instalaciones a escala real, son posible de ser realizadas pero desde nuestro prototipo a
hacerlo real hay un largo trayecto, puesto que se deben identificar muchas partes del proyecto, su
instalación con 220v su acertada función sin errores críticos, la seguridad de los circuitos de bajo
consumo y además la instalación local de la casa, la idea es seguir informándose y viendo todos los
posibles problemas que se pueden acumular al realizar una instalación en casa.
Referencias
(1) Kickstar: http://www.99lime.com/elements/ (Página Oficial)
(2) AJAX: http://www.imaginanet.com/blog/usando-ajax-un-simple-ejemplo-con-php-y-jquery.html
(3) WiringPi: https://projects.drogon.net/raspberry-pi/wiringpi/ (Página Oficial)