Instalación de un sistema de alarma utilizando una Raspberry

SERGIO MUÑOZ DE MORALES ÁLVAREZ
COLEGIO SALESIANO “HERMANO GARATE” | C/RAMIREZ DE ARELLANO Nº 1, 13001, CIUDAD REAL
INSTALACIÓN DE UN SISTEMA
DE ALARMA UTILIZANDO UNA
RASPBERRY

2
Índice
Memoria descriptiva ..................................................................................................................... 3
Definicion del proyecto............................................................................................................. 3
Objetivo del proyecto................................................................................................................ 3
Datos del equipamiento a utilizar............................................................................................. 3
Conexión de los componentes...................................................................................................... 5
Conexión del sensor HC-SR04 ................................................................................................... 5
Conexión de la cámara PiCam................................................................................................... 5
Instalación y configuración del sistema operativo Rasbian .......................................................... 6
¿Qué es Raspbian? .................................................................................................................... 6
Instalación de Raspbian............................................................................................................. 6
Configuración inicial de Raspbian ............................................................................................. 6
Programación del script en Python............................................................................................... 7
¿Qué es Python? ....................................................................................................................... 7
Idea del programa..................................................................................................................... 7
Instalación del servidor web Apache ........................................................................................ 8
Configuración del cliente de correo electrónico Mutt.............................................................. 9
Programación del script ............................................................................................................ 9
Funcionamiento del script......................................................................................................... 9
Pliego de condiciones.................................................................................................................. 11
Definición y características técnicas de los equipos a utilizar................................................. 11
Planos.......................................................................................................................................... 12
Plano de conexiones de los componentes en protoboard ..................................................... 13
Plano de conexiones de componentes en Raspberry ............................................................. 14
Plano de conexiones completas de los componentes ............................................................ 15
Plano planta del montaje real................................................................................................. 16
Presupuesto ................................................................................................................................ 17
Anexos......................................................................................................................................... 18
Código del programa............................................................................................................... 18
Referencias.................................................................................................................................. 21

3
Memoria descriptiva
Definicion del proyecto
Este proyecto recoje la instalación, configuración y puesta en marcha de un sistema de
alarma en una vivienda. Este sistema será montado en una Raspberry Pi 2 B. El Proyecto
tiene dos partes: una parte física que será el montaje de los componentes de la arlama y
una parte lógica que será la programación de un script en lenguaje Python para hacer
funcionar la alarma.
La alarma consistirá en una señal luminosa y una alerta al usuario por correo electrónico.
En dicho correo electrónico se adjuntará una foto y del momento exacto de la intrusión.
Objetivo del proyecto
La realización de este proyecto rádica en conseguir que cualquier persona pueda instalar
y configurar un sistema de alarma de bajo coste utilizando una Raspberry. El proyecto
tiene los siguientes objetivos:
 Alertar al usuario vía correo electrónico si alguien ha entrado en nuestra casa.
 Enviar una foto del momento de la intrusión al usuario vía correo electrónico.
 Almacenar las fotos en un pequeño servidor web.
Datos del equipamiento a utilizar
Este proyecto utiliza la plataforma Rapsberry como base principal para su realización. A
continuación se exponen los diferentes componentes y equipamentos que son necesarios
para llevar a cabo este proyecto:
 Raspberry Pi 2 B: Será necesario la utilización de la Raspberry para llevar a cabo
la programación del script que nos permitirá realizar y configurar las funciones de
la alarma. He elegido este modelo de Raspberry ya que las especificaciones son
suficientes para llevar a cabo este proyecto. Tendrá instalado el sistema operativo
Raspbian
 Micro SD: Necesaria para instalar el sistema operativo Raspbian.
 Sensor de ultrasonidos: Será utilizado para medir la distancia de un objeto.
Gracias a esto podremos detectar cualquier tipo de intrusión y activar la alarma.
 Cámara PiCam: La utilizaremos para realizar una captura fotografica del
momento de la intrusión.
 Fuente de alimentación para Raspberry: Utilizaremos una fuente de alimentación
de la marca Aukey que proporciona 2A de salida y 5V de salida, suficientes para
alimentar nuestra Raspberry. Además también conectaremos esta fuente de
alimentación con un cable Micro USB a USB.
 Disco duro 160GB: Se utilizará un disco duro externo SATA de la marca Seagate
con una capacidad de 160 GB para almacenar en él los diferentes scripts y
programas necesarios para la utilización de la alarma. Esto es opcional ya que
podemos alamacenarlos en la partición libre que nos queda en la Micro SD pero
he decidido usar un disco duro externo para no ocupar espacio de la Micro SD.
 Carcasa disco duro: Carcasa para discos duros de 2,5”, se usará para poder
conectar el disco duro descrito anteriormente por USB a la Raspberry.

4
 USB WiFi: Será necesario disponer de una conexión a Internet en nuestra
Raspberry. Para ello he utilizado un adaptador WiFi para conectar la Raspberry a
Internet.
 Teclado y ratón inalambricos: Utilizaremos un teclado y un ratón para poder
movernos por el entorno de Raspbian.
 HUB USB alimentado: Se necesita un HUB alimentado para conectar el disco
duro externo, el adaptador WiFi y el receptor inalambrico del teclado y ratón. Es
necesario usar un HUB con fuente de alimentación diferente a la de la Raspberry
ya que sin ello la Raspberry no es capaz de suministrar la suficiente energía para
hacer funcionar todos los elementos conectados.
 LED Azul: Lo usaremos como señal luminosa de la alarma.
 Resistencias: Utilizaremos tres resistencias para la conexión de componentes.
 Cables: Se han usado varios cables para las conexiones entre la Raspberry y los
componentes.
 Protoboard: Necesitamos una protoboard para facilitar las conexiones de los
componentes a la Raspberry.
 Botón: Se usará un botón para facilitar el apagado de la alarma en cualquier
momento.
Las caracteristicas técnicas de cada componente serán explicadas detalladamente en el
pliego de condiciones.

5
Conexión de los componentes
La Raspberry Pi 2 B dispone de 40 pines del tipo GPIO. Gracias a estos pines podemos
conectar a ella sensores, detectores y otro tipo de componentes. En este proyecto se ha
conectado el sensor de ultrasonidos y un led a los pines GPIO. Además la Raspberry
cuenta con una conexión específica para conectar la cámara. Hemos aprovechado esta
conexión para conectarla. A continuación se explican y se detallan las conexiones
físicas entre los componentes y sensores y la Raspberry.
Conexión del sensor HC-SR04
El sensor de ultrasonidos que hemos usado en este proyecto es el HC-SR04. Las
caracteristicas técnicas de este sensor se detallan en el pliego de condiciones. El sensor
HC-SR04 cuenta con 4 conexiones. Dos de ellas representan VCC y GND y las otras dos
son la conexión de Trigger y la conexión de Echo.
El Trigger es la conexión/pin mediante el cuál emitiremos un pulso alto y Echo es la
conexión/pin por la que recibiremos el pulso de vuelta. De esta manera podemos emitir
un pulso alto mediante el pin Trigger y esperar a que el Echo lo reciba, con esto podemos
calcular la distancia a un objeto usando las formulas correspondientes.
En los planos se detalla la conexión del sensor en la Raspberry.
Conexión de la cámara PiCam
El modulo de cámara de Raspbeery se llama PiCam y su conexión es muy sencilla ya
que la Raspberry dispone de una conexión especifica para conectar esta cámara. La
cámara se conecta mediante un bus a la conexión de la Raspberry. Esta conexión
dispone de 16 pines de información.
En los planos se detalla la conexión de la cámara en la Raspberry.
Así mismo también se han conectado un botón simple y un led. Sus conexiones son
muy simples y se pueden ver detalladas en los planos.

6
Instalación y configuración del sistema operativo Rasbian
¿Qué es Raspbian?
Raspbian es un sistema operativo libre basado en Debian optimizado para el hardware de
Raspberry Pi. Además, Raspbian ofrece más de 35.000 paquetes, esto quiere decir que
incluye software precompilado para una fácil instalación en la Raspberry Pi
En este proyecto se ha usado la distribución Raspbian Jessie con escritorio PIXEL en su
versión de Abril de 2017.
Instalación de Raspbian
Para la elaboración de este proyecto he optado por elegir un sistema operativo ligero pero
que a su vez me de bsatantes posibilidades para programar la Raspberry. He decidido usar
Raspbian. A continuación se detalla como se ha instalado Raspbian OS en la Raspberry.
La instalación de Raspbian en Raspberry es sencilla. Lo primero que se necesita es la
imagen del sistema operativo que vayamos a intalar. Esta imagen es facilmente
descargable desde la página oficial de Raspberry. Una vez descargada la imagen,
debemos instalarla en la tarjeta Micro SD con la ayuda del programa Win32 Disk Imager
que nos facilita la tarea de la instalación.
Configuración inicial de Raspbian
Una vez instalado el sistema operativo e iniciado, he configurado algunos parametros
necesarios para poder realizar el proyecto. Configuraciones realizadas:
 Establecer una IP estática: Se ha establecido una IP estática a la Raspberry para
poder tenerla controlada y acceder a ella remotamente.
 Instalar un servidor de escritorio remoto: Se ha instalado el servidor de escritorio
remoto XRDP para poder acceder a la Raspberry remotamente.
 Habilitar el uso de la PiCam: Se ha habilitado el uso de la cámara PiCam desde
la configuración de la Raspberry.
 Actualizar repositorios y modulos del sistema operativo.

7
Programación del script en Python
A continuación se explican las diferentes partes del programa que he creado y que hace
funcionar el sistema de alarma. El programa consiste en un pequeño script programado
en Python 3.
¿Qué es Python?
Python es un lenguaje de programación. Cuenta con estructuras de datos eficientes y de
alto nivel y un enfoque simple pero efectivo a la programación orientada a objetos. Python
tiene la poderosa capacidad de contar con una sintáxis muy limpia y clara, es decir,
altamente legible y comprensible para el ser humano esto hace que sea un lenguaje ideal
para scripting y desarrollo rápido de aplicaciones en diversas áreas y sobre la mayoría de
las plataformas. Los programas en Python necesitan del Python interpreter para poder ser
ejecutados lo que hace que un programa en Python programado en Windows sea
ejecutable en Linux o en cualquier otro sistema si el interprete de Python está intalado. El
intérprete de Python puede extenderse fácilmente con nuevas funcionalidades y tipos de
datos implementados en C o C++ (u otros lenguajes accesibles desde C). Python también
puede usarse como un lenguaje de extensiones para aplicaciones personalizables.
Idea del programa
El script nos ayudará a detectar si la puerta de la casa se ha abierto. Para ello estará
recogiendo la distancia que hay hasta la puerta cada segundo. De manera que si la puerta
se abre la distancia variará y el script activará la alarma. Una vez que la alarma se active
se desencadenarán una serie de acciones para avisarnos de que la puerta ha sido abierta.
La distancia es posible calcularla mediante la siguiente formula:
=
·
2
Primero se tomará una foto del lugar, acto seguido se guardará y finalmente el script
enviará un correo electrónico a nuestra dirección alertandonos de que la puerta ha sido
abierta y adjuntando la foto que se ha tomado previamente.
Si la puerta se vuelve a abrir se vuelve a repetir el mismo proceso. Además en cada correo
electrónico que el script manda sale detallada la hora del suceso. Para ello será necesario
instalar un cliente de correo electrónico para el envío de los e-mail de alerta.
Como elemento adicional del programa crearemos un pequeño lugar donde cada foto que
es tomada sea guardada. Para ello usaremos un servidor web donde copiar todas las fotos
y poder acceder a ellas desde cualquier lugar.
A continuación se puede ver la estructura básica del programa mediante un diagrama de
flujo:

8
Instalación del servidor web Apache
Como explicabamos en la idea del programa he decidido crear un pequeño servidor web
que nos facilite una copia de las fotos que realiza la alarma. Para ello hemos instalado el
servidor web Apache. En el hemos creado una carpeta donde se guardaran las fotos y
hemos realizado un pequeño archivo index.html para poder acceder facilmente a ellas.
También como seguridad hemos protegido el acceso con usuario y contraseña mediante
la propia funcionalidad del servidor web .htpasswd. De esta manera hemos creado un
usuario y le hemos asignado una contraseña para que solamente ese usuario pueda acceder
al servidor.
La funcionalidad de este servidor web es copiar todas las fotos que realiza la alarma y
poder tener acceso a ellas desde cualquier sitio. Para poder acceder a el servidor web
desde fuera de nuestra red local es necesario instalar un servicio de DNS dinamica, en
este proyecto hemos optado por utilizar No-Ip. Esto lo que hace es darle un nombre de
dominio a la IP publica de nuestro router y así facilitar el acceso desde fuera de nuestra
red.

9
Por último hemos redirigido el puerto 7070 publico al puerto LAN 80 con IP de destino
de nuestra Raspberry. De esta manera podremos acceder al servidor web desde fuera de
nuestra red local por medio del uso de nuestro DDNS a través del puerto 7070.
Configuración del cliente de correo electrónico Mutt
Para el envío del correo electrónico de alerta he decidido usar el cliente de correo
electrónico Mutt. He optado por este cliente por su facilidad de configuración y por su
liviano tamaño ideal para ser instalado en Raspbian. Además permite el envío de e-mails
desde la consola de Raspbian de manera muy sencilla.
Una vez instalo el cliente su configuración es muy sencilla y se limita a editar un archivo
de configuración en el cual debemos de especificarle la dirección de correo electrónico
de origen, su contraseña y los servidores de SMTP para el envío de correo electrónico y
de IMAP para la recepción de correo electrónico.
Programación del script
He decidido usar el lenguaje de programación Python 3 puesto que es un lenguaje perfecto
para realizar pequeños programas y scripting. Además su sintaxis es sencilla y fácil de
entender.
Funcionamiento del script
El script puede ser abierto manualmente desde el escritorio de Raspbian o mediante
consola remotamente. También existe la posibilidad de que se ejecute automaticamente
cada vez que se inicie el sistema operativo Rasbpian.
El script se puede dividir en 3 que vamos a analizar a continuación. El código está
comentado para que sea más fácil su comprensión.
Primera parte del script:
En esta parte se importan las librerias para poder usar las diferentes funciones en el
script. Además se fijan unas configuraciones inciales como la referencia de los pines
GPIO en al Raspberry. También definimos los pines que vamos a usar y aclaramos si
son de entrada o salida.
Segunda parte del script:
En esta segunda parte del script definimos y programamos dos funciones muy importantes
ya que sin ellas no podriamos saber cuando activar o desactivar la alarma. En la primera
función llamada medida hacemos uso del sensor de untrasonidos para calcular la distancia
que hay hasta el objeto. En la segunda función llamda media_medida lo que hacemos es
recojer tres medidas rapidamente y hacer la media de estas tres para así obtener unos
valores de medidas más fieles a la realidad.
Tercera parte del script:
Por último tenemos la tercera parte del script. Aquí es donde está todo el funcionamiento
del programa. Lo que hace el script es repetir en bucle siempre la misma acción principal.
El bucle se encarga de recojer cada 1 segundo una medida, si la medida es inferior a 10
cms se vuelve a coger otra medida hasta que la medida supera los 10 cms, lo cual es señal
de que la puerta se ha abierto, cuando esta medida es superada se pausa la recogida de
medidas y se activa la alarma que consiste en la realización de una foto del momento de

10
la intrusión y el envío por correo electrónico de la foto con la fecha y hora exactas de la
intrusión. Además la foto realizada se copia en un pequeño servidor que funciona con
Apache al cual podemos acceder, con usuario y contraseña, para ver todas las fotos.
Solo podemos salir del bucle presionando la combinación de teclas CTRL + C de esta
manera saldremos del bucle y por consiguiente del programa. Antes de salir del programa
se realiza una acción de cierre ordenada limpiando los pines GPIO usados para que esten
disponible la proxima vez. También se puede salir del programa presionando el botón
físico que se ha instalado en la Raspberry.
En la parte de Anexos de este proyecto se puede leer el código completo del programa.

11
Pliego de condiciones
Definición y características técnicas de los equipos a utilizar
Tal y como se exponia en la memoria descriptiva el equipamiento a utilizar, a
continuación se detallan las caracteristicas tecnicas de cada componente que se utilizará
en el proyecto.
 Raspberry Pi 2 B: Procesaor ARM Quad-Core 900 MHz, 1 GB de memoria
LPDDR2-SDRAM, 4 puertos USB, 1 salida HDMI, 1 puerto Ethernet, 40 pines
GPIO, zocalo para Micro SD, salida de audio Mini jack 3,5 mm, entrada para
cámara y pantalla.
 Micro SD: Tarjeta Micro SD Samsung EVO. 16 GB de almacenamiento. Clase
10.
 Sensor de ultrasonidos: Sensor HC-SR04 ultrasónico. Voltaje de trabajo 5V,
capaz de enviar pulsos ultrasónicos desde 0V a 5V. Distancia de alcance desde 2
centimetros a 4,5 metros. Rango de precisión de 2mm.
 Cámara PiCam: Cámara PiCam con una distancia focal de 3.29 y una apertura de
2.9. Resolución 2592x1944 con 5 megapixeles.
 Fuente de alimentación para Raspberry: Cargador Aukey PA-T9, tecnología
AUKEY Quick Charge 3.0, entrada corriente alterna 100-240V, salida corriente
continua 3,5-6,5V y 3A.
 Disco duro 160GB: Disco duro de 160 GB marca Seagate, velocidad 5.200 rpm,
conectores SATA.
 Carcasa disco duro: Carcasa marca Conceptronic, fabricada en plástico, con
entradas SATA y salidas USB.
 USB WiFi: Adaptador WiFi que funciona con el estandar 802.11n/g/b y puede
llegar a funcionar a una velocidad de 150 mbps. Utiliza una conexión USB para
ser conectado en la Raspberry.
 HUB USB alimentado: HUB con 6 salidas USB.
 LED Azul: Led azul de 3,2 – 3,4 V.
 Resistencias: Una resistencia de 1kohm y otra resistencias de 330 ohms.
 Cables: Cables de tipo jumper y dupont.
 Protoboard: Protoboard de 400 puntos de los cuales 100 son utilizados para fines
de alimentación y tierra.
 Botón: Se utiliza un botón simple de 4 patillas.

12
Planos
A continuación se detallan los diferentes planos que han sido elaborados para la
realización de este proyecto.
 Plano de conexiones de los componentes en protoboard.
 Plano de conexiones de componentes en Raspberry.
 Plano de conexiones completas de los componentes.
 Plano planta del montaje real.

COLEGIO SALESIANO HERMANO GARATE
Fecha Denominación Curso
29 / 05 / 2017 Conexión de componentes en protoboard 2º CFGS Telecomunicaciones e Informática

29 / 05 / 2017 Conexión de componentes en Raspberry 2º CFGS Telecomunicaciones e Informática

29 / 05 / 2017 Conexión completa de componentes 2º CFGS Telecomunicaciones e Informática

29 / 05 / 2017 Plano planta del montaje real 2º CFGS Telecomunicaciones e Informática

17
Presupuesto
CONCEPTO UNIDADES PRECIO/UNIDAD TOTAL
Raspberry Pi 2 B 1 39,90€ 39,90€
Sensor HC-SR04 1 1,23€ 1,23€
PiCam 1 7,53€ 7,53€
Disco duro 160 GB 1 19,00€ 19,00€
Carcasa disco duro 1 20,00€ 20,00€
Fuente alimentación Raspberry 1 11,89€ 11,89€
Cable alimentación Raspberry 1 9,98€ 9,98€
HUB USB 1 9,95€ 9,95€
Adaptador USB WiFi 1 2,48€ 2,48€
Combo teclado y ratón inalambrico 1 10,22€ 10,22€
Cables 5 0,05€ 0,25€
Resistencias 2 0,03€ 0,06
Diodo LED azul 1 0,27€ 0,27
Protoboard 1 3€ 3€
Botón 1 0,10€ 0,10€
Suma 135,86€
IVA Añadido
TOTAL PRESUPUESTO 135,86€

18
Anexos
Código del programa
# -----------------------------------
# Configuracion inicial del programa
# ------------------------------------
# coding: utf-8
# Librerias necesarias
import time # Para conocer la fecha y la hora
import RPi.GPIO as GPIO # Para usar los pines GPIO
import picamera # Para usar la camara
import os # Para usar las funciones del sistema
import shutil # Para realizar funciones de copiado
import sys #Para utilizar funciones del sistema
# Usamos la referencia BOARD para los pines GPIO
GPIO.setmode(GPIO.BOARD)
#Defininos el modulo de la camara
camera = picamera.PiCamera()
# Definimos los pines que vamos a usar
GPIO_TRIGGER = 11
GPIO_ECHO = 13
GPIO_LED = 15
GPIO_BOTON = 12
# Configuramos los pines como entradas y salidas
GPIO.setup(GPIO_TRIGGER,GPIO.OUT) # Trigger
GPIO.setup(GPIO_ECHO,GPIO.IN) # Echo
GPIO.setup(GPIO_LED ,GPIO.OUT) #Led
GPIO.setup(GPIO_BOTON, GPIO.IN) #Boton
# -----------------------
# Definimos algunas funciones
# -----------------------
def medida(): # Esta funcion mide una distancia
GPIO.output(GPIO_TRIGGER, True) # Emito un pulso alto
time.sleep(0.00001) # Espero
GPIO.output(GPIO_TRIGGER, False) # Dejo de emitir el pulso
comienzo = 0
final = 0
a = time.time()
while GPIO.input(GPIO_ECHO)==0: # Mientras la entrada del Echo sea 0
comienzo = time.time() # La variable start guarda el tiempo actual
if ((comienzo - a) > 0.043236): # Pero si el tiempo excede de 0.04
break # Se rompe el While y el programa sigue. Esto se hace para que no se quede esperando el valor 0 eternamente
while GPIO.input(GPIO_ECHO)==1: # Mientras que la entrada del Echo sea 0
final = time.time() # La variable start guarda el tiempo actual
if ((final - comienzo) > 0.043236): # Pero si el tiempo excede de 0.0.4
break # Se rompe el While y el programa sigue. Esto se hace para que no se quede esperando el valor 0 eternamente
tiempo = final-comienzo # El tiempo va a ser igual a el tiempo de inicio menos el tiempo de finalizacion
distancia = (tiempo * 34300)/2 # Y la distancia es igual al tiempo * la velocidad del sonido partido de 2 porque es ida y vuelta
if distancia > 0: # Este if sirve para comprobar si hay algun error ya que el tiempo siempre tiene que ser positivo
return distancia
else:
return -1
def media_distancia(): # Esta funcion recoge 3 medidas y devuelve la media de las 3, asi obtenemos una medida mas exacta
distancia1=medida()
time.sleep(0.1)
distancia2=medida()

19
time.sleep(0.1)
distancia3=medida()
distancia = distancia1 + distancia2 + distancia3
distancia = distancia / 3
return distancia
# -----------------------
# Programa principal
# -----------------------
print ("############################")
print ("###### RaspAlarm v1.0 ######")
print ("############################")
print ("")
# Ponemos el Trigger en falso (low)
GPIO.output(GPIO_TRIGGER, False)
# Ponemos el Led en falso (low)
GPIO.output(GPIO_LED, False)
# Metemos el bloque principal en un Try para asi poder
# comprobar si el usuario presiona Ctrl + C
# y poder ejecutar una limpieza del GPIO, esto tambien
# evita el usuario tener que ver muchos mensajes de error
b=0 # Utilizo la variable a para poder para el proceso mas adelante
try:
while True: # Este bucle se repite siempre
valorDelBoton = GPIO.input(12) #Guardamos el estado del boton
if (valorDelBoton == True): #Si el boton esta pulsado terminamos el programa
# Limpiamos los pines GPIO y salimos del programa
os.system('clear')
print ("Apagando LED")
time.sleep(1)
print ("Limpiando GPIO")
GPIO.cleanup()
time.sleep(1)
print ("GPIO limpio")
print ("Saliendo")
os.system('clear')
print ("Saliendo.")
time.sleep(0.5)
os.system('clear')
print ("Saliendo..")
time.sleep(0.5)
os.system('clear')
print ("Saliendo...")
time.sleep(0.5)
print ("Hecho por Sergio")
time.sleep(1)
sys.exit(1)
else:
# Lo primero que hago es medir la distancia
distancia = media_distancia()
# Compruebo si la distancia es menor que 10
# Si es menor que 10 muestro la distancia por pantalla
if distancia < 10:
distancia = media_distancia() # Medidos la distancia
#print ("Distancia: %.1f" % distancia) # Mostramos la distancia por pantalla

20
print ("Distancia: {:.2f}" .format (distancia)) # Mostramos la distancia por pantalla. Solo mostramos 2 decimales
time.sleep(1) # Esperamos 1 segundo
distancia = media_distancia()
b = 0 # Utilizo la variable a para poder para el proceso mas adelante
# Pregunto si la variable a es igual a 1
# Si lo es no hago nada y repito el if anterior
if b == 1:
pass
# Pero si no es 1 le asigno el valor 0
# Para poder seguir con el IF siguiente
else:
b = 0
if distancia > 10 and b == 0: # Si la distancia es mayor que 10cms
fecha = time.strftime("%d%m%Y-%H%M%S") # En esta variable se guarda la fecha actual y la hora para renombrar la foto
#guardada
fecha_completa = time.strftime("%c")
print ("La distancia es mayor de 10 cms. Alarma activada!!") # Se interrumpe el bucle y se muestra un aviso
GPIO.output(GPIO_LED, True)
camera.capture('/home/pi/Desktop/RaspAlarm/Fotos/{}.jpg'.format(fecha)) # Se toma una foto
print("Capturando foto")
time.sleep(2)
print("Copiando foto al servidor")
shutil.copy("/home/pi/Desktop/RaspAlarm/Fotos/{}.jpg".format(fecha), "/var/www/html/Fotos/{}.jpg".format(fecha)) # Se
#copia a la carpeta del servidor
time.sleep(1)
print("Foto guardada")
print("Enviando foto")
os.system('sudo echo "La alarma ha sido activada. Fecha de la activacion: {0}" | mutt -s "Alguien ha abierto la puerta"
smma_225@hotmail.com -a /home/pi/Desktop/RaspAlarm/Fotos/{1}.jpg' .format(fecha_completa, fecha)) # Se envia la foto por
#correo
print("Foto enviada con exito")
b = 1 # Pongo la variable en 1 para parar el proceso y que no se repita
distancia = media_distancia() # Seguimos midiento la distancia
while distancia < 10: # Pero si la distancia vuelve a ser menor de 10
break # Se termina este bucle y volvemos al principio nuevamente
except KeyboardInterrupt: # Si el usuario presiona crtl + C
# Limpiamos los pines GPIO y salimos del programa
os.system('clear')
time.sleep(1)
GPIO.cleanup()
time.sleep(1)
print ("Saliendo")
os.system('clear')
print ("Saliendo.")
time.sleep(0.5)
os.system('clear')
print ("Saliendo..")
time.sleep(0.5)
os.system('clear')
print ("Saliendo...")
time.sleep(0.5)
print ("Hecho por Sergio")
time.sleep(1)

21
Referencias
https://www.raspberrypi.org
https://www.raspberrypi.org/learning/getting-started-with-picamera/
https://www.python.org/
https://docs.python.org
http://docs.python.org.ar/tutorial/3/index.html
http://stackoverflow.com/
https://librosweb.es/libro/python/

Instalación de un sistema de alarma utilizando una Raspberry

Recomendados

Recomendados

Más contenido relacionado

Similar a Instalación de un sistema de alarma utilizando una Raspberry

Similar a Instalación de un sistema de alarma utilizando una Raspberry (20)

Más de Sergio Muñoz

Más de Sergio Muñoz (9)

Último

Último (20)

Instalación de un sistema de alarma utilizando una Raspberry