Domótica para todos I

Trabajo de investigación en el ámbito tecnológico

Autor: Carles Llobet Pons

Curso académico: 2º Batxillerat A

Generalitat de Catalunya Departament de Educació Institut de Secundária Vilatzara

Av. Arquitecte Eduard Ferrés, 101 08340 Vilassar de Mar Tel. 93 750 63 66 Fax 93 750 65 53 [email protected]

Automatitzación económica del hogar 2 | Domótica

Índex 1. Introducción .............................................................................................................. 4

1.1 Introducción a la domótica .................................................................................. 4

1.2 Objetivos ............................................................................................................. 4

1.2.1 Aprendizaje .................................................................................................. 4

1.2.2 Guía .............................................................................................................. 5

1.2.3 Cómo lo haremos? ........................................................................................ 5

1.2.4 Qué necesito? ............................................................................................... 6

1.2.5 Qué necesitará el lector para automatizar su hogar? .................................... 6

2. Historia del proyecto ................................................................................................. 7

2.1 Transcurso del proyecto ...................................................................................... 7

2.1.1 Idea inicial .................................................................................................... 7

2.1.2 Hipótesis....................................................................................................... 8

2.1.3 Aprendizaje .................................................................................................. 8

.............................................................................................................................. 9

2.1.4 Exposición del progreso al tutor ................................................................. 10

2.1.5 Reunión con el tutor ................................................................................... 10

2.1.6 Entrevista ................................................................................................... 11

2.1.7 Conexión entre Arduino y Processing.......................................................... 14

2.1.8 Programar actuadores ................................................................................ 14

2.1.9 Motores...................................................................................................... 15

2.1.10 Alarma ...................................................................................................... 16

2.1.11 Calibrando los termistores ........................................................................ 20

............................................................................................................................... 21

............................................................................................................................... 21

2.2 Problemas y dificultades comunes..................................................................... 23

2.2.1 Soluciones .................................................................................................. 23




3. Guía para la realización ........................................................................................... 24

3.1 Programación .................................................................................................... 24

3.1.1 Plano .......................................................................................................... 24

3.1.2 Botones ...................................................................................................... 25

3.1.3 Funciones de los botones ........................................................................... 26

3.2 Conexión a Arduino ........................................................................................... 28

4.Conclusiones ............................................................................................................ 30

4.1 Opinión del Trabajo ........................................................................................... 30

4.2 Objectivos conseguidos ..................................................................................... 30

4.3 Posiblas mejoras ................................................................................................ 31

4.3.1 Ampliación de los elementos ...................................................................... 31

4.3.1 Ampliación de los controladores ................................................................. 31

5.Anexo....................................................................................................................... 32

5.1 Elementos utilizados ......................................................................................... 32

5.1.1 Para la maqueta ......................................................................................... 32

5.1.2 Programas .................................................................................................. 35

5.1.3 Plano .......................................................................................................... 36

............................................................................................................................ 36

5.2 Cómo hemos conectado los elementos ............................................................. 37

5.3 Programa .......................................................................................................... 44

6.Bibliografia ............................................................................................................... 69

6.1 Libros ................................................................................................................ 70

6.1.1 En formato PDF .......................................................................................... 70

6.1.2 En formato papel ........................................................................................ 70

6.2 Páginas web ...................................................................................................... 71

6.3 Agradecimientos a los asesores ......................................................................... 71




1. Introducción

1.1 Introducción a la domótica Un hogar con instalación domótica es un espacio en el cual los diversos elementos de

control de la casa, en lugar de tener mandos independientes, convergen en un control

central que será el encargado de decidir como ha de actuar cada elemento de la

instalación. La manera de programar este control central dependerá del sistema

domótico que nosotros usemos.

Hay de muchos tipos; unos son más intuitivos a la hora de programarlos y otros tienen

un poco más de complejidad. También existen algunos sistemas que están más

estandarizados y otros que utilizan un protocolo propio o propietario (no estándar).

Ningún sistema es mejor que otro, pero obviamente, siempre es preferible un sistema

creado únicamente para tu hogar, que un sistema estándar.

1.2 Objetivos En esta memoria crearemos un control central de nuestro hogar a través de un

programa en Processing, que nos permita controlar desde la iluminación de e

habitaciones, como el sistema antiincendios, hasta los sistemas de riego o de control

de temperatura de la casa, de una manera cómoda y sencilla a través de cualquier

sistema capaz de ejecutar un programa con Java (desde el típico Windows o Mac OS

hasta Linux o variantes de este).

1.2.1 Aprendizaje A través de esta guía queremos ser capaces de entender qué es una casa domótica y

cómo funciona: Saber como funciona el algoritmo del programa, qué dispositivos

permiten comunicar el ordenador con la casa, etc.,... para a ser capaces de cumplir el

segundo objetivo de este proyecto.




1.2.2 Guía El objetivo de este proyecto es que todo el mundo pueda tener a su alcance este

recurso de la domótica sin tener un nivel alto de vida económica. Lo haré a través de

una guía con la cual cualquier persona podrá transformar la su hogar en un hábitat

domótico perfectamente funcional, reduciendo en gran medida el precio al hacerlo él

mismo.

Este proyecto está enfocado sobretodo a personas que no pueden asumir el coste de

una instalación domótica pero que necesitan este tipo de instalación ya sea porque

tienen una discapacidad, o porque tienen una edad en que ya les es difícil el

movimiento. Aún y así cualquier persona con ganas puede conseguir realizar este

proyecto.

1.2.3 Cómo lo haremos? Realizaremos un programa con Processing que muestre los planos de una casa

indicando qué luces están encendidas o apagadas, qué persianas están abiertas o

cerradas, la temperatura de la casa y hasta las alarmes de incendio y de seguridad

permitiendo controlarlas; y todo, a través de una sencilla conexión USB a una placa

Arduino.

En el caso del nuestro trabajo de investigación, al no poder hacerlo en una casa real,

construiremos una maqueta de una casa modelo con la cual representaremos el

funcionamiento real de una casa (adaptándonos a nuestro presupuesto, utilizando

elementos que ya tenemos, la mayoría reciclados). Una vez hecho esto, realizaremos

una guía con la que cualquier lector pueda adaptar este programa para su propia casa.

Así cualquiera podrá tener automatizada su casa a precio de coste, solamente pagando

el cableado de la casa y los motores de las persianas, ya que el programa, el dispositivo

de control, y las conexiones de los actuadores/sensores al dispositivo de control las

hará él mismo.




1.2.4 Qué necesito? Conocimientos

Para este proyecto necesitaré conocimientos básicos de arquitectura y diseño para hacer los planos de la casa (la maqueta representativa y el plano de ésta); conocimientos avanzados de programación en la plataforma gráfica Processing (que trabaja con lenguaje Java) para crear un programa mutable y adaptable a cualquier lector que siga la guía, y conocimientos medios en electrónica para a conectarlo todo al ordenador correctamente y explicar como hacerlo de manera sencilla.

Materiales

Este proyecto tiene infinidad de posibilidades, y adaptaremos la maqueta representativa con los materiales de que disponemos en aquel momento, tanto para presupuesto como para viabilidad dentro de una maqueta de medida reducida. Suponemos que estos materiales serán: Cartón, telas para las persianas, cableado diverso, leds, sensores de temperatura y de infrarrojos, y de otros similares. Explicaremos los materiales que finalmente hemos podido utilizar en los anexos.

1.2.5 Qué necesitará el lector para automatizar su hogar? Conocimientos

La guía estará enfocada a que el lector, si ya tiene los planos de su hogar, no necesite ningún tipo de conocimiento a parte de los que se le enseñaran en la Guía de Realización.

Materiales

Si el lector quiere aplicar el proyecto a su propio hogar, solamente necesitará los actuadores y sensores que quiera incorporar, una placa Arduino, relés para las luces, y metros suficientes de cable. Son todo cosas que si no sabe como instalar, cualquier lampista puede hacérselo a precio de coste, reduciendo el coste de la automatización a la factura de este lampista. En las conclusiones, en “objetivos conseguidos” habrá una referencia del precio que hemos conseguido reducir.




2. Historia del proyecto

2.1 Transcurso del proyecto

2.1.1 Idea inicial El principio de un trabajo de investigación es siempre complicado. Todo y tener una

idea aproximada de lo que se quiere hacer, nunca sabes por dónde empezar. En mi

caso, tenia claro que quería hacer alguna cosa relacionada con la domótica, ya que

tanto la arquitectura como, sobretodo, la programación y la electrónica, me

apasionan.

Además del hecho de que la domótica es un recurso poco explotado y muy útil,

especialmente para persones minusválidas, que puede facilitar muchísimo la vida

cotidiana del día a día. Como no era viable construir una casa domótica real, decidí

hacer una maqueta y así poder hacer una demostración de la utilidad en cualquier

presentación, en persona.

El problema era que no sabía exactamente qué podía demostrar, ya que quería que mi

proyecto tuviese alguna utilidad, sirviese de algo.

Mi tutor me sugirió usar el lenguaje de programación Processing en lugar de JDK, que

era demasiado complejo, o Visual Basic, al cual le faltaban varias funciones. Así que a

principios de verano y a través de una lista de libros en inglés, especialmente el

“Learning Processing” de Daniel Shiffman, empecé a aprender este lenguaje de

programación.




2.1.2 Hipótesis Pero como enfocar el trabajo? Qué hipótesis podía plantearme? Que quería descubrir?

La verdad eso no lo supe hasta casi la mitad del trabajo, pero no me preocupaba. Tenía

claro lo que quería, y sabía que encontraría esta hipótesis.

Finalmente decidí que quería hacer una guía con la que cualquier persona pudiese

hacerse su propia casa domótica reduciendo así el coste en casi dos tercios del coste

original, ya que con la actual crisis la domótica está arrinconada por culpa de los

precios excesivamente altos. Poco a poco la idea fue evolucionando y finalmente,

cuando tuve una entrevista con Roberto Novo, como veremos más tarde, y me informé

de los precios reales de una instalación media decidí finalmente que esta sería la

hipótesis o investigación de mi trabajo.

2.1.3 Aprendizaje Al principio no entendía un ápice, pero después de unos cuantos ejercicios y prácticas

empecé a entender el concepto. Empecé a estructurar el algoritmo del programa que

usaría para la maqueta, y empecé a escribir código con las funciones que necesitaba

para crear una ventana con el plano insertado, y para a colocar los botones, de los que

tuve que buscar una a una las coordenadas en píxeles y escribirlos en una tabla de

datos en Excel:




Una vez tuve la tabla de Excel con las coordenadas de los botones del plano,

solamente tenía que crear una variable booleana, ya que los botones solamente

pueden estar en dos estados (1 o 0, encendido o apagado). Después creamos unas

variables “x1”, “y1”, “w1” y “h1” para entender mejor el programa y no confundir

coordenadas de unos botones con otros.

Finalmente en el “void draw” solamente faltaba definir la función del botón tal como

podemos ver en la figura 1.

Con esto ya teníamos prácticamente la estructura base de lo que vendría a ser muy por

encima nuestro programa, ahora solo faltaría ir poco a poco expandiendo, ampliando,

y perfeccionando el programa sobre esta estructura base hasta llegar a cumplir los

objetivos que nos habíamos marcado previamente en el apartado de la introducción.

Figura 1




2.1.4 Exposición del progreso al tutor Una vez conseguí abrir el plano y ponerle los botones justo donde tocaba, para seguir

avanzando necesitaba concretar qué placa usaría. Me puse en contacto con mi tutor,

explicándole lo que había hecho hasta el momento, y qué placa podría usar. Me dijo

que buscase información sobre la placa Arduino UNO, que era la que seguramente

usaríamos, y concertamos una cita la semana antes de comenzar el curso.

Además de buscar información sobre la placa mencionada, busqué información

general sobre la domótica, y encontré una cosa bien interesante. Al buscar

información por internet sobre las casas domóticas, solamente encontraba páginas

donde daban opción a calcular un presupuesto o explicaciones de qué era una casa

domótica, pero no encontraba ni precios ni explicaciones de cómo se podía

automatizar una casa por ti mismo. Entonces fue cuando empecé a intuir hacia donde

podía enfocar mi trabajo ya que si una instalación domótica era de precios elevados, y

sobretodo ahora con la crisis actual, la producción de instalaciones domóticas se

reduciría enormemente, y nos privaría de una comodidad que cualquiera desea en su

hogar.

2.1.5 Reunión con el tutor Tal como habíamos quedado, una semana antes de empezar las clases, tuvimos una

reunión Joan Alós, Elisabet Alsina y yo. En ésta, a parte de enseñar los progresos que

ya había hecho, estuvimos valorando todas las posibilidades que teníamos para poder

aplicar las funciones que se harían en una instalación domótica estándar a nuestra

maqueta.

Una vez decididas las funciones que haríamos,

hicimos una lista con los actuadores y sensores

que necesitábamos y las correspondientes

entradas y salidas de la placa que necesitaríamos.

Para no quedarnos justos, decidimos sustituir la

Figura 2




placa que habíamos comentado, la Arduino UNO de 14 entradas/salidas, por la

Arduino Mega 2560 con 54 entradas/salidas digitales y 15 analógicas. (Fig.2)

2.1.6 Entrevista Después de la reunión con el tutor, me di cuenta que solamente

nos habíamos hecho una idea por encima de lo que haríamos, y

estaba empezando a programar en Processing sin saber realmente

si la idea sería factible. Además, aún no sabía bien cual era el

propósito que quería conseguir a través de mi proyecto, por lo que

busqué a alguien que me pudiera asesorar.

Lo primero que hice fue buscar las empresas más cercanas a Vilassar de Mar, y decidí

hacer una visita a algunas de ellas. Empresas de Barcelona como Engtel o Equinsa

estaban cerradas o no me proporcionaban mucha información, pero al final encontré

lo que buscaba. Una empresa llamada I-DO (integración domótica) me atendió muy

amablemente a pesar de llevar cerrada algunos años.

El ex-propietario Roberto Novo (Fig.3), ingeniero en Telecomunicaciones, accedió a mi

entrevista, incluso me invitó a su casa para enseñarme las instalaciones que él mismo

había integrado en su hogar. Cuando le pregunté por los precios de estas instalaciones,

me dijo que oscilan mucho dependiendo de qué se quiera instalar. El precio de una

casa normal de unos 120m2 con funciones simples como iluminación, temperatura,

alarma de seguridad i anti-incendios, persianas i sensores de presencia, oscila entre los

4.000€ y los 5.000€ en total, contando la instalación, la mano de obra y los dispositivos

y controladores de la casa. Hay instalaciones mucho más caras simplemente por el

tamaño de la casa o la cantidad de elementos a instalar y las diferentes funciones o

modos personalizados de iluminación y temperatura.

Las instalaciones completas van desde los 3.000€ hacia arriba, por lo que las

instalaciones más solicitadas, o no son completas o bien no garantizan fiabilidad, y

están hechas con poca calidad, lo que pone en riesgo la seguridad de nuestras vidas i

Figura 3




pueden producir desde cortocircuitos que provoquen incendios hasta accidentes

propios de una película de Alfred Hitchcock como dejarnos encerrados en casa sin

posibilidad de salir.

En el siguiente gráfico extraído de un estudio realizado en el año 2008 (4ª página web

del anexo) vemos la cantidad de instalaciones en España en función del precio de

éstas, se puede observar cómo a partir de los 3.000€, que es cuando empiezan a

considerarse instalaciones completas, la cantidad de hogares construidos disminuye

drásticamente. La mayoría de instalaciones son de entre 1.000€ y 1.500€, se trata de

instalaciones incompletas o demasiado sencillas.

Gráfico 1




También me explicó las diferentes maneras de hacer el cableado de la casa. Una funciona por BUS, se trata de un solo cable que va por toda la casa y tu lo pinchas allí donde quieres poner un dispositivo. Este sistema es el más caro, pero para futuras posibles reformas o ampliaciones es muy cómodo. Aquí vemos un esquema extraído de la 5º página web del anexo.

El otro sistema es por Centralización: A partir de un dispositivo central, como sería

nuestro ordenador o placa Arduino Mega, se tiran todos los cables necesarios

(esquema de la

5ª página web

del anexo).

Hay otros sistemas, como el PLC, un sistema de autómatas programables basados en

relés de Siemens o Omron por ejemplo, que suelen ser muy sencillos de conectar y de

ver dónde puede fallar algún cable, pero la instalación se encarece, obviamente.

Me recomendó utilizar un programa autómata a la hora de programar el Arduino, si

puedo, ya que en el momento de adaptarlo a la realidad es menos viable tener un

ordenador encendido tanto tiempo sin descanso, a no ser que fuera un ordenador

industrial o con un sistema de refrigeración específico.




2.1.7 Conexión entre Arduino y Processing Después vi que para introducir las variables de los actuadores (motores, luces, timbre)

y sensores (de presencia y de temperatura) tenía que hacer que mi programa escrito

en Processing, que creaba la interfaz gráfica, y la placa Arduino que enviaría o recibiría

las señales de los actuadores y sensores, se comunicasen, y descubrí que podía hacerlo

de dos maneras.

En el primer método, que me habían propuesto inicialmente mis tutores, tenía que

escribir un programa en Arduino que leyera los datos de la placa y los enviara al puerto

serie, y que leyera los datos del puerto serie y los enviara a la placa, y después hacer

mi programa en Processing que se comunicara de igual manera con el puerto serie.

Pero me parecía muy engorroso este método, y encontré otro método que utilizaba

una librería especial para Processing que incluía diversas funciones de la programación

Arduino a Processing, haciendo el programa más difícil de programar, pero más fácil de

estructurar, cosa conveniente para que fuese más fácil de modificar por el lector.

2.1.8 Programar actuadores Una vez supe como conectar Arduino y Processing, sólo faltaba definir las funciones de

todos los botones en función del actuador al que correspondías, por ejemplo el botón

que correspondía a la luz del comedor en las coordenadas del el plano ha de enviar

una señal a la salida donde hemos conectado esa luz, y mostrar en el plano del

ordenador que esa luz está encendida.

Ejemplo:




A partir de ahí, ya podía programar todas las luces, pero obviamente fui haciendo

pequeñas modificaciones conforme avanzaba, como por ejemplo las variables de texto

que utilizamos para escribir el valor del termistor en la interfaz del programa, o el

sensor de presencia y el timbre, aunque la estructura básica del programa ya estaba

terminada.

2.1.9 Motores Después de tener las luces de la casa programadas, decidí programar las persianas. Era

el segundo elemento más fácil de programar, ya que no tenía que recibir señales de

ningún sensor como en los elementos que incorporaría más adelante. Aún y así, al

contrario que las luces, las persianas se me resistieron mucho.

Con el material que disponíamos, lo que queríamos era adaptar la persiana del salón

de la maqueta con un motor sencillo (DC) y los motores de las persianas del piso de

arriba hacerlos con motores Stepper que nos permitían regular el ángulo de giro y la

velocidad de éste.

Motor Stepper

Para programar estos motores (Fig.4), después de estar estancado varias tardes

intentando programarlos, me di cuente que necesitaba incluir una librería del

programa Arduino a Processing, y que Processing no la tenía. Para eso tendría que

cambiar todo el programa de nuevo, y haría mucho más complicado al lector de la guía

modificar el programa a su gusto y conveniencia. Además, tampoco nos ayudaba

mucho controlar el ángulo de giro ya que lo que queremos no es que se abra y se

cierre sino tener la total libertad de abrir y

cerrar en la medida que nos interese. Por

eso decidimos hacer todas las persianas de

la casa con los mimos motores de corriente

continua.

Figura 4




Motor DC

Para hacer que nuestro motor funcionara tanto de subida como de bajada, teníamos

que realizar un puente H, un tipo de circuito que permite cambiar la polaridad de un

motor sin tener que desconectarlo e invertir el sentido de los cables, a través de una

señal que le puedes enviar.

Por suerte, en el aula disponíamos de unos circuitos ya preparados para el uso de dos

puentes H, los llamados L293D, con los que podíamos invertir la dirección de nuestro

motor. Cogí el esquema de conexiones (fig.5), de la página

web de Tecnología de mi instituto (URL número 10 de la

bibliografía) para saber como conectar este circuito integrado.

Al conectar y hacer las pruebas tuve algunos errores, pero los

solucioné al día siguiente conectando 3 de las patas al positivo

la de abajo a la derecha al GND (tierra).

2.1.10 Alarma Alarma de seguridad

Esta parte del programa ya estaba más elaborada ya que teníamos que recibir el valor

de un sensor de infrarrojos que detectase que, una vez activada la alarma, si pasaba

cualquier cosa por delante del sensor, activara un timbre que no dejase de sonar hasta

desactivar la alarma.

Al principio intenté hacer que si activábamos el botón de alarma, nos enviase a leer un

“void loop” (trozo de código que se lee repetidamente como el “void draw”) del cual

no saldría hasta que se desactivara la alarma. Pero no encontraba ninguna función en

Processing que te permitiese enviar a leer una línea de código diferente.

Finalmente opté por hacer una subrutina, concretamente un “if-then-else” dentro de

otra.

Figura 5




A la hora de probarlo nos daba algunos problemas: primero no funcionaba el botón y

tuve que revisar todas las coordenadas del botón, y lo solucionamos (fig.6), y después

no funcionaban los sensores correctamente, y probamos con otros diferentes.

Los primeros sensores que usamos eran dos DIY1 (fig.7) que permitían de manera

sencilla conectar los sensores a la placa Arduino sin tener que añadir ninguna

resistencia ni ningún tipo de elemento entre la placa y los sensores.

1 DIY (Do It Yourself): Sensores integrados listos para funcionar

Figura 6

Figura 7




Pero al final por un error del DIY emisor tuvimos que sustituirlo por un emisor de

infrarrojos no integrado (el TSUS4400) debiendo poner nosotros las conexiones como

en el circuito extraído de la página web de tecnología del IES Vilatzara (fig.8):

Tuvimos que añadir la resistencia de 330Ω de la Figura 8. Ahora el emisor funcionaba

(veíamos como se encendía con una cámara) pero seguía fallando por lo que

cambiamos el DIY receptor por un receptor no integrado (el BPW96) con una

resistencia de 22000 ohm, tal como se puede observar en su datasheet:

Figura 8




Alarma antiincendios

Aún y así, no nos terminaba de funcionar por culpa de las pocas funciones posibles que

no da la conexión de Processing y Arduino a través del Firmata (pero me interesaba

más que me diera problemas a mí antes que al usuario de la guía en el momento de

modificar el programa).

Por tanto, decidí cambiar la alarma de seguridad por una alarma anti-incendios

aprovechando el termistor, del que os explicaré como lo calibré en el siguiente

apartado.

Esta nueva alarma nos avisará en la interfaz cuando la casa incremente su temperatura

hasta niveles extremos para prevenir incendios; se activará una alarma (zumbador en

la maqueta) y activará los sistemas de riego, aunque no podemos mojar nuestra

maqueta. También nos avisará en la interfaz si la temperatura de la casa desciende

demasiado, y activaría la calefacción de la casa. En la siguiente figura podemos ver el

algoritmo:




2.1.11 Calibrando los termistores KY-13

A falta de conocimientos y/o manuales o libros dónde poder buscar como programar

un termistor, acabé optando por el método de prueba-error. Empecé a modificar las

líneas de código allí donde me aparecían errores, pensando un poco en qué podía

funcionar y probándolo.

Después de horas haciendo prueba-error, y reescribiendo esa parte del programa,

finalmente conseguí eliminar todos los errores y hacerlo funcionar.

Pero esto obviamente no significa que haga lo que tu quieres que haga. Cuando probé

el termistor aluciné con el valor que me daba (550). Ahora, como ya no era error de

programación sino del termistor en sí, busqué información sobre los termistores.

Los termistores (Fig.9) son unos aparatos que generas

diferentes resistencias en función de la temperatura a la

que están; pero estos valores no varían según una

función lineal, sino en función de una asíntota, que es lo

que nos dio más dolores de cabeza.

Pedí ayuda a un trabajador de a compañía Picaxe (Joan Pellicer Moreno) vía e-mail y

me respondió que para transformar la resistencia a una temperatura, primero hay que

encontrar la temperatura característica del material del termistor (β) a través de los

siguientes cálculos

Dónde:

R1 y R2 son las resistencias que pone el termistor a las temperaturas T1 y T2 respectivamente

T1 y T2 son dos temperaturas ya conocidas que hemos escogido para calcular el valor, suficientemente separadas para eliminar margen de error.

Figura 9




Una vez hemos encontrado la β (que nos dio “2,93315”) tenemos que aplicar la

siguiente ecuación para transformar la resistencia obtenida en temperatura real:

Pero claro, lo que nosotros buscamos no es el valor de la resistencia en función de la

temperatura a la que lo ponemos, sino que buscamos la temperatura equivalente al

valor de la resistencia que nos indica el termistor. Para eso pedimos ayuda al físico y

profesor de matemáticas Jaume Serra para asegurar que se pudiese aislar sin

problemas y no errar a la hora de trabajar con logaritmos y numero de Euler. Una vez

aislada la temperatura, solamente teníamos que definir la temperatura del programa

en base a la fórmula resultante. En el recuadro de más abajo podemos observar cómo

aislamos la temperatura para que la fórmula nos quedase en función de ésta:

Dónde:

RT es la resistencia que nos da el termistor a la temperatura T y R0 la resistencia a la temperatura T0.

T es la temperatura a la que está el termistor y T0 una temperatura de referencia cualquiera (podríamos aprovechar la T1 y R1 que utilizamos para calcular la β.

푅 = 푅 ∙ 푒 ( ) = 푒 ( )

ln( ) = 훽( − ) ( )

= −

( )+ =

푇 =1

ln(푅푅 )훽 + 1

푇




Dallas DS18B20

Al intentar aplicar la fórmula de la temperatura del anterior termistor, nos aproximaba

el valor del logaritmo neperiano a 0, por lo que nos daba una temperatura 0. Después

de varias pruebas, decidimos probar con este otro termistor que ya había funcionado

con otros miembros del grupo.

Lo conectamos tal como se muestra

en su Datasheet (fig.10) y como

explicamos en los anexos en el

apartado “5.2 como hemos

conectado los elementos”. En el

momento de probarlo nos daba un

valor 1021 pero éste ni siquiera

reaccionaba al calor o al frio.

Modificamos el programa y lo

probamos con programas de prueba

extraídos de ejemplos en internet (8ª y 9ª página web del anexo), pero con estos

ejemplos ni siquiera nos reconocía el termistor como elemento conectado, por lo que

decidimos volver a buscar una solución para el termistor anterior, que al menos

reaccionaba al calor i solamente teníamos que transformar la resistencia en

temperatura.

Para hacerlo optamos por hacer una tabla de condiciones que definiese cada grado

entre dos valores de resistencia, en lugar de usar fórmulas complicadas para

transformar el valor. Así marcaría la temperatura a la que se correspondiera ese valor.

Es un método más engorroso para calibrar, pero más seguro.

Figura 10




2.2 Problemas y dificultades comunes Al empezar a programar empezaron a surgir, como siempre acostumbra a pasar al

programar, problemas que no tenían explicación aparente. Había problemas que se

solucionaban en un segundo, y otros que estancaban el proyecto semanas enteras.

Aquí os los explicaremos para que no tropecéis con la misma piedra, con su solución

adjunta correspondiente al mismo número:

1. El primer problema que apareció fue a la hora de adjuntar el plano como

imagen en el programa. Me daba error siempre que lo intentaba, y a pesar de

revisar la ruta de la imagen mil veces, no conseguía encontrar el error.

2. Podéis encontrar también muchos errores como “missing expected ;” o

“doesn’t expect some function”.

3. En el momento de programar el valor del termistor, si solamente le decís

“analogRead(___)” os dará el valor de la resistencia según aquella temperatura.

2.2.1 Soluciones 1. Finalmente descubrí que la imagen la has de transportar a la carpeta de

instalación de Processing, o a la carpeta donde se guarda la aplicación de

Processing que exportas.

2. Este problema se arregla normalmente buscando una línea inconclusa en la

que nos hayamos dejado el signo de puntuación punto y coma.

3. Es importante preguntar por el valor Beta de vuestro sensor de

temperatura allí donde lo compréis, que es el que os ayudará a través de la

ecuación de la temperatura del apartado “2.1.11 Calibrando los

termistores” a transformar el valor de resistencia en un valor de

temperatura en grados Centígrados. Sino, tendréis que encontrarlo como

he tenido que hacer yo, a través de diversas pruebas a diferentes

temperaturas.




Figura 11

3. Guía para la realización Aquí es donde se centra el grueso de la guía para automatizar tu propia casa. Mientras

realizáis el primer apartado de programación, para aprovechar el tiempo, sería

conveniente que los lampistas empezaran a cablear y a hacer las regatas necesarias.

3.1 Programación Para realizar el proyecto de automatización de vuestro hogar, sólo tendréis que seguir

tres sencillos pasos que se explican a continuación.

3.1.1 Plano Lo primero es añadir nuestro plano a la carpeta dónde hemos guardado el programa,

que lo podemos descargar de: www.domoticaperlallar.blogspot.com

Una vez sustituimos la imagen que hay (la del plano de la maqueta) por la de nuestra

casa, solamente hemos de cambiar la posición de los botones que teníamos del plano

de la maqueta a los del nuevo plano. Para esto, primero nos hemos de descargar

Processing de http://www.processing.org/download/ para poder editar el programa.

Al abrir el programa lo primero que hemos de hacer es ir al apartado “void setup”

(fig.11) y sustituir la medida de la imagen (donde pone “size(1276,696)”) y el nombre

de esta (donde pone (“Planol.jpg”) por las medidas en píxeles del vuestro plano

(aparecen en las propiedades de la imagen) y el nombre del archivo donde habéis

guardado la foto de vuestro plano.

Una vez hecho esto, al clicar el botón de play se ejecutará un programa donde se

abrirá el plano de vuestra casa, pero con los mismos botones que teníamos en el plano

anterior. Ahora hay que sustituir la posición de estos botones por la de los nuevos

botones. Es una tarea laboriosa pero no complicada, como veréis a continuación.




3.1.2 Botones Para agilizar al máximo y modificar el mínimo de coses, a la hora de cambiar la posición

de cada botón tenéis que tener en cuenta el numero de luces, motores o botones

conectados a un sensor que tengáis. Así, si colocáis las coordenadas de vuestras luces

donde existe una luz en la maqueta, no tendréis que cambiar la función de este botón.

Veremos como cambiar las funciones en el apartado siguiente.

Para cambiar la posición de los botones hemos de abrir la imagen en Paint y colocar el

ratón en el vértice superior izquierdo de cada botón y apuntar los valores que nos de

que correspondan a las variables “x”, “y” de nuestro programa. Ahora hemos de

calcular la anchura y la altura de los botones desde estos botones hasta donde

queremos que lleguen. (Tomamos el valor “x” del lado derecho del botón y el restamos

al valor de “x” que teníamos, y lo mismo con

el lado inferior y la “y”, y nos darán los valores

“w” (width, anchura) y “h” (“height”, altura).

Una vez hemos hecho esto con todos los

botones (podemos escribirlo en una tabla de

datos como Excel para estructurarlo mejor, si

queréis podéis tomar como ejemplo la de mi

proyecto que está colgada en: .

www.domoticaperlallar.blogspot.com)

tendremos que sustituir los valores de la tabla

que hemos hecho en el nuevo programa.

Para hacerlo, iremos al apartado donde

definimos las variables de cada botón (fig. 12)

y sustituiremos los valores.

El número que sigue a cada variable “x”, ”y”,

”w” o “h” simboliza el número que hemos Figura 12




asignado a cada botón (1, 2, 3...).

También podéis editar los comentarios que aparecen en gris para aclararos mejor a la

hora de entender el programa, y poner nombres a cada botón en vuestro plano.

3.1.3 Funciones de los botones A pesar de haber intentado colocar las luces en los botones existentes de luces o las

persianas en los botones donde había persianas, siempre habrá botones a los que

habrá que cambiar la función. Este punto es el más crítico y donde podemos cometer

más errores.

Si necesitáis añadir un botón al programa, tenéis que tener en cuenta TODAS las partes

del programa, desde definir variable hasta definir las coordenadas o definir qué

sucederá cuando lo presionemos.

Primero hemos de definir

el nuevo botón en el

estado apagado, como

variable booleana,

encendido o apagado. Las

coordenadas del botón ya

las habremos estipulado

en el paso anterior. Si

queremos añadir un botón

(11, por ejemplo),

deberemos definir unas nuevas coordenadas (“x11”, “y11”, “w11” y “h11”) .

Esto lo haremos en la primera parte del programa (fig.13). Una vez hecho, el programa

ya reconoce el botón como una variable con unas coordenadas en la interfaz. Ahora

solamente falta explicarle que al clicar encima cambiaremos el estado de éste (de

apagado a encendido y a la inversa), y definir qué queremos que haga tanto cuando

está encendido como cuando está apagado.

Figura 13




Para activar/desactivar al presionar el ratón encima, tendremos que copiar una de las líneas del final del programa, el “void mousePressed”, y sustituir el valor de todos los números que corresponderían al número del botón anterior por el de nuestro nuevo botón, como en el siguiente ejemplo:

Por último, deberemos asignar la función que deseamos que haga, para lo cual

podemos copiar alguno de los ejemplos que he puesto ( luz, motor DC, motor Stepper,

sensor de temperatura o sensor de presencia) de la parte final del programa y sustituir

el número de botón por el de nuestro nuevo botón.

En el ejemplo de la imagen, el botón 1 al encenderse se pone de color verde (función

stroke) y activa la salida “PinMotor31” a la que hemos asignado uno de nuestros

motores.2 Al apagarse (else), se pone de color rojo y se apaga la salida. La función

“noFill” sobre el rectángulo de las coordenadas del botón la usamos solamente para

pintar de color verde/rojo el recuadro del botón, y no la parte de dentro.

2 Con el único objetivo de facilitar la comprensión del programa y saber a qué salida pertenece cada botón. Se podría evitar y poner directamente el número de la salida o entrada deseadas




3.2 Conexión a Arduino Ahora ya hemos finalizado la programación, que era la etapa más ardua, y tenemos un

programa funcional con botones que se encienden y se apagan sobre el plano de

nuestra casa. Además, el lampista ya habrá terminado con la instalación del cableado

de la casa y habrá conectado los actuadores (motores de persiana, luces, sistemas de

riego, …) y os habrá dejado un montón de cables. Lo único que falta es conectar los

cables de cada actuador o sensor a la entrada/salida correspondiente.

Figura 14




Para conectar correctamente el cableado que os ha puesto el lampista, tenéis que

reconocer donde ha de ir cada cosa. Si observamos la fig. 14, el esquema de

conexiones que hemos hecho para la maqueta, veremos que la parte izquierda (Analog

IN) es donde se conectan los sensores (temperatura, presencia humedad, ...). En la

parte derecha (PWM) y en su defecto si faltasen conectores, en la parte inferior

(Digital), es donde conectaremos las salidas (motores, luces, ...). Siguiendo este

sistema deberéis conectar cada uno de los cables donde le corresponda dependiendo

de la salida que le hayamos asignado en nuestro programa.

Siempre debemos especificar en nuestro “void setup” si las salidas las estamos

tratando como a salida o entrada, como en la figura 15, primero encendiendo la placa

Arduino con la función “Arduino = new Arduino (this, Arduino.list()[0], 57600)” y

posteriormente con la función “Arduino.pinMode” especificando cada una de las

salidas como “INPUT” o “OUTPUT”.

Figura 15




4.Conclusiones

4.1 Opinión del Trabajo Un trabajo así es una prueba de madurez que no solamente me ha demostrado los

conocimientos que he adquirido a lo largo del periodo estudiantil, sino que también

me ha hecho ver y desarrollar mi capacidad de moverme y buscar de manera

autónoma y autodidacta la información que requería para realizar el trabajo. Gracias al

trabajo he comprobado y mejorado la capacidad de soportar la tensión y la

responsabilidad de tener que entregar un trabajo sin que nadie esté constantemente

encima mío explicándome como hacer las cosas y guiándome en cada paso hasta

terminar.

Esta autonomía y responsabilidad del trabajo, hace realmente difíciles las decisiones

que has de tomar sobre cómo encaminarás tu trabajo, ya que de cada una de estas

decisiones depende el resultado final, y tu tienes toda la responsabilidad.

Personalmente se me hizo difícil escoger qué quería controlar en mi casa, qué era

esencial y qué no lo era, a la hora de automatizar una casa.

4.2 Objetivos conseguidos Aún y así, hemos podido demostrar lo que nos planteamos al principio: Hemos

demostrado que la domótica es cara porque así lo quieren las empresas, y que

podemos transformar nuestro hogar en una casa domótica nosotros mismos sin

apenas conocimientos, siguiendo esta guía. Hemos conseguido reducir el precio de la

automatización en aproximadamente un 80% (considerando que nuestra instalación

tiene la calidad de una instalación que comprada costaría unos 2500€, reduciéndola a

500€ que es lo que nos puede costar el lampista por el cableado completo y los

motores de persiana, relés, etc.…).




4.3 Posibles mejoras

4.3.1 Ampliación de los elementos A pesar de haber alcanzado nuestros objetivos, el proyecto está abierto a muchísimas

posibilidades. Lo podríamos mejorar aumentando el presupuesto del trabajo para

pones más sensores (luces que se activen con presencia o sonido) o más actuadores

(puertas automáticas).

Aun así, las bases para programar estos nuevos sensores o actuadores serían las

mismas, por lo que siguiendo esta guía podríamos mejorar el proyecto hasta dónde

quisiéramos, gracias a las infinitas posibilidades de programar con lenguaje Java.

4.3.1 Ampliación de los controladores A parte de ampliar los actuadores y sensores de nuestra casa, podemos mejorar la

comodidad con la que controlamos la casa. Estudiando los lenguajes de programación

de Apple o Android, podríamos crear una aplicación similar a la nuestra para

plataformas móviles como el teléfono o las tabletas (Ipad, …).

Esto abriría las puertas a posibilidades como recibir una notificación cuando alguien

entra en casa sin identificares o poder visualizar tu casa con cámaras desde cualquier

lugar del mundo a través de internet, además de poder controlar la casa desde donde

quieras.

Las placas Arduino que hemos utilizado tienen las puertas abiertas a todo el mundo de

internet a través de una librería llamada Wifi Shield que permite conectar tu placa a

internet desde tu casa para enviarte lo que necesites al móvil en cualquier momento y

a cualquier lugar donde tengas conexión.




5.Anexo

5.1 Elementos utilizados

5.1.1 Para la maqueta

Arduino Mega con cable USB

Soldador de estaño, estaño, soporte y

pasta para soldar




Pistola de silicona

Motores para las persianas y puente H

(L293D)

Timbre




Resistencias (330Ω y 220Ω)

LED’S

Emisor de Infrarrojos

Receptor de Infrarrojos




Termistor 1 (KY-13)

Termistor 2 (DS18B20)

5.1.2 Programas

Processing y

Arduino

instalados en

el ordenador




5.1.3 Plano




5.2 Maqueta

5.2.1 Maqueta antes de automatizar En las siguientes fotografías vemos la maqueta justo después de construirla con cartón

y cola termoestable. Es una casa cualquiera que inicialmente no fue construida para

ser automatizada, y por lo tanto no tenía ninguna preparación especial.




5.2.2 Como hemos conectado los elementos LED: Para conectar

los LED siempre lo

haremos con una

resistencia de 330

Ω en serie. Para

nuestro proyecto

hemos

aprovechado la

resistencia que

incorpora la placa

Arduino a la salida

13 especial para a

LED. Para los otros

dos hemos tenido

que conectar la

resistencia entre

el ánodo (pata

larga) y la salida.

Los cátodos (pates

cortas) van todos

conectados a la

tierra de la placa

Arduino (GND).




Motores DC:

Hemos conectado

los motores a

nuestro L293D tal

como se muestra

en la figura 5 de la

página 17. Para

reducir la

velocidad de los

motores hemos

conectado nuestro

puente H a 3V en

lugar de a 5V, ha

que si no las

persianas bajaban

demasiado

deprisa y podían

ocasionar

problemas.




Termistor 1:

Hemos conectado

el termistor tal

como muestro en

el diagrama de la

fig. 9 en la página

20: La pata

izquierda al GND,

la del medio a los

5V de la placa

Arduino y la pata

derecha a la

entrada 0 de la

placa. Pero al no

funcionar

correctamente

tuvimos que

sustituirlo por el

siguiente

termistor.




Termistor 2:

Para conectar el

segundo

termistor hemos

tenido que seguir

el datasheet de la

pág. 22 que nos

muestra como

hemos de

conectar la

resistencia de

4700 Ω que

hemos de

incorporar a

nuestro sensor. A

parte de esto, no

tiene otra

complicación, una

pata va a tierra y

las otras a 5V y la

pata 0 de las

entradas

analógicas, con la

resistencia entre

el voltaje y la pata.




Alarma:

Para conectar los

elementos que

vana a formar

nuestra alarma

(receptor IR,

emisor IR y

timbre), tuvimos

que incorporar

una resistencia de

330 Ω al emisor y

una resistencia de

22000 Ω al

receptor entre los

ánodos y la

salida/entrada. El

timbre lo

conectamos

directamente a la

salida

correspondiente.

Los cátodos y el

negativo del

timbre los hemos

conectado a tierra

(GND de Arduino).




5.2.3 Maqueta automatizada En estas imágenes vemos el proceso de automatización que sufrió nuestro hogar,

empezando por conectar a la protoboard los diversos elementos, después cableándola

con múltiples cables juntos, y finalmente la maqueta toda montada y preparada para

la demostración.




5.3 Programa Aquí está adjunto el programa:




6.Bibliografía

6.1 Libros

6.1.1 En formato PDF Éstos los podéis encontrar en mi página web www.domoticaperlallar.blogspot.com o

bien me los podéis pedir contactando conmigo. Mis datos de contacto aparecen en la

página web.

1. Gerhart, J: “Home Automation and wiring” (Mc Graw‐Hill Professional,1999)

2. Gavin Smith: “Arduino Cheat Sheet”

3. Jonathan Oxer y Hugh Blemings: “Practical Arduino”

4. Daniel Shiffman: “Learning Processing”

5. Ignacio Arata, Francisco Arrufat, Pablo Palacios y Santiago Folie: “Variaciones

de una resistencia con la temperatura”

6.1.2 En formato papel Éstos son los libros de consulta de la biblioteca o de familiares que me los han dejado

para solucionar alguno de los muchos problemas que han surgido a lo largo del

trabajo.

1. Ben Fry & Casey Reas: “Getting started with Processing” 2. Juan Mª Sarrió García: Manual de ayuda de Processing (adaptación de

“Processing: A programming handbook for visual designers and artists”)




6.2 Páginas web 1. http://www.smarthome.com/about_x10.html

2. http://arduino.cc/forum/index.php?

3. http://www.hispavila.com/3ds/atmega/motorescc.html

4. http://www.casadomo.com/noticiasDetalle.aspx?idm=10&id=10907&c=6

5. http://www.casadomo.com/noticiasDetalle.aspx?c=14

6. http://pscmpf.blogspot.com.es/2008/12/arduino-lm35-sensor.html

7. http://miqueridopinwino.blogspot.com.es/2012/07/como-utilizar-un-

termistor-o-sensor-de.html

8. http://tushev.org/articles/electronics/42-how-it-works-ds18b20-and-arduino

9. http://itmanageratschool.blogspot.com.es/2012/05/control-de-temperatura-

usando-arduino-y.html

10. http://www.wikipedia.org/

11. http://robots-argentina.com.ar/MotorCC_L293D.htm

12. https://sites.google.com/site/tecnologiavilatzara/home/altresprojectes

13. https://www.underground.org.mx/index.php?topic=24860.0

14. http://viver.disca.upv.es/~arduino/documentacion/sensores/

15. http://www.jeremyblum.com/category/arduino-tutorials/

6.3 Agradecimientos a los asesores Agradezco profundamente la ayuda que me han bridado las siguientes personas, que

han hecho posible continuar el trabajo en los momentos más difíciles:

Elisabet Alsina - Enginyeria en Telecomunicacions

Joan Alós – Enginyeria Agrónoma

Jaume Serra – Física y cátedra en matemátiques

Roberto Novo Ramudo - Enginyeria en Telecomunicacions

Joan Pellicer - Tecnóleg de l'IES Cendrassos de Figueres.

Domótica para todos I

Documents

Transcript of Domótica para todos I