Aperçu : Système de divertissement à domicile et de sécurité : 6 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

À propos de l'application

Ce système IOT est un système de divertissement et de sécurité à domicile.

1. Sécurité

   1. Appuyez sur Carte RFID et les entrées sont enregistrées dans Firebase.
   2. Si autorisé, vous pouvez entrer paisiblement et la photo est prise et téléchargée sur S3
   3. Si non autorisé, la section de défense entre et un écran LCD dira que vous n'êtes pas autorisé.

2. La défense

   1. Appuyez sur le bouton du tableau de bord.
   2. Les tourelles laser attaqueront en rafale et en vitesse aléatoires.

3. Divertissement

   1. Si un mouvement est détecté, le jeu démarre.
   2. Une fois que l'utilisateur a joué au jeu, le score est enregistré dans Firebase.
   3. Les valeurs LDR seront prises et affichées sur le tableau de bord.

Cette application est contrôlable et consultable via le serveur Web IBM Node-Red. Nous utilisons AWS et IBM Cloud Services et nous avons utilisé Firebase comme base de données.

Résumé des étapes qui seront décrites

• Exigences matérielles
• Sécurité - Comment créer un système de sécurité qui utilise l'entrée RFID et un logiciel de reconnaissance d'images
• Défense - Comment créer une tourelle laser
• Divertissement - Comment créer un jeu Simon-says
• IOT App Watson sur IBM Bluemix - Comment intégrer tous les systèmes dans un seul tableau de bord

Allez-y et accédez au fichier pdf pour une explication plus détaillée sur la façon de créer ce projet.

Étape 1: Configuration matérielle requise

C'est ce dont vous aurez besoin

1. Sécurité

   • 1 Framboise Pi
   • 1 écran LCD
   • 1 lecteur RFID
   • 1 caméra vidéo
   • 2 cartes/boutons RFID
   • X Femelle -> Câbles de démarrage mâle

2. La défense

   • 1 Framboise Pi
   • 2 10 ㏀ Résistance (pour les boutons)
   • 2 micro servos
   • 1 module émetteur laser 650 nm
   • 2 bouton poussoir
   • 1 sonnerie
   • 3 petits élastiques/attaches de câble (pour la fixation)
   • X Femelle -> Câbles de démarrage mâle
   • X câbles de saut réguliers
   • 1 transistor
   • 1 condensateur

3. Divertissements

   • 1 Framboise Pi
   • 3 1 ㏀ Résistance (pour LED)
   • 1 résistance 10㏀ (pour LDR)
   • 3 LED (Différentes Couleurs)
   • 3 boutons
   • 1 LDR
   • 1 écran LCD
   • 1 capteur de mouvement Pir
   • X Femelle -> Câbles de démarrage mâle
   • X câbles de saut réguliers

Étape 2: Sécurité

Création du matériel du système de sécurité

Connectez les circuits comme indiqué dans le schéma de frittage

Création du logiciel du système de sécurité

1. Configurer AWS en créant un objet
2. Installer la bibliothèque AWS Python
3. Installer la bibliothèque LCD
4. Installer la bibliothèque RFID
5. Configurer Firebase
6. Configurer le stockage S3
7. Installer Boto sur Raspberry Pi
8. Installer AWS ClI sur Raspberry Pi
9. Créer des informations d'identification AWS
10. Configurer AWS
11. Télécharger security.py sur RPi
12. Télécharger imagerecognition.py sur RPi

security.py est un code qui lira les entrées rfid et détectera si l'utilisateur est un intrus ou non. Si l'utilisateur est reconnu, une image sera prise et téléchargée sur s3. Le code est également publié dans un sujet dans aws MQTT

Étape 3: Défense

Création de la tourelle laser Hardware

1. Nous créons la tourelle laser en utilisant 2 servos et 1 module laser
2. Connectez les circuits comme indiqué dans le schéma de frittage

Création du logiciel de la tourelle laser

Le code ci-dessous fera tirer la tourelle laser dans des directions aléatoires, en rafales et à une vitesse aléatoires

laserturret.py

depuis gpiozero import LED, buzzer, bouton, temps de servoimport depuis le signal import pause import aléatoire

#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("La LED est allumée") def ledOFF(): led.off() print("La LED est éteinte")

def feu():

print("armes chaudes") buzzer_pin.on() time.sleep(0.1) buzzer_pin.off()

def lasertourelle():

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(detail) while shot<numshots: shot+="1" servo1.value="servo1start" servo2.value="servo2start" servo1start="servo1change" servo2start="servo2change" time.sleep(timebetweenburst)

remarques = {

'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(fréquence, longueur): #créer la fonction "buzz" et lui donner le pitch et la durée)

si(fréquence==0):

time.sleep(length) période de retour = 1,0 / fréquence #fréquence delayValue = period / 2 #calculer le temps pour la moitié de l'onde numCycles = int(length * fréquence) #num of waves = durée x freq for i in range(numCycles): #commencer une boucle de 0 à la variable "cycles" calculée ci-dessus buzzer_pin.on() time.sleep(delayValue) buzzer_pin.off() time.sleep(delayValue)

def play (mélodie, tempo, pause, rythme = 0,800):

pour i dans la plage (0, len(melody)): # Jouer la chanson noteDuration = rythme/tempo buzz(melody, noteDuration) # Changer la fréquence le long de la chanson note pauseBetweenNotes = noteDuration * pause time.sleep(pauseEntreNotes)

tant que vrai:

tourelle laser () pause;

Étape 4: Divertissement

Création du matériel de divertissement

Nous créons le jeu de boutons Simon-says, où vous devez suivre le schéma des LED qui s'allument et appuyer sur les boutons correspondants. Il télécharge les scores et l'horodatage dans la base de données NoSQL de firebase pour une utilisation ultérieure dans les tableaux de bord.

Connectez les circuits comme indiqué sur le schéma de Fritzing.

Création du logiciel de divertissement

divertissement.py

importation RPi. GPIO comme GPIOimport filetage import temps tweepy import os aléatoire d'importation à l'importation de LCD d'importation rpi_lcd d'appel d'importation subprocess de temps de sommeil d'importation de datetime datetime importation de firebase d'importation firebase CONSUMER_KEY = 'h5Sis7TXdoUVncrpjSzGAvhBH' CONSUMER_SECRET = 'ZfDVxc4aTd9doGmBQO3HiSKKzxSTKT4C3g0B3AGx8eETCJm2rY' ACCESS_KEY = « 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', Aucun) lcd=LCD() lcd.text('Amusez-vous bien !', 1) lcd.text('Bonne chance !', 2) sleep(1) # LUMIÈRES rouges, jaunes, vertes = [40, 38, 36] BOUTONS = [37, 33, 35] NOTES = ["E3", "A4", "E4"] # valeurs que vous pouvez modifier qui affectent la vitesse de jeu = 0.5 # drapeaux utilisés pour signaler le jeu status is_displaying_pattern = Faux is_won_curr ent_level = False is_game_over = False # état du jeu current_level = 1 current_step_of_level = 0 pattern = def initialize_gpio(): GPIO.setmode(GPIO. BOARD) GPIO.setup(LIGHTS, GPIO. OUT, initial=GPIO. LOW) GPIO. configuration (BUTTONS, GPIO. IN, pull_up_down=GPIO. PUD_DOWN) pour i dans la plage (3): GPIO.add_event_detect(BUTTONS, GPIO. FALLING, verify_player_selection) def verify_player_selection(channel): global current_step_of_level, current_level, is_won_current_level is_game_over sinon is_displaying_pattern et non is_won_current_level et non is_game_over: flash_led_for_button(channel) if channel == BOUTONS[pattern[current_step_of_level]: current_step_of_level += 1 if current_step_of_level >= True current_level: current_level += 1 is_game_level = 1 is_game_level 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, curé 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 = Truecurrent GPIO.output(LIGHTS for, GPIO. LOW): GPIO.output(LIGHTS[pattern, GPIO. HIGH) time.sleep(speed) GPIO.output(LIGHTS[pattern, GPIO. LOW) time.sleep(speed) is_displaying_pattern = False def wait_for_player_to_repeat_pattern (): bien que non is_won_current_level et non 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, pattern is_displaying_pattern = False 0 is_won = False is_won_level = current_step_of_level = False 0 is_won = False is_won GPIO.output(LIGHTS, GPIO. LOW) def send_data(score): lcd.text('Fin de partie, ', 1) lcd.text('A bientôt !', 2) datestr = str(datetime. now()) tandis que True: print(datestr) print(score) data={ 'Date': datestr, 'Score': score } result = firebase.post('/scores/', data) print(result) if score > 2: status='Quelqu'un a marqué ' + (str(score)) +' sur '+datestr+' !' 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 est {} couleurs!\n".format(current_level - 1)) sleep(2) print("Merci d'avoir joué !\n") lcd.text('', 1) lcd.text('', 2) pause 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("Begin new round!\n") initialize_gpio() start_game_monitor() enfin: GPIO.cleanup() if _name_ == '_main_': main()

Étape 5: IOT App Watson sur IBM Bluemix [Première partie]

Configurer le service Blumix IoT

1. Configurer un type de périphérique de passerelle
2. Configurer un appareil

Faites les étapes 1 et 2 3 fois. Un RPi est pour une section (Sécurité/Défense/Divertissement)

Configurer Node-Red

Exécuter node-red

démarrage nœud-rouge

1. Aller à gérer la palette dans le menu hamburger (en haut à droite)

2. Téléchargez les palettes suivantes

   1. node-red-tableau de bord
   2. node-red-contrib-firebase
   3. noeud-rouge-contrib-ibm-watson-iot

Étape 6: Flux de nœuds rouges

Téléchargez les fichiers et exportez-les dans votre node-red.

Nœud de sécurité-Rouge

rien

Défense Rpi Noeud-Rouge

laserturret.txt

Divertissement Rpi Node-Rouge

• divertissement rpi flow.txt
• ldr rpi flux.txt

IBM Bluemix Node-Red