Visão geral: entretenimento doméstico e sistema de segurança: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Sobre o aplicativo

Este sistema IOT é um sistema de entretenimento e segurança em casa.

1. Segurança
   1. Toque no cartão RFID e os dados serão salvos no Firebase.
   2. Se autorizado, você pode entrar pacificamente e a foto é tirada e carregada no S3
   3. Se não autorizado, a seção de defesa entra e uma tela LCD dirá que você não está autorizado.
2. Defesa
   1. Pressione o botão no painel.
   2. As torres de laser atacarão em rajadas e velocidade aleatórias.

3. Entretenimento

   1. Se for detectado movimento, o jogo será iniciado.
   2. Depois que o usuário joga o jogo, a pontuação é salva no Firebase.
   3. Os valores de LDR serão obtidos e exibidos no painel.

Este aplicativo pode ser controlado e visualizado por meio do servidor da web IBM Node-Red. Usamos AWS e IBM Cloud Services e usamos o Firebase como nosso banco de dados.

Resumo das etapas que serão descritas

• Requisitos de Hardware
• Segurança - Como criar um sistema de segurança que usa entrada RFID e um software de reconhecimento de imagem
• Defesa - Como criar uma torre de laser
• Entretenimento - Como criar um jogo Simon-says
• IOT App Watson no IBM Bluemix - Como integrar todos os sistemas em um painel

Vá em frente e acesse o arquivo pdf para uma explicação mais detalhada sobre como criar este projeto.

Etapa 1: Requisito de Hardware

Isso é o que você vai precisar

1. Segurança
   • 1 Raspberry Pi
   • 1 LCD
   • 1 leitor RFID
   • 1 PiCam
   • 2 cartões / botões RFID
   • X Fêmea -> Cabos de ligação macho
2. Defesa
   • 1 Raspberry Pi
   • 2 10 ㏀ Resistor (para botões)
   • 2 Micro Servo
   • Módulo transmissor laser de 1 650 nm
   • 2 botão de pressão
   • 1 campainha
   • 3 pequenas bandas de borracha / abraçadeiras (para fixação)
   • X Fêmea -> Cabos de ligação macho
   • X Cabos de salto regulares
   • 1 transistor
   • 1 capacitor

3. Entretenimentos

   • 1 Raspberry Pi
   • 3 1 ㏀ Resistor (para LEDs)
   • 1 Resistor de 10㏀ (para LDR)
   • 3 LEDs (cores diferentes)
   • 3 botões
   • 1 LDR
   • 1 LCD
   • 1 sensor de movimento Pir
   • X Fêmea -> Cabos de ligação macho
   • X Cabos de salto regulares

Etapa 2: Segurança

Criação do hardware do sistema de segurança

Conecte os circuitos conforme mostrado no diagrama de fritzing

Criação do software do sistema de segurança

1. Configure a AWS criando algo
2. Instale a biblioteca AWS Python
3. Instalar biblioteca LCD
4. Instalar biblioteca RFID
5. Configure o Firebase
6. Configurar o armazenamento S3
7. Instale o Boto no Raspberry Pi
8. Instale o AWS ClI no Raspberry Pi
9. Criar credenciais AWS
10. Configurar AWS
11. Faça upload de security.py para RPi
12. Faça upload de imagerecognition.py para RPi

security.py é um código que lê entradas rfid e detecta se o usuário é um intruso ou não. Se o usuário for reconhecido, uma imagem será tirada e enviada para s3. O código também publica em um tópico no aws MQTT

Etapa 3: Defesa

Criando o Hardware da torre do laser

1. Nós criamos a torre de laser usando 2 servos e 1 Módulo de Laser
2. Conecte os circuitos conforme mostrado no diagrama de fritzing

Criando o software da torre do laser

O código abaixo fará com que a torre do laser atire em direções aleatórias, em rajadas e velocidade aleatórias

laserturret.py

de gpiozero import LED, campainha, botão, servoimportação de tempo de importação de sinal pausa importação aleatória

#led = LED (12)

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

def ledON ():

led.on () print ("LED está ligado") def ledOFF (): led.off () print ("LED está desligado")

def fire ():

print ("armas quentes") 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 - servo1início) / numShots servo2change = (servo2end - servo2início) / numShots servo1.value = servo1iniciar servo = servo2start time.sleep (0.1) shot = 0 detail = [timeBetweenBurst, timeBetweenShots, servo1.value, servo2.value, numShots] imprimir (detalhe) durante o tiro <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 (frequência, comprimento): #crie a função "buzz" e alimente-a com o tom e a duração)

if (frequência == 0):

time.sleep (length) return period = 1.0 / frequencia #frequency delayValue = period / 2 #calcute o tempo para a metade da onda numCycles = int (length * frequencia) #num of waves = duratime x freq for i in range (numCycles): # iniciar um loop de 0 até a variável "ciclos" calculada acima buzzer_pin.on () time.sleep (delayValue) buzzer_pin.off () time.sleep (delayValue)

def play (melodia, tempo, pausa, ritmo = 0,800):

para i no intervalo (0, len (melodia)): # Tocar música noteDuration = pace / tempo buzz (melody , noteDuration) # Alterar a frequência ao longo da nota da música pauseBetweenNotes = noteDuration * pause time.sleep (pauseBetweenNotes)

enquanto verdadeiro:

laserturret () quebra;

Etapa 4: Entretenimento

Criação do hardware de entretenimento

Criamos o jogo de botão Simon-says, no qual você deve seguir o padrão dos LEDs acesos e pressionar os botões correspondentes. Ele carrega pontuações e carimbo de data / hora no banco de dados Firebase NoSQL para uso posterior nos painéis.

Conecte os circuitos conforme mostrado no diagrama de Fritzing.

Criação do software de entretenimento

entertainment.py

importação RPi. GPIO como GPIOimport tempo de threading importação tweepy importação aleatória import os import de LCD rpi_lcd importação da chamada subprocesso de importação de tempo de sono de importação a partir de data e hora de data e hora de importação de firebase CONSUMER_KEY importação firebase = '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 ', Nenhum) lcd = LCD () lcd.text (' Divirta-se! ', 1) lcd.text (' Boa Sorte! ', 2) sleep (1) # Vermelho, Amarelo, Verde LUZES = [40, 38, 36] BUTTONS = [37, 33, 35] NOTES = ["E3", "A4", "E4"] # valores que você pode alterar que afetam a velocidade de jogo = 0,5 # sinalizadores usados para sinalizar o jogo status is_displaying_pattern = False is_won_curr ent_level = False is_game_over = False # estado do jogo 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. configuração (BUTTONS, GPIO. IN, pull_up_down = GPIO. PUD_DOWN) para i no intervalo (3): GPIO.add_event_detect (BUTTONS , GPIO. FALLING, verify_player_selection) def verify_player_selection (canal): global, current_step_of_level é atual is_game_over if not is_displaying_pattern and not is_won_current_level e not is_game_over: flash_led_for_button (channel) if channel == BUTTONS [pattern [current_step_of_level]: current_step_of_level + = 1 if current_step_of_level = current_step_of_level + = 1 if current_step_of_level + = 1 if current_step_of_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_cevel_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 = true GPIO.inível de saída (GPIO.live_pattern atual) (intervalo_lIGHTS_inível) (GPIO.output atual) (GPIO.lIGHTS_pattern atual) (intervalo_lIGHTS atual) (intervalo_lIGHTS_inível) (nível_lIGHTS atual) para saída GPIO.: GPIO.output (LIGHTS [padrão , GPIO. HIGH) time.sleep (velocidade) GPIO.output (LIGHTS [padrão , GPIO. LOW) time.sleep (velocidade) is_displaying_pattern = Falso def wait_for_player_to_repeat_pattern (): embora não is_won_current_level e não 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 (): global is_displaying_pattern, is_won_current_level, is_game_over global Current_level, current_step_of_level, padrão is_displaying_pattern, is_won_current_level, is_game_over global False_step_level = current_step_level_levelse = 1_padrão_padrão_padrão_atual = 0_padrão_padrão_corrente é 0_padrão_padrão_corrente = nível_padrão_corrente 0 GPIO.output (LIGHTS, GPIO. LOW) def send_data (pontuação): lcd.text ('Fim do jogo,', 1) lcd.text ('Vejo você em breve!', 2) datestr = str (datetime. now ()) enquanto True: print (datestr) print (score) data = {'Date': datestr, 'Score': score} result = firebase.post ('/ scores /', data) print (result) if score> 2: status = 'Someone has score' + (str (pontuação)) + 'on' + datestr + '!' api.update_status (status = status) break def start_game (): enquanto 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! n.format (current_level - 1)) sleep (2) print ("Obrigado por jogar! / 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 ("Começar uma nova rodada! / n") initialize_gpio () start_game_monitor () finalmente: GPIO.cleanup () if _name_ ==' _main_ ': main ()

Etapa 5: IOT App Watson no IBM Bluemix [Parte Um]

Configurar serviço Blumix IoT

1. Configurar um tipo de dispositivo de gateway
2. Configurar um dispositivo

Execute as etapas 1 e 2 por 3 vezes. Um RPi é para uma seção (Segurança / Defesa / Entretenimento)

Configurar Node-Red

Executar node-red

nó-vermelho início

1. Vá para gerenciar paleta no menu de hambúrguer (canto superior direito)

2. Baixe os seguintes paletes

   1. node-red-dashboard
   2. node-red-contrib-firebase
   3. node-red-contrib-ibm-watson-iot

Etapa 6: fluxos vermelhos do nó

Baixe os arquivos e exporte para o seu node-red.

Nó de Segurança - Vermelho

Nenhum

Defesa Rpi Nó-Vermelho

laserturret.txt

Entertainment Rpi Node-Red

• entretenimento rpi flow.txt
• ldr rpi flow.txt

IBM Bluemix Node-Red