Przegląd: Domowa rozrywka i system bezpieczeństwa: 6 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:31

O aplikacji

Ten system IOT to domowa rozrywka i system bezpieczeństwa.

1. Bezpieczeństwo

   1. Dotknij karty RFID i dane wejściowe są zapisywane w Firebase.
   2. Jeśli masz uprawnienia, możesz wejść spokojnie, a zdjęcie zostanie zrobione i przesłane do S3
   3. Jeśli nieautoryzowany, pojawi się sekcja obrony, a ekran LCD powie, że nie masz autoryzacji.
2. Obrona
   1. Naciśnij przycisk na desce rozdzielczej.
   2. Wieżyczki laserowe będą atakować w losowych seriach i szybkościach.
3. Zabawa
   1. Jeśli ruch zostanie wykryty, gra się rozpocznie.
   2. Gdy użytkownik zagra w grę, wynik zostanie zapisany w Firebase.
   3. Wartości LDR zostaną pobrane i wyprowadzone na desce rozdzielczej.

Tą aplikacją można sterować i przeglądać za pośrednictwem serwera WWW IBM Node-Red. Korzystamy z usług AWS i IBM Cloud Services, a jako bazy danych wykorzystaliśmy Firebase.

Podsumowanie kroków, które zostaną opisane

• Wymagania sprzętowe
• Bezpieczeństwo - Jak stworzyć system bezpieczeństwa wykorzystujący wejście RFID i oprogramowanie do rozpoznawania obrazu
• Obrona - Jak stworzyć wieżyczkę laserową
• Rozrywka - Jak stworzyć grę Simon-mówi
• IOT App Watson na IBM Bluemix - jak zintegrować wszystkie systemy w jeden pulpit nawigacyjny

Śmiało i uzyskaj dostęp do pliku pdf, aby uzyskać bardziej szczegółowe wyjaśnienie, jak utworzyć ten projekt.

Krok 1: Wymagania sprzętowe

To jest to, czego będziesz potrzebować

1. Bezpieczeństwo

   • 1 Raspberry Pi
   • 1 wyświetlacz LCD
   • 1 czytnik RFID
   • 1 PiCam
   • 2 karty/przyciski RFID
   • X żeńskie -> męskie kable rozruchowe
2. Obrona
   • 1 Raspberry Pi
   • 2 10 ㏀ Rezystor (dla przycisków)
   • 2 mikro serwo
   • 1 moduł nadajnika laserowego 650nm
   • 2 przycisk
   • 1 brzęczyk
   • 3 małe gumki/opaski kablowe (do mocowania)
   • X żeńskie -> męskie kable rozruchowe
   • X Zwykłe kable połączeniowe
   • 1 tranzystor
   • 1 kondensator
3. Rozrywka
   • 1 Raspberry Pi
   • 3 1 ㏀ Rezystor (dla diod LED)
   • 1 Rezystor 10㏀ (dla LDR)
   • 3 diody LED (różne kolory)
   • 3 przyciski
   • 1 LDR
   • 1 wyświetlacz LCD
   • 1 czujnik ruchu Pir
   • X żeńskie -> męskie kable rozruchowe
   • X Zwykłe kable połączeniowe

Krok 2: Bezpieczeństwo

Tworzenie sprzętu systemu bezpieczeństwa

Podłącz obwody, jak pokazano na schemacie fritzowania

Tworzenie oprogramowania systemu bezpieczeństwa

1. Skonfiguruj AWS, tworząc coś
2. Zainstaluj bibliotekę Pythona AWS
3. Zainstaluj bibliotekę LCD
4. Zainstaluj bibliotekę RFID
5. Skonfiguruj Firebase
6. Konfiguracja pamięci S3
7. Zainstaluj Boto na Raspberry Pi
8. Zainstaluj AWS CLI na Raspberry Pi
9. Utwórz poświadczenia AWS
10. Skonfiguruj AWS
11. Prześlij security.py do RPi
12. Prześlij imagerecognition.py do RPi

security.py to kod, który odczytuje dane wejściowe RFID i wykrywa, czy użytkownik jest intruzem, czy nie. Jeśli użytkownik zostanie rozpoznany, zdjęcie zostanie zrobione i przesłane do s3. Kod publikuje również w temacie w aws MQTT

Krok 3: Obrona

Tworzenie sprzętu wieży laserowej

1. Tworzymy wieżyczkę laserową za pomocą 2 serw i 1 modułu laserowego
2. Podłącz obwody, jak pokazano na schemacie fritzowania

Tworzenie oprogramowania wieży laserowej

Poniższy kod sprawi, że wieżyczka laserowa będzie strzelać w losowych kierunkach, w losowych seriach i szybkości

laserturret.py

z gpiozero import LED, Buzzer, Button, Servoimport czas z sygnału import pauza import losowo

#led = LED(12)

#pir = MotionSensor(19, sample_rate=5, queue_len=1) buzzer_pin = Atak brzęczyka(17) = Button(5, pull_up=False) #reset = Button(6, pull_up=False) servo1 = Servo(18) servo2 = Serwo(24)

def ledON():

led.on() print("LED świeci") def ledOFF(): led.off() print("LED nie świeci")

def ogień():

print("broń gorąca") buzzer_pin.on() time.sleep(0.1) buzzer_pin.off()

def wieżyczka laserowa():

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(timemiędzystrzałami)=""time.sleep(czasmiędzywybuchami)

notatki = {

'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(częstotliwość, długość): #utwórz funkcję "buzz" i podaj jej wysokość i czas trwania)

jeśli(częstotliwość==0):

time.sleep(length) return period = 1.0 / frequency #frequency delayValue = period / 2 #oblicz czas dla połowy fali numCycles = int(długość * częstotliwość) #liczba fal = czas trwania x freq for i in range(numCycles): #rozpocznij pętlę od 0 do zmiennej "cykle" obliczonej powyżej buzzer_pin.on() time.sleep(delayValue) buzzer_pin.off() time.sleep(delayValue)

def play (melodia, tempo, pauza, tempo=0.800):

for i in range(0, len(melody)): # Odtwórz nutę piosenki Duration = tempo/tempo buzz(melody, noteDuration) # Zmień częstotliwość wzdłuż nuty piosenki pauseBetweenNotes = noteDuration * pause time.sleep(pauza między nutami)

podczas gdy prawda:

laserturret() przerwa;

Krok 4: Rozrywka

Tworzenie sprzętu rozrywkowego

Tworzymy grę przyciskową Simon-mówi, w której musimy podążać za wzorem zapalających się diod i naciskać odpowiednie przyciski. Przesyła wyniki i znaczniki czasu do bazy danych Firebase NoSQL w celu dalszego wykorzystania w pulpitach nawigacyjnych.

Połącz obwody, jak pokazano na schemacie Fritzing.

Tworzenie oprogramowania rozrywkowego

rozrywka.py

import RPi. GPIO jak GPIOimport czasie gwintowania import import import random import os tweepy z importu rpi_lcd LCD z połączenia importu podproces od czasu snu importu z datetime import datetime z Firebase import Firebase CONSUMER_KEY = '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', Brak) lcd=LCD() lcd.text('Baw się dobrze!', 1) lcd.text('Powodzenia!', 2) sleep(1) # Czerwony, Żółty, Zielony ŚWIATŁA = [40, 38, 36] PRZYCISKI = [37, 33, 35] UWAGI = ["E3", "A4", "E4"] # wartości, które możesz zmienić, które wpływają na szybkość gry = 0.5 # flag używanych do sygnalizowania gry status is_displaying_pattern = Fałsz is_won_curr ent_level = False is_game_over = False # stan gry 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) dla i w zakresie(3): GPIO.add_event_detect(BUTTONS, GPIO. FALLING, Verify_player_selection) def Verify_player_selection(kanał): globalny bieżący_krok_poziomu,won_bieżący_poziom, is_game_over if not is_displaying_pattern i not is_won_current_level and not is_game_over: flash_led_for_button(kanał) if channel == PRZYCISKI[wzór[bieżący_krok_poziomu]: bieżący_krok_poziomu += 1 if true_step_of_level >= obecny_poziom: bieżący_poziom += is_defw 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, kundel 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.output range(LIGHTS, dla iGPIO na poziomie LOW).: GPIO.output(LIGHTS[wzór, GPIO. HIGH) time.sleep(prędkość) GPIO.output(LIGHTS[wzór, GPIO. LOW) time.sleep(prędkość) is_displaying_pattern = False def wait_for_player_to_repeat_pattern (): while not is_won_current_level i nie 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 is_won_current_levels pattern GPIO.output(LIGHTS, GPIO. LOW) def send_data(score): lcd.text('Koniec gry, ', 1) lcd.text('Do zobaczenia wkrótce!', 2) datestr = str(datetime. now()) while True: print(datestr) print(score) data={ 'Data': datestr, 'Wynik': wynik } wynik = firebase.post('/scores/', data) print(wynik) if score > 2: status='Ktoś zdobył punkty ' + (str(wynik)) +' na '+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("Koniec gry! wynik to {} kolorów!\n".format(bieżący_poziom - 1)) sleep(2) print("Dziękujemy za grę!\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("Rozpocznij nową rundę!\n") initialize_gpio() start_game_monitor() w końcu: GPIO.cleanup() if _name_ == '_main_': main()

Krok 5: Aplikacja IOT Watson na IBM Bluemix [część pierwsza]

Skonfiguruj usługę Blumix IoT

1. Skonfiguruj typ urządzenia bramy
2. Skonfiguruj urządzenie

Wykonaj kroki 1 i 2 3 razy. Jeden RPi jest dla jednej sekcji (Bezpieczeństwo/Obrona/Rozrywka)

Skonfiguruj węzeł czerwony

Uruchom węzeł-czerwony

węzeł-czerwony początek

1. Przejdź do zarządzania paletą w menu hamburgerów (prawy górny róg)

2. Pobierz następujące palety

   1. węzeł-czerwony-dashboard
   2. node-red-contrib-firebase
   3. node-red-contrib-ibm-watson-iot

Krok 6: Przepływa czerwony węzeł

Pobierz pliki i wyeksportuj do swojego węzła-red.

Węzeł bezpieczeństwa-czerwony

Żaden

Węzeł obrony Rpi-czerwony

laserturret.txt

Rozrywka Węzeł Rpi-czerwony

• rozrywka rpi flow.txt
• ldr rpi przepływ.txt

IBM Bluemix Node-czerwony