Cámara de video de vigilancia WhatsApp con sensor de proximidad IR

Descripción

En este proyecto, quería crear una cámara de video de vigilancia para mi biblioteca, especialmente para una biblioteca en particular, para recibir una notificación cuando alguien toma un libro u organiza libros de manera diferente. En ese sentido, programé un Raspberry Pi 3 Modelo B + para capturar la imagen en miniatura de primer vistazo y grabar un video con marca de tiempo de acuerdo con los datos recopilados por Arduino Nano: movimiento y brillo. Después de recopilar archivos e información de los sensores, Raspberry Pi los transfiere al webhook file_pathway para enviarlos al número de teléfono verificado como mensajes de notificación de WhatsApp. En PHP, proporcioné el código fuente del webhook file_pathway: guarde el webhook file_pathway en su servidor ingresando la configuración de su cuenta Twilio, funciona de manera excelente incluso en el host local.

COMPONENTES

Raspberry Pi 3
Módulo de cámara Raspberry Pi
Arduino Nano R3
Sensor de proximidad IR Sharp de DigitSpace
LDR, 5 Mohm
LED de 5 mm: rojo
LED de 5 mm: verde
Tablero de pan
Resistencia 1k ohm
Resistencia 221 ohmios
Cables de puente macho / hembra
Cables de puente macho / macho

Paso 1: Twilio para WhatsApp

Para enviar mensajes de WhatsApp a través de la API de Twilio, lo único que debe hacer es registrarse para obtener una cuenta de prueba de Twilio.

Después de registrarse, con su SID y token de autenticación, puede usar la API de Twilio para WhatsApp sin ningún cargo. Como se explica en Twilio, debe unir un número de teléfono compartido con su teléfono para verificar su número de teléfono e iniciar mensajes de plantilla de WhatsApp.

Importante: En este proyecto, utilizamos la API de Twilio para enviar mensajes de notificación de WhatsApp en PHP y, por lo tanto, no necesita cambiar la URL de punto final predeterminada de su aplicación Twilio en el Sandbox. En otras palabras, puede usar el webhook file_pathway incluso en el host local.

Para obtener más información y aprender cómo activar su cuenta, haga clic en el enlace a continuación.

Ve con Twilio.

Paso 2: Desarrollar el webhook file_pathway

Obtenga archivos e información de Raspberry Pi para guardarlos en el servidor: video, imagen en miniatura capturada y brillo.

Envíe los archivos cargados actualmente al número de teléfono verificado como alerta de intrusión a través de WhatsApp.

Para administrar eso, debe descargar Twilio PHP Helper Library en su servidor desde aquí.

Si los nombres de los archivos cargados no están vacíos, obtenga el valor de brillo y las propiedades del archivo para cada archivo cargado: nombre, nombre temporal, tamaño y extensión.
Compruebe si las extensiones de archivo cargadas están en formatos permitidos y si los tamaños de los archivos cargados exceden el límite de datos: 5 MB.
Definir URL de medios.
Sube archivos al servidor.
Envíe la información de los archivos cargados, incluidos los nombres temporales, a Raspberry Pi como mensaje de respuesta.
Defina las propiedades requeridas por la API de Twilio para enviar archivos e información al número de teléfono verificado a través de WhatsApp: SID, AUTH_TOKEN, Número verificado y Número compartido.
Nota: Abstenerse de agregar ‘+’ al comienzo de los números de teléfono al ingresarlos como parámetros de la función send_data_to_WhatsApp () .

Paso 3: Configuración de Raspberry Pi

Si es un novato en programación con Raspberry Pi, puede encontrar instrucciones y tutoriales bien explicados en el sitio web oficial de Raspberry Pi.

– Actualice Raspberry Pi antes de ejecutar el terminal.

Paso 4: configuración del módulo de la cámara

Para aprender cómo conectar el módulo de cámara Raspberry Pi a su Raspberry Pi y tomar fotos, grabar videos y aplicar efectos de imagen, vaya al tutorial oficial sobre cómo comenzar con el módulo de cámara .

Paso 5: Programación de Raspberry Pi para enviar archivos e información al webhook file_pathway en Python

– Cree un archivo llamado whatsapp_surveillance.py en su IDE.

Agregue las bibliotecas requeridas.
Configure la numeración BCM GPIO.
Defina los pines de entrada para obtener señales de Arduino Nano.
Inicie el módulo de la cámara con configuraciones predefinidas.
Anote la fecha en los archivos generados como la marca de tiempo.
Capture una imagen como miniatura y grabe un video de 15 segundos.

Nota: Raspberry Pi graba videos en formato h264, pero desafortunadamente, este formato no es compatible con WhatsApp. Para convertir formatos de video, descargue MP4Box como se muestra aquí.

Convierta el formato h264 al formato mp4 usando MP4Box como comando de terminal para abrir videos en WhatsApp.
Defina la ubicación file_pathway para enviar el video y los datos actualmente grabados al servidor. Usé TheAmplituhedron para alojar el webhook file_pathway para mi cámara de vigilancia, cambiar la URL como la ubicación del directorio file_pathway en su servidor, por ejemplo, https://www.theamplituhedron.com/dashboard/WhatsApp-Surveillance-Camera/file_pathway.php
Defina los archivos y los parámetros de datos: video, imagen capturada y brillo.

Nota: Descargue la biblioteca de solicitudes para realizar solicitudes HTTP en Python como se muestra aquí.

Realice una solicitud de publicación HTTP al webhook file_pathway para enviar información.
Imprima la respuesta enviada por el webhook file_pathway.
Inicia el bucle.
Obtenga valores de los pines de entrada.
Si el sensor de proximidad detecta movimiento, active las funciones record_trespassing () y send_video_to_server () .

Paso 6: Lectura de sensores analógicos con Raspberry Pi usando Arduino Nano

Desafortunadamente, Raspberry Pi no es capaz de leer señales analógicas de sensores analógicos ya que no incluye un circuito ADC (convertidor analógico a digital) incorporado.

Puede agregar un ADC externo como el MCP3008 para leer señales analógicas con Raspberry Pi o usar condensadores para leer valores de resistencia.

Sin embargo, en este proyecto, utilicé un Arduino Nano para leer señales analógicas de los sensores analógicos porque tengo muchas placas Arduino Nano de repuesto a mi disposición. Arduino Nano genera valores de salida digital de acuerdo con los umbrales para cada sensor: sensor de proximidad infrarrojo GP2Y0A02YK0F y fotoresistor. Si se cumple la condición predefinida, produce 1 (ALTO) como salida digital detectada como valor de entrada por Raspberry Pi.

Entonces, Raspberry Pi puede leer señales analógicas de los sensores como los valores de salida digital generados por Arduino Nano con los pines de entrada para activar las funciones record_trespassing () y send_video_to_server () .

No olvide agregar divisores de voltaje para cada pin de entrada debido a la discrepancia de voltaje entre Raspberry Pi y Arduino Nano.

Obtenga brillo como valores porcentuales de la fotorresistencia utilizando la función map () .
Obtenga la distancia en centímetros del sensor de proximidad infrarrojo GP2Y0A02YK0F utilizando el valor del sensor en la hoja de datos: 0.0048828125 (5/1024).
Defina las condiciones para generar valores de salida digital como señales detectables por Raspberry Pi.

Caracteristicas

Verifique si el brillo es óptimo o bajo para el módulo de cámara que usa el fotorresistor.
Detecta intrusos usando el sensor de proximidad infrarrojo GP2Y0A02YK0F.
Si el sensor de proximidad detecta movimiento, capture una imagen en miniatura de primer vistazo y grabe un video de 15 segundos.
Envíe la imagen capturada (jpg), el video (mp4) y el valor de brillo como alerta de intrusión al número de teléfono verificado a través de WhatsApp.

Conexiones

Configure Raspberry Pi y sus periféricos.
Montaje del soporte del módulo de cámara.
Conecte Arduino Nano, sensores y componentes en la placa de pruebas.
Coloque el módulo de la cámara y la placa de pruebas en la caja de la placa Raspberry Pi. Y, conecte los pines de entrada GPIO de Raspberry Pi a los pines de salida digital Arduino Nano como se muestra en el esquema.

CÓDIGO

<? php 
// Implemente la API de Twilio para enviar datos a WhatsApp. 
require_once  $ _SERVER [ 'DOCUMENT_ROOT' ] . '/path/to/vendor/autoload.php' ;  
use Twilio \ Rest \ Client ; if ( ! empty ( $ _FILES [ "rasp_video" ] [ "name" ]) && ! empty ( $ _FILES [ "rasp_capture" ] [ "name" ])) { // Obtenga el valor de brillo de Raspberry Pi.
 
  

	  'brillo' ]))  ?  $ _POST [ 'brillo' ]  :  "¡No detectado!" ; 
// Obtener propiedades de los archivos cargados. // Archivo de video: $ video_properties = array ( "name" => $ _FILES [ "rasp_video" ] [ "name" ], "tmp_name" => $ _FILES [ "rasp_video" ] [ "tmp_name" ], "size" = > $ _FILES [ "rasp_video" ] [ "tamaño" ],
	
	  
		  $ _FILES [ "rasp_video" ] [ "nombre" ],  PATHINFO_EXTENSION ) 
); // Archivo de imagen: $ capture_properties = array ( "name" => $ _FILES [ "rasp_capture" ] [ "name" ], "tmp_name" => $ _FILES [ "rasp_capture" ] [ "tmp_name" ], "size" = > $ _FILES [ "rasp_capture" ] [ "size" ], "extension" =>
	
		  
		  ] [ "nombre" ],  PATHINFO_EXTENSION ) 
); // Comprueba si las extensiones de archivo cargadas están en formatos permitidos. $ allowed_formats = array ( 'jpg' , 'png' , 'mp4' ); if ( ! in_array ( $ video_properties [ "extension" ], $ allowed_formats ) || ! in_array ( $ capture_properties [ "extension" ], $ allowed_formats )) { echo 'RESPUESTA DEL SERVIDOR: \ r \ nFILE => ¡Formato de archivo no permitido! '
	
	
		 
	} else { 
// Comprueba si los tamaños de los archivos cargados exceden el límite de datos: 5 MB. if ( $ video_properties [ "size" ] > 5000000 || $ capture_properties [ "size" ] > 5000000 ) { echo 'RESPUESTA DEL SERVIDOR: \ r \ nFILE => El tamaño del archivo no puede exceder los 5MB.' ; } else { $ video_root = $ video_properties [ "name" ]; $ capture_root = $ capture_properties [ "nombre" ]; $ media = "[_URL_]"

	      
			  . $ capture_properties [ "nombre" ];  // por ejemplo, https://www.theamplituhedron.com/dashboard/WhatsApp-Surveillance-Camera/ 
$ video = "[_URL_]" . $ video_properties [ "nombre" ]; // por ejemplo, https://www.theamplituhedron.com/dashboard/WhatsApp-Surveillance-Camera/ // Subir archivos - video y capturar imagen. move_uploaded_file ( $ video_properties [ "tmp_name" ], $ video_root ); move_uploaded_file ( $ capture_properties [ "tmp_name" ], $ capture_root );
			     
			
			
		    // Enviar la información de los archivos cargados, incluidos los nombres temporales, a Raspberry Pi como mensaje de respuesta. 
echo "RESPUESTA DEL SERVIDOR: \ r \ n ARCHIVO => Archivos cargados correctamente ! \ r \ n TMP_VIDEO =>" . $ video_properties [ "tmp_name" ] . " \ r \ n VIDEO_SIZE =>" . $ video_properties [ "tamaño" ] . " \ r \ n TMP_CAPTURE =>" . $ capture_properties [ "tmp_name" ] . " \ r \ n CAPTURE_SIZE =>" .
		     "tamaño" ] . " \ r \ n DATA => Recibido:" . $ brillo ; 
// Envía los archivos cargados recientemente a WhatsApp: video y captura de imagen. // Defina las propiedades requeridas por la API de Twilio: // SID, AUTH_TOKEN, FROM_PHONE_NUMBER, TO_PHONE_NUMBER, MESSAGE BODY y MEDIA FILE PATH (CAPTURE). // Nota: Abstenerse de agregar '+' al comienzo de los números de teléfono al ingresarlos como parámetros de la función send_data_to_WhatsApp (). send_data_to_WhatsApp ( "[_SID_]" , "[_AUTH_TOKEN_]" , "[_FROM_PHONE_NUMBER_]" , "[_TO_PHONE_NUMBER_]" , "  
			
			
			    \ n \ n Brillo => " . $ brillo . " \ n \ n Video => \ n " . $ video ,  $ media ); 
echo " \ r \ n API => Archivos enviados a WhatsApp! " ; } } } else { echo "RESPUESTA DEL SERVIDOR: \ r \ n ARCHIVO => ¡No se detectó ningún archivo!" ; } función send_data_to_WhatsApp ( $ sid , $ token , $ from , $ to , $ body , $ media ) { $ twilio
			 
	
	 =  nuevo  cliente ( $ sid ,  $ token ); 
$ mensaje = $ twilio -> mensajes -> create ( "whatsapp: +" . $ to , array ( "from" => "whatsapp: +" . $ from , "body" => $ body , "mediaUrl" => matriz ( $ media ))); } ?>

# Cámara de video vigilancia de WhatsApp con sensor de proximidad infrarrojo 
# 
# Raspberry Pi 
# 
# Por Kutluhan Aktar 
# 
# Reciba notificaciones a través de WhatsApp con un video y una miniatura de primer vistazo capturada como alerta de intrusión 
# cuando el sensor de proximidad detecta movimiento. 


de  picamera  importación  PiCamera 
de  tiempo de  importación  sueño 
importación  de fecha y hora 
del  subproceso  de importación  de llamadas  
de importación  solicitudes 
importar  RPi.GPIO  como  GPIO 
# Activa el BCM GPIO numeración GPIO . setmode ( GPIO . BCM ) # Configurar pines de entrada IR_INPUT = 22 PR_INPUT = 23 GPIO . configuración ( IR_INPUT , GPIO . IN ) GPIO


 
. configuración ( PR_INPUT ,  GPIO . IN ) 
# Definir funciones: # Iniciar el módulo de la cámara con ajustes predefinidos. cámara = PiCamera () de la cámara . resolución = ( 640 , 480 ) cámara . framerate = 15 def record_trespassing ( file_h264 , file_mp4 , file_capture , text ): # Agregar fecha como marca de tiempo en los archivos generados. la cámara .


    annotate_text  =  text 
# Capture una imagen como miniatura. dormir ( 2 ) cámara . capture ( file_capture ) print ( " \ r \ n Image Captured! \ r \ n " ) # Grabe un video de 15 segundos. la cámara . start_recording ( file_h264 ) sueño ( 20 ) de la cámara . stop_recording () print ( "Rasp_Pi => Video grabado! \ r \ n " )
    
    
    
    # Convierta el formato h224 al formato mp4. 
command = "MP4Box -add" + file_h264 + "" + file_mp4 call ([ command ], shell = True ) print ( " \ r \ n Rasp_Pi => Video Converted! \ r \ n " ) def send_video_to_server ( file_mp4 , file_capture , brillo ): # Defina la ruta del archivo para enviar el video actualmente grabado al servidor.  url =
            
     
   
      'https://www.theamplituhedron.com/dashboard/WhatsApp-Surveillance-Camera/file_pathway.php' 
files = { 'rasp_video' : open ( file_mp4 , 'rb' ), 'rasp_capture' : open ( file_capture , 'rb' )} data = { 'brillo' : brillo } # Realice una solicitud de publicación HTTP al servidor. solicitud = solicitudes . post ( url , archivos = archivos , datos = datos
           
       
        ) 
# Imprime la respuesta del servidor. print ( "Rasp_Pi => Archivos transferidos! \ r \ n " ) print ( request . text + " \ r \ n " ) # Inicia el ciclo. while True : print ( "Esperando ..." ) si GPIO . input ( IR_INPUT ): brillo = "BAJO" si GPIO . input ( PR_INPUT ) más "OPTIMUM"
    
     
        
        # Obtenga la fecha actual como la marca de tiempo para generar nombres de archivo únicos. 
fecha = fecha y hora . fecha y hora ahora () . strftime ( '% m- % d -% Y_% H.% M.% S' ) capture_img = '/ home / pi / Surveillance / intrusion_' + date + '.jpg' video_h264 = '/ home / pi / Surveillance / intrusion_ ' + date + ' .h264 ' video_mp4 = ' / home / pi / Surveillance / intrusion_ ' + date + ' .mp4 ' # Crear y enviar archivos: record_trespassing
          
       
        ( video_h264 ,  video_mp4 ,  capture_img ,  date ) 
send_video_to_server ( video_mp4 , capture_img , brillo ) sleep ( 1 )

         //////////////////////////////////////////////////// //  
 
        // Cámara de video vigilancia de WhatsApp //
 
       // con sensor de proximidad infrarrojo //
 
      // ------------------------- //
 
     // Arduino Nano //           
 
    // por Kutluhan Aktar // 
 
   // //
 
  //////////////////////////////////// ////////////////
 
// Reciba notificaciones a través de WhatsApp con un video y una miniatura de primer vistazo capturada como alerta de intrusión cuando el sensor de proximidad detecta movimiento.
//
 // Este código es solo para leer entradas analógicas para pasar los valores a Raspberry Pi.

/ / Conexiones
 
// Arduino Nano:           
 
// Sensor IR Sharp-GP2Y0A02YK0F
 
// GND --------------------------- GND
 
// 5V - ------------------------- +
// A0 --------------------------- Señal
 
//
 
// Fotoresistor
 
// A1 ----------- ---------------- 
 
// IR_OUTPUT_LED
 
// D3 --------------------------- 
 
/ / PR_OUTPUT_LED
 
// D4 --------------------------- 
 
// Defina los pines del sensor.
#define IR_PIN A0 #define PR_PIN A1 #define IR_OUTPUT 3 #define PR_OUTPUT 4 // Defina los titulares de datos.
int distancia, brillo ; configuración nula () {   Serial.begin ( 9600 ) ;   pinMode ( IR_OUTPUT, OUTPUT



) ; 
  pinMode ( PR_OUTPUT, OUTPUT ) ; 
} void loop () {   // Obtiene brillo.
brillo = mapa ( analogRead ( PR_PIN ) , 0 , 1023 , 0 , 100 ) ;   // Obtenga distancia del sensor IR Sharp-GP2Y0A02YK0F.
voltios   flotantes = analogRead ( IR_PIN ) * 0 .0048828125 ; // Valor del sensor: ( 5 / 1024
  


 ) 
distancia = 13 * pow ( voltios, -1 ) ; // del gráfico de hoja de datos
   delay ( 100 ) ;   Serial.println ( "Brillo:" + Cadena ( brillo ) + "% \ n \ n" ) ;   Serial.println ( "Distancia:" + Cadena ( distancia ) + "cm" ) ;   // Enviar señal a Raspberry Pi.
if ( distancia < 9 ) { digitalWrite (
    


  IR_OUTPUT, HIGH ) ;  } else { digitalWrite ( IR_OUTPUT, LOW ) ;  } 
if ( brillo < 10 ) { digitalWrite ( PR_OUTPUT, HIGH ) ; } else { digitalWrite ( PR_OUTPUT, LOW ) ; } }