LEDs y switch para sistema de videovigilancia en Raspberry Pi

En este artículo es donde explico cómo he montado el hardware del sistema de videovigilancia, la parte física. Esto es, los LEDs y el botón de On/Off, y todos los scripts que hay detrás. Este artículo es un complemento al artículo principal.

Mi idea era, aparte de ser capaz de idear y ejecutar la parte de programas, investigar un poco de electrónica, cosa que nunca había hecho. Y la Raspberry Pi te lo pone muy fácil, gracias al puerto GPIO puedes interactuar con muchos sensores, LEDs, y demás dispositivos físicos.

GPIO para video vigilancia

Yo lo he hecho a mano, o sea, primero monté el sistema usando un protoboard y, una vez que estuve contento, pasé a armar una cajita con los LEDs y el botón. Pero existen HATs como este para la Raspberry Pi que, si no quieres complicarte con cables, protoboards y soldando, también son fáciles de montar. En ese caso igualmente los scripts que presento son igual de válidos.

Esquema físico y protoboard

Yo usé 4 LEDs, este esquema tiene algunos cambios de color con respecto al mío. Básicamente no encontré LEDs azules y amarillos. 🙂 Pero la idea es la misma.

  • Azul: es el testigo de que la videovigilancia está ejecutándose, en cualquier estado. LED siempre encendido.
  • Verde: sistema en standby, esperando activación.
  • Amarillo: sistema activado, no se detecta movimiento.
  • Rojo: ¡detecta movimiento!

Esquema GPIO para Video Vigilancia

Protoboard GPIO para Video Vigilancia

Una vez tengamos el “cableado” listo, hay que ponerse manos a la obra con los scripts.

¿Que deben hacer los scripts?

  • Al inicio de la Raspberry, activar los puertos del GPIO que tocan. Y supervisar cuándo apretamos el botón
  • Además, activar el LED azul (testigo de que el sistema de videovigilancia está funcionando) y encender el LED verde (sistema desarmado)
  • Cuando presionemos el botón, cambiar el estado del sistema (activado, desactivado o armando)

Scripts del inicio

Los siguientes son los scripts que tengo en /etc/init.d

GPIO.sh se encarga de preparar los PINs de la interfaz GPIO para que Python pueda encender y apagar los LEDS y pueda supervisar el switch. Si no ejecutamos este comando, no podremos interactuar con el puerto GPIO.

#!/bin/sh
### BEGIN INIT INFO
# Provides: GPIO
# Required-Start: hostname $local_fs
# Required-Stop:
# Should-Start:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Gestiona el puerto GPIO al arranque y stop
### END INIT INFO

#Script para preparar GPIO para VV
#PIN 27: LED amarillo
#PIN 17: LED verde
#PIN 22: LED rojo
#PIN 23: LED azul-monitor-always on

PATH=/sbin:/usr/sbin:/bin:/usr/bin
. /lib/init/vars.sh

do_start () {
 # Arrancamos GPIO

 echo Preparando GPIO de la Raspberry Pi

 #Creamos estructura GPIO en PINs deseados
 echo 17 > /sys/class/gpio/export
 echo 27 > /sys/class/gpio/export
 echo 22 > /sys/class/gpio/export
 echo 23 > /sys/class/gpio/export

 #Configuramos PINs de salida/entrada 
 echo out > /sys/class/gpio/gpio17/direction
 echo out > /sys/class/gpio/gpio27/direction
 echo out > /sys/class/gpio/gpio22/direction
 echo out > /sys/class/gpio/gpio23/direction

 #Encendemos los LEDS 2 segundos
 echo 1 > /sys/class/gpio/gpio17/value
 echo 1 > /sys/class/gpio/gpio27/value
 echo 1 > /sys/class/gpio/gpio22/value
 echo 1 > /sys/class/gpio/gpio23/value

 sleep 2s

# Apagamos LEDs, dejamos sólo el PIN 23 encendido (azul)
 echo 0 > /sys/class/gpio/gpio17/value
 echo 0 > /sys/class/gpio/gpio22/value
 echo 0 > /sys/class/gpio/gpio27/value
 
# Nos aseguramos que los scripts del usuario pi pueda interactuar con la interface GPIO
 chgrp -R gpio /sys/devices/platform/soc/20200000.gpio/gpio 
 chmod -R g+rw /sys/devices/platform/soc/20200000.gpio/gpio
}
 
do_status () {
 echo No implementado
}

do_stop () {
 echo Cerrando GPIO
 #Apagamos LEDs
 echo 0 > /sys/class/gpio/gpio17/value
 echo 0 > /sys/class/gpio/gpio22/value
 echo 0 > /sys/class/gpio/gpio27/value
 
 #Cerramos estrutura GPIO
 echo 17 > /sys/class/gpio/unexport
 echo 22 > /sys/class/gpio/unexport
 echo 27 > /sys/class/gpio/unexport
 echo 23 > /sys/class/gpio/unexport
 
}

case "$1" in
 start)
 do_start
 ;;

 restart|reload|force-reload)
 echo "Error: argumento '$1' no implementado" >&2
 exit 3
 ;; 
 stop)
 do_stop
 ;;
 status)
 do_status
 exit $?
 ;;
 
 *)
 echo "Uso: GPIO [start|stop]" >&2
 exit 3
 ;;
esas
:

boton.sh se encarga de iniciar al arranque, el script de Python que supervisa el switch.

#!/bin/sh
### BEGIN INIT INFO
# Provides:          BotonGPIO
# Required-Start:    hostname $all
# Required-Stop:
# Should-Start:
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Controla botó GPIO
### END INIT INFO

PATH=/sbin:/usr/sbin:/bin:/usr/bin
. /lib/init/vars.sh

do_start () {
	cd /home/pi/motion
        echo Arrancamos monitor de switch
        python switch.py &
}
               

case "$1" in
	start)
        	do_start
             	;;

	*)
		exit 3
		;;
esac
:


Hacemos que estos servicios se inicien al arranque

cd /etc/init.d
sudo update-rc.d GPIO.sh defaults
sudo update-rc.d boton.sh defaults

¿Y cuando apretamos el switch?

El script switch.py es un bucle infinito, que se queda esperando a que presionemos el switch. Cuando lo apretamos ejecuta otro script (en bash) llamado isrunning, que se encarga de cambiar de estado el sistema.

/home/pi/motion/switch.py

# Importa las librerías necesarias de Python
import RPi.GPIO as GPIO
import time
import os

GPIO.setwarnings(False)
GPIO.setmode(GPIO.BCM)
GPIO.setup(17,GPIO.OUT)

GPIO.output(17, True)
GPIO.setup(18, GPIO.IN, pull_up_down=GPIO.PUD_UP)

# Con while True nos aseguramos que el script se ejecute indefinidamente
while True:
 input_state = GPIO.input(18)
 if input_state == False:
 # Cuando el estado es Falso (presionado), ejecutamos isrunning
 os.system("sudo -u pi /home/pi/motion/isrunning &")
 time.sleep(5) 

El sistema puede estar en tres estados:

* En espera (motion desactivado)
* Armado – en ejecución (motion activado)
* Armando (desde que presionamos el botón, yo tengo configurado que motion se active en 5 minutos, para salir de casa)

/home/pi/motion/isrunning

#!/bin/bash
#Está funcionando la videovigilancia?

#PIN 27: LED amarillo
#PIN 17: LED verde
#PIN 22: LED rojo
#PIN 23: LED azul-testigo-always on

cd /home/pi/motion
# Si el sistema estaba armándose, cancelamos el armado
if [ -f arming ];
then
# Matamos el proceso sleep 5m 
 killall sleep
 sleep 10s
 rm arming
 ./yatoy
fi

if [ -f running ];
then 
# yatoy es el script para desactivar motion
 ./yatoy
else
# Armando sistema
 touch arming
# Encendemos luz amarilla y verde
 echo 1 > /sys/class/gpio/gpio27/value
 echo 1 > /sys/class/gpio/gpio17/value
# Esperamos 5 minutos para salir de casa
 sleep 5m
 rm arming
# Apagamos luz amarilla y verde
 echo 0 > /sys/class/gpio/gpio27/value
 echo 0 > /sys/class/gpio/gpio17/value
# Activamos videovigilancia
 ./mevoy
fi

Para que el script isrunning sepa en qué estado está, utilizo unos ficheros de bandera (flags) en el directorio /home/pi/motion

Si el fichero arming existe, hemos presionado el botón cuando el sistema estaba armándose. Con lo cual, el sistema tiene que pasar a stand-by. Matamos el proceso sleep, y luego ejecutamos yatoy (sistema desactivado)

Si existe el fichero running, es porque motion está activado. Simplemente lo desactivamos con el script yatoy.

En otro caso es porque el sistema estaba en stand-by. Procedemos entonces a armar el sistema. Encendemos los LEDs verde y amarillo, esperamos 5 minutos para salir de casa, y luego activamos motion con el script mevoy.

Y con estos ficheros, he logrado que el sistema de videovigilancia se active de manera fácil, que cualquiera pueda hacerlo, y además saber en cualquier momento en qué estado está gracias a los LEDs. 🙂

Si estás pensando en montarte un sistema de videovigilancia, espero con estos dos artículos haberte ayudado. ¡Y espero que me dejes un comentario!

No se admiten más comentarios