Panoramica: Home Entertainment e sistema di sicurezza: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Informazioni sull'applicazione

Questo sistema IOT è un sistema di Home Entertainment e di sicurezza.

1. Sicurezza
   1. Tocca Scheda RFID e l'input viene salvato in Firebase.
   2. Se autorizzato si può entrare serenamente e la foto viene scattata e caricata su S3
   3. Se non autorizzato, entra la sezione di difesa e uno schermo LCD dirà che non sei autorizzato.
2. Difesa
   1. Premere il pulsante sul cruscotto.
   2. Le torrette laser attaccheranno a raffica e velocità casuali.

3. Divertimento

   1. Se viene rilevato un movimento, il gioco inizierà.
   2. Dopo che l'utente ha giocato, il punteggio viene salvato in Firebase.
   3. I valori LDR verranno presi e visualizzati sul dashboard.

Questa applicazione è controllabile e visualizzabile tramite il server Web IBM Node-Red. Utilizziamo AWS e IBM Cloud Services e abbiamo utilizzato Firebase come nostro database.

Riepilogo dei passaggi che verranno descritti

• Requisiti hardware
• Sicurezza - Come creare un sistema di sicurezza che utilizzi l'input RFID e un software di riconoscimento delle immagini
• Difesa - Come creare una torretta laser
• Intrattenimento - Come creare un gioco come dice Simon
• IOT App Watson su IBM Bluemix - Come integrare tutti i sistemi in un'unica dashboard

Vai avanti e accedi al file pdf per una spiegazione più dettagliata su come creare questo progetto.

Passaggio 1: requisiti hardware

Questo è ciò di cui avrai bisogno

1. Sicurezza
   • 1 lampone pi
   • 1 LCD
   • 1 lettore RFID
   • 1 PiCam
   • 2 schede/pulsanti RFID
   • X Cavi jumper femmina -> maschio
2. Difesa
   • 1 lampone pi
   • 2 Resistenza 10 ㏀ (per pulsanti)
   • 2 micro servi
   • 1 modulo trasmettitore laser da 650 nm
   • 2 pulsanti
   • 1 cicalino
   • 3 piccoli elastici/fascette (per il fissaggio)
   • X Cavi jumper femmina -> maschio
   • X Cavi di Salto Regolari
   • 1 transistor
   • 1 condensatore

3. Intrattenimenti

   • 1 lampone pi
   • 3 1 ㏀ Resistenza (per LED)
   • 1 Resistenza da 10㏀ (per LDR)
   • 3 LED (diversi colori)
   • 3 pulsanti
   • 1 LDR
   • 1 LCD
   • 1 sensore di movimento Pir
   • X Cavi jumper femmina -> maschio
   • X Cavi di Salto Regolari

Passaggio 2: sicurezza

Creazione dell'hardware del sistema di sicurezza

Collegare i circuiti come mostrato nello schema fritzing

Creazione del software del sistema di sicurezza

1. Configura AWS creando qualcosa
2. Installa AWS Python Library
3. Installa la libreria LCD
4. Installa la libreria RFID
5. Imposta Firebase
6. Configurazione della memoria S3
7. Installa Boto su Raspberry Pi
8. Installa AWS ClI su Raspberry Pi
9. Crea credenziali AWS
10. Configura AWS
11. Carica security.py su RPi
12. Carica imagerecognition.py su RPi

security.py è un codice che legge gli input rfid e rileva se l'utente è un intruso o meno. Se l'utente viene riconosciuto, verrà scattata un'immagine e caricata su s3. Il codice pubblica anche su un argomento in aws MQTT

Fase 3: Difesa

Creazione dell'hardware della torretta laser

1. Creiamo la torretta laser utilizzando 2 servocomandi e 1 modulo laser
2. Collegare i circuiti come mostrato nello schema fritzing

Creazione del software della torretta laser

Il codice seguente farà sparare la torretta laser in direzioni casuali, in raffiche e velocità casuali

laserturret.py

da gpiozero import LED, Buzzer, Button, Servoimport tempo da segnale import pausa import random

#led = LED(12)

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

def ledON():

led.on() print("LED acceso") def ledOFF(): led.off() print("LED spento")

def fuoco():

print("armi calde") buzzer_pin.on() time.sleep(0.1) buzzer_pin.off()

def torretta laser():

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

note = {

'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, 'RE2': 73, 'DS2': 78, 'EB2': 78, 'MI2': 82, 'F2': 87, 'FS2': 93, 'S2': 98, 'GS2': 104, 'LA2': 110, 'AS2': 117, 'BB2': 123, 'B2': 123, 'DO3': 131, 'CS3': 139, 'RE3': 147, 'DS3': 156, 'EB3 ': 156, 'MI3': 165, 'FA3': 175, 'FS3': 185, 'sol3': 196, 'GS3': 208, 'LA3': 220, 'LA3': 233, 'BB3': 233, 'B3': 247, 'DO4': 262, 'CS4': 277, 'RE4': 294, 'DS4': 311, 'EB4': 311, 'MI4': 330, 'FA4': 349, 'FS4': 370, 'G4': 392, 'GS4': 415, 'A4': 440, 'AS4': 466, 'BB4': 466, 'B4': 494, 'C5': 523, 'CS5 ': 554, 'RE5': 587, 'DS5': 622, 'EB5': 622, 'MI5': 659, 'FA5': 698, 'FS5': 740, 'sol5': 784, 'GS5': 831, 'LA5': 880, 'LA5': 932, 'BB5': 932, 'LA5': 988, 'DO6': 1047, 'CS6': 1109, 'RE6': 1175, 'DS6': 1245, 'EB6': 1245, 'E6': 1319, 'F6': 1397, 'FS6': 1480, 'G6': 1568, 'GS6': 1661, 'A 6': 1760, 'LA6': 1865, 'BB6': 1865, 'LA6': 1976, 'DO7': 2093, 'CS7': 2217, 'RE7': 2349, 'DS7': 2489, 'EB7': 2489, 'E7': 2637, 'F7': 2794, 'FS7': 2960, 'G7': 3136, 'GS7': 3322, 'LA7': 3520, 'AS7': 3729, 'BB7': 3729, 'B7': 3951, 'DO8': 4186, 'CS8': 4435, 'RE8': 4699, 'DS8': 4978 }

def buzz(frequency, length): #crea la funzione "buzz" e inserisci intonazione e durata)

if(frequenza==0):

time.sleep(length) return period = 1.0 / frequency #frequency delayValue = period / 2 #calcola il tempo per metà dell'onda numCycles = int(length * frequency) #num of wave = duratime x freq for i in range(numCycles): #avvia un ciclo da 0 alla variabile "cycles" calcolata sopra buzzer_pin.on() time.sleep(delayValue) buzzer_pin.off() time.sleep(delayValue)

def play(melodia, tempo, pausa, ritmo=0.800):

for i in range(0, len(melody)): # Riproduci song noteDuration = pace/tempo buzz(melody, noteDuration) # Cambia la frequenza lungo la nota della canzone pauseBetweenNotes = noteDuration * pause time.sleep(pausa tra le note)

mentre vero:

torretta laser() interruzione;

Passaggio 4: intrattenimento

Creare l'hardware per l'intrattenimento

Creiamo il gioco dei pulsanti Simon-says, in cui devi seguire lo schema dei LED che si accendono e premere i pulsanti corrispondenti. Carica punteggi e timestamp nel database NoSQL di Firebase per un ulteriore utilizzo nei dashboard.

Collegare i circuiti come mostrato nello schema di Fritzing.

Creazione del software di intrattenimento

intrattenimento.py

importazione RPi. GPIO come GPIOimport tempo filettatura importazione tweepy importazione casuale import os importazione da LCD rpi_lcd importazione dalla chiamata sottoprocesso importazione di tanto sonno importazione da datetime datetime import da Firebase CONSUMER_KEY importazione Firebase = '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', Nessuno) lcd=LCD() lcd.text('Buon divertimento!', 1) lcd.text('Buona fortuna!', 2) sleep(1) # LUCI rosse, gialle, verdi = [40, 38, 36] PULSANTI = [37, 33, 35] NOTE = ["E3", "A4", "E4"] # valori modificabili che influenzano la velocità di gioco = 0.5 # flag usati per segnalare il gioco status is_displaying_pattern = False is_won_curr ent_level = False is_game_over = False # game state 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. setup(BUTTONS, GPIO. IN, pull_up_down=GPIO. PUD_DOWN) for i in range(3): GPIO.add_event_detect(BUTTONS, GPIO. FALLING, verificare_player_selection) def verificare_player_selection(canale): global current_step_of_level, current_level, is,won_current_level is_game_over if not is_displaying_pattern e not is_won_current_level e not is_game_over: flash_led_for_button(canale) if channel == BUTTONS[pattern[current_step_of_level]: current_step_of_level += 1 if current_step_of_level >= true_level_other = current_level è def_current_level += 1_current_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, cura 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(): globale is_displaying_pattern is_displaying_pattern = True GPIO.output(currentS, GPIO_range): 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 (): while not is_won_current_level e not 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 = current_step_level = current_step = livello_corrente_falso è_falso_livello di gioco 1 GPIO.output(LIGHTS, GPIO. LOW) def send_data(score): lcd.text('End of game, ', 1) lcd.text('A presto!', 2) datestr = str(datetime. now()) mentre True: print(datestr) print(score) data={ 'Date': datestr, 'Score': score } result = firebase.post('/scores/', data) print(result) if score > 2: status='Qualcuno ha segnato ' + (str(punteggio)) +' su '+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! il punteggio è {} colori!\n".format(current_level - 1)) sleep(2) print("Grazie per aver giocato!\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("Inizia un nuovo round!\n") initialize_gpio() start_game_monitor() infine: GPIO.cleanup() if _name_ == '_main_': main()

Passaggio 5: IOT App Watson su IBM Bluemix [Parte prima]

Configura il servizio Blumix IoT

1. Configurare un tipo di dispositivo gateway
2. Configura un dispositivo

Eseguire i passaggi 1 e 2 per 3 volte. Un RPi è per una sezione (Sicurezza/Difesa/Intrattenimento)

Configura Nodo-Rosso

Esegui node-red

inizio nodo rosso

1. Vai a gestire la tavolozza nel menu dell'hamburger (in alto a destra)

2. Scarica i seguenti pallet

   1. nodo-rosso-dashboard
   2. nodo-rosso-contrib-firebase
   3. nodo-rosso-contrib-ibm-watson-iot

Passaggio 6: flussi rossi del nodo

Scarica i file ed esportali nel tuo node-red.

Nodo di sicurezza-rosso

nessuno

Nodo Rpi Difesa-Rosso

laserturret.txt

Intrattenimento Rpi Nodo-Rosso

• intrattenimento rpi flow.txt
• ldr rpi flusso.txt

IBM Bluemix Node-Rosso