En la anterior entrada sobre domótica asequible basada en Raspberry PI, aprendimos a controlar conexiones de la red eléctrica de casa desde una placa de ocho relés conectada a nuestra Raspberry PI.

Hoy veremos como controlar un total de dieciséis aparatos eléctricos gracias al circuito que implementamos anteriormente, y a las placas facilitadoras que me ha prestado Jordi de @electronics.cat y que ya pudísteis ver en el resumen del Hardware Freedom Day; diseñadas por el mismo, y cien por cien hardware libre.

Para esta práctica voy a usar la pi de tres ramales, que se encargará de adaptar todos los pins GPIO de Raspberry PI de 3.3V a 5V bidireccionalmente y nos permitirá trabajar con el segundo bus I2C reservado para la PiCam; también emplearé la placa de relés optoacoplados que utilicé en el anterior artículo sobre domótica.

Todo ello pone a nuestra disposición un total de dieciséis enchufes domotizados repartidos entre dos Raspberry, y con capacidad de expansión de hasta 128 en el caso de la pi de 3 ramales, ya que nos permite aprovechar los dos buses I2C sacrificando la posibilidad de utilizar el conector para la PiCam.

Para conectar la pi de tres ramales, debemos soldar los seis pins correspondientes al segundo bus I2C que no vienen soldados de fábrica, en estos momentos Jordi está trabajando activamente en una nueva versión de su placa para los modelos Raspberry PI B+ y Raspberry PI 2.

Podemos ayudarnos a soldar los pins sujetando las dos tiras de tres con jumpers, pero debemos asegurarnos de que estén lo mas alineados que nos sea posible en todo momento antes de proceder a soldarlos.

Ya podemos conectar la pi de tres ramales a la Raspberry que hemos modificado anteriormente aislando las dos placas, para lo que Jordi utiliza separadores plásticos de este tipo.

Para llevar a cabo la conexión con la placa adaptadora de relés, debemos doblar los pins de la placa de relés que vamos a conectar a la pi de tres ramales, ayudándonos con unas alicates; en la siguiente fotografía se puede apreciar el resultado final.

Dependiendo de la posición de los pins VCC y GND en nuestro relé, colocaremos este jumper del módulo de relés en una, u otra posición para invertirlos; siempre teniendo en cuenta que la placa de relés debe alimentarse mediante USB.

Modulo relés optoacoplados	Conector P3	Raspberry PI Modelo B
VCC	+ 5V	+ 5V
IN 7	Bit 0	GPIO 29
IN 6	Bit 1	GPIO 28
IN 5	Bit 2	GPIO 18
IN 4	Bit 3	GPIO 7
IN 3	Bit 4	GPIO 8
IN 2	Bit 5	GPIO 10
IN 1	Bit 6	GPIO 9
IN 0	Bit 7	GPIO 11
GND	GND	GND

En este momento procedemos a conectar la placa de relés optoacoplados directamente al GPIO de la otra Raspberry, en la siguiente imagen se puede ver el resultado final.

Las conexiones entre el GPIO de nuestra Raspberry serán las mismas que en el anterior artículo, sin embargo en este caso he añadido toda la tabla de conexiones.

Modulo relés optoacoplados	Raspberry PI Modelo B
VCC	+ 5V
IN 1	GPIO 3
IN 2	GPIO 2
IN 3	GPIO 24
IN 4	GPIO 25
IN 5	GPIO 23
IN 6	GPIO 27
IN 7	GPIO 22
IN 8	GPIO 4
GND	GND

Para ejecutar los scripts en python de la web que veremos mas abajo, primero tenemos que dar permisos al usuario www-data que es el usuario asignado al servidor web; para lo que primero instalaremos el servidor web apache como vimos en este anterior artículo y escribiremos sudo visudo en la terminal y al final del archivo añadiremos a www-data como sudoer, quedando el resultado final como a continuación.

# See sudoers(5) for more information on "#include" directives:

#includedir /etc/sudoers.d
pi ALL=(ALL) NOPASSWD: ALL
www-data ALL=(ALL) NOPASSWD: ALL

Para cada uno de los dieciséis pins GPIO empleados en esta práctica, debemos crear un subdirectorio, y dos scripts en Python; uno para encender, y otro para apagar el relé, veamos un ejemplo con el pin 11.

#!usr/bin/env/ python
#enciende.py
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(11, GPIO.IN)

#!usr/bin/env/ python
#apaga.py
import RPi.GPIO as GPIO
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(11, GPIO.OUT)

En cada una de las Raspberry PI colocaremos sus dieciséis scripts para apagar o encender los relés conectados a los pins empleados en cada una de ellas, que podéis consultar en las anteriores tablas; los scripts correspondientes a la Raspberry conectada directamente del GPIO a la placa de relés los colocaremos en el directorio /home/pi/reles/gpio.

Para crear la jerarquía de directorios y subdirectorios, y copiar los archivos programados en python utilizaremos estos otros dos scripts en Bash; el primero será el que ejecutaremos en la Pi conectada a la pi de tres ramales.

#!/bin/bash
#Raspberry PI con la pi de 3 ramales.

#Creamos la jerarquía de directorios.
mkdir /home/pi/reles/gpio
mkdir /home/pi/reles/gpio/11
mkdir /home/pi/reles/gpio/9
mkdir /home/pi/reles/gpio/10
mkdir /home/pi/reles/gpio/8
mkdir /home/pi/reles/gpio/7
mkdir /home/pi/reles/gpio/18
mkdir /home/pi/reles/gpio/28
mkdir /home/pi/reles/gpio/29
ls /home/pi/reles/gpio

#Y copiamos los scripts
cp enciende.py apaga.py /home/pi/reles/gpio/11
cp enciende.py apaga.py /home/pi/reles/gpio/9
cp enciende.py apaga.py /home/pi/reles/gpio/10
cp enciende.py apaga.py /home/pi/reles/gpio/8
cp enciende.py apaga.py /home/pi/reles/gpio/7
cp enciende.py apaga.py /home/pi/reles/gpio/18
cp enciende.py apaga.py /home/pi/reles/gpio/28
cp enciende.py apaga.py /home/pi/reles/gpio/29
ls /home/pi/reles/gpio/*

Los otros dieciséis scripts correspondientes al control de la Raspberry conectada a la pi de tres ramales los guardaremos en el directorio /var/www/rele/gpio/.

#!/bin/bash
#Raspberry pi con relé compatible con GPIO.

#Creamos la jerarquía de directorios.
mkdir /var/www/rele/gpio
mkdir /var/www/rele/gpio/4
mkdir /var/www/rele/gpio/22
mkdir /var/www/rele/gpio/27
mkdir /var/www/rele/gpio/23
mkdir /var/www/rele/gpio/25
mkdir /var/www/rele/gpio/24
mkdir /var/www/rele/gpio/2
mkdir /var/www/rele/gpio/3
ls /var/www/rele/gpio

#Y copiamos los scripts.
cp enciende.py apaga.py /var/www/rele/gpio/4
cp enciende.py apaga.py /var/www/rele/gpio/22
cp enciende.py apaga.py /var/www/rele/gpio/27
cp enciende.py apaga.py /var/www/rele/gpio/23
cp enciende.py apaga.py /var/www/rele/gpio/25
cp enciende.py apaga.py /var/www/rele/gpio/24
cp enciende.py apaga.py /var/www/rele/gpio/2
cp enciende.py apaga.py /var/www/rele/gpio/3
ls /var/www/rele/gpio/*

En este momento debemos crear un par de claves para que la Raspberry PI que aloja la página pueda ejecutar los scripts de la conectada a la pi de tres ramales de forma remota, como el usuario que lo hará es www-data debemos asignarle un password para poder hacer login y crear en su nombre el par de claves.

#Asignamos un password al usuario www-data
usuario@maquina:~$ passwd www-data

Introduzca la nueva contraseña de UNIX: 
Vuelva a escribir la nueva contraseña de UNIX: 
passwd: contraseña actualizada correctamente

#Creamos el par de claves RSA de 4096 bits
www-data@maquina:~$ ssh-keygen -b 4096 -t rsa

Generating public/private rsa key pair.
Enter file in which to save the key (/var/www/.ssh/id_rsa): 
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /var/www/.ssh/id_rsa.
Your public key has been saved in /var/www/.ssh/id_rsa.pub.
The key fingerprint is:
5a:dc:bd:af:0d:ae:9d:9f:bb:c2:d4:5b:dd:67:8d:18 tmo@tmo-K55A
The key's randomart image is:
+--[ RSA 4096]----+
|                 |
|                 |
|                 |
|       . . .E    |
|        S . .+ .+|
|       o    o.o B|
|      .    oo  +.|
|           oo=.. |
|          ..=+Bo |
+-----------------+

#Copiamos la clave pública a la otra raspberry
www-data@maquina:~$ ssh-copy-id pi@192.168.*.***                 
Number of key(s) added: 1

Now try logging into the machine, with:   "ssh 'pi@192.168.*.***'"
and check to make sure that only the key(s) you wanted were added.

Una vez creado el par de claves publica y privada, comprobaremos que podemos acceder por SSH sin introducir el password; para accionar desde la misma web los relés de distintas Raspberry de la misma red local, en este caso las he interconectado gracias al pequeño router libre WRTNode.

A continuación vamos a crear nuestra página de inicio que contendrá los botones tipo input que deberemos pulsar para ejecutar los scripts en Python desde una interfaz web mediante el método post; para este ejemplo voy a mostrar la web con solo cuatro salidas para que el artículo no sea demasiado extenso.

<html>
 <head>
                 <!--/var/www/rele/index.php-->
 </head>
 <body>

 <!--GPIO11--> 
 <form action="" method="post">
 Enchufe 0 [GPIO 11 - P3 Bit 7 - IN1]&nbsp;<input type="submit" name="encender11" value="Encender">
 <input type="submit" name="apagar11" value="Apagar">
 </form>
 &nbsp;&nbsp;

 <!--GPIO04--> 
 <form action="" method="post">
 Electrodomestico 0 [GPIO 04 - P4 Bit 7 - IN1]&nbsp;<input type="submit" name="encender4" value="Encender">
 <input type="submit" name="apagar4" value="Apagar">
 </form>
 <br></br>

 <!--GPIO09--> 
 <form action="" method="post">
 Enchufe 1 [GPIO 09 - P3 Bit 6 - IN2]&nbsp;<input type="submit" name="encender9" value="Encender">
 <input type="submit" name="apagar9" value="Apagar">
 </form>
 &nbsp;&nbsp;

 <!--GPIO22--> 
 <form action="" method="post">
 Electrodomestico 1 [GPIO 22 - P4 Bit 6 - IN2]&nbsp;<input type="submit" name="encender22" value="Encender">
 <input type="submit" name="apagar22" value="Apagar">
 </form>
 </body>
</html>

<?php

// Funciones PHP del pin GPIO 11
 if ($_POST[encender11]) { 
 $a- exec("sudo python /var/www/rele/gpio/11/enciende.py");
 echo $a;
 }

 if ($_POST[apagar11]) { 
 $a- exec("sudo python /var/www/rele/gpio/11/apaga.py");
 echo $a;
 }
// Fin de las funciónes del pin GPIO 11

// Funciones PHP del pin GPIO 9
 if ($_POST[encender9]) { 
 $a- exec("sudo python /var/www/rele/gpio/9/enciende.py");
 echo $a;
 }

 if ($_POST[apagar9]) { 
 $a- exec("sudo python /var/www/rele/gpio/9/apaga.py");
 echo $a;
 }
// Fin de las funciónes del pin GPIO 9

// Funciones PHP del pin GPIO 04

  if ($_POST[encender4]) { 
   $a- exec("ssh root@192.168.*.*** python /home/pi/reles/gpio/4/enciende.py");
   echo $a;
  }

  if ($_POST[apagar4]) { 
   $a- exec("ssh root@192.168.*.*** python /home/pi/reles/gpio/4/apaga.py");
   echo $a;
  }

// Fin de las funciónes del pin GPIO 04

// Funciones PHP del pin GPIO 22

  if ($_POST[encender22]) { 
   $a- exec("ssh root@192.168.*.*** python /home/pi/reles/gpio/22/enciende.py");
   echo $a;
  }

  if ($_POST[apagar22]) { 
   $a- exec("ssh root@192.168.*.*** python /home/pi/reles/gpio/22/apaga.py");
   echo $a;
  }

// Fin de las funciónes del pin GPIO 22
?>

Si queremos alimentarlo todo desde un único enchufe, debemos puentear todos los negativos de las salidas de 220V del relé.

Las conexiones a la red eléctrica las haremos de la misma forma que en la pasada entrada, adjunto los esquemas entre el enchufe y el interruptor magnetotérmico para facilitar el seguimiento de la práctica.

En la próxima entrega sobre domótica asequible aprenderemos a aprovechar los dos buses I2C gracias a la pi de tres ramales, y haremos una prueba de concepto controlando 128 leds intercambiables por aparatos eléctricos.

Si te ha gustado puedes seguirme en Twitter, Facebook, Google+, Linkedin, o compartirlo con los botones ubicados debajo de esta publicación, si tienes cualquier pregunta o sugerencia no dudes en comentar.