सिंहावलोकन: गृह मनोरंजन और सुरक्षा प्रणाली: 6 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

इस एप्लिकेशन के बारे में

यह IOT सिस्टम एक होम एंटरटेनमेंट और सिक्योरिटी सिस्टम है।

1. सुरक्षा

   1. आरएफआईडी कार्ड टैप करें और इनपुट फायरबेस में सहेजे जाते हैं।
   2. यदि अधिकृत हो, तो आप शांति से प्रवेश कर सकते हैं और चित्र लिया जाता है और S3. पर अपलोड किया जाता है
   3. यदि अनधिकृत है, तो रक्षा अनुभाग आता है और एक LCD स्क्रीन कहेगी कि आप अधिकृत नहीं हैं।

2. रक्षा

   1. डैशबोर्ड पर बटन दबाएं।
   2. लेजर बुर्ज यादृच्छिक विस्फोट और गति में हमला करेगा।

3. मनोरंजन

   1. यदि गति का पता चलता है, तो खेल शुरू हो जाएगा।
   2. उपयोगकर्ता द्वारा गेम खेलने के बाद, स्कोर फायरबेस में सहेजा जाता है।
   3. LDR मान लिया जाएगा और डैशबोर्ड पर आउटपुट होगा।

यह एप्लिकेशन आईबीएम नोड-रेड वेब सर्वर के माध्यम से नियंत्रित और देखने योग्य है। हम AWS और IBM Cloud Services का उपयोग करते हैं और हमने अपने डेटाबेस के रूप में Firebase का उपयोग किया है।

वर्णित चरणों का सारांश

• हार्डवेयर आवश्यकताएँ
• सुरक्षा - आरएफआईडी इनपुट और छवि पहचान सॉफ़्टवेयर का उपयोग करने वाली सुरक्षा प्रणाली कैसे बनाएं
• रक्षा - लेजर बुर्ज कैसे बनाएं
• मनोरंजन - साइमन-सेज़ गेम कैसे बनाएं
• आईबीएम ब्लूमिक्स पर आईओटी ऐप वाटसन - सभी प्रणालियों को एक डैशबोर्ड में कैसे एकीकृत करें

आगे बढ़ें और इस प्रोजेक्ट को बनाने के तरीके के बारे में अधिक विस्तृत विवरण के लिए पीडीएफ फाइल तक पहुंचें।

चरण 1: हार्डवेयर आवश्यकता

यह वही है जिसकी आपको आवश्यकता होगी

1. सुरक्षा

   • 1 रास्पबेरी पाई
   • 1 एलसीडी
   • 1 आरएफआईडी रीडर
   • 1 पिकैम
   • 2 आरएफआईडी कार्ड / बटन
   • X महिला -> पुरुष जम्पर केबल

2. रक्षा

   • 1 रास्पबेरी पाई
   • 2 10 रोकनेवाला (बटन के लिए)
   • 2 माइक्रो सर्वो
   • 1 650nm लेजर ट्रांसमीटर मॉड्यूल
   • 2 पुश बटन
   • 1 बजर
   • 3 छोटे रबर बैंड/केबल टाई (फिक्सिंग के लिए)
   • X महिला -> पुरुष जम्पर केबल
   • एक्स रेगुलर जंप केबल्स
   • 1 ट्रांजिस्टर
   • 1 संधारित्र

3. एंटरटेनमेंट

   • 1 रास्पबेरी पाई
   • 3 1 प्रतिरोधी (एल ई डी के लिए)
   • 1 10㏀ प्रतिरोधी (एलडीआर के लिए)
   • 3 एलईडी (विभिन्न रंग)
   • 3 बटन
   • 1 एलडीआर
   • 1 एलसीडी
   • 1 पीर मोशन सेंसर
   • X महिला -> पुरुष जम्पर केबल
   • एक्स रेगुलर जंप केबल्स

चरण 2: सुरक्षा

सुरक्षा प्रणाली हार्डवेयर बनाना

सर्किट को कनेक्ट करें जैसा कि फ्रिटिंग आरेख में दिखाया गया है

सुरक्षा प्रणाली सॉफ्टवेयर बनाना

1. एक चीज़ बनाकर AWS को कॉन्फ़िगर करें
2. एडब्ल्यूएस पायथन लाइब्रेरी स्थापित करें
3. एलसीडी लाइब्रेरी स्थापित करें
4. आरएफआईडी पुस्तकालय स्थापित करें
5. सेटअप फायरबेस
6. सेटअप S3 संग्रहण
7. रास्पबेरी पाई पर बोटो स्थापित करें
8. रास्पबेरी पाई पर एडब्ल्यूएस सीएलआई स्थापित करें
9. एडब्ल्यूएस क्रेडेंशियल बनाएं
10. एडब्ल्यूएस कॉन्फ़िगर करें
11. सुरक्षा.py को RPi पर अपलोड करें
12. इमेजरिकॉग्निशन.py को आरपीआई पर अपलोड करें

security.py एक कोड है जो आरएफआईडी इनपुट को पढ़ेगा और पता लगाएगा कि उपयोगकर्ता घुसपैठिया है या नहीं। यदि उपयोगकर्ता को पहचाना जाता है, तो एक छवि ली जाएगी और s3 पर अपलोड की जाएगी। कोड भी एक विषय पर प्रकाशित करता है aws MQTT

चरण 3: रक्षा

लेजर बुर्ज हार्डवेयर बनाना

1. हम 2 सर्वो और 1 लेजर मॉड्यूल का उपयोग करके लेजर बुर्ज बनाते हैं
2. सर्किट को कनेक्ट करें जैसा कि फ्रिटिंग आरेख में दिखाया गया है

लेजर बुर्ज सॉफ्टवेयर बनाना

नीचे दिया गया कोड लेजर बुर्ज शूट को रैंडम दिशाओं में, रैंडम बर्स्ट और स्पीड में करेगा।

लेसरटुरेट.py

जीपीओजेरो से आयात एलईडी, बजर, बटन, सिग्नल आयात से सर्वोइमपोर्ट समय आयात रोकें आयात यादृच्छिक

# एलईडी = एलईडी(12)

#पीर = मोशन सेंसर (१९, सैंपल_रेट = ५, क्यू_लेन = १) बजर_पिन = बजर (१७) अटैक = बटन (५, पुल_अप = झूठा) #रीसेट = बटन (६, पुल_अप = झूठा) सर्वो १ = सर्वो (१८) सर्वो २ = सर्वो(24)

डीईएफ़ लेडॉन ():

एलईडी.ऑन () प्रिंट ("एलईडी चालू है") डीईएफ़ एलईडीऑफ़ (): एलईडी.ऑफ़ () प्रिंट ("एलईडी बंद है")

डीईएफ़ फायर ():

प्रिंट ("हथियार गर्म") buzzer_pin.on() time.sleep(0.1) buzzer_pin.off()

डीईएफ़ लेसरटुरेट ():

टाइमबीच बर्स्ट = रैंडम.यूनिफ़ॉर्म (0.2, 1) टाइमबीनशॉट्स = रैंडम.यूनिफ़ॉर्म (0.05, 0.2) सर्वो1स्टार्ट = रैंडम.रैंडरेंज (-1, 1) सर्वो 1एंड = रैंडम.रैंडरेंज (-1, 1) सर्वो 2स्टार्ट = रैंडम.रैंडरेंज (-1), १) सर्वो२एंड = रैंडम.रैंडरेंज (-१, १) numShots = random.randrange(५, २०) सर्वो१चेंज = (सर्वो१एंड - सर्वो१स्टार्ट)/numShots सर्वो२चेंज = (सर्वो२एंड - सर्वो२स्टार्ट)/न्यूमशॉट्स सर्वो१.वैल्यू = सर्वो१स्टार्ट सर्वो२.वैल्यू = सर्वो२स्टार्ट टाइम.स्लीप (०.१) शॉट = ० डिटेल = [टाइमबीटबर्स्ट, टाइमबीटवीनशॉट्स, सर्वो१.वैल्यू, सर्वो२.वैल्यू, numShots] प्रिंट (विस्तार) शॉट के दौरान <numshots: शॉट + = "१" सर्वो १.वैल्यू = "सर्वो १स्टार्ट" सर्वो २.value="servo2start" सर्वो1स्टार्ट="सर्वो1चेंज" सर्वो२स्टार्ट="सर्वो२चेंज" आग टाइम.स्लीप टाइम.स्लीप (टाइमबीटबीनबर्स्ट)

नोट्स = {

'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, 'बी3': 247, 'सी4': 262, 'सीएस4': 277, 'डी4': 294, 'डीएस4': 311, 'ईबी4': 311, 'ई4': 330, 'एफ4': 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 (आवृत्ति, लंबाई): # फ़ंक्शन "buzz" बनाएं और इसे पिच और अवधि खिलाएं)

अगर (आवृत्ति == 0):

समय। नींद (लंबाई) वापसी की अवधि = 1.0 / आवृत्ति # आवृत्ति देरी मान = अवधि / 2 # तरंग संख्या के आधे के लिए समय की गणना करें = int (लंबाई * आवृत्ति) # तरंगों की संख्या = ड्यूराटाइम x आवृत्ति के लिए i रेंज में (संख्या साइकिल)): # buzzer_pin.on() time.sleep(delayValue) buzzer_pin.off() time.sleep(delayValue) से ऊपर परिकलित वेरिएबल "साइकिल" के लिए 0 से एक लूप शुरू करें।

डीईएफ़ प्ले (मेलोडी, टेम्पो, पॉज़, पेस = 0.800):

फॉर आई इन रेंज (0, लेन (मेलोडी)): # गाना प्ले करें नोट अवधि = गति / गति buzz (मेलोडी , नोट अवधि) # गाने के साथ आवृत्ति बदलें विराम के बीच नोट्स)

जबकि सच:

लेसरटुरेट () ब्रेक;

चरण 4: मनोरंजन

मनोरंजन हार्डवेयर बनाना

हम साइमन-सेज बटन गेम बनाते हैं, जिसमें आपको एलईडी लाइटिंग के पैटर्न का पालन करना होता है और संबंधित बटन को दबाना होता है। यह डैशबोर्ड में आगे उपयोग के लिए फायरबेस NoSQL डेटाबेस में स्कोर और टाइमस्टैम्प अपलोड करता है।

सर्किट को कनेक्ट करें जैसा कि फ्रिटिंग आरेख में दिखाया गया है।

एंटरटेनमेंट सॉफ्टवेयर बनाना

Entertainment.py

आयात RPi. GPIO GPIOimport सूत्रण आयात समय आयात यादृच्छिक आयात ओएस आयात firebase आयात firebase CONSUMER_KEY से = 'h5Sis7TXdoUVncrpjSzGAvhBH' CONSUMER_SECRET = 'ZfDVxc4aTd9doGmBQO3HiSKKzxSTKT4C3g0B3AGx8eETCJm2rY' ACCESS_KEY = 'datetime आयात दिनांक-समय आयात नींद से उपप्रक्रिया आयात कॉल से rpi_lcd आयात एलसीडी से tweepy रूप 988333099669901312- YDLEQN1weW2n1JP4lxJcFPppCsbvzQh 'ACCESS_SECRET =' K2IlUPur6jx7DO5S0HhhZW29H5AQFOvkMMevSsk9ZzwLk 'प्रमाणन = tweepy. OAuthHandler (CONSUMER_KEY, CONSUMER_SECRET) auth.secure = सच auth.set_access_token (ACCESS_KEY, ACCESS_SECRET) API = tweepy. API (प्रमाणन) firebase = firebase. FirebaseApplication (' https:// iotca2 -12f48.firebaseio.com', कोई नहीं) LCD=LCD() LCD.text('मज़े करें!', 1) LCD.text('गुड लक!', 2) स्लीप (1) # लाल, पीली, हरी बत्ती = [४०, ३८, ३६] बटन = [३७, ३३, ३५] नोट = ["ई३", "ए४", "ई४"] # मान जो आप बदल सकते हैं जो गेम खेलने की गति को प्रभावित करते हैं = ०.५ # झंडे गेम को सिग्नल करने के लिए उपयोग किए जाते हैं स्थिति is_displaying_pattern = गलत is_won_curr ent_level = False is_game_over = गलत # गेम स्थिति current_level = 1 current_step_of_level = 0 पैटर्न = def Initialize_gpio (): GPIO.setmode (GPIO. BOARD) GPIO.setup (LIGHTS, GPIO. OUT, प्रारंभिक = GPIO. LOW) GPIO। सेटअप (बटन, GPIO. IN, pull_up_down = GPIO. PUD_DOWN) मैं रेंज में (3) के लिए: GPIO.add_event_detect(BUTTONS, GPIO. FALLING, Verify_player_selection) def Verify_player_selection (चैनल): ग्लोबल current_step_of_won_level, current_level, is is_game_over अगर is_displaying_pattern नहीं है और is_won_current_level नहीं है और is_game_over नहीं है: flash_led_for_button(चैनल) अगर चैनल == बटन [पैटर्न [current_step_of_level]: current_step_of_level += 1 अगर current_step_of_level >= current_level है: current_level += 1 is_ flash_led_for_button(button_channel): एलईडी = लाइट्स [बटन.इंडेक्स (बटन_चैनल)] GPIO.आउटपुट (एलईडी, GPIO. HIGH) समय। नींद (0.4) GPIO.output (एलईडी, GPIO. LOW) def add_new_color_to_pattern (): वैश्विक is_won_current_level, कुर 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(LIGHTS) for i GPIO. LOW. 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 (): जबकि is_won_current_level नहीं है और is_game_over नहीं है: time.sleep(0.1) def reset_board_for_new_game(): ग्लोबल is_displaying_pattern, is_won_current_level, is_game_over Global current_level, current_step_of_level, पैटर्न is_displaying_pattern = False is_step_current_level_over = 0 GPIO.output(LIGHTS, GPIO. LOW) def send_data(score): LCD.text ('खेल का अंत,', 1) LCD.text ('जल्द ही मिलते हैं!', 2) datestr = str(datetime. now ()) जबकि ट्रू: प्रिंट (datestr.)) प्रिंट (स्कोर) डेटा = {'दिनांक': डेटस्ट्र, 'स्कोर': स्कोर} परिणाम = फायरबेस। पोस्ट ('/ स्कोर /', डेटा) प्रिंट (परिणाम) अगर स्कोर> 2: स्थिति = 'किसी ने स्कोर किया है' + (str(score)) +' '+ datestr+' पर!' api.update_status (status = status) ब्रेक डिफ स्टार्ट_गेम (): जबकि ट्रू: add_new_color_to_pattern() display_pattern_to_player() wait_for_player_to_repeat_pattern() अगर is_game_over: send_data(current_level - 1) प्रिंट ("गेम ओवर! स्कोर {} रंग है!\n".format(current_level - 1)) स्लीप(2) प्रिंट ("खेलने के लिए धन्यवाद!\n") LCD.text('', 1) LCD.text('', 2) ब्रेक टाइम। स्लीप (2) def start_game_monitor (): t = थ्रेडिंग। थ्रेड (लक्ष्य = start_game) t.daemon = ट्रू t.start () t.join () def main (): कोशिश करें: os.system ('cls' अगर os.name == 'nt ' और 'क्लियर') प्रिंट ("नया राउंड शुरू करें! / n") इनिशियलाइज़_जीपीओ () start_game_monitor () अंत में: GPIO.cleanup () अगर _name_ == '_main_': main()

चरण 5: आईबीएम ब्लूमिक्स पर IOT ऐप वाटसन [भाग एक]

ब्लूमिक्स IoT सेवा सेट करें

1. गेटवे डिवाइस प्रकार सेट करें
2. डिवाइस सेट करें

चरण 1 और 2 को 3 बार करें। एक आरपीआई एक सेक्शन के लिए है (सुरक्षा/रक्षा/मनोरंजन)

नोड-लाल सेट करें

नोड-लाल चलाएं

नोड-लाल प्रारंभ

1. हैमबर्गर मेनू में पैलेट प्रबंधित करने के लिए जाएं (ऊपर दाएं)

2. निम्नलिखित पैलेट डाउनलोड करें

   1. नोड-लाल-डैशबोर्ड
   2. नोड-लाल-योगदान-फायरबेस
   3. नोड-लाल-योगदान-आईबीएम-वाटसन-आईओटी

चरण 6: नोड लाल प्रवाह

फ़ाइलें डाउनलोड करें और अपने नोड-रेड में निर्यात करें।

सुरक्षा नोड-लाल

कोई नहीं

रक्षा आरपीआई नोड-लाल

लेसरटुरेट.txt

मनोरंजन आरपीआई नोड-लाल

• मनोरंजन आरपीआई प्रवाह.txt
• एलडीआर आरपीआई प्रवाह.txt

आईबीएम ब्लूमिक्स नोड-रेड