Descripción general: Sistema de seguridad y entretenimiento en el hogar: 6 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Acerca de la aplicación

Este sistema IOT es un sistema de seguridad y entretenimiento para el hogar.

1. Seguridad

   1. Toque Tarjeta RFID y la entrada se guardará en Firebase.
   2. Si está autorizado, puede ingresar pacíficamente y la foto se toma y se carga en S3
   3. Si no está autorizado, entra la sección de defensa y una pantalla LCD indicará que no está autorizado.
2. Defensa
   1. Presione el botón en el tablero.
   2. Las torretas láser atacarán en ráfagas y velocidades aleatorias.

3. Entretenimiento

   1. Si se detecta movimiento, se iniciará el juego.
   2. Una vez que el usuario juega, la puntuación se guarda en Firebase.
   3. Los valores de LDR se tomarán y se mostrarán en el tablero.

Esta aplicación se puede controlar y visualizar a través del servidor web IBM Node-Red. Hacemos uso de AWS e IBM Cloud Services y usamos Firebase como nuestra base de datos.

Resumen de los pasos que se describirán

• Requisitos de hardware
• Seguridad: cómo crear un sistema de seguridad que utilice entrada RFID y un software de reconocimiento de imágenes
• Defensa: cómo crear una torreta láser
• Entretenimiento: cómo crear un juego de Simon-dice
• IOT App Watson en IBM Bluemix: cómo integrar todos los sistemas en un panel

Continúe y acceda al archivo pdf para obtener una explicación más detallada sobre cómo crear este proyecto.

Paso 1: requisito de hardware

Esto es lo que necesitaras

1. Seguridad

   • 1 frambuesa Pi
   • 1 pantalla LCD
   • 1 lector RFID
   • 1 PiCam
   • 2 tarjetas / botones RFID
   • X hembra -> cables de puente macho
2. Defensa
   • 1 frambuesa Pi
   • 2 Resistencia de 10 ㏀ (para botones)
   • 2 Micro Servo
   • 1 módulo transmisor láser de 650 nm
   • 2 pulsador
   • 1 timbre
   • 3 pequeñas bandas de goma / bridas para cables (para fijar)
   • X hembra -> cables de puente macho
   • X Cables de salto regulares
   • 1 transistor
   • 1 condensador

3. Entretenimientos

   • 1 frambuesa Pi
   • 3 1 ㏀ Resistencia (para LED)
   • 1 resistencia de 10㏀ (para LDR)
   • 3 LED (diferentes colores)
   • 3 botones
   • 1 LDR
   • 1 pantalla LCD
   • 1 sensor de movimiento Pir
   • X hembra -> cables de puente macho
   • X Cables de salto regulares

Paso 2: seguridad

Creando el hardware del sistema de seguridad

Conecte los circuitos como se muestra en el diagrama de fritzing

Creando el software del sistema de seguridad

1. Configure AWS creando una cosa
2. Instalar la biblioteca de AWS Python
3. Instalar la biblioteca LCD
4. Instalar biblioteca RFID
5. Configurar Firebase
6. Configurar almacenamiento S3
7. Instalar Boto en Raspberry Pi
8. Instale AWS ClI en Raspberry Pi
9. Crear credenciales de AWS
10. Configurar AWS
11. Sube security.py a RPi
12. Sube imagerecognition.py a RPi

security.py es un código que leerá las entradas rfid y detectará si el usuario es un intruso o no. Si se reconoce al usuario, se tomará una imagen y se cargará en s3. El código también se publica en un tema en aws MQTT.

Paso 3: Defensa

Creación del hardware de la torreta láser

1. Creamos la torreta láser usando 2 servos y 1 módulo láser
2. Conecte los circuitos como se muestra en el diagrama de fritzing

Creación del software de la torreta láser

El siguiente código hará que la torreta láser dispare en direcciones aleatorias, en ráfagas y velocidades aleatorias

laserturret.py

de gpiozero import LED, Buzzer, Button, Servoimport time from signal import pause import random

#led = LED (12)

#pir = MotionSensor (19, sample_rate = 5, queue_len = 1) buzzer_pin = Buzzer (17) attack = Button (5, pull_up = False) #reset = Button (6, pull_up = False) servo1 = Servo (18) servo2 = Servo (24)

def ledON ():

led.on () print ("LED encendido") def ledOFF (): led.off () print ("LED apagado")

def fuego ():

print ("armas calientes") buzzer_pin.on () time.sleep (0.1) buzzer_pin.off ()

def laserturret ():

timeBetweenBurst = random.uniform (0.2, 1) timeBetweenShots = random.uniform (0.05, 0.2) servo1start = random.randrange (-1, 1) servo1end = random.randrange (-1, 1) servo2start = random.randrange (-1), 1) servo2end = random.randrange (-1, 1) numShots = random.randrange (5, 20) servo1change = (servo1end - servo1start) / numShots servo2change = (servo2end - servo2start) / numShots servo1.value = servo1start servo2.value = servo2start time.sleep (0.1) shot = 0 detail = [timeBetweenBurst, timeBetweenShots, servo1.value, servo2.value, numShots] print (detalle) mientras se dispara <numshots: shot + = "1" servo1.value = "servo1start" servo2.value = "servo2start" servo1start = "servo1change" servo2start = "servo2change" fire () = "" time.sleep (timebetweenshots) = "" time.sleep (timebetweenburst)

notas = {

'B0': 31, 'C1': 33, 'CS1': 35, 'D1': 37, 'DS1': 39, 'EB1': 39, 'E1': 41, 'F1': 44, 'FS1 ': 46,' G1 ': 49,' GS1 ': 52,' A1 ': 55,' AS1 ': 58,' BB1 ': 58,' B1 ': 62,' C2 ': 65,' CS2 ': 69, 'D2': 73, 'DS2': 78, 'EB2': 78, 'E2': 82, 'F2': 87, 'FS2': 93, 'G2': 98, 'GS2': 104, 'A2': 110, 'AS2': 117, 'BB2': 123, 'B2': 123, 'C3': 131, 'CS3': 139, 'D3': 147, 'DS3': 156, 'EB3 ': 156,' E3 ': 165,' F3 ': 175,' FS3 ': 185,' G3 ': 196,' GS3 ': 208,' A3 ': 220,' AS3 ': 233,' BB3 ': 233, 'B3': 247, 'C4': 262, 'CS4': 277, 'D4': 294, 'DS4': 311, 'EB4': 311, 'E4': 330, 'F4': 349, 'FS4': 370, 'G4': 392, 'GS4': 415, 'A4': 440, 'AS4': 466, 'BB4': 466, 'B4': 494, 'C5': 523, 'CS5 ': 554,' D5 ': 587,' DS5 ': 622,' EB5 ': 622,' E5 ': 659,' F5 ': 698,' FS5 ': 740,' G5 ': 784,' GS5 ': 831, 'A5': 880, 'AS5': 932, 'BB5': 932, 'B5': 988, 'C6': 1047, 'CS6': 1109, 'D6': 1175, 'DS6': 1245, 'EB6': 1245, 'E6': 1319, 'F6': 1397, 'FS6': 1480, 'G6': 1568, 'GS6': 1661, 'A 6 ': 1760,' AS6 ': 1865,' BB6 ': 1865,' B6 ': 1976,' C7 ': 2093,' CS7 ': 2217,' D7 ': 2349,' DS7 ': 2489,' EB7 ': 2489, 'E7': 2637, 'F7': 2794, 'FS7': 2960, 'G7': 3136, 'GS7': 3322, 'A7': 3520, 'AS7': 3729, 'BB7': 3729, 'B7': 3951, 'C8': 4186, 'CS8': 4435, 'D8': 4699, 'DS8': 4978}

def buzz (frecuencia, duración): #crea la función "buzz" y dale el tono y la duración)

si (frecuencia == 0):

time.sleep (longitud) período de retorno = 1.0 / frecuencia #frequency delayValue = period / 2 #calcular el tiempo para la mitad de la onda numCycles = int (longitud * frecuencia) #num of waves = duratime x freq for i in range (numCycles): # iniciar un bucle de 0 a la variable "ciclos" calculada arriba buzzer_pin.on () time.sleep (delayValue) buzzer_pin.off () time.sleep (delayValue)

def play (melodía, tempo, pausa, ritmo = 0.800):

para i en rango (0, len (melodía)): # Reproducir canción noteDuration = ritmo / tempo buzz (melodía , noteDuration) # Cambia la frecuencia a lo largo de la canción note pauseBetweenNotes = noteDuration * pause time.sleep (pauseBetweenNotes)

mientras que es cierto:

laserturret () romper;

Paso 4: entretenimiento

Creación del hardware de entretenimiento

Creamos el juego de botones Simon-dice, que tienes que seguir el patrón de los LEDs encendidos y presionar los botones correspondientes. Carga puntuaciones y marcas de tiempo en la base de datos NoSQL de firebase para su uso posterior en los paneles.

Conecte los circuitos como se muestra en el diagrama de Fritzing.

Creación del software de entretenimiento

entretenimiento.py

importación RPi. GPIO como GPIOimport tiempo de importación roscado tweepy importar importar al azar import os de LCD importación rpi_lcd de llamada de importación subproceso de suspensión de importaciones de tiempo desde la fecha y hora de fecha y hora de importación de base de fuego CONSUMER_KEY base de fuego import = 'h5Sis7TXdoUVncrpjSzGAvhBH' CONSUMER_SECRET = ACCESS_KEY 'ZfDVxc4aTd9doGmBQO3HiSKKzxSTKT4C3g0B3AGx8eETCJm2rY' = '988333099669901312- YDLEQN1weW2n1JP4lxJcFPppCsbvzQh 'ACCESS_SECRET = 'K2IlUPur6jx7DO5S0HhhZW29H5AQFOvkMMevSsk9ZzwLk' auth = tweepy. OAuthHandler (CONSUMER_KEY, CONSUMER_SECRET) auth.secure = True auth.set_access_token (ACCESS_KEY, ACCESS_SECRET) API = tweepy. API (auth) firebase = firebase. FirebaseApplication (' https:// iotca2 -12f48.firebaseio.com ', Ninguno) lcd = LCD () lcd.text (' ¡Diviértete! ', 1) lcd.text (' ¡Buena suerte! ', 2) sleep (1) # LUCES rojas, amarillas, verdes = [40, 38, 36] BOTONES = [37, 33, 35] NOTAS = ["E3", "A4", "E4"] # valores que puedes cambiar que afectan la velocidad de juego = 0.5 # banderas utilizadas para señalar el juego status is_displaying_pattern = Falso is_won_curr ent_level = False is_game_over = False # estado del juego current_level = 1 current_step_of_level = 0 patrón = def initialize_gpio (): GPIO.setmode (GPIO. BOARD) GPIO.setup (LIGHTS, GPIO. OUT, initial = GPIO. LOW) GPIO. setup (BUTTONS, GPIO. IN, pull_up_down = GPIO. PUD_DOWN) para i en el rango (3): GPIO.add_event_detect (BUTTONS , GPIO. FALLING, verify_player_selection) def verify_player_selection (canal): global current_step_on_level_level, current_level, is current_level is_game_over si no es is_displaying_pattern y no is_won_current_level y no is_game_over: flash_led_for_button (canal) if channel == BUTTONS [patrón [current_step_of_level]: current_step_of_level + = 1 if current_step_of_level = 1 iflew_level_verdadero flash_led_for_button (button_channel): led = LIGHTS [BUTTONS.index (button_channel)] GPIO.output (led, GPIO. HIGH) time.sleep (0.4) GPIO.output (led, GPIO. LOW) def add_new_color_to_pattern (): global is_won_current_level, canalla rent_step_of_level is_won_current_level = False current_step_of_level = 0 next_color = random.randint (0, 2) pattern.append (next_color) def display_pattern_to_player (): global is_displaying_pattern is_displaying_pattern = True GPIO.level in range (LIGHTS) para i: GPIO.output (LIGHTS [patrón , GPIO. HIGH) time.sleep (velocidad) GPIO.output (LIGHTS [patrón , GPIO. LOW) time.sleep (velocidad) is_displaying_pattern = False def wait_for_player_to_repeat_pattern (): mientras no es is_won_current_level y no is_game_over: time.sleep (0.1) def reset_board_for_new_game (): global is_displaying_pattern, is_won_current_level, is_game_over global current_level, current_step_of_level, patrón is_displaying_levelon_patrón_actual = False_patrón_actual = Falso GPIO.output (LIGHTS, GPIO. LOW) def send_data (score): lcd.text ('Fin del juego,', 1) lcd.text ('¡Hasta pronto!', 2) datetr = str (datetime. ahora ()) mientras que True: print (datetr) imprimir (puntuación) datos = {'Fecha': fechastr, 'Puntuación': puntuación} resultado = firebase.post ('/ puntuaciones /', datos) imprimir (resultado) si puntuación> 2: estado = 'Alguien ha puntuado' + (str (puntuación)) + 'en' + datetr + '!' api.update_status (status = status) break def start_game (): while True: add_new_color_to_pattern () display_pattern_to_player () wait_for_player_to_repeat_pattern () if is_game_over: send_data (current_level - 1) print ("Game Over! Score is {} colors! / n.format (current_level - 1)) sleep (2) print ("¡Gracias por jugar! / n") lcd.text ('', 1) lcd.text ('', 2) break time.sleep (2) def start_game_monitor (): t = threading. Thread (target = start_game) t.daemon = True t.start () t.join () def main (): try: os.system ('cls' if os.name == 'nt 'else' clear ') print ("¡Comenzar nueva ronda! / n") initialize_gpio () start_game_monitor () finalmente: GPIO.cleanup () if _name_ ==' _main_ ': main ()

Paso 5: Aplicación de IOT Watson en IBM Bluemix [Primera parte]

Configurar el servicio Blumix IoT

1. Configurar un tipo de dispositivo de puerta de enlace
2. Configurar un dispositivo

Realice los pasos 1 y 2 3 veces. Un RPi es para una sección (Seguridad / Defensa / Entretenimiento)

Configurar Node-Red

Ejecutar node-red

inicio de nodo-rojo

1. Vaya a administrar la paleta en el menú de hamburguesas (arriba a la derecha)

2. Descarga las siguientes paletas

   1. nodo-tablero-rojo
   2. node-red-contrib-firebase
   3. nodo-rojo-contrib-ibm-watson-iot

Paso 6: Flujos de nodo rojo

Descargue los archivos y expórtelos a su nodo rojo.

Nodo de seguridad rojo

ninguno

Defensa Rpi Node-Red

laserturret.txt

Entretenimiento Rpi Node-Red

• entretenimiento rpi flow.txt
• ldr rpi flow.txt

IBM Bluemix Node-Red