MicroPython נמצא בשימוש נרחב עם מיקרו-בקרים ומערכות משובצות. אנחנו יכולים לכתוב קוד וספריות בתוך MicroPython IDE ולהתממשק למספר חיישנים. כתיבה זו תדריך אותך למדידת מרחק באמצעות ה-ESP32 עם חיישן HC-SR04.
ESP32 עם חיישן אולטראסוני HC-SR04 באמצעות MicroPython
התממשקות ESP32 עם אולטרסאונד רק דורשת חיבור של שני חוטים. באמצעות חיישנים קוליים, אנו יכולים למדוד מרחק עצמים ויכולים להפעיל תגובות המבוססות על מערכת זו, כגון מערכות למניעת התנגשות ברכב.
באמצעות MicroPython שהיא שפה מעוצבת עבור ESP32 ומיקרו-בקרים אחרים נוכל לממשק חיישנים מרובים כמו HC-SR04 . ייכתב קוד MicroPython שמחשב את הזמן שלוקח לגל ה-SONAR להגיע מחיישן לאובייקט וחזרה לאובייקט. מאוחר יותר באמצעות נוסחת המרחק, נוכל לחשב מרחק אובייקט.
הנה כמה דגשים עיקריים של חיישן HC-SR04:
| מאפיינים | ערך |
| מתח הפעלה | 5V DC |
| זרם הפעלה | 15mA |
| תדירות הפעלה | 40KHz |
| המטווח שלי | 2 ס'מ/1 אינץ' |
| טווח מקסימלי | 400 ס'מ / 13 רגל |
| דיוק | 3 מ'מ |
| זווית מדידה | <15 מעלות |
HC-SR04 Pinout HC-SR04 מכיל את הדברים הבאים ארבע סיכות:
- Vcc: חבר לפין Vin ESP32
- Gnd: התחבר ל-GND
- טְרִיגוֹנוֹמֶטרִיָה: הצמד כדי לקבל אות בקרה מלוח ESP32
- הֵד: שלח אות חזרה. לוח המיקרו-בקר מקבל אות זה כדי לחשב מרחק תוך שימוש בזמן
איך עובד אולטרסאונד
לאחר חיבור חיישן HC-SR04 עם ESP32, אות ב- טְרִיגוֹנוֹמֶטרִיָה סיכה תיווצר על ידי לוח. ברגע שהאות מתקבל בפין ההדק של חיישן HC-SR04 ייווצר גל קולי שעוזב את החיישן ופוגע באובייקט או בגוף המכשול. לאחר הפגיעה הוא יקפוץ חזרה אל פני האובייקט.
ברגע שהגל המוחזר יגיע חזרה לקצה הקולט של החיישן ייווצר דופק אות בפין הד. ESP32 מקבל את אות ה-Echo Pin ומחשב מרחק בין אובייקט לחיישן באמצעות מרחק-נוסחה.
יש לחלק את המרחק הכולל המחושב בשניים בתוך קוד ה-ESP32 שכן המרחק שאנו מקבלים במקור שווה למרחק הכולל מחישן לחפץ ובחזרה לקצה המקבל של החיישן. אז המרחק האמיתי הוא האות השווה למחצית מהמרחק הזה.
סכמטי
להלן הסכימה של התממשקות ESP32 עם חיישן קולי:
חבר את ההדק וההד של החיישן עם GPIO 5 ו-GPIO 18 של ESP32 בהתאמה. חבר גם את ESP32 GND ופין Vin עם פיני חיישן.
| חיישן אולטראסוני HC-SR04 | פין ESP32 |
| טְרִיגוֹנוֹמֶטרִיָה | GPIO 5 |
| הֵד | GPIO 18 |
| GND | GND |
| VCC | לבוא |
חוּמרָה
הרכיבים הבאים נדרשים לתכנת חיישן קולי:
- ESP32
- HC-SR04
- קרש לחם
- חוטי מגשר
כיצד להגדיר Ultrasonic HC-SR04 עם ESP32 באמצעות MicroPython
לפני שנוכל לתכנת את ESP32 עם חיישן קולי עלינו להתקין בו ספרייה. חבר את לוח ESP32 למחשב. בצע את השלבים להשלמת תצורת ESP32 עם חיישן קולי ב-Thonny IDE באמצעות MicroPython.
שלב 1: כעת פתח את Thonny IDE. צור קובץ חדש בחלון העורך עבור אל : קובץ>חדש או לחץ Ctrl + N .
לאחר פתיחת הקובץ החדש, הדבק את הקוד הבא בחלון עורך Thonny IDE.
יְבוּא מְכוֹנָה , זְמַןמ מְכוֹנָה יְבוּא פִּין
מעמד HCSR04:
# echo_timeout_us מבוסס על מגבלת טווח שבבים (400 ס'מ)
def __חַם__ ( עצמי , trigger_pin , echo_pin , echo_timeout_us = 500 * שתיים * 30 ) :
עצמי . echo_timeout_us = echo_timeout_us
# סיכת ההדק של Init (יוצא)
עצמי . הדק = פִּין ( trigger_pin , מצב = פִּין. הַחוּצָה , מְשׁוֹך = אף אחד )
עצמי . הדק . ערך ( 0 )
# סיכת הד איניט (בפנים)
עצמי . הֵד = פִּין ( echo_pin , מצב = פִּין. IN , מְשׁוֹך = אף אחד )
def _שלח_דופק_ו_חכה ( עצמי ) :
עצמי . הדק . ערך ( 0 ) # ייצב את החיישן
זְמַן . לישון_נו ( 5 )
עצמי . הדק . ערך ( 1 )
# שלח דופק של 10 אס.
זְמַן . לישון_נו ( 10 )
עצמי . הדק . ערך ( 0 )
לְנַסוֹת :
זמן_דופק = מְכוֹנָה. זמן_דופק_נו ( עצמי . הֵד , 1 , עצמי . echo_timeout_us )
לַחֲזוֹר זמן_דופק
מלבד OSError כפי ש לְשֶׁעָבַר:
אם לְשֶׁעָבַר. args [ 0 ] == 110 : # 110 = זמן קצוב
הַעֲלָאָה OSError ( 'מחוץ לטווח' )
הַעֲלָאָה לְשֶׁעָבַר
def distance_mm ( עצמי ) :
זמן_דופק = עצמי ._שלח_pulse_and_wait ( )
מ'מ = זמן_דופק * 100 // 582
לַחֲזוֹר מ'מ
def distance_cm ( עצמי ) :
זמן_דופק = עצמי ._שלח_pulse_and_wait ( )
ס'מ = ( pulse_time / שתיים ) / 29.1
לַחֲזוֹר ס'מ
שלב 2: לאחר כתיבת ה סִפְרִיָה קוד בתוך חלון העורך כעת עלינו לשמור אותו בתוך מכשיר ה-MicroPython.
שלב 3: לך ל : קובץ>שמור או לחץ Ctrl + S .
שלב 4: יופיע חלון חדש. ודא שה-ESP32 מחובר למחשב. בחר התקן MicroPython כדי לשמור את קובץ הספרייה.
שלב 5: שמור את קובץ הספרייה האולטרסאונד עם השם hcsr04.py ולחץ בסדר .
כעת נוספה בהצלחה ללוח ה-ESP32 ספריית החיישנים האולטראסוניים hcsr04. כעת אנו יכולים לקרוא לפונקציות ספרייה בתוך קוד כדי למדוד מרחק של אובייקטים שונים.
קוד לחיישן אולטראסוני באמצעות MicroPython
עבור קוד חיישן קולי צור קובץ חדש ( Ctrl + N ). בחלון העורך, הזן את הקוד שמופיע למטה ושמור אותו בתוך main.py אוֹ boot.py קוֹבֶץ. קוד זה ידפיס את המרחק של כל אובייקט שמגיע לפני HC-SR04.
קוד התחיל בקריאה לספריות חשובות כגון HCSR04 ו זְמַן ספריה יחד עם לִישׁוֹן לתת עיכובים.
לאחר מכן, יצרנו אובייקט חדש עם שם חיישן . אובייקט זה לוקח שלושה ארגומנטים שונים: טריגר, הד ופסק זמן. כאן פסק זמן מוגדר כזמן המקסימלי לאחר שהחיישן יוצא מתחום.
חיישן = HCSR04 ( trigger_pin = 5 , echo_pin = 18 , echo_timeout_us = 10000 )כדי למדוד ולשמור מרחק אובייקט חדש בשם מֶרְחָק נוצר. אובייקט זה יחסוך מרחק בס'מ.
מֶרְחָק = חיישן. distance_cm ( )כתוב את הקוד הבא כדי לקבל נתונים במ'מ.
מֶרְחָק = חיישן. distance_mm ( )לאחר מכן, הדפסנו את התוצאה על מעטפת ה-MicroPython IDE.
הדפס ( 'מֶרְחָק:' , מֶרְחָק , 'ס'מ' )בסופו של דבר ניתן עיכוב של 1 שניה.
לִישׁוֹן ( 1 )הקוד המלא ניתן להלן:
מ hcsr04 יְבוּא HCSR04מ זְמַן יְבוּא לִישׁוֹן
# ESP32
חיישן = HCSR04 ( trigger_pin = 5 , echo_pin = 18 , echo_timeout_us = 10000 )
# ESP8266
#sensor = HCSR04(trigger_pin=12, echo_pin=14, echo_timeout_us=10000)
בזמן נָכוֹן :
מֶרְחָק = חיישן. distance_cm ( )
הדפס ( 'מֶרְחָק:' , מֶרְחָק , 'ס'מ' )
לִישׁוֹן ( 1 )
לאחר כתיבה ושמירת קוד בתוך מכשיר ה-MicroPython, אני מריץ כעת את החיישן האולטראסוני main.py קוד קובץ. לחץ על כפתור ההפעלה או לחץ F5 .
פלט של חיישן אולטראסוני כאשר אובייקט קרוב
כעת הנח חפץ ליד החיישן האולטראסוני ובדוק את המרחק הנמדד בחלון הצג הטורי של Arduino IDE.
מרחק האובייקט מוצג במסוף המעטפת. כעת האובייקט ממוקם במרחק של 5 ס'מ מהחיישן האולטראסוני.
פלט של חיישן אולטראסוני כאשר האובייקט רחוק
כעת כדי לאמת את התוצאה שלנו נמקם עצמים רחוק מהחיישן ונבדוק את פעולת החיישן האולטראסוני. מקם חפצים כמו שמוצג בתמונה למטה:
חלון הפלט ייתן לנו מרחק חדש וכפי שאנו יכולים לראות האובייקט רחוק מהחיישן, כך שהמרחק הנמדד הוא בערך. 15 ס'מ מהחיישן האולטראסוני.
סיכום
למדידת מרחק יש אפליקציה מצוינת בכל הנוגע לרובוטיקה ופרויקטים אחרים, ישנן דרכים שונות למדידת מרחק. HC-SR04 עם ESP32 יכול למדוד את המרחק של עצמים שונים. כאן הכתיבה הזו תכסה את כל השלבים שצריך כדי לשלב ולהתחיל למדוד מרחק עם ESP32.