रास्पबेरी पीआई एलईडी मौसम स्टेशन: 8 कदम

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

हमने रास्पबेरी पीआई वेदर एलईडी स्टेशन बनाया। यह उपयोगकर्ता को बताता है कि रोशनी, और डिमिंग, एलईडी द्वारा शहर कितना गर्म और ठंडा है। इसमें उन्हें यह बताने के लिए एक नेतृत्व भी है कि उन्होंने जिस शहर में टाइप किया है वहां बारिश हो रही है या नहीं।

माइकल एंड्रयूज और टियो मारेलो द्वारा बनाया गया।

आपूर्ति

उपकरण

1. सोल्डरिंग आयरन
2. Dremel
3. देखा

सामग्री

1. रास्पबेरी पाई 3 बी+ ~40 डॉलर ~ 30 डॉलर
2. महिला से पुरुष जम्पर तार ~7 डॉलर
3. 3 नीले और 2 लाल एलईडी डायोड ~ 11 डॉलर
4. १०० ओम प्रतिरोध ~ १३ डॉलर
5. 4 x 4 x 1/4 वुड प्लैंक ~ 5 डॉलर
6. मिलाप ~ १० डॉलर
7. तांबे के तार ~ 5 डॉलर

चरण 1: समस्या समाधान के रूप में कोडिंग

कोडिंग समस्या समाधान है

तो, हमारे प्रोजेक्ट में, हमारी समस्या क्या है? हमारी समस्या मौसम डेटा प्राप्त कर रही है और फिर उस डेटा का उपयोग हमारे एल ई डी को बताने के लिए कर रही है कि वे बंद हैं या चालू हैं। तो यह हमारी समस्या को तीन क्षेत्रों में विभाजित करता है।

1. मौसम डेटा प्राप्त करना

2. उस डेटा का उपयोग करना

3. एलईडीएस का उपयोग करना

हालांकि, इस परियोजना के लिए हमने जिस भाषा का उपयोग किया है, वह पायथन, और जिस हार्डवेयर पर यह चल रहा है, वह हमें इन लक्ष्यों को प्राप्त करने का एक आसान तरीका प्रदान करता है।

तो, हम पहली समस्या से शुरू करते हैं, मौसम डेटा प्राप्त करना।

चरण 2: कोडिंग: मौसम डेटा प्राप्त करना

पायथन अपने आप में मौसम का डेटा नहीं प्राप्त कर सकता है। मौसम डेटा प्राप्त करने के लिए हमें दो उपकरण, साथ ही एक बाहरी सेवा आयात करनी होगी। ऐसा करने के लिए, हम तीन टूल का उपयोग करते हैं।

1. अनुरोध, एक पायथन मॉड्यूल जो वेबस्क्रैपिंग की अनुमति देता है

2. जेसन, एक पायथन मॉड्यूल जो हमें JSON फ़ाइल प्रारूप का उपयोग करने की अनुमति देता है

3. ओपनवेदर, एक वेबसाइट जो हमें मौसम संबंधी जानकारी दे सकती है

इसलिए, हम इस कोड को अपनी पायथन लिपि के शीर्ष पर लिखकर दो मॉड्यूल लाते हैं।

आयात अनुरोध

आयात जोंस

हालांकि, इन उपकरणों का उपयोग करने से पहले, हमें ओपनवेदर का उपयोग करने की आवश्यकता है। उसके लिए, हमें उनकी साइट पर एक खाता बनाना होगा और एक एपीआई कुंजी प्राप्त करनी होगी। उनकी वेबसाइट पर दिए गए निर्देशों का पालन करें और आपको अक्षरों और संख्याओं की एक स्ट्रिंग मिलेगी जो हमें उनकी सेवा का उपयोग करने देगी। कैसे?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #हमारी एपीआई कुंजी (असली नहीं)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" #OpenWeather कॉल # यहां हमें टेक्स्ट प्रिंट के रूप में उपयोगकर्ता का शहर मिलता है ("एक शहर में टाइप करें!") शहर_नाम = इनपुट () #यहां हमने वह पता असेंबल किया है जिसे हम रिक्वेस्ट में प्लग करेंगे। Response = request.get(full_call) WeatherData = Response.json() #JSON फाइलों में अलग-अलग वेरिएबल्स होते हैं जिन्हें हम इस सिंटैक्स का उपयोग करके एक्सेस कर सकते हैं। ["मौसम"] [0] ["आईडी"] City_TemperatureK = WeatherData ["मुख्य"] ["अस्थायी"]

यहां हमारे पास वह कोड है जो हमें हमारा मौसम डेटा प्राप्त करता है। अनुरोध, request.get के रूप में, एक वेबसाइट का पता लेता है और हमें उस वेबसाइट से एक फाइल वापस देता है। OpenWeather हमें कॉल करने के लिए एक पता देता है जो हमें मौसम संबंधी डेटा एक json के रूप में देता है। हम एक पता इकट्ठा करते हैं जिसे हम अनुरोधों में प्लग करते हैं और एक जेसन फ़ाइल वापस प्राप्त करते हैं। फिर हम दो चर बनाते हैं और उन्हें उपयोगकर्ता के शहर के तापमान और मौसम के अनुसार असाइन करते हैं।

तो अब, इस कोड के साथ, हमारे पास दो चर हैं। हमारे पास केल्विन में एक मौसम आईडी और तापमान है।

चरण 3: कोडिंग: उस डेटा का उपयोग करना

अब जब हमारे पास ये दो चर हैं, तो हमें उन्हें अपने एल ई डी के उपयोग के लिए तैयार करना होगा। इस पहलू के लिए, हमें इसके लिए कोई मॉड्यूल आयात करने की आवश्यकता नहीं है।

सबसे पहले, हम केल्विन को फारेनहाइट में बदलते हैं।

हम इस सिंटैक्स के साथ एक वेरिएबल बनाकर ऐसा करते हैं

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

जो केल्विन से फ़ारेनहाइट में परिवर्तित होता है (जो वास्तव में K -> C -> F से परिवर्तित हो रहा है)

अगला हमारा वेदरआईडी है। वेदरआईडी एक आईडी है जो ओपनवेदर प्रदान करती है जो हमें किसी शहर की मौसम की स्थिति के बारे में बताती है।

openweathermap.org/weather-conditions यहां उनकी एक सूची है।

हमने देखा कि 700 से नीचे की हर चीज किसी न किसी प्रकार की वर्षा थी, इसलिए हमने यह देखने के लिए कि क्या बारिश हो रही है, कोड 700 से नीचे था या नहीं, इसकी जाँच की।

डीईएफ़ चेकरेन (आईडीकोड): यदि आईडीकोड <700: रिटर्न ट्रू इयर: रिटर्न फॉल्स

इसके साथ, हमारे पास हमारे रास्पबेरी पीआई पिन और एलईडी डायोड के साथ उपयोग के लिए हमारे दो चर तैयार हैं।

चरण 4: कोडिंग: RPi. GPIO और LED डायोड का उपयोग करना

रास्पबेरीपी पुरुष पिन के एक सेट के साथ आता है जिसका उपयोग हम कई विद्युत घटकों के साथ संचार करने के लिए कर सकते हैं, जो इस मामले में एलईडी डायोड है; यह Arduino और उसके सिस्टम के समान है। हालाँकि, रास्पबेरी पीआई एक सामान्य उद्देश्य वाला कंप्यूटर है, जैसा कि Arduino जैसे माइक्रोकंट्रोलर के विपरीत है। इसलिए इनका इस्तेमाल करने के लिए हमें थोड़ा और काम करना होगा। इसमें रास्पबेरी पाई पर पिन सेट करना शामिल है। हम इस कोड का उपयोग करके ऐसा करते हैं।

RPI. GPIO को GPIO के रूप में आयात करें #हम मॉड्यूल आयात करते हैं ताकि हम इसका उपयोग कर सकें

# पिन सेट करेंGPIO.setmode(GPIO. BCM) GPIO.setwarnings(गलत)

# एलईडी को पिन में प्लग किया जाता है। यदि आप इसे बनाते हैं तो ये भिन्न हो सकते हैं, इसलिए जब आवश्यक हो तो तुलना करना और बदलना सुनिश्चित करें

एक्सट्रीम_हॉट_एलईडी_पिन = 26 हॉट_एलईडी_पिन = 16

एक्सट्रीम_कोल्ड_एलईडी_पिन = 5

कोल्ड_एलईडी_पिन = 6

Rain_LED_PIN = 23

#हम प्रत्येक पिन से गुजरते हैं,.setup कमांड का उपयोग करते हुए, उसका नंबर डालते हैं और इसे आउटपुट पिन के रूप में सेट करते हैं

GPIO.setup(Rain_LED_PIN, GPIO. OUT)GPIO.setup(Extreme_Cold_LED_PIN, GPIO. OUT) GPIO.setup(Cold_LED_PIN, GPIO. OUT) GPIO.setup(Hot_LED_PIN, GPIO. OUT)INtreme_LED_PIN, GPIO. OUT) GPIO.setup

हालाँकि, यह कोड हमें केवल दो राज्यों को एलईडी के साथ उपयोग करने देगा, जो कि चालू और बंद है। हालाँकि, हमें रोशनी कम करने में सक्षम होने की आवश्यकता है। ऐसा करने के लिए, हम पल्स चौड़ाई मॉडुलन का उपयोग करते हैं।

पल्स चौड़ाई मॉडुलन का उपयोग करना

पल्स चौड़ाई मॉडुलन हमें डिजिटल पिन का उपयोग करके एक एनालॉग सिग्नल आउटपुट करने देता है। अनिवार्य रूप से, यह उच्च दर पर सिग्नल स्रोत को चालू और बंद करता है, जो कि कुछ वोल्टेज के लिए औसत होता है। RPi. GPIO हमें कुछ अतिरिक्त कोड के साथ इसका उपयोग करने की अनुमति देता है।

#हम GPIO. PWM कमांड का उपयोग करके चार पिन ऑब्जेक्ट बनाते हैं, जो एक चैनल नंबर लेता है

#दूसरा नंबर यह प्रति सेकंड अपडेट होने की संख्या है

एक्सट्रीमहॉटएलईडी = जीपीआईओ। पीडब्लूएम (एक्सट्रीम_हॉट_एलईडी_पिन, 100) हॉटलेड = जीपीआईओ। पीडब्लूएम (हॉट_एलईडी_पिन, 100)

एक्सट्रीम कोल्डएलईडी = जीपीआईओ.पीडब्लूएम (एक्सट्रीम_कोल्ड_एलईडी_पिन, 100)

कोल्डएलईडी = जीपीआईओ.पीडब्लूएम (कोल्ड_एलईडी_पिन, 100)

अगले चरण के लिए, आपको यह जानना होगा कि हम इन पिनों को कैसे अपडेट करते हैं।

हम कमांड का उपयोग करके पिन को अपडेट करते हैं

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्स) कोल्डएलईडी.स्टार्ट (एक्स)

एक्सट्रीमहॉटएलईडी.स्टार्ट(x)

HotLED.start(x)

x इस मामले में कर्तव्य चक्र होगा, जो निर्धारित करता है कि यह कितना स्पंदित होता है। यह 0-100 के बीच होता है, इसलिए हमें अपना अगला कोड उस तथ्य पर आधारित करना होगा।

चरण 5: कोडिंग: एलईडी चमक प्राप्त करना

चूंकि हमारे पास चार अलग-अलग एल ई डी हैं, इसलिए हम इस पर निर्भर करते हुए उन्हें प्रकाश में लाना चाहते हैं। ठंडा या गर्म यह उपयोगकर्ता के शहर में है। हमने नेतृत्व के लिए चार चरणों का फैसला किया।

#कार्य

def getmiddleleftledintensity(TemperatureinF): #Left Equation: y=-(50/20)x + 175 #Right Equation: y = (50/20)x - 75 रिटर्न -(50/20)*F + 175 में तापमान

डीईएफ़ getmiddlerightledintensity(TemperatureinF):

#बायां समीकरण: y=-(50/20)x + 175 #सही समीकरण: y = (50/20)x - 75 रिटर्न (50/20)*F - 75 में तापमान

डीईएफ़ गेट एक्सट्रीम लेफ्टेड इंटेंसिटी (तापमान एफ):

#वाम समीकरण: y = -(100/30)x + 200 #RightEquation: y = (100/30)x - (400/3)

वापसी - (100/30) * तापमान एफ + 200. में

def getextremerightledintensity(TemperatureinF):

# वाम समीकरण: y = -(100/30)x + 200 # दायां समीकरण: y = (100/30)x - (400/3)

रिटर्न (१००/३०)*F में तापमान - (४००/३)

#एलईडी लाइट्स सेट करना

डीईएफ़ GetLEDBrightness (अस्थायी):

अगर अस्थायी <= 0: अत्यधिक ठंडा = 100 ठंडा = 100 गर्म = 0 चरम गर्म = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif temp >= १००: एक्स्ट्रीमकोल्डेड = ० कोल्डल्ड = ० हॉटल्ड = १०० एक्सट्रीमहोटल = १००

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif 0 <temp <= 30: एक्स्ट्रीमकोल्ड = getextremeleftledintensity(temp) - १०० कोल्डल्ड = १०० हॉटल्ड = ० एक्सट्रीमहोटल = ०

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif 100 > temp >= 70: एक्स्ट्रीमकोल्ड = 0 कोल्डल्ड = 0 हॉटल्ड = १०० एक्सट्रीमहोटल = getextremerightledintensity(temp) - १००

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif 30 <temp <50: एक्स्ट्रीमकोल्डेड = 0 कोल्डल्ड = getmiddleleftledintensity(temp) hotled = १०० - कोल्डेड एक्सट्रीमहोटल = ०

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif 50 <temp <70: hotled = getmiddlerightledintensity(temp) एक्सट्रीमहोटल = 0

ठंडा = १०० - गरम किया हुआ

अत्यधिक ठंडा = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start(hotled) elif temp == ५०: एक्स्ट्रीमकोल्डेड = ० कोल्डल्ड = ५० हॉटल्ड = ५० एक्सट्रीमहॉटल्ड = ०

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (कोल्डल्ड)) प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल)) प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्ड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

ठीक है, कोड का यह खंड वास्तव में लंबा है। समझाना भी काफी मुश्किल है। अनिवार्य रूप से, ऊपर दिया गया कोड फ़ारेनहाइट में तापमान को देखता है, और यह निर्धारित करता है कि यह श्रेणियों के एक सेट में है या नहीं। रेंज के आधार पर, यह प्रत्येक एलईडी और उसकी चमक के लिए एक नंबर देता है और फिर स्टार्ट () कमांड को कॉल करके ब्राइटनेस सेट करता है। वह त्वरित स्पष्टीकरण है। यदि यह पर्याप्त है, तो मैं आपको अगले चरण पर जाने की सलाह देता हूं, लेकिन यदि आप लंबी और थकाऊ व्याख्या देखना चाहते हैं, तो पढ़ते रहें।

जब हमने प्रोग्राम किया, तो हमने तय किया कि तापमान से मान प्राप्त करने का सबसे आसान तरीका गणितीय फ़ंक्शन के रूप में था। इसलिए, हमने जियोजेब्रा में एक ग्राफ बनाया जो यह दर्शाता है कि हमारे तापमान और हमारे एलईडी चमक के बीच क्या संबंध है; 100 से ऊपर जाने का कारण यह है कि अतिरिक्त दूसरी लीड में जाएगा। हालाँकि, हम इन सभी बिंदुओं को एक ही फ़ंक्शन में मैप करने के लिए एकल फ़ंक्शन प्राप्त करने के मुद्दे में भाग गए। हमने सोचा था कि हम एक परवलय का उपयोग कर सकते हैं, लेकिन हमने if कथनों की एक श्रृंखला का उपयोग करने के लिए बस समझौता करने का निर्णय लिया। संक्षेप में, यह संपूर्ण कोड एक टुकड़े-टुकड़े का कार्य है।

शीर्ष पर कार्य रेखाओं के संबंधित समीकरण हैं। एक बार जब हम यह निर्धारित कर लेते हैं कि ग्राफ पर तापमान कहाँ है, तो हम इसे उस फ़ंक्शन के माध्यम से चलाते हैं, चमक प्राप्त करते हैं, और इसे एलईडी पर पास करते हैं।

चरण 6: कोडिंग: अंतिम चरण

अंत में, हम इस कथन को अंत में जोड़ते हैं।

प्रयत्न:

जबकि (ट्रू): GetLEDBrightness(City_TemperatureF) GetRainLED(WeatherID) time.sleep(10) KeyboardInterrupt को छोड़कर: छोड़ें ()

कोशिश और अपवाद कथन हमें कीबोर्ड शॉर्टकट का उपयोग करके कोड से बाहर निकलने की अनुमति देते हैं; या तो, हमें कोड को पुनः आरंभ करने के लिए रास्पबेरी पाई को बंद करना होगा। फिर हमारे पास थोड़ी देर का लूप होता है जो हमेशा के लिए चलता है। हम एलईडी को अपडेट करते हैं, साथ ही रेन एलईडी को भी अपडेट करते हैं। हम दस सेकंड के लिए रुकते हैं; ओपनवेदर प्रति मिनट डेटा के लिए केवल 60 कॉल की अनुमति देता है, और 10 सेकंड बहुत सारे अपडेट हैं।

और इसके साथ ही हमारा कोड समाप्त हो गया है। नीचे समाप्त कोड है।

रास्पबेरीPIWeatherStation.py

आयात अनुरोध

importRPi. GPIOasGPIO

इंपोर्टजसन

आयात समय

#ओपनवेदर आईडीकोड 700 से कम वर्षा वाले हैं

defCheckRain (IdCode):

ifIdCode<700:

रिटर्न ट्रू

अन्यथा:

विवरण झूठा है

defgetmiddleleftledintensity(F में तापमान):

#बायां समीकरण: y=-(50/20)x + 175

#सही समीकरण: y = (50/20)x - 75

वापसी-(50/20)*F+175 में तापमान

defgetmiddlerightledintensity(F में तापमान):

#बायां समीकरण: y=-(50/20)x + 175

#सही समीकरण: y = (50/20)x - 75

वापसी (50/20)*F-75. में तापमान

defgetextremeleftledintensity(F में तापमान):

#वाम समीकरण: y = -(100/30)x + 200

#RightEquation: y = (100/30)x - (400/3)

वापसी- (१००/३०)*F+200 में तापमान

defgetextremerightledintensity(F में तापमान):

# लेफ्टइक्वेशन: y = - (100/30)x + 200

# राइटइक्वेशन: y = (100/30)x - (400/3)

रिटर्न (100/30)*F- (400/3) में तापमान

#GPIO सेटअप

GPIO.सेटमोड (GPIO. BCM)

GPIO.चेतावनी (गलत)

#पिन

एक्सट्रीम_हॉट_एलईडी_पिन=26

Hot_LED_PIN=16

एक्सट्रीम_कोल्ड_एलईडी_पिन=5

कोल्ड_एलईडी_पिन=6

Rain_LED_PIN=23

#पिन सेटअप

GPIO.setup(Rain_LED_PIN, GPIO. OUT)

GPIO.setup(Extreme_Cold_LED_PIN, GPIO. OUT)

GPIO.setup(Cold_LED_PIN, GPIO. OUT)

GPIO.setup(Hot_LED_PIN, GPIO. OUT)

GPIO.setup(Extreme_Hot_LED_PIN, GPIO. OUT)

एक्सट्रीमहॉटएलईडी=GPIO. PWM(Extreme_Hot_LED_PIN, 100)

HotLED=GPIO. PWM(Hot_LED_PIN, 100)

एक्सट्रीम कोल्डएलईडी=GPIO. PWM(Extreme_Cold_LED_PIN, 100)

कोल्डएलईडी=GPIO. PWM(Cold_LED_PIN, 100)

defGetLEDBब्राइटनेस (अस्थायी):

iftemp<=0:

अत्यधिक ठंडा = १००

ठंडा = 100

हॉटल्ड = 0

एक्सट्रीमहोटल = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

एलिफटेम्प>=100:

अत्यधिक ठंडा = 0

ठंडा = 0

हॉटल्ड = 100

एक्सट्रीमहोटल = १००

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्ड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

elif0<अस्थायी<=30:

एक्सट्रीमकोल्डेड = गेटेक्स्टरेमलेफ्टेडइंटेंसिटी (अस्थायी) -100

ठंडा = 100

हॉटल्ड = 0

एक्सट्रीमहोटल = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

elif100>अस्थायी>=70:

अत्यधिक ठंडा = 0

ठंडा = 0

हॉटल्ड = 100

एक्सट्रीमहोटल = गेटटेक्स्टरेमराइटलइंटेंसिटी (अस्थायी) -100

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्डेड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

elif30<अस्थायी<50:

अत्यधिक ठंडा = 0

ठंडा = मध्य बाएं तीव्रता (अस्थायी) प्राप्त करें

हॉटल्ड = १००-ठंडा

एक्सट्रीमहोटल = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्ड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

elif50<अस्थायी<70:

हॉटल्ड = getmiddlerightledintensity (अस्थायी)

एक्सट्रीमहोटल = 0

ठंडा = १००-गर्म

अत्यधिक ठंडा = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्ड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

एलिफटेम्प == 50:

अत्यधिक ठंडा = 0

ठंडा = 50

गरमागरम=50

एक्सट्रीमहोटल = 0

प्रिंट ("अत्यधिक ठंड का नेतृत्व किया:" + str (अत्यधिक ठंडा))

प्रिंट ("कोल्ड एलईडी:" + स्ट्र (ठंडा))

प्रिंट ("एक्सट्रीम हॉट एलईडी" + स्ट्र (एक्सट्रीमहोटल))

प्रिंट ("हॉट एलईडी:" + स्ट्र (हॉटल्ड))

एक्सट्रीम कोल्डएलईडी.स्टार्ट (एक्सट्रीमकोल्ड)

कोल्डलेड.स्टार्ट (ठंडा)

एक्सट्रीमहॉटएलईडी.स्टार्ट (एक्सट्रीमहोटल)

HotLED.start (हॉटल्ड)

defGetRainLED (idCode):

अगर चेकरेन (आईडीकोड):

GPIO.output(Rain_LED_PIN, GPIO. HIGH)

अन्यथा:

GPIO.output(Rain_LED_PIN, GPIO. LOW)

#एपीआई जानकारी: एपीआई कुंजी को अपने ओपेनवेदर एपीआई कुंजी के साथ बदलें

openweather_api_key="460a23f27ff324ef9ae743c7e9c32d7e"

base_call="https://api.openweathermap.org/data/2.5/weather?q="

प्रिंट ("एक शहर में टाइप करें!")

शहर_नाम = इनपुट ()

full_call=base_call+city_name+"&appid="+openweather_api_key

#मौसम डेटा प्राप्त करना

प्रतिक्रिया = अनुरोध। प्राप्त करें (पूर्ण_कॉल)

WeatherData = Response.json ()

WeatherID=WeatherData["weather"][0]["id"]

City_TemperatureK=WeatherData["main"]["temp"]

City_TemperatureF= (City_TemperatureK-273)*1.8+32#फ़ारेनहाइट में कनवर्ट करें

#LED/GPIO सामग्री

प्रिंट ("के:" + str (City_TemperatureK))

प्रिंट ("एफ:" + str (City_TemperatureF))

प्रिंट (मौसम आईडी)

प्रयत्न:

जबकि (सच):

GetLEDBrightness (City_TemperatureF) प्राप्त करें

GetRainLED (वेदरआईडी)

समय सो जाओ(१०)

कीबोर्ड इंटरप्ट को छोड़कर:

छोड़ना()

देखें rawRaspberryPIWeatherStation.py GitHub द्वारा ❤ के साथ होस्ट किया गया

चरण 7: बिल्डिंग और वायरिंग अप

वाह! उस कोडिंग के बाद, हम इमारत में पहुँच जाते हैं, जो काफी आसान है।घर पर रहने के आदेश के कारण, हम स्कूल में होने वाले कई उपकरणों को प्राप्त नहीं कर सके। तो, यह हिस्सा हमारे इरादे से थोड़ा आसान है। विशिष्टताएं स्वयं भी लचीली हैं। पहले हमने लकड़ी के तख़्त पर एक आयत बनाया। विशिष्ट आकार वास्तव में बहुत अधिक मायने नहीं रखता है, क्योंकि यह केवल एलईडी और इलेक्ट्रॉनिक्स को लगाने के लिए एक मंच के रूप में कार्य करता है।

फिर हमने अपने लकड़ी के टुकड़े में छेद में पांच 1/8 वां ड्रिल किया।

फिर हमने अपने इलेक्ट्रॉनिक्स के लिए अपने प्लेटफॉर्म के रूप में उपयोग करने के लिए तख़्त से आयत को काट दिया।

(यह तब था जब हमने शुरुआत की थी; हमें एक बड़ी आरी मिली!)

फिर हम छेद में एलईडी के एनोड और कैथोड पिन को धक्का देते हैं; एल ई डी को ऊपर रखा जाना चाहिए, उनके बल्ब चिपके हुए हैं; ट्रैक करें कि कौन सा पैर लंबा और छोटा है। फिर हम तारों को एक साथ मिलाना शुरू करने के लिए तैयार हो गए। पहले हम प्रतिरोधों को एलईडी (लंबे पैर) के एनोड लेग में मिलाते हैं।

फिर, हम एल ई डी के कैथोड पैरों को एक तांबे के तार में मिलाते हैं जिसे हम जमीन के रूप में उपयोग करेंगे। इसे ऐसा दिखना चाहिए।

ऐसा करने के बाद, हम महिला-पुरुष जम्पर केबल्स के नर सिरों को प्रत्येक प्रतिरोधी और तांबे के ग्राउंड तार के अंत सिरों तक मिलाते हैं। एक बार जब हम ऐसा कर लेते हैं, तो हम रास्पबेरी PI GPIO पिन में तारों को प्लग करना शुरू कर सकते हैं। यहाँ एक आरेख है! हालाँकि, ध्यान दें, पिन पहले से स्पर्श किए गए कोड में हैं।

एक बार जब आपके पास वह सब हो जाता है, तो अब आपको बस इतना करना है कि रास्पबेरी पाई पर पायथन फ़ाइल प्राप्त करें और टर्मिनल खोलें। "python3 RaspberryPIWeatherStation.py" चलाएं और फिर जैसा यह दिखाता है वैसा ही करें।

चरण 8: प्रदर्शन और निष्कर्ष

पूरी तरह से पढ़ने के लिए धन्यवाद! मैं नीचे पायथन लिपि संलग्न करूँगा! अगर ऐसी चीजें होतीं जिन्हें हम जोड़ सकते थे, तो शायद यह होता …

1. विभिन्न इनपुट प्रकारों (शहरों, भौगोलिक बिंदुओं, आदि) के लिए समर्थन

2. अधिक मौसम की जानकारी के लिए समर्थन

3. जानकारी दिखाने के लिए एक छोटी सी स्क्रीन जोड़ें

हमें अपने विचार बताएं! यह निर्माण करने के लिए एक मजेदार परियोजना थी। हमने पाइथन का उपयोग करके अनुरोधों और इंटरनेट दस्तावेज़ प्राप्त करने के बारे में बहुत कुछ सीखा, और हमने सोल्डरिंग का उपयोग करने के बारे में भी बहुत कुछ सीखा।