Domotica Low Cost con Raspberry PI

En esta ocasión me gustaría desviarme un poco de la temática principal de este blog para hablaros de un proyecto que he emprendido y del cual estoy bastante conforme con su funcionamiento, aunque a decir verdad, la utilidad es un tanto limitada.

HARDWARE

En primer lugar, el servidor bien, gracias.  El pequeño y robusto portátil Siemens con aproximadamente diez años de antiguedad sigue funcionando como el primer día, con incluso unos grados menos de temperatura y sin apenas mantenimiento. Sin embargo ahora toca hablar de otro pequeño proyecto que llevé a cabo hace unas semanas y que os voy a detallar a continuación… La Raspberry PI

RBPI

Como sabéis, la Raspberry Pi es  un mini ordenador con procesador ARM 700Mhz que tan sólo vale 30€. Como tal, es accesible al bolsillo de todos y cuenta con unas características muy interesantes.

La placa programable de bajo nivel que contiene llamó mi atención desde el primer momento. Mis nociones en electrónica eran limitadas, así que tuve que tirar de google para al menos aclarar ciertos conceptos básicos y descubrir qué posiblidades tenía. De lo primero que me cercioré gracias a la red de redes era la existencia de los puertos GPIO. Puertos de entrada-salida que pueden ser controlados por el usuario… vamos… que puedo aplicar 0 ó 1 cuando me plazca. También, claro está, puedo leer en qué estado se encuentran los mismos en el caso de interesarme.

Me regalaron la Raspberry PI en un hackaton y no le había prestado mucha atención por falta de tiempo y tampoco tenía claro realmente qué tipo de proyecto podía crear con ella. No tenía intención ninguna de usarlo como MediaCenter teniendo una SmartTV y mucho menos como sistema de escritorio… más que nada por la ausencia de monitor. ¿Servidor? ¿Otro? ¿Realmente me iba a poner a probar como servidor otro dispositivo y escribir sobre ello? Sí y no. Ya os daréis cuenta porqué.

Es entonces cuando nació la idea de poder controlar partes básicas de mi casa por medio de estos puertos. Pero antes de nada hablemos un poco de las peculiaridades de los mismos. En primer lugar, cuando el estado del puerto es 1, se aplica un voltaje de 3.3 voltios, cuando el 0, obviamente, ninguno, A ver cómo hacemos para que se lleven bien 3.3V DC con unos bonitos 220V AC que circulan por mi casa.

Antes de entrar en materia, quise hacer unas pequeñas pruebas y compré un Kit con las cosas básicas:

  • Protoboard
  • LEDs
  • Cables
  • Resistencias

Los LEDs eran de varios colores y no pude sucumbir a la tentación de hacer un bonito semáforo. Como la placa de la Raspberry no está protegida, tuve que tener especial cuidado al elegir las resistencias y tiré por lo alto aunque los LEDs no brillen en demasía. El lenguage de programación elegido para este caso es Python y tengo que decir que me ha sorprendido su potencia y facilidad.

La distro elegida para esta causa fue, naturalmente, Raspbian, la cual es la más fiel a Debian y además cuenta ya con el entorno de desarrollo Python instalado. Tan sólo tuve que instalar unas librerías para controlar los GPIO y listo. Como comentaba anteriormente, hice mis primeras pruebas con los LEDs y aunque llevo muchos años trabajando en el mundo de la informática, a mí me sigue todavía llamando la atención cómo podía hacer parpadear LEDs a mi antojo, no sé… llamadme romántico.

RELÉS

Los relés eran una parte básica del proyecto. Necesitaba algo puramente mecánico que dejara pasar la electricidad ante cualquier evento. Hay un sin fin de relés disponibles con varios rangos de entrada y salida, pero a decir verdad, eran todos muy limitados y ninguno cumplía con mis premisas. Algunos sí se adaptaban a mis necesidades, pero como bien dice el título del presente blog, quería algo Low Cost.

Después de plantearme construir algún tipo de circuito manual para manejar tales rangos, no sé cómo fui a parar a la página de un simpático americano más bien rellenito que me dio a conocer unas de los aparatos que acabaría radicalmente con mi dolor de cabeza.

SOLID STATE RELAY

Parecía un producto caído del cielo. Ya ni siquiera no era mecánico, que es maravilloso, sino que además manejaba rangos de entrada DC de 3 a 32V… y no os lo perdáis, el rango de salida  era AC de 24 a 380V con un máximo de 25A. En cuestión, este el producto que adquirí:

SSR-25 DA

Aunque hay un sin fin de marcas y modelos, finalmente me decidí como os he comentado por este en cuestión ya que aguanta más amperaje y por lo que pude ver, FOTEK es una marca “consagradísima” de electrónica de Taiwan. 🙂

Antes de entrar en materia, primero tenía que saber qué partes de la casa podía controlar y cómo. Mi morada no es nada del otro mundo… de hecho es pequeña y, bueno, en teoría eso me favorecía a la hora de los relés usados. Dispongo de un salón con cocina integrada, baño y tan sólo una habitación. También cuento con una terraza que dispone a su vez de iluminación.

El siguiente paso es sencillo… ¿dónde puedo colocar la Raspberry, los relés y el cableado? Pues en el único sitio donde se encuentra todo centralizado… en el cuadro eléctrico. Sí, a mi también me tembló el pulso cuando pensé en colocar allí un mini ordenador de 30€ con la bonita responsabilidad de salvaguardar la iluminación de mi casa.

Como ya he comentado, hice una pruebas básicas con Python controlando los leds y  los nuevos  relés para comprobar que efectivamente funcionaban observando sus estados . Lo siguiente era estudiar cómo estaba diseñada la instalación eléctrica y ver qué posibilidades tenía. Unos de los fusibles controlaba las luces del salón y de la cocina, recordad, integrada. El siguiente controlaba mi habitación y, maldición, también el baño. No era partidario de incluir esta fase dentro del proyecto, pero no tenía otro remedio.

Otro de los fusibles daba al traste con la energía de los enchufes. Pensaba yo, ufano, que serían los aquellos localizados en el salón y que habría otro extra para aquellos colocados en  la habitación. Pero no, cortaba la energía de todo lo enchufado excepto los enchufes que requirieran más potencia como lavadora, horno y frigorífico; ya que estos contaban con sus propios fusibles.

Para aquellos más avispados, atentos a la siguiente explicación. Como sabéis, la Raspberry cuenta con su puerto HDMI  y poder usar así un monitor, pero claro está que donde radica su versatilidad es en poder conectar por VNC y por SSH sin necesidad de tal armatoste. ¿Qué pasa si corto la energía de los enchufes? Tendría que conectarlos manualmente en el cuadro eléctrico o llevar el router a algún enchufe no afectado para recuperar la conexión con mi RBPI.

Mi lugar de residencia en una pequeña isla del Mediterráneo, y como tal, cálida como es, todas las casas cuentan con unos paneles solares en los tejados para generar agua caliente. El problema es que en invierno, a veces el sol no es suficiente y contamos con un interruptor en el pasillo para calentar el agua usando la energía eléctrica. Os cuento esto porque de ese interruptor, en vez de llegar como de costumbre el cable marrón de FASE, llegaban los dos, FASE y NEUTRO. Es así como fabriqué un enchufe de la nada y fuera de peligro y apagones. Al tener en router en modo repetidor, tampoco me hacía falta que llegase ningún cable de teléfono. El router repite la señal wifi de un hotspot de pago cercano y así me aseguro de que mi raspberry no pierde internet nunca.

Colocando la RBPI y la protoboard en la compuerta del cuadro eléctrico.

Colocando la RBPI y la protoboard en la compuerta del cuadro eléctrico.

Una vez decidido qué partes tenía la posibilidad de controlar, llegó el momento de montar el sistema con RBPI y relés en el cuadro electrico. Mi intención era que una vez todo montado, tuviera la posibilidad de cerrar de nuevo el armario, por lo que tuve que medir los espacios que tenía y poner las piezas en sitios concretos.

En la imagen publicada podéis ver en principio dónde coloqué la RBPI y la protoboard. Hay dos grupos de tres cables que provienen de los GPIO. Tres de ellos para los tres relés, y los otros tres para alimentar tres Leds que usaré como monitor de temperatura. Dado que el cuadro estará cerrado la mayor parte del tiempo, es posible que la temperatura suba mucho debido a que el aire de dentro no se renueva. Quiero encontrar una solución a eso, pero hasta entonces, un pequeño ventilador en el procesador bajaba la temperatura hasta los 38º. Es por eso que cuento con los Leds en forma de semáforo. Con un script en Bash y ejecutado cada minuto, visualmente puedo hacerme a la idea del calor que está pasando el sistema. Además, ahora he colocado los LEds en la esquina para poder así ver el color de los mismos con el armario cerrado.

  • < 38º – 42º VERDE
  • 42º – 47º VERDE-AMARILLO
  • 48º – 52º AMARILLO – ROJO
  • > 52 ROJO

Otro de los problemas que tuve a la hora de montar el sistema en el cuadro eléctrico fue la fuente de alimentación. La que yo tenía era tan sólo de 700mA y no era suficiente para mover Raspbian (SO), el dongle WIFI y una cámara que tenía pensado poner para monitorizar la casa en mi ausencia. Luego tuve la gran idea de comprar otra cámara y poder así alternar entre ver mi cuarto y en salón cuando más me plazca.

Es por eso que adquirí por Amazon una USB Hub compatible con Raspberry y alimentado por su propia fuente de 2A. Eso se tornaba también en un problema, ya que no sabía donde colocar dos fuentes de alimentación en un espacio tan reducido como el cuadro eléctrico. Y no, alimentar la Raspberry por usb usando el Hub no funciona ya que el flujo de intensidad fluctúa y la hace comportarse de forma inestable.

Diseño completo antes de acoplar la compuerta al cuadro eléctrico.

Diseño completo antes de acoplar la compuerta al cuadro eléctrico.

Así es como quedó el diseño preliminar antes de acoplarlo al cuadro eléctrico, aunque he hecho algunas pequeñas modificaciones que ya veréis en el vídeo. Como veis he conectado tan solo una masa de la entrada DC de la raspberry en serie al igual que la FASE en la salida AC. Los cables restantes van directamente conectados al cuadro electrico.

Fui consciente del peligro que entrama que todo la intensidad de corriente para por esos pequeños cables. De los relés no tengo que preocuparme, ya que aguantan un máximo de 25A. De los cables para alimentar luces, tampoco era problema, puesto que con toda la iluminación conectada, no llega tirando por lo alto a 400W. Pero de los enchufes tengo que tener especial cuidado, porque conectando el tostador + estufa + secador podríamos llegar a los 20A fácilmente y los cables no están preparados para semejante intensidad. Como se puede observar, los cables que uso, aun siendo FASE y NEUTRO, uso los dos para evitarme como he comentado, calentamientos innecesarios. Aunque sí es verdad que tengo mucho cuidado a la hora de enchufar cosas.

De todas formas, ahora que voy a contratar mi propio internet, creo que voy a tener que buscar otro uso al tercer relé y así de paso me  quito la preocupación de ver ardiendo el sistema entero por sobrecarga.

Así quedó el sistema una vez acoplado todo. Os aseguro que cierra perfectamente 😉

IMG_20130715_232538

 SOFTWARE

Sí, muy bonito, la puerta cierra perfectamente… pero ahora qué. Hagámoslo, pues, funcionar con algunas líneas de código. Mi meta era clara, quería hacer un programilla elegante y simple para mis propósitos. Aunque la aplicación en sí no va a ser utilizada por otros usuarios, quise aplicar un férreo control de validaciones y por supuesto, que admita en el caso de que los haya, nuevos relés para otra futura instalación. No os penséis una obra de arte, aunque en mi trabajo veo mucho código, no me considero un programador, aunque nunca es tarde si la dicha es buena.

Como comenté anteriormente, opté por Python para realizar la aplicación “Domo” ya que el entorno está instalado en la distribución Raspbian para RBP y verdaderamente es un lujo trabajar con él. Poco después de preparar el entorno, me sentía más cómodo programando en un editor con alguna ayuda integrada.

Me instalé para ello  PyScripter Portable disponible dentro de Portable Python y para modificar directamente los archivos de la Raspberry tiré, lógicamente, del magnífico WinSCP con una pequeña ayudita que hará las delicias de muchos… En lugar de tirar del editor por defecto, instalé aparte el Sublime Text 2 y lo definí como editor predeterminado del WInSCP. Una verdadera maravilla.

Mi idea era editar directamente los archivos en el editor con SublimeText, que en sí corrige varios cosas, ya que en Python hay que tener especial cuidado porque todo funciona a través de tabulaciones. Si en tiempo de ejecución ocurrían problemas que no sabía a primera vista interpretar, tiraba del PyScripter para detectar los fallos más fácilmente.

Empecemos destripando el código:


#!/usr/bin/env python
#
# Nombre: Domotica
# Lenguaje: Python

# Importo las librerias para manejar los GPIO

from time import sleep
import RPi.GPIO as GPIO
import sys

#Funciones

############################################
# VALIDO ARGUMENTOS ########################
############################################

# Recojo el numero de argumentos que recibe la aplicacion.

def parametres(p):

blink = False

if (p < 5 and p > 2):
 print "Missing arguments"
 sys.exit()

if (p > 5):
 print "Too many arguments"
 sys.exit()

if (p == 1):
 print "Domo has the followings values"
 read()
 sys.exit()

# Es una puta chapuza. Pero despues de las anteriores
validaciones, esta ultima quiere decir que el usuario
quiere invocar el parpadeo de la casa.

if (p != 2):
 blink = True

return blink

Desde el principio quería que la aplicación aceptara argumentos. Me parecía mucho más cómodo que crear un menú con diferentes opciones y de lo que se trataba era de accionar rápidamente cualquiera de los relés. Usé para ellos el atributo argv del objeto sys. Pueden pasar tantos argumentos como quieras siendo almacenados en un array.

Los argumentos de entrada son muy simples. Tan sólo introduzco 0 ó 1 para determinar el estado de los relés. Ahora comentaré porqué acepto más argumentos que los ya comentados.  Como veis, puedo aceptar más de un argumento debido a una propiedad que aún estoy intentando integrar para hacer parpadear las luces de la casa a mi antojo. Mi intención no es crear una casa de esas navideñas, sino que simule presencia en mi casa, ya que cuando vuelvo a la madre patria por vacaciones lo hago por un largo periodo de tiempo y nunca está demás tomar precauciones.

Tengo que madurar aún la idea, y voy a quitar esas líneas innecesarias que afean un poco el código. Prefiero hacer otro script que invoque a este programa para manejar la simulación ya que es algo que tan sólo usaré en días de largas ausencias.

##############################
# VALIDA LOS ESTADOS #########
##############################
# Valido si el estado introducido por el usuario es 0 o 1.
def StateValidation(states):

for elements in states:

if elements != "0" and elements != "1":
 print "Value " + elements + " is incorrect"
 sys.exit()

if len(states) != n:
 print "Max number of states is " + str(n)
 print "Input states by user: " + str(len(states))
 sys.exit()

return states

Esta función no tiene ninguna complicación. Tan sólo me aseguro que no cometa el error de introducir un estado que no sea 0 ó 1 y, obviamente, no intentar encender o apagar partes de la casa que no existen.

##################
# DO THE JOB ########
##################

def Action(states, parts, blink, interval = None, times = None):

 GPIO.setwarnings(False)
 if blink == False:

 x=open("/usr/local/bin/logs", "w")

for i in range(0, n):

 x.write(states[i])
 GPIO.setup(parts[i], GPIO.OUT)
 GPIO.output(parts[i],int(states[i]))

x.close

 else:

for i in range(int(times)):

print i

GPIO.setup(parts[i], GPIO.OUT)

if int(states[0]) == True:
 GPIO.output(17, 1)
 sleep(float(interval))
 GPIO.output(17, 0)

if int(states[1]) == True:
 GPIO.output(27, 1)
 sleep(float(interval))
 GPIO.output(27, 0)

 if int(states[2]) == True:
 GPIO.output(22, 1)
 sleep(float(interval))
 GPIO.output(22, 0)

 Action("111", parts, False)

####################
# READ FILE##########
####################

def read():

 x = open("/usr/local/bin/logs", "r")
 print x.read()
 x.close

Las líneas anteriores tampoco tienen complicación. Es básicamente donde se realizan las acciones que invoco desde el Main que veremos más tarde. En primer lugar me aseguro que el usuario no tenga intención de hacer parpadear la casa y simplemente me dispongo a apagar o encender las partes deseadas.

Antes de nada abro un fichero plano para guardar cómo quedarán los estados después de la ejecución. A continuación, simplemente con un simple FOR, recorro tantas partes como haya definido y se aplica el resultado. Si añado más relés a la vivienda, es una parte del código que no se debe tocar, puesto que la variable “n” almacena el número de relés de los que dispongo.

Por favor, ignorar las líneas referentes al parpadeo. Las dejo si por casualidad sirven de ayuda, pero semejantes líneas merecen arder en el infierno para siempre. Para terminar, defino la función que leerá el fichero que contiene el último estado de los relés. Será llamada si ejecutamos el programa sin argumentos.


###################################
 # MAIN ############################
 ###################################

def main():
 pass

if __name__ == '__main__':
 main()

room = 17
 plugs = 22
 hall = 27

parts = [hall, room, plugs]

# How many rooms are available in the house
 n = len(parts)
 # How many arguments input by the user.
 p = len(sys.argv)
 #GPIO ports
 GPIO.setmode(GPIO.BCM)

blink = parametres(p)

states = StateValidation(sys.argv[1])

if blink == True:

Action(states, parts, blink, sys.argv[3], sys.argv[4])

else:

Action(states, parts, blink)

El cuerpo MAIN tampoco puede ser más simple. Si ignoramos la comprobación que hago  para el dichoso parpadeo, no hago más que definir en un array las partes de la casa y el número de GPIO que tienen asignado.

Las restantes líneas contienen la llamada a la función “Action” y que puedo llamar de diferentes maneras depende, cómo no, de el dichoso parpadeo.  Simplemente añadía a la función el número de parpadeos y cuánto tiempo en segundos había entre ellos.

Hasta aquí la pequeña criatura que ilumina mis momentos de tiniebla. Insisto en que las cosas se pueden hacer mucho mejor y estoy abierto a toda crítica constructiva que se precie. Al fin y al cabo y como he comentado, ya no ejerzo la programación y tan sólo la tengo como hobbie.

FRONT-END

Supongamos que llego a casa después de un arduo y sinuoso día de trabajo. Debido al calor sofocante he bebido cantidades ingentes de agua y requiero vaciar la vejiga y no es plan de orinar a oscuras. Pues queda muy bien la pantallita negra para fardar con los colegas, sin embargo es de agradecer contar con una interfaz donde poder apagar y encender fácilmente las luces. Si a eso le añades unas camaras conectadas a la RBPI, la fabulosa idea empieza a tomar forma.

Insisto que el único usuario soy yo, pero ya lo dice el refrán… “las cosas bien hechas, bien parecen”. Sí he realizado bastante diseño web y he toqueteado muchas cosas, pero juro que odio con todas mis fuerzas todo lo relativo a HMTL, CSS y la madre que los paseó a todos. Aún así me armé de valor para realizar una simple interfaz donde pudiera visualizar las imágenes de la habitación y el salón y además unos botones muy monos para manejarlas.

Me compré dos cámaras muy simples Logitech c130 que funcionaban sin la necesidad de instalar ningún driver e instalé el software “motion” que aunque no es del todo fácil, pero con la ayuda de internet y una tarde tienes lo básico para hacerlo funcionar.

Aunque tampoco es lo más elegante, usando PHP tienes la intrucción “exec” donde puedes ejecutar cualquier comando en la máquina remota. Me venía de perlas para mi propósito, sin embargo había una cosa con la que no había planeado. El uso de un enlace, sea un link o un botón, conlleva que la página web se recargue. No era un problema muy grande, pero quería evitar que con cada pulsación el usuario tuviera que esperar a que las imágenes se generaran otra vez.

Tuve algunos problemas de ancho de banda con los usb que solventé bajando la calidad de las imágenes y ya por fin soy capaz de visualizar las dos cámaras sin problemas, pero con un retraso de unos cuatro segundos. Motion también te ofrece la posibilidad que ejecutar cualquier comando sea cual sea el evento. Por ejemplo, puedo hacer parpadear las luces si detecta movimiento e incluso hacer sonar por los altavoces una alarma y ahuyentar así a los cacos.

Volviendo a la interfaz web y evitar así que la página recargue, me centré en el uso de AJAX y con una función para cada relé me las apañé para poder encender y apagar con sólo apretar el botón. Fácil, sencillo y puedes visualizar en la cámara sin cortes si la acción ha dado resultado o no.

He aquí la página web.

Interfaz Web

Interfaz Web

Pasando el cursor por las imágenes de la cámara, se mostrará unas flechas que te permiten visualizar la otra cámara. Pedí por DX un servomotor y será el paso siguiente del proyecto junto con unos altavoces para no sólo hacer sonar alarmas, sino también como un equipo decente de sonido mientras hago las labores del hogar.

El servomotor me permite con una solo cámara hacerla girar los grados que desee y poder visualizar incluso el baño. Los controles se añadirían en la interfaz web y es a día de hoy el siguiente paso y que documentaré tan pronto como lo instale. Obviamente perdería las prestaciones de “detector de movimiento”, pero creo que vale la pena.

Lamentablemente no os puedo dar la url de la interfaz web porque quiero vivir tranquilo sin tener que sufrir decenas de apagones diarios. He creado también un simple script para levantar y desactivar la interfaz cuando me plazca dejando tan sólo el servidor SSH como método primario.

En definitiva el proyecto puede crecer mucho, pero siendo honesto no tiene mucha utilidad. A todo mortal nos gusta pulsar el interruptor para que luz se encienda y no tener que ir con el teléfono pulsando botones todo el tiempo. Además, aunque a día de hoy la Raspberry me está respondiendo perfectamente, el hecho de que un dispositivo de 30€ sea el que mantenga la luz de mi casa es cuanto menos una locura. Aunque he sido lo suficientemente cuerdo para dejar fuera de la ecuación al frigorifico y demás electrodomésticos por si acaso ocurre algo en mi ausencia.

Bienvenidos sois todos de darme nuevas ideas y, por favor, corregirme si en algo me he equivocado o se puede hacer mucho mejor en lo referente al código publicado, ya que de la interfaz web ni me atrevo. Por último, os dejo un vídeo de demostración para que veáis el sistema funcionando in situ.

Anuncios

78 pensamientos en “Domotica Low Cost con Raspberry PI

  1. […] Cómo domotizar tu casa con una Raspberry PI y por 60€.   […]

    • Paco dice:

      Quisiera hacer una puntualizacion sobre los reles. Pretendes instalar unos reles puramente mecanicos y has instalado unos reles de estado solido que son todolo contrario, es decir son totalmente electronicos. Si bien son mejores que los mecanicos para algunas aplicaciones pueden dar problemas en otras en funcion de la carga que se les conecte. Por otra parte son mas faciles de manejar desde la Raspberry ya que necesitan muy poca corriente de disparo y asi se evita una electronica añadida.

  2. Fran dice:

    Estupendo trabajo

  3. felisuco dice:

    Hola yo también tengo un sistema de domótica funcionando casero, he probado con un cubox que es como un raspberri pi pero al fina uso un portatil por la potencia de cálculo ¿potencia de cálculo para que? Deteccion de movimiento y grabación de video, Si quieres saber mas te dejo mi mail a ver si me curro una web un saludeo y te sigo, me mola poder tener reles de bajo coste controlados por una rasberri pi seguramente lo use para tener relés ips de bajo coste…

  4. Ana Voytieso dice:

    se dice “corregidme” 🙂

    El resto muy guapo

  5. Ayoze dice:

    Estupendo el uso de los relés de estado solido… como recomendación puedo decirte que puedes añadir detrás del relé un TRIAC para controlar la intensidad de la luz con la onda PWM que puedes sacar del mismo RPi!

    • Gorgue dice:

      Hola, yo estoy empezando mis pinitos con la raspberrypi, y he estado buscando el dispositivo para controlar la intensidad! no sabia que era un TRIAC, hasta leer tu comentario. Sabes de algun ejemplo en ebay o dx para comprar y yo aprender a comparar. Gracias

  6. Stark dice:

    Con un móvil android con autoremote, triumfas 🙂

  7. David Malz dice:

    Excelente trabajo, me gusta tu forma de pensar, muy similar a la mia!

  8. Antonio dice:

    para los mortales que no sabemos de programación o electrónica tenemos que conformarnos con ver proyectos comerciales tipo Wattio o Dymotics u otras marcas más comerciales y caras.

    • No te preocupes, soy desarrollador pero me considero nulo en electrónica. Y para decir verdad, el invento no tiene mucha utlidad excepto para simular presencia en casa. Leyendo se consigue todo. Animo y gracias.

  9. Échale un vistazo a https://code.google.com/p/openhab/ yo lo tengo montado con mi raspberry pi (30€), y por RF controlo tres enchufes http://www.amazon.es/Elro-AB440S-3C-distancia-importado/dp/B002QXN7X6/ref=sr_1_1?ie=UTF8&qid=1379625631&sr=8-1&keywords=enchufes+remotos (16€) mediante una placa emisora de RF http://dx.com/es/p/433mhz-rf-transmitter-receiver-link-kit-green-221225 (5€) que sustituye al mando de los enchufes. Con esto no tengo que desarrollar la interfaz (uso openHAB y lo puedo usar desde smartphone, pc, etc), y no tengo que modificar el cuadro eléctrico. Ahora estoy en el paso de usar mi propio emisor/receptor, para controlar más cosas además de la corriente de un enchufe…

    • FresyMetal dice:

      Hola campeón estoy intentando hacer lo mismo que tu con los enchufes, me podrias decir como has hecho el montaje y que codigo usas’??
      gracias es que no hay mucho sobre esto en especial jejee

      • Buenas,
        tengo conectado el emisor de 433MHz a un pin de raspberry, con el código que puedes ver en https://github.com/r10r/rcswitch-pi aparece un ejemplo de como controlar dichos enchufes ejecutando un comando en la consola de raspberry pi. Es el que yo he utilizado. Al programa le pasas como parámetros el identificador del enchufe y si quieres encender o apagar.

      • Uso Python y el montaje como ves lo he hecho “de aquella manera” y directamente en el cuado de mandos.

      • Muchas gracias Angel. Estoy usando esa librería para hacer una pequeña aplicación en Android. Pero me hacía ilusión hacer la mía propia en Python y poder jugar más con las posibilidades que tengo. Gracias por tu aporte.

  10. AntonioNav dice:

    Para las cámaras, si no necesitas detección de movimiento, puedes usar mjpeg-streamer http://sourceforge.net/projects/mjpg-streamer/ es más ligero que motion, eso sí, sin detección de movimiento.
    Yo lo tengo montado en un raspberry y enciendo y apago la cámara en remoto cuando quiero.

    • Tienes razón, porque ahora mismo motion cuando recibe peticiones empieza a subir la temperatura bastante. En cuando me llegue el servomotor y la camara se mueva no me hará falta y le daré una oportunidad.

      Espero que sirva también para transmitir imagen por la web. Un saludo.

  11. Juan dice:

    Buenas! 🙂

    Por curiosidad… ¿Qué usas cómo alimentación de la Raspberry Pi? He tenido problemas con algunos cargadores de móvil…

  12. Tequi dice:

    Grande la idea y grande tu, y la web es buenisima

  13. Jorge dice:

    No cese… no cese el ingenio aunque pese…

  14. BrunoVD dice:

    Hola, muy buenas. Felicidades por el artículo. Me encantaría hacerte una propuesta si me dejas tu correo. Es alucinante la cantidad de soluciones que puedes idear con Raspberry. Me ha motivado el artículo aprobar más cosas. Saludos y enhorabuena

  15. Hola, felicidades por tu proyecto!

    Yo tengo uno parecido en un chalet cerca de Alicante (España) y creo que he solucionado algunos de los problemas que tu tienes con el tuyo: el problema del calor en espacios cerrados, el poder usar los conmutadores de las luces que ya tienes instalados en casa junto con los reles y que se enciendan y se apaguen como deben, etc… Si quieres te puedes pasar por mi blog (trasteandoarduino.blogspot.com.es) y echarle un vistazo a lo que he bautizado como JDomo, y que de momento funciona bastante bien. Es parecido a lo que has usado tu: una RPi, con un arduino para gestionar los sensores, reles, y demas, junto a un hub usb alimentado de 3A, un router 3G para poder conectarme desde cualquier sitio y un sistema para enviar alertas por SMS, …

    Espero que te guste, y si quieres podemos ir avanzando juntos… 🙂

    Ahora estoy desarrollando el modulo para gestionar el riego por goteo, pero lo tengo aun en una version muy preliminar y por probar… 🙂

  16. juanitol dice:

    Muy bueno lo de los relé de estado sólido, yo estuve probando con relés normales pero se cuelgan cuando menos te lo esperas :S. Muy buen artículo!

    • Están dando mejor resultado que esperaba. Cuando hago parpadear la casa tienen una respuesta buenísima. El problema es que se calientan cuando pasan por ellos aprox 7-8 amperios. Un saludo

  17. maik dice:

    Hola! Muy bueno! Yo tengo hecho el mio con Arduino y modulos X10. Si os apetece echarle un vistazo… http://negarduino.blogspot.com.es/2012/08/negamatik-x10-arduino.html

  18. H dice:

    Enhorabuena, está muy muy chulo.

  19. Toni dice:

    mis 10! gran trabajo y muy interesante, hace tiempo que estoy mirando que cosas puedo hacer con Raspberry y creo que la voy a comprar para trastear con cosas de este estilo.

  20. azzurro dice:

    Yo tengo un RaspBMC (Raspberry Pi + XBMC), una de las primeras (junio 2012, 256MBytes). La alimentación la hago desde el bus USB 2.0 que le tengo conectado, así que sólo tengo una fuente de alimentación (la del bus) .Tengo conectado: teclado+ratón infrarrojo en USB, dongle wifi, disco duro USB 2.0, llave memoria USB, salida video composite, audio analógico. Eso sí, no la tengo overclocked. La SD card es de 32GB tipo 10.

    Para mi peque tengo otra SD Card con Raspbian, para que use el Scracth.

    Hay un sitio en Zaragoza creo, que venden kits de Raspberry Pi : http://www.libelium.com.
    Tanbién venden waspmotes con sensores y kits Arduino-Raspberry Pi.

  21. Noesreal dice:

    Reblogged this on SIESREAL and commented:
    Añade tus pensamientos aquí… (opcional)

  22. Isidoro dice:

    http://es.wikipedia.org/wiki/Copyleft Muy buen trabajo, felicidades, te ruego que leas sobre el enlace que te adjunto con la finalidad de que te cubras un poco las ideas, Creo en las buenas iniciativas pero al menos si evolucionan o crecen que tengan testigo de quien las inicia, un saludo.

  23. Pepevilluela dice:

    Muy bueno. Si a alguien le gusta en un viejo experimento usé un viejo móvil Siemens como modulo gsm y un relé de sparkfun de 30A que no se si es más barato que el de estado solido, pero creo que sí:
    http://cacharreoelectronico.blogspot.com.es/?m=1

  24. Maite dice:

    Eres una máquina!!

  25. La verdad es genial lo que haces, no solo por la idea sino por las ventajas que esto tiene. Con solo imaginar que una persona en una silla de ruedas totalmente inmóvil pueda mezclando estas cosas con un soft que le reconozca el movimiento de ojos prender y apagar cosas de su casa a este costo es impagable. Muchísimas felicitaciones por tu idea!

  26. Paco dice:

    Respondiendo a Ayoze. No es necesario instalar un triac para regular la luminosidad, ya que los reles de estado solido son basicamente eso, un triac. Basta con aplicar la señal PWM a la entrada del rele de estado solido.

  27. Gesvaltica dice:

    Muy buen tutorial. Seguro que lo probamos.

  28. villanovano dice:

    Reblogged this on villanovano and commented:
    Otro gran post, en este caso para utilizar un raspberry pi y montar un sistema domótico en casa. Dan ganas de ponerse con ello mañana mismo. Otro post top quality… Enhorabuena gomezbecerra25.com!

  29. villanovano dice:

    Un post excelente. Menudo trabajo de hacerlo en primer lugar, fotografiarlo, escribirlo, explicarlo, etc. Currazo!

  30. sergio dice:

    Muy buena informacion! Gracias!!

  31. legoisa dice:

    Chemito sigues siendo todo un friki! Me ha gustado mucho tu invento! 🙂

  32. Jose dice:

    Hola!! En primer lugar felicitarte por tu gran trabajo.
    Soy un estudiante de ingeniería telemática y estoy haciendo el proyecto de fin de carrera basado en domotica con la raspberry pi. Mi problema lo tengo con la aplicacion web para controlar todo y la tuya veo que es muy chula. Me gustaría saber cómo la has hecho con mas detalle (si es posible) porque no tengo mucha idea de como hacerlo.
    Espero tu respuesta!
    Muchas gracias!!!

    • Hola Jose. En un simple comando PHP llamado “exec” que ejecuta un comando en el ordenador que acoge el servidor, en este caso la raspberry. Lo unico ue quiero evitar es que la página se recarge y para eso uso ajax. Ahora no tengo tiempo, pero te daré más detalles.

      • Jose dice:

        Muchas gracias. La verdad es que no tengo ni idea de php ni de ajax asi que me vendrían muy bien unos consejillos. Espero tu respuesta cuando tengas un hueco, mi correo por si lo prefieres enriquez86@gmail.com.

        Muchisimas gracias de verdad!

  33. setterlee dice:

    Oye sabes que quiero hacer esto mismo en mi casa pero me surge una duda. Como haces para tener este proyecto y no perder la operatividad del interruptor común? Cuando uno quiere tener en un bombillo dos interruptores se hace uso de lo que llamamos conmutador pero en este caso dudo que los reles que se usan en este proyecto te permitan hacerla de conmutador. Existe algo distinto a los reles paea eso? O como le haces? Porque me parece que ya no apagas y prendes loa bombillos con loa interruptores comunes. O bien, puede que si los prendas con el interruptor común pero si en el RBPI mandas a apagar, no se apagará porque tienes al interruptor común mandandole corriente. No se si me explico. Gracias

    • jdiazgorriz dice:

      Si que puedes usar un rele normal como pareja para un interruptor y que funcionen los dos, si buscas en google por ‘control de luces con rele y conmutador arduino’ te sale un esquema que hace un tiempo llevo usando yo en casa 🙂 y funciona bastante bien… Ademas puedes usarlo con un cruzamiento para tener varios interruptores y un rele (o varios) siguiendo el mismo montaje.

  34. setterlee dice:

    Amigo excelente blog. Quiero hacer algo así en mi casa pero me surge una duda. Al hacer esto se pierde la funcionalidad del interruptor común de los bombillos? Porque para tener más de un interruptor en un solo bombillo se requiere un conmutador a menos que se mantenga un interruptor común pero en algún punto uno de los dos no apagará el bombillo porque siempre habrá un interruptor alimentando el bombillo. No se si me explico. Gracias

  35. txemi dice:

    Hola, me pareció interesante el artículo. Periódicamente suelo mirar el estado del arte de la domótica doméstica de bajo coste. Reformé la casa y aunque sí metí red local y comunicaciones no me decidí por domotizar aún porque no me sentí convencido por ninguna solución y simplemente he dejado cajas y tubos estratégicos para hacerlo en un futuro cuando lo vea más claro.

    Ambiciono tener domotizadas persianas, calefacción, sensores baratos de todo tipo pero lo que no veo claro es el bus con el cual integrar todo esto y finalmente controlarlo desde un equipo con software que yo controle (software libre). No veo un claro ganador entre lo que existe en lo referente a tecnologías de bus y las tecnologías de radio no me convencen por seguridad. Por otro lado los electrodomésticos comunes aún no están preparados para integrarse de manera sencilla en una red de este tipo lo cual me inspira que pasarán cosas interesantes en este área en los próximos años.

    Me ha gustado mucho el dispositivo SSR-25 DA que has usado para controlar algunos elementos, me lo anoto para un futuro.

    Creo que hay suficiente interés en estos temas como para tener una comunidad y compartir información. ¿Qué os parecería crear dicha comunidad en alguna de las plataformas gratuitas que ya existen?

  36. jpardobl dice:

    Aquí os dejo un link a un proyecto que estoy llevando a cabo para domotizar con la Raspberry: http://jpardobl.com/home-automation-python-project/

  37. Añep dice:

    Buenas tardes, una duda. Estoy haciendo pruebas con el mismo relé que has utilizado, una Raspi y controlando una bombilla de bajo consumo. El problema que tengo es que cuando el rele esta OFF, aún así, parece que circula algo de corriente y hace parpadear la bombilla cada segundo.

    Con una bombilla de filamento de toda la vida no ocurre, imagino que porque necesita mas para lucir.

    ¿Te ha pasado algo parecido? ¿Se te ocurre porque podría ser?

    Saludos, muchas gracias por el magnifico trabajo y que lo compartas 😉

    • Ayoze dice:

      Buenas,
      ¿Tienes material de medición a mano? Yo miraría con un osciloscopio la tensión en la pata de la raspberry con la que excitas el relé para aislar el problema.. es decir, si viene del relé hacia la raspberry, o del relé en adelante (circuitos de baja y de alta tensión).

      Saludos y suerte!

      • Añep dice:

        Buenas,

        Gracias por contestar Ayoze. Lo he probado desactivando por completo las Raspi, dejando solo el rele con el cable de la bombilla, y hace el mismo funcionamiento, parpadeo continuo, midiendo da voltaje variable cuando esta en corte, de 64 a 120v, lo que provoca el parpadeo.

        Revisando un poco por internet, parece que aveces ocurre con los reles de estado solido (SSR), ya que tienen cierta fuga, que provoca este funcionamiento extraño.

        En el siguiente enlace, el último comentario indica lo que me ocurre a mi, al poner una lampara compacta fluorescente (CFL), las típicas en espiral:

        http://www.raspberrypi.org/phpBB3/viewtopic.php?f=37&t=57965&p=440276&hilit=SSR#p440276

        Por lo que entiendo, según el uso que se le vaya a dar, hay que usar un tipo de rele u otro.

        Saludos.

    • Sí, sí pasa por la naturaleza de las bombillas de bajo consumo. YO tenía tres conectadas al mismo circuito y no me pasaba, pero en cuanto quité una me empezaban a parpadear. Estas bombillas contienen fosforo es la parte visible, pero por sí solo no actúa, lo que sucede en la mayoría de los casos es que están bajo la influencia de campos electromagnéticos invisibles para nosotros, tales como lineas de alta tensión, fuentes de alta frecuencia y similares.

      Si tienes 220v entre fases, no tienes neutro que todavía se puede ver en muchos sitos, una solución es poner un interruptor doble (corta los dos hilos) y entonces el parpadeo desaparece (no el reflejo que dura solo unos segundos) el problema es que solo lo puedes poner en una cocina donde solo tienes 1 interruptor y no en las habitaciones donde hay conmutadores y cruzamientos.

      Échale un vistazo a este vídeo. Es algo común incluso en viviendas habituales. A mí me pasa lo mismo y lo he solucionado uniendo otro circuito para que absorba esa fuga.

      • Añep dice:

        Muchas gracias, muy buen video. Ahora ya lo he entendido a la perfección 😉

        Saludos.

  38. […] para ver pelis con calidad 1080p en tu salón hasta un sistema de control domótico para controlar las luces o la temperatura de tu hogar, pasando por utilizarla para emular juegos o incluso crear una […]

  39. […] uno es manitas puede seguir esta guía https://chemise23.wordpress.com/2013/09/19/domotica-con-raspberry/ . Es un sistema básico, pero muy barato (unos 80 € […]

  40. […] la comida en función del código de barras o incluso las órdenes por voz, convertir tu casa en una vivienda domótica por poco dinero, un smartphone hecho en casa… Las posibilidades son […]

  41. […] me dispongo de nuevo a documentar la nueva versión del sistema de domótica que ya desarrollé en entradas anteriores y enumerar las nuevas características con las que lo he […]

  42. ander garitano dice:

    Ojo. Que los SSR necesitan normalmente disipador de calor. Creo que con todo cerrado en la caja eléctrica la cosa puede estar ahí ahí.

    • Hola Ander. Gracias por tu apunte. La verdad es que tengo un ventilador apuntando directamente a los SSR por si acaso. Pero tengo que decir que me ha sorprendido su comportamiento en referente a la temperatura.

  43. Marc dice:

    Me gustaría preguntar:he adquirido hace unos días el relé fotek y el problema que tengo, una vez le doy tensión a este, tarda un buen rato a encendre la luz. en Cambio para apagarlo va rápido…

  44. Ignacio Rubin dice:

    Hola, buenas tardes,

    Vuelvo a repetir mi pregunta, en un raspberry pi 2 todo va perfectamente, pero me resulta imposible de instalarlo en un Raspberry pi 3, podrías aclararme por favor?, gracias

    Ignacio

  45. […] Seguir leyendo el tutorial | gomezbecerra25.com […]

  46. Buenas tardes, muy buen proyecto. Yo quiero montar algo similar para poder controlar la carga de mi vehiculo electrico, para sustituir al reloj analogico que tengo pues se activa todos los dias las X horas que tenga asignado. Con tu proyecto el rele ssd podria gobernar el enchufe del cargador del coche y a traves de una interfaz web poder encenderlo/apagarlo, e incluso hacer algun script para que pasandole el porcentaje de carga que quiero que tenga la bateria asi como el SOC (estado de carga de la misma) y los amperios a los que funciona el cargador (10 o 16 Ah), calcule el tiempo estimado de carga y la raspberry encienda/apague el enchufe en consecuencia.
    No se si lo ves factible.
    Un saludo.

    • Hola Antonio. PUes en teoría sí debería ser posible. En tu caso antes de hacerlo deberías saber cuánto amperaje consume el cargador exactamente para así elegir el SSR correcto (los hay hasta de 40A). Pero si dices que va de 10 a 16, con el de 25A te sobra.

      Y sí, podrías muy fáil medir la carga de batería y pasarselo a la RAspberry por medio de los puertos. Un saludo.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

A %d blogueros les gusta esto: