תחנת מזג אוויר IoT עם RPi ו- ESP8266: 10 שלבים

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

בהדרכות קודמות, שיחקנו עם NodeMCU, חיישנים ולמדנו כיצד ללכוד ולרשום נתונים על ThingSpeak (פלטפורמת Internet of Things (IoT) המאפשרת לך לאסוף ולאחסן נתוני חיישנים בענן ולפתח יישומי IoT):

IOT עשה את זה קל: לכידת נתוני מזג אוויר מרחוק: טמפרטורת UV ואוויר ולחות

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

חיישנים וסוג הביון:

• DHT22 (טמפרטורה ולחות) ==> תקשורת דיגיטלית
• BMP180 (טמפרטורה ולחץ) ==> פרוטוקול I2C
• DS18B20 (טמפרטורה) ==> פרוטוקול חד-חוטי

תרשים הבלוק מראה מה נקבל בסוף הפרויקט הזה:

שלב 1: BoM - שטר חומרים

1. Raspberry Pi V3 - 32.00 דולר ארה"ב
2. חיישן טמפרטורה ולחות יחסית DHT22 - 9.95 דולר
3. התנגדות 4K7 אוהם
4. חיישן טמפרטורה עמיד למים DS18B20 - 5.95 דולר
5. התנגדות 4K7 אוהם
6. חיישן לחץ ברומטרי, טמפרטורה וגובה BMP180 - 6.99 דולר

שלב 2: התקנת חיישן הטמפרטורה והלחות

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

סקירה כללית

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

המאפיינים העיקריים של DHT22:

• זול
• הספק של 3 עד 5V וקלט/פלט
• שימוש מקסימלי 2.5mA בזמן ההמרה (תוך בקשת נתונים)
• טוב לקריאות לחות של 0-100% עם דיוק של 2-5%
• טוב ל -40 עד 125 ° C קריאות טמפרטורה ± 0.5 ° C דיוק
• קצב דגימה לא יותר מ 0.5 הרץ (אחת לשתי שניות)
• גודל גוף 15.1mm x 25mm x 7.7mm
• 4 סיכות עם מרווח של 0.1 אינץ '

פעם אחת בדרך כלל תשתמש בחיישן על מרחקים של פחות מ -20 מ ', יש לחבר נגד הנגן 4K7 אוהם בין פינים ל- VCC. סיכת נתוני הפלט DHT22 תחובר ל- Raspberry GPIO 16. בדוק את התרשים החשמלי לעיל, מחבר את החיישן לסיכות RPi כמפורט להלן:

1. פין 1 - Vcc ==> 3.3V
2. סיכה 2 - נתונים ==> GPIO 16
3. פין 3 - לא להתחבר
4. סיכה 4 - Gnd ==> Gnd

אל תשכח להתקין את הנגד 4K7 אוהם בין סיכות Vcc ו- Data

לאחר חיבור החיישן, עלינו להתקין גם את הספרייה שלו ב- RPi שלנו.

התקנת ספריית DHT:

ב- Raspberry שלך, החל מ /home, עבור אל /Documents

cd מסמכים

צור ספרייה להתקנת הספרייה ועבור לשם:

mkdir DHT22_Sensor

cd DHT22_Sensor

בדפדפן שלך, עבור אל Adafruit GitHub:

github.com/adafruit/Adafruit_Python_DHT

הורד את הספרייה על ידי לחיצה על הקישור להורדת zip מימין ופתח את הארכיון בתיקיית ה- Raspberry Pi שלך שנוצרה לאחרונה. לאחר מכן עבור אל הספרייה של הספרייה (תיקיית המשנה שנוצרת אוטומטית כאשר ביטלת את הרכיפה של הקובץ) ובצע את הפקודה:

sudo python3 setup.py התקנה

פתח תוכנית בדיקה (DHT22_test.py) מ- GITHUB שלי

יבוא Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 לחות, טמפרטורה = Adafruit_DHT.read_retry (DHT22Sensor, DHTpin) אם הלחות אינה אין והטמפרטורה אינה: הדפס ('Temp = {0: 0.1f}*C לחות = {1: 0.1 f}%'. פורמט (טמפרטורה, לחות)) אחר: הדפס (' לא הצלחתי לקרוא. נסה שוב! ')

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

python3 DHT22_test.py

מסך ההדפסה של מסוף להלן מציג את התוצאה.

שלב 3: התקנת DS18B20 - חיישן טמפרטורה

סקירת חיישן:

נשתמש במדריך זה בגרסה אטומה למים של חיישן DS18B20. הוא שימושי מאוד לטמפרטורה מרוחקת בתנאים רטובים, למשל על אדמה לחה. החיישן מבודד ויכול לבצע מדידות עד 125oC (Adafrut לא ממליצה להשתמש בו מעל 100oC בגלל מעיל ה- PVC הכבל שלו).

ה- DS18B20 הוא חיישן דיגיטלי מה שעושה אותו טוב לשימוש אפילו למרחקים ארוכים! חיישני טמפרטורה דיגיטליים בעלי חוט אחד הם מדויקים למדי (± 0.5 מעלות צלזיוס בהרבה מהטווח) ויכולים לתת עד 12 פיסות דיוק מהממיר הדיגיטלי לאנלוגי המשולב. הם עובדים מצוין עם ה- NodeMCU באמצעות סיכה דיגיטלית אחת, וניתן אפילו לחבר מספר אחד לאותו סיכה, לכל אחד מזהה ייחודי של 64 סיביות שנצרב במפעל כדי להבדיל ביניהם.

החיישן עובד מ -3.0 עד 5.0V, מה שאומר שהוא יכול להיות מופעל ישירות מה -3.3V המסופק על ידי אחד מסיכות הפטל (1 או 17).

לחיישן 3 חוטים:

• שחור: GND
• אדום: VCC
• צהוב: נתוני חוט אחד

כאן תוכל למצוא את הנתונים המלאים: גליון הנתונים DS18B20

התקנת חיישן:

בצע את התרשים לעיל וביצע את החיבורים:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Data ==> GPIO 4 (ברירת מחדל לספרייה)

התקנת ספריית פייתון:

לאחר מכן, בוא נתקין את ספריית Python שתטפל בחיישן:

sudo pip3 התקן w1thermsensor

לפני הפעלת הסקריפט לבדיקת החיישן, בדוק אם ממשק "חוט אחד" מופעל ב- RPi שלך (ראה מסך הדפסה למעלה)

אל תשכח להפעיל מחדש את ה- RPi שלך לאחר שינוי התצורה שלו

בדיקת החיישן:

לבדיקת החיישן ניתן להשתמש בסקריפט פייתון פשוט:

זמן יבוא

מאת w1thermsensor יבוא W1ThermSensor ds18b20Sensor = W1ThermSensor () בעוד True: temperature = ds18b20Sensor.get_temperature () הדפס ("הטמפרטורה היא % s צלזיוס" % טמפרטורה) time.sleep (1)

שלב 4: התקנת BMP180

סקירת חיישן:

BMP180 הוא ממשיכו של BMP085, דור חדש של חיישני לחץ דיגיטליים דיוק גבוה ליישומי צריכה. הספק נמוך במיוחד, מתח נמוך של BMP180 מותאם לשימוש בטלפונים ניידים, מחשבי כף יד, התקני ניווט GPS וציוד חיצוני. עם רעש בגובה נמוך של 0.25 מ 'בלבד בזמן המרה מהיר, ה- BMP180 מציע ביצועים מעולים. ממשק I2C מאפשר אינטגרציה קלה של המערכת עם מיקרו -בקר. ה- BMP180 מבוסס על טכנולוגיה עמידה לפיזו עבור חוסן EMC, דיוק גבוה, לינאריות וכן יציבות לטווח ארוך.

את גליון הנתונים המלא של BMP ניתן למצוא כאן: BMP180 - חיישן לחץ דיגיטלי

התקנת חיישן: עקוב אחר התרשים לעיל וביצע את החיבורים:

• וין ==> 3.3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

הפעלת ממשק I2C

עבור אל תצורת RPi וודא שממשק I2C מופעל. אם לא, הפעל אותו והפעל מחדש את ה- RPi.

שימוש ב- BMP180

אם הכל הותקן בסדר והכל מחובר תקין, אתה מוכן כעת להפעיל את ה- Pi ולהתחיל לראות מה ה- BMP180 מספר לך על העולם סביבך.

הדבר הראשון שאתה צריך לעשות הוא לבדוק אם ה- Pi רואה את ה- BMP180 שלך. נסה את הדברים הבאים בחלון מסוף:

sudo i2cdetect -y 1

אם הפקודה עבדה, אתה אמור לראות משהו דומה במסך ההדפסה של טרמינל למעלה, המראה כי BMP180 נמצא בערוץ '77'.

התקנת ספריית BMP180:

צור ספרייה להתקנת הספרייה:

mkdir BMP180_Sensorcd BMP180_Sensor

בדפדפן שלך, עבור אל Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

הורד את הספרייה על ידי לחיצה על הקישור להורדת zip מימין ופתח את הארכיון בתיקייה שלך שנוצרה על ידי Raspberry Pi. לאחר מכן עבור אל תיקיית המשנה שנוצרה ובצע את הפקודה הבאה בספריית הספרייה:

sudo python3 setup.py התקנה

פתח את ה- Python IDE שלך וצור תוכנית בדיקה ושם אותה, למשל BMP180Test.py

יבוא Adafruit_BMP. BMP085 כ- BMP085sensor = BMP085. BMP085 () הדפס ('Temp = {0: 0.2f} *C'.format (sensor.read_temperature ())) הדפס (' לחץ = {0: 0.2f} Pa '. format (sensor.read_pressure ())) print ('Altitude = {0: 0.2f} m'.format (sensor.read_altitude ())) print (' Sealevel Pressure {0: 0.2f} Pa'.format (חיישן.read_sealevel_pressure ()))

בצע את תוכנית הבדיקה:

python3 BMP180Test.py

מסך ההדפסה של מסוף לעיל מציג את התוצאה.

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

שלב 5: מדידת מזג אוויר וגובה עם BMP180

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

אם אתה רוצה לדעת יותר על קריאות חיישן, עבור למדריך הנהדר הזה:

ה- BMP180 תוכנן למדידה מדויקת של הלחץ האטמוספרי. לחץ האטמוספירה משתנה הן מבחינת מזג האוויר והן מבחינת הגובה.

מהו לחץ אטמוספרי?

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

אם היית לוקח עמוד אוויר ברוחב סנטימטר אחד היה שוקל כק ג

משקל זה, הלחיצה כלפי מטה על טביעת הרגל של העמודה הזו, יוצר את הלחץ האטמוספרי שנוכל למדוד בעזרת חיישנים כמו BMP180. מכיוון שעמוד האוויר ברוחב סנטימטר שוקל כ -1 ק ג, מכאן נובע כי הלחץ הממוצע של פני הים הוא כ 101325 פסקל, או טוב יותר, 1013.25 hPa (1 hPa מכונה גם מיליבר - mbar). זה ירד בערך 4% על כל 300 מטר שאתה עולה. ככל שתגיע גבוה יותר, כך תראה פחות לחץ, כי העמוד לראש האטמוספירה הוא הרבה יותר קצר ולכן שוקל פחות. זה שימושי לדעת, כי על ידי מדידת הלחץ וחישובים, אתה יכול לקבוע את הגובה שלך.

לחץ האוויר ב -3, 810 מטרים הוא רק חצי מזה בגובה פני הים.

BMP180 מוציא לחץ מוחלט בפסקל (Pa). פסקל אחד הוא כמות קטנה מאוד של לחץ, בערך הכמות שדף נייר יפעיל על שולחן. לעתים קרובות יותר תראה מדידות בהקטופאקל (1 hPa = 100 Pa). הספרייה המשמשת כאן מספקת פלט ערכי נקודה צפה ב- hPa, מה שקורה גם הוא למיליבר אחד (mbar).

להלן מספר המרות ליחידות לחץ אחרות:

• 1 hPa = 100 Pa = 1 mbar = 0.001 בר
• 1 hPa = 0.75006168 Torr
• 1 hPa = 0.01450377 psi (פאונד לאינץ 'מרובע)
• 1 hPa = 0.02953337 inHg (סנטימטרים של כספית)
• 1 hpa = 0.00098692 אטם (אטמוספרות סטנדרטיות)

השפעות טמפרטורה

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

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

מדידת לחץ מוחלט

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

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

תצפיות מזג אוויר

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

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

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

קביעת גובה

מכיוון שהלחץ משתנה עם הגובה, אתה יכול להשתמש בחיישן לחץ למדידת גובה (עם כמה אזהרות). הלחץ הממוצע של האטמוספירה בגובה פני הים הוא 1013.25 hPa (או mbar). זה יורד לאפס כאשר אתה מטפס לכיוון ואקום החלל. מכיוון שהעקומה של ירידה זו מובנת היטב, ניתן לחשב את הפרש הגובה בין שתי מדידות לחץ (p ו- p0) על ידי שימוש במשוואה ספציפית.

אם אתה משתמש בלחץ פני הים (1013.25 hPa) בתור הלחץ הבסיסי (p0), תפוקת המשוואה תהיה הגובה הנוכחי שלך מעל פני הים. בספרייה יש פונקציה בשם גובה (P, P0) המאפשרת לך לקבל את "הגובה המחושב".

ההסבר לעיל הופק מהמדריך BMP 180 Sparkfun.

שלב 6: ה- HW המלא

שלב 7: שליחת נתונים ל- ThingSpeak

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

בואו נתחיל!

ראשית, עליך להיות בעל חשבון ב- ThinkSpeak.com

בצע את ההוראות ליצירת ערוץ ושימו לב למזהה הערוץ ולמפתח API של כתיבה

הורד את סקריפט Python מה- GitHub שלי: localData ToTS_v1_EXT.py

בואו נגיב על החלקים החשובים ביותר בקוד:

ראשית, בואו לייבא את ספריית ThingSpeak, להגדיר את לקוח ה- WiFi ולהגדיר את נתוני הנתב המקומי ואת Thinkspeak:

ייבא דברים שיא

ישנן מספר דרכים לתקשר עם ThingSpeak, הדרך הפשוטה ביותר היא שימוש בספריית הלקוחות עבור ה- API של thingspeak.com שפותח על ידי מיקולאי צ'וואליז וקית 'אליס.

ניתן להוריד את הספרייה מ- https://github.com/mchwalisz/thingspeak או להשתמש ב- PIP במסוף:

sudo pip3 התקן thingspeak

לאחר מכן, בתוך הסקריפט, עדכן את אישורי הערוץ של ThingSpeak

chId = 9999999 # הזן עם מזהה הערוץ שלך

tsKey = 'הזן עם מפתח הכתיבה שלך לערוץ' tsUrl = 'https://api.thingspeak.com/update' ts = thingspeak. Channel (chId, tsUrl, tsKey)

כעת, בואו לאתחל את 3 החיישנים:

# DS18B20 ספריית חוט אחת

מ- w1thermsensor יבוא W1ThermSensor ds18b20Sensor = W1ThermSensor () # כברירת מחדל GPIO 4 משמש על ידי הספרייה # DHT22 יבוא ספרייה Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 ספריית יבוא BMaf1BMP0BP085 עליך להגדיר את הגובה האמיתי שבו נמצאת תחנת מזג האוויר שלך, ולעדכן את המשתנה הגלובלי "altReal". במקרה שלי, התחנה שלי ממוקמת בגובה 950 מ 'מעל פני הים

altReal

altReal = 950

לאחר שנכנסים עם הגובה האמיתי של התחנה כקלט, אנו יכולים להשיג את הלחץ המוחלט, לחץ פני הים, הטמפרטורה והגובה באמצעות הפונקציה bmp180GetData (גובה):

def bmp180GetData (גובה):

temp = bmp180Sensor.read_temperature () pres = bmp180Sensor.read_pressure () alt=bmp180Sensor.read_altitude () presSeaLevel = pres/pow (1.0 - altitude/44330.0, 5.255) temp = round (temp, 1) pres = round (pres/100, 2) # לחץ מוחלט ב- hPa (או mbar) alt=עגול (alt) presSeaLevel = עגול (presSeaLevel/100, 2) # לחץ מוחלט ב- hPa (או mbar) טמפרטורת החזרה, pres, alt, presSeaLevel

הפונקציה getLocalData (), תחזיר את כל הנתונים המקומיים שנלכדים על ידי התחנה שלנו:

def getLocalData ():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # קבל זמן קריאה עכשיו = datetime.datetime.now () timeString = now.strftime ("%Y-%m-%d%H:%M") # קרא טמפרטורת חוץ (מרחק מטר אחד) tempExt = עגול (ds18b20Sensor.get_temperature (), 1) tempLab, presAbs, altLab, presSL = bmp180GetData (altReal) humDHT, tempDHT = Adafruit_DHT.read_retry (DHT22Sensor None), DHT22Sensor None, DHT ו- tempDHT אינו None: humLab = עגול (humDHT

לאחר שכל הנתונים נתפסו על ידי הפונקציות שלמעלה, עליך לשלוח אותם ל- ThingSpeak. אתה תעשה את זה באמצעות הפונקציה sendDataTs ():

def sendDataTs ():

data = {"field1": tempLab, "field2": tempExt, "field3": humLab, "field4": presSL, "field5": altLab} ts.update (data) print ("[INFO] הנתונים נשלחו עבור 5 שדות: ", tempLab, tempExt, humLab, presSL, altLab)

כאשר נתוני הערוץ שלך מעודכנים, שמור את הסקריפט והפעל אותו במסוף שלך:

sudo Python3 localData_ToTs_v1_EXT.py

על פרוטוקולי תקשורת

שים לב כי באמצעות "ספריית Thingspeak", "ספריית הבקשות" מיובאת, כלומר ספריית HTTP מורשה של Apache2, שנכתבה ב- Python. את מסמך ההתקנה הרשמי של הבקשה ניתן למצוא כאן:

docs.python-requests.org/en/latest/user/install/

במידת הצורך, לפני הפעלת הסקריפט, תוכל לוודא אם מותקנת ספריית הבקשות:

sudo pip3 בקשות להתקנה

לחלופין תוכל להשתמש ב- MTTQ כשיטה לשליחת נתונים ל- ThingSpeak. MQTT שונה מ- HTTP, פעם הוא תוכנן במיוחד להיות קל משקל ומיועד למכשירים מוטבעים עם זיכרון RAM נמוך וביצועי מעבד. כמו כן, ברוב המקרים, MQTT משתמש בפחות רוחב פס.

עיין במדריך זה: עדכן ערוץ ThingSpeak באמצעות MQTT ב- Raspberry Pi לפרטים נוספים.

שלב 8: שליחת נתונים מרוחקים ל- ThingSpeak באמצעות ESP8266

לשלב זה נשתמש באותו HW שהוסבר במדריך muy:

IOT עשה את זה קל: לכידת נתוני מזג אוויר מרחוק: טמפרטורת UV ואוויר ולחות

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

ראשית, בואו להתקשר לספריית ESP8266, להגדיר את לקוח ה- WiFi ולהגדיר את הנתב המקומי ואת אישורי Thinkspeak:

/ * NodeMCU ESP12-E */

#כלול לקוח WiFiClient; const char* MY_SSID = "היכנס עם SSDID שלך"; const char* MY_PWD = "היכנס באמצעות סיסמתך"; /* Thinkspeak*/ const char* TS_SERVER = "api.thingspeak.com"; מחרוזת TS_API_KEY = "היכנס עם מפתח הכתיבה שלך";

שנית, בואו לכלול ספרייה חשובה מאוד לפרויקטים של IoT: SimpleTimer.h:

/ * TIMER */

#כלול טיימר SimpleTimer;

שלישית, במהלך ההתקנה (), נתחיל תקשורת טורית, נקרא לפונקציה connectWiFi () ונגדיר את הטיימרים. שים לב ששורת הקוד: timer.setInterval (60000L, sendDataTS); יקרא לפונקציה sendDataTS () כל 60 שניות, על מנת להעלות נתונים לערוץ ThinkSpeak.

הגדרת חלל ()

{… Serial.begin (115200); עיכוב (10); … connectWifi (); timer.setInterval (60000L, sendDataTS); …}

סוף סוף אבל לא פחות מזה, במהלך הלולאה (), הפקודה היחידה הדרושה היא ליזום את הטיימר וזהו!

לולאת חלל ()

{… Timer.run (); // יוזם SimpleTimer}

להלן תוכל לראות את שתי הפונקציות החשובות המשמשות לטיפול בתקשורת Thinkspeak:

חיבור ESP12-E עם רשת ה- WiFi שלך:

/***************************************************

*חיבור WiFi ******************************************** ***/ void connectWifi () {Serial.print ("מתחבר ל-"+*MY_SSID); WiFi.begin (MY_SSID, MY_PWD); בעוד (WiFi.status ()! = WL_CONNECTED) {עיכוב (1000); Serial.print ("."); } Serial.println (""); Serial.println ("מחובר WiFi"); Serial.println (""); }

שליחת נתונים ל- ESP12-E ל- ThinkSpeak:

***************************************************

*שליחת נתונים לערוץ Thinkspeak ***************************************** ******/ void sendDataTS (void) {if (client.connect (TS_SERVER, 80)) {String postStr = TS_API_KEY; postStr += "& field6 ="; postStr += מחרוזת (טמפ '); postStr += "& field7 ="; postStr += מחרוזת (זמזום); postStr += "& field8 ="; postStr += String (dataSensorUV); postStr += "\ r / n / r / n"; client.print ("POST /עדכון HTTP /1.1 / n"); client.print ("מארח: api.thingspeak.com / n"); client.print ("חיבור: סגור / n"); client.print ("X-THINGSPEAKAPIKEY:" + TS_API_KEY + "\ n"); client.print ("סוג תוכן: application/x-www-form-urlencoded / n"); client.print ("אורך התוכן:"); client.print (postStr.length ()); client.print ("\ n / n"); client.print (postStr); עיכוב (1000); } נשלח ++; client.stop (); }

הקוד המלא ניתן למצוא ב- GitHub שלי: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

לאחר שהעלית את הקוד ל- NodeMCU שלך. נחבר סוללה חיצונית ונערוך מדידה תחת השמש. הנחתי את התחנה המרוחקת על הגג ומתחיל לצלם נתונים ב- ThingSpeak.com כפי שמוצג בתמונות למעלה.

שלב 9: הערות אחרונות

המטרה העיקרית של הדרכה זו הייתה להראות כיצד לחבר את ה- Raspberry Pi ל- ThingSpeak. זה נהדר ללכוד נתונים ולרשום אותם בפלטפורמת IoT.

בהזדמנות שלחנו גם נתונים לאותו ערוץ ספציפי, ולכוד אותם מתחנה מרוחקת באמצעות ESP8266. גישה זו היא בסדר, אך לא הטובה ביותר. מכיוון שיש לנו פעולה "אסינכרונית", לפעמים שניהם, RPi ו- ESP8266 מנסים לרשום במקביל (או עם מרווח קטן) את מה שמופרך על ידי ThingSpeak. האידיאל הוא ש- ESP8266 ישלח נתונים מקומית ל- Raspberry Pi והאחרון יהיה אחראי לטפל בכל הנתונים. פעולה זו, "התחנה המרכזית" (Raspberry Pi), יכולה לעשות 3 דברים:

• רשום את כל הנתונים במסד נתונים מקומי
• הצג את כל הנתונים בדף אינטרנט מקומי (באמצעות בקבוק כפי שמוצג בתמונה למעלה)
• שליחת כל הנתונים ל- ThingSpeak בו זמנית.

במדריך עתידי נבחן את האפשרויות הללו.

שלב 10: סיכום

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

לפרטים וקוד סופי, בקר במחסן GitHub שלי: RPi-NodeMCU-Weather-Station

לפרויקטים נוספים, בקר בבלוג שלי: MJRoBot.org

המשך לעקוב! ההדרכה הבאה נשלח נתונים מתחנת מזג אוויר מרוחקת למרכזית, המבוססת על שרת אינטרנט Raspberry Pi:

כל הכבוד מדרום העולם!

נתראה במדריך הבא שלי!

תודה, מרסלו