פטל PI תחנת מזג אוויר LED: 8 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

יצרנו תחנת LED מזג אוויר מסוג Raspberry PI. הוא מספר למשתמש כמה עיר חמה וקרה היא על ידי תאורה ותאורה של תאורות. יש לו גם מדריך לספר להם אם יורד גשם בעיר שהם הקלידו.

נוצר על ידי מייקל אנדרוז וטיו מארלו.

אספקה

כלים

1. מלחם
2. דרמל
3. ראה

חומרים

1. פטל פי 3 B+ ~ 40 דולרים ~ 30 דולרים
2. חוטי מגשר נקבה לזכר ~ 7 דולר
3. 3 דיודות LED כחולות ו -2 אדומות ~ 11 דולר
4. 100 נגדי אוהם ~ 13 דולר
5. 4 x 4 x 1/4 לוח עץ ~ 5 דולר
6. הלחמה ~ 10 דולר
7. חוט נחושת ~ 5 דולר

שלב 1: קידוד כפתרון בעיות

קידוד הוא פתרון בעיות

אז, בפרויקט שלנו, מה הבעיה שלנו? הבעיה שלנו היא לקבל נתוני מזג אוויר ולאחר מכן להשתמש בנתונים אלה כדי לספר לנוריות שלנו אם הם כבויים או דולקים. אז זה מחלק את הבעיה שלנו לשלושה תחומים.

1. קבלת נתוני מזג אוויר

2. שימוש בנתונים אלה

3. שימוש ב- LEDs

עם זאת, השפה בה השתמשנו לפרויקט זה, פייתון והחומרה שבה הוא פועל, פייתון, נותנים לנו דרך קלה להשיג את המטרות הללו.

אז נתחיל בבעיה הראשונה, קבלת נתוני מזג האוויר.

שלב 2: קידוד: קבלת נתוני מזג אוויר

Python כשלעצמו לא יכול לקבל נתוני מזג אוויר. עלינו לייבא שני כלים, כמו גם שירות חיצוני, כדי לקבל נתוני מזג אוויר. לשם כך אנו משתמשים בשלושה כלים.

1. בקשות, מודול פייתון המאפשר גריפת אתרים

2. Json, מודול פייתון המאפשר לנו להשתמש בפורמט קובץ JSON

3. OpenWeather, אתר שיכול לתת לנו נתוני מזג אוויר

לכן, אנו מביאים את שני המודולים על ידי כתיבת קוד זה בראש סקריפט הפיתון שלנו.

בקשות ייבוא

יבוא json

אולם לפני שנשתמש בכלים אלה עלינו להשתמש ב- Openweather. לשם כך עלינו ליצור חשבון באתר שלהם ולקבל מפתח API. עקוב אחר ההוראות באתר שלהם ותקבל שורה של אותיות ומספרים שיאפשרו לנו להשתמש בשירותם. אֵיך?

openweather_api_key = "260a23f27f5324ef2ae763c779c32d7e" #מפתח ה- API שלנו (לא אמיתי)

base_call = "https://api.openweathermap.org/data/2.5/weather?q=" שיחת #OpenWeather #כאן אנו מקבלים את עיר המשתמש בצורת הדפסת טקסט ("הקלד עיר!") city_name = קלט () #כאן ריכזנו את הכתובת שאנו מתחברים ל- request.get לקבל נתוני מזג אוויר full_call = base_call+city_name+"& appid ="+openweather_api_key #לבסוף אנו קוראים ל- request.get עם כתובתנו ולאחר מכן הופכים אותם לקובץ json Response = requests.get (full_call) WeatherData = Response.json () קבצי #JSON מכילים משתנים שונים אליהם נוכל לגשת באמצעות תחביר זה #כאן אנו מקבלים את מזהה מזג האוויר ואת הטמפרטורה בקלווין של העיר שהמשתמש הקליד WeatherID = WeatherData ["מזג אוויר"] [0] ["id"] City_TemperatureK = WeatherData ["main"] ["temp"]

כאן יש לנו את הקוד שמביא לנו את נתוני מזג האוויר שלנו. בקשות, בצורה של request.get, לוקחת כתובת אתר ומחזירה לנו קובץ מאותו אתר. OpenWeather נותן לנו כתובת להתקשר כדי לתת לנו נתוני מזג אוויר בצורה של json. אנו מרכיבים כתובת שאנו מחברים לבקשות ומקבלים קובץ json בחזרה. לאחר מכן אנו יוצרים שני משתנים ומייחסים אותם לטמפרטורה ולמזג האוויר של עיר המשתמש.

אז עכשיו, עם הקוד הזה, יש לנו שני משתנים. יש לנו מזהה מזג אוויר וטמפרטורה בקלווין

שלב 3: קידוד: שימוש בנתונים אלה

כעת, כאשר יש לנו את שני המשתנים הללו, עלינו להכין אותם לשימוש עבור ה- LEDs שלנו. בהיבט זה, איננו צריכים לייבא מודולים לשם כך.

ראשית, אנו ממירים את הקלווין לפרנהייט.

אנו עושים זאת על ידי יצירת משתנה עם תחביר זה

City_TemperatureF = (City_TemperatureK - 273)*1.8 + 32

הממיר מקלווין לפרנהייט (שבאמת הופך מ- K -> C -> F)

הבא הוא מזהה מזג האוויר שלנו. WeatherID הוא מזהה ש- Openweather מספקת המספרת לנו על תנאי מזג האוויר בעיר.

openweathermap.org/weather-conditions להלן רשימתם.

שמנו לב שהכל מתחת למספר 700 הוא סוג של משקעים, אז בדקנו אם הקוד מתחת ל -700 כדי לראות אם יורד גשם.

def CheckRain (IdCode): אם IdCode <700: return True else: return False

עם זאת, יש לנו את שני המשתנים שלנו מוכנים לשימוש עם סיכות ה- RI של פטל ודיודות LED.

שלב 4: קידוד: שימוש בדיודות RPi. GPIO ו- LED

ה- RaspberryPi מגיע עם קבוצה של סיכות זכר בהן אנו יכולים להשתמש כדי לתקשר עם שלל רכיבים חשמליים, שבמקרה זה הינם דיודות LED; זה דומה לארדואינו ולמערכת שלו. עם זאת, ה- Raspberry PI הוא מחשב למטרות כלליות, בניגוד לבקר מיקרו כמו ה- Arduino. לכן, עלינו לעשות קצת יותר עבודה כדי להשתמש בהם. זה מורכב מהגדרת הפינים ב- Raspberry Pi. אנו עושים זאת באמצעות קוד זה.

יבוא RPi. GPIO כ- GPIO #אנו מייבאים את המודול כדי שנוכל להשתמש בו

#הגדר את הסיכות GPIO.setmode (GPIO. BCM) GPIO.setwarnings (שקר)

#הסיכות שאליהן מחברים נוריות הלדים. אלה עשויים להיות שונים אם אתה בונה אותו, לכן הקפד להשוות ולשנות בעת הצורך

Extreme_Hot_LED_PIN = 26 Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 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) GPIO.setup (Extreme_Hot_L_

עם זאת, קוד זה רק יאפשר לנו להשתמש בשתי מצבים עם ה- LED, כלומר לסירוגין. עם זאת, אנו זקוקים לו בכדי להיות מסוגלים לעמעם את האורות. לשם כך אנו משתמשים באפנון רוחב הדופק.

שימוש באפנון רוחב הדופק

אפנון רוחב הדופק מאפשר לנו להוציא אות אנלוגי באמצעות סיכה דיגיטלית. בעיקרו של דבר, הוא מפעיל ומכבה את מקור האות בקצב גבוה, הממוצע הוא למתח מסוים. ה- RPi. GPIO מאפשר לנו להשתמש בזה, אם כי עם קוד נוסף.

#אנו יוצרים ארבעה אובייקטים של פינים באמצעות הפקודה GPIO. PWM, המקבלת מספר ערוץ

#המספר השני הוא מספר הפעמים שהוא מתעדכן בשנייה

ExtremeHotLED = GPIO. PWM (Extreme_Hot_LED_PIN, 100) HotLED = GPIO. PWM (Hot_LED_PIN, 100)

ExtremeColdLED = GPIO. PWM (Extreme_Cold_LED_PIN, 100)

ColdLED = GPIO. PWM (Cold_LED_PIN, 100)

לשלב הבא תצטרך לדעת כיצד אנו מעדכנים סיכות אלה.

אנו מעדכנים את הסיכות באמצעות הפקודה

ExtremeColdLED.start (x) ColdLED.start (x)

ExtremeHotLED.start (x)

HotLED.start (x)

x במקרה זה יהיה מחזור העבודה, שקובע כמה הוא פועם. הוא נע בין 0-100, ולכן עלינו לבסס את הקוד הבא שלנו מעובדה זו.

שלב 5: קידוד: קבלת בהירות LED

מכיוון שיש לנו ארבעה נוריות שונות, אנו רוצים להאיר אותן בהתאם לאופן שבו. קר או חם הוא נמצא בעיר של המשתמש. החלטנו שיהיו לנו ארבעה שלבים למובילים.

#פונקציות

def getmiddleleftledintensity (טמפרטורה ב- F): #משוואת שמאל: y = -(50/20) x + 175 #משוואת ימינה: y = (50/20) x -75 החזרה -(50/20)*טמפרטורהinF + 175

עוצמה (טמפרטורה ב- F):

משוואת שמאל: y = - (50/20) x + 175 #משוואה ימנית: y = (50/20) x - 75 החזרה (50/20)*טמפרטורה ב- F - 75

החשיפה לעוצמה חמורה יותר (טמפרטורה ב- F):

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

החזרה -(100/30)*טמפרטורה ב- + 200

עוצמת החום (טמפרטורה ב- F):

# משוואה שמאלית: y = - (100/30) x + 200 # משוואה ימנית: y = (100/30) x - (400/3)

החזרה (100/30)*טמפרטורה ב- F - (400/3)

#הגדרת נורות LED

def GetLEDBrightness (טמפ '):

אם הטמפ '<= 0: extremecoldled = 100 coldled = 100 hotled = 0 extremehotled = 0

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Cold led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif temp> = 100: extremecoldled = 0 coldled = 0 hotled = 100 extremehotled = 100

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Led led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif 0 <temp <= 30: extremecoldled = getextremeleftledintensity (temp) - 100 coldled = 100 hotled = 0 extremehotled = 0

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Led led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif 100> temp> = 70: extremecoldled = 0 coldled = 0 hotled = 100 extremehotled = getextremerightledintensity (temp) - 100

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Led led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif 30 <temp <50: extremecoldled = 0 coldled = getmiddleleftledintensity (temp) hotled = 100 - coldled extremehotled = 0

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Cold led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif 50 <temp <70: hotled = getmiddlerightledintensity (temp) extremehotled = 0

מקורר = 100 - חם

קיצוני קריר = 0

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Led led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled) elif temp == 50: extremecoldled = 0 coldled = 50 hotled = 50 extremehotled = 0

- הדפס ("הוביל לקר קיצוני:" + str (קריר מאוד))

print ("Led led:" + str (coldled)) print ("Extreme hot led" + str (extremehotled)) print ("Hot led:" + str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

בסדר, קטע הקוד הזה באמת ארוך. זה גם די קשה להסביר. בעיקרו, הקוד למעלה מעלה את הטמפרטורה ב פרנהייט, וקובע אם הוא נמצא בקבוצת טווחים. בהתאם לטווחים, הוא נותן מספר לכל לד ולבהירותו ולאחר מכן מגדיר את הבהירות על ידי קריאת הפקודה start (). זה ההסבר המהיר. אם זה מספיק, אני ממליץ לך לעבור לשלב הבא, אבל אם אתה רוצה לראות את ההסבר הארוך והמייגע, המשך לקרוא.

כאשר תיכנתנו, החלטנו שהדרך הקלה ביותר לקבל ערך מטמפרטורה היא בצורה של פונקציה מתמטית. לכן, יצרנו גרף ב- GeoGebra כדי לייצג את הקשר בין הטמפרטורה שלנו לבין הבהירות המובילה שלנו; הסיבה שהוא עולה על 100 היא שהתוספת תיכנס להוביל השני. עם זאת, נתקלנו בבעיה של קבלת פונקציה אחת שתמפה את כל הנקודות הללו לפונקציה אחת. חשבנו שנוכל להשתמש בפרבולה, אבל החלטנו להסתפק בשימוש בסדרה של הצהרות אם. בעיקרו של דבר, כל הקוד הזה הוא פונקציה חתיכה.

הפונקציות בחלק העליון הן משוואת הקווים המתאימה. ברגע שאנו קובעים היכן הטמפרטורה נמצאת בגרף, אנו מפעילים אותה באמצעות הפונקציה הזו, מקבלים את הבהירות ומעבירים אותה אל הנורות.

שלב 6: קידוד: שלבים אחרונים

לבסוף, אנו מוסיפים את ההצהרה הזו בסוף.

לְנַסוֹת:

while (True): GetLEDBrightness (City_TemperatureF) GetRainLED (WeatherID) time.sleep (10) למעט KeyboardInterrupt: צא ()

הצהרות הניסיון וחוץ מאפשרות לנו לצאת מהקוד באמצעות קיצור דרך במקלדת; בכל מקרה, נצטרך לסגור את ה- Raspberry Pi כדי להפעיל מחדש את הקוד. אז יש לנו לולאת זמן שנמשכת לנצח. אנו מעדכנים את הלדים וכן מעדכנים את נורית הגשם. אנו עוצרים למשך עשר שניות; OpenWeather מאפשרת רק 60 שיחות לנתונים לדקה, ו -10 שניות הן שפע של עדכונים.

ועם זה, הקוד שלנו הסתיים. להלן הקוד המוגמר.

פטל PIWeatherStation.py

בקשות יבוא

importRPi. GPIOasGPIO

importjson

זמן יבוא

#קוד OpenWeather קודים שפחות מ -700 הם כולם משקעים

defCheckRain (IdCode):

ifIdCode <700:

returnTrue

אַחֵר:

returnFalse

עייפות (טמפרטורה ב- F):

משוואת שמאל: y =-(50/20) x + 175

#משוואה ימינה: y = (50/20) x - 75

החזרה- (50/20)*טמפרטורה ב- F+175

עייפות (טמפרטורה ב- F):

משוואת שמאל: y =-(50/20) x + 175

#משוואה ימינה: y = (50/20) x - 75

החזרה (50/20)*טמפרטורה ב- F-75

עייפות extremeleledledensens (טמפרטורה inF):

#LeftEquation: y = -(100/30) x + 200

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

תמורה- (100/30)*טמפרטורה ב- F+200

עייפות קיצונית ניכרת (טמפרטורה ב- F):

# משוואה שמאלית: y = -(100/30) x + 200

# משוואה נכונה: y = (100/30) x - (400/3)

החזרה (100/30)*טמפרטורה ב- F- (400/3)

הגדרת #GPIO

GPIO.setmode (GPIO. BCM)

GPIO.setwarnings (שקר)

#סיכות

Extreme_Hot_LED_PIN = 26

Hot_LED_PIN = 16

Extreme_Cold_LED_PIN = 5

Cold_LED_PIN = 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)

ExtremeHotLED = GPIO. PWM (Extreme_Hot_LED_PIN, 100)

HotLED = GPIO. PWM (Hot_LED_PIN, 100)

ExtremeColdLED = GPIO. PWM (Extreme_Cold_LED_PIN, 100)

ColdLED = GPIO. PWM (Cold_LED_PIN, 100)

בהירות defGetLED (טמפ '):

iftemp <= 0:

קיצוני קריר = 100

מקורר = 100

hotled = 0

extremehotled = 0

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Led led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp> = 100:

קיצוני קריר = 0

מקורר = 0

חם = 100

extremehotled = 100

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Led led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif0 <temp <= 30:

צמרמורת קלה = getextremeleftledintensity (temp) -100

מקורר = 100

hotled = 0

extremehotled = 0

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Cold led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif100> טמפ '> = 70:

קיצוני קריר = 0

מקורר = 0

חם = 100

extremehotled = getextremerightledintensity (temp) -100

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Cold led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif30 <טמפ '<50:

קיצוני קריר = 0

מקורר = מקבל בינוני עלה בעוצמה (טמפ ')

חם = 100-קר

extremehotled = 0

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Led led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

elif50 <טמפ '<70:

hotled = getmiddlerightled עוצמת (טמפ ')

extremehotled = 0

מקורר = 100-חם

קיצוני קריר = 0

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Led led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

eliftemp == 50:

קיצוני קריר = 0

מקורר = 50

חם = 50

extremehotled = 0

- הדפס ("הוביל לקר קיצוני:"+str (קריר מאוד))

הדפסה ("Cold led:"+str (coldled))

print ("Extreme hot led"+str (extremehotled))

print ("Hot led:"+str (hotled))

ExtremeColdLED.start (extremecoldled)

ColdLED.start (קר)

ExtremeHotLED.start (extremehotled)

HotLED.start (hotled)

defGetRainLED (idCode):

ifCheckRain (idCode):

פלט GPIO.out (Rain_LED_PIN, GPIO. HIGH)

אַחֵר:

פלט GPIO.out (Rain_LED_PIN, GPIO. LOW)

מידע על #Api: חזור על מפתח ה- API עם מפתח ה- API שלך oepnweather

openweather_api_key = "460a23f27ff324ef9ae743c7e9c32d7e"

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

הדפס ("הקלד עיר!")

city_name = קלט ()

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

#קבלת נתוני מזג אוויר

תגובה = request.get (full_call)

WeatherData = Response.json ()

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

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

City_TemperatureF = (City_TemperatureK-273)*1.8+32#המרה לפרנהייט

#דברים LED/GPIO

print ("K:"+str (City_TemperatureK))

print ("F:"+str (City_TemperatureF))

הדפס (WeatherID)

לְנַסוֹת:

בעוד (נכון):

GetLEDBrightness (עיר_טמפרטורה F)

GetRainLED (WeatherID)

time.sleep (10)

למעט KeyboardInterrupt:

לְהַפְסִיק()

הצג rawRaspberryPIWeatherStation.py המתארח אצל ❤ על ידי GitHub

שלב 7: בנייה והתחברות

וואו! אחרי כל הקידוד הזה, אנחנו מגיעים לבניין, שהוא הרבה יותר קל.בשל פקודות השהות בבית הקורונה, לא הצלחנו להגיע להרבה מהכלים שציפינו שיהיו לנו בבית הספר. אז החלק הזה קצת יותר פשוט ממה שהתכוונו. הפרטים עצמם גם גמישים. תחילה ציירנו מלבן על קרש עץ. הגודל הספציפי לא באמת משנה יותר מדי, מכיוון שהוא פשוט משמש כפלטפורמה להנחת נוריות ואלקטרוניקה.

אחר כך קידחנו חמישה 1/8 בחורים בחתיכת העץ שלנו.

לאחר מכן חתכנו את המלבן מהקרש כדי להשתמש בו כפלטפורמה שלנו לאלקטרוניקה.

(זה היה כשהתחלנו; מצאנו מסור גדול יותר!)

לאחר מכן אנו דוחפים את סיכות האנודה והקטודה של הלייד לתוך החורים; האורות צריכים להיות מונחים על הגג, הנורות שלהם בולטות החוצה; עקוב אחר איזו רגל ארוכה וקצרה יותר. לאחר מכן התחלנו להתחיל בהלחמה של חוטים. ראשית אנו מלחמים את הנגדים לרגל האנודה של ה- LED (הרגל הארוכה יותר).

לאחר מכן, אנו מלחימים את רגלי הקתודה של הלדים לחוט נחושת יחיד בו נשתמש כקרקע. זה אמור להיראות כך.

לאחר שנעשה זאת, אנו מלחמים את קצות הזכרים של כבלי מגשר נקבה-נקבה לקצות הקצה של כל נגד ולחוט הארקה הנחושת. ברגע שנעשה זאת, נוכל להתחיל לחבר את החוטים לסיכות ה- PI GPIO פטל. הנה תרשים! עם זאת, שים לב, הסיכות הן אלה בקוד שנגע בעבר.

לאחר שהכל יסתיים, כל שעליך לעשות הוא להעלות את קובץ ה- Python לפאי הפטל ולפתוח את הטרמינל. הפעל את "python3 RaspberryPIWeatherStation.py" ולאחר מכן בצע כפי שהוא מראה.

שלב 8: הפגנה ומסקנה

תודה שקראתם לאורך כל הדרך! אצרף את סקריפט הפיתון למטה! אם היו דברים שנוכל להוסיף, כנראה שזה היה …

1. תמיכה בסוגי קלט שונים (ערים, נקודות גיאוגרפיות וכו ')

2. תמיכה למידע נוסף על מזג האוויר

3. הוסף מסך קטן להצגת מידע

ספר לנו את דעתך! זה היה פרויקט מהנה לבנות. למדנו הרבה על בקשות וקבלת מסמכי אינטרנט באמצעות פייתון, ולמדנו גם הרבה על שימוש בהלחמה.