Esp32 Bluetooth נמוכה באנרגיה (ble) - חיבור ללהקת כושר להפעלת נורה

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

כבר בחנו את הפונקציות BLE (Bluetooth Low Energy) של מודול ESP32 ואני די נרגש מכך. כדי לתת סיכום, יש למודול זה גם Bluetooth קלאסי וגם Bluetooth אנרגיה נמוכה (BLE), ניתן להשתמש ב- Bluetooth הקלאסי להעברת שירים או קבצים ואפשרות ה- BLE יכולה לשמש ליישומים המותאמים לסוללה כמו משואות Bluetooth, להקות כושר, קרבה וכו 'ניתן גם להשתמש בו כבלוטות' סדרתי כמו המודולים HC-05 או HC-06 לפרויקטים פשוטים של מיקרו-בקר.

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

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

דרישות קדם

במאמר זה, אני מניח שאתה כבר מכיר כיצד להשתמש בלוח ESP32 עם Arduino IDE, אם לא תחזור להתחיל עם מדריך ESP32.

חילקנו את ה- Bluetooth ה- ESP32 השלם לשלושה קטעים כדי להקל על ההבנה. לכן מומלץ לעבור על שתי ההדרכות הראשונות לפני שמתחילים בהדרכה זו.

Bluetooth סידורי ב- ESP32 מחליף נורית מהטלפון הנייד
שרת BLE לשליחת נתונים ברמת הסוללה לטלפון נייד באמצעות שירות GATT
לקוח BLE לסרוק אחר מכשירי BLE ולשמש כמגדלור.

כבר כיסינו את שתי ההדרכות הראשונות, כאן אנו ממשיכים עם האחרון להסביר את ESP32 כלקוח BLE.

חומרים נדרשים

מועצת הפיתוח ESP32
עומס AC (מנורה)
מודול ממסר

חוּמרָה

החומרה של פרויקט לקוח ESP32 BLE זה די ברורה מכיוון שרוב הקסם מתרחש בתוך הקוד. ה- ESP32 צריך להחליף מנורת AC (Load) כאשר אות ה- Bluetooth מתגלה או אבד. כדי להחליף עומס זה נשתמש בממסר, ומכיוון שסיכות ה- GPIO של ESP32 תואמות 3.3V בלבד, אנו זקוקים למודול ממסר שניתן להניע עם 3.3V. רק בדוק באיזה טרנזיסטור משתמשים במודול הממסר אם זה BC548 אתה יכול ללכת אחר לבנות מעגל משלך על ידי ביצוע דיאגרמת המעגל למטה.

אזהרה: המעגל עוסק במתח 220V AC ישיר. היזהר עם חוטים חיים וודא שאתה לא יוצר קצר חשמלי. ראה הוזהרת.

הסיבה מאחורי השימוש ב- BC548 מעל BC547 או 2N2222 היא שיש להם מתח נמוך של פולט בסיס שניתן להפעיל עם 3.3V בלבד. הממסר משמש כאן הוא ממסר 5V, כך כ"ן אותו עם סיכה והין אשר מקבלת 5V מהווה את כבל החשמל. סיכת הארקה מחוברת לקרקע המעגל. 1K R1 הנגד משמש נגד מגביל זרם בסיס. חוט הפאזה מחובר לסיכת ה- NO של הממסר והסיכה המשותפת של הממסר מחוברת לעומס והקצה השני של העומס מחובר לניטראלי. אתה יכול להחליף את המיקום של שלב ונייטרלי, אך הקפד שלא לקצר אותם ישירות. הזרם תמיד צריך לעבור דרך העומס (הנורה).השתמשתי במודול ממסר כדי לשמור על דברים פשוטים והעומס כאן הוא מנורת LED פוקוס. ההגדרה שלי נראית ככה למטה

אם ברצונך לדלג על החומרה לעת עתה, תוכל להשתמש בסיכה GPIO 2 במקום בסיכה GPIO 13 כדי להחליף את נורית הלוח על ESP32. שיטה זו מומלצת למתחילים.

קבל את כתובת ה- Bluetooth שלך של השרת (כתובת של פס הכושר)

כפי שנאמר קודם, אנו הולכים לתכנת את ה- ESP32 לשמש כלקוח (בדומה לטלפון) ולהתחבר לשרת שהוא הלהקה שלי (Lenovo HW-01). כדי שלקוח יתחבר לשרת הוא צריך לדעת את כתובת ה- Bluetooth של השרת. לכל שרת Bluetooth כמו להקת הכושר שלי כאן, יש כתובת Bluetooth ייחודית משלה שהיא קבועה. אתה יכול לקשר זאת לכתובת ה- MAC של המחשב הנייד או הטלפון הנייד שלך.

כדי לקבל כתובת זו מהשרת, אנו משתמשים ביישום שנקרא nRF connect ממוליכים למחצה נורדיים שכבר השתמשנו בהדרכה הקודמת שלנו. זה זמין בחינם למשתמשי IOS וגם למשתמשי Android. כל שעליך לעשות הוא להוריד, להפעיל את היישום ולסרוק למכשירי ה- Bluetooth הסמוכים. היישום יפרט את כל מכשירי ה- BLE שהוא מוצא. שלי נקרא HW-01 פשוט תסתכל מתחת לשמו ותמצא את כתובת החומרה של השרת כפי שמוצג להלן.

אז כתובת החומרה ESP32 BLE של רצועת הכושר שלי היא C7: F0: 69: F0: 68: 81, תהיה לך קבוצה שונה של מספרים באותו פורמט. פשוט רשמו זאת מאחר שנצטרך כאשר אנו מתכנתים את ה- ESP32 שלנו.

השגת השירות וה- UUID האופייני לשרת

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

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

כאן UUID השירות שלי ו- UUID האופייני זהה, אך הוא לא חייב להיות זהה. רשום את ה- UUID של השרת שלך. שלי צוין בתור

שירות UUID: 0000fee7-0000-1000-8000-00805f9b34fb אופייני UUID: 0000fee7-0000-1000-8000-00805f9b34fb

אין חובה להשתמש במאפייני הכתיבה; באפשרותך להשתמש בכל שירות ו UUID מאפיין של השרת המוצג ביישום.

תכנות ה- ESP32 לשמש כלקוח ליישום מתג קרבה

הרעיון של התוכנית הוא לגרום ל- ESP32 לשמש כלקוח שממשיך לסרוק אחר התקני Bluetooth כאשר הוא מוצא את השרת (פס הכושר) שלנו, הוא מאמת את מזהה החומרה והוא יעבור את האור דרך סיכת ה- GPIO 13. טוב בסדר! !, אבל יש בזה בעיה אחת. לכל שרתי ה- BLE יש טווח של 10 מטרים שזה קצת יותר מדי. כך שאם אנו מנסים להפוך את מתג הקרבה להפעלת אור של דלת פתוחה טווח זה הוא גבוה מאוד.

כדי לצמצם את טווח שרת ה- BLE נוכל להשתמש באפשרות ההתאמה. שרת BLE ולקוח יישארו לזווג רק אם שניהם נמצאים במרחק של 3-4 מטרים. זה מושלם ליישום שלנו. לכן, אנו מייצרים את ה- ESP32 לא רק כדי לגלות את שרת ה- BLE אלא גם להתחבר אליו ולוודא אם הוא נשאר מזווג. כל עוד הם משויכים מנורת ה- AC תישאר דולקת, כאשר הטווח יעלה על ההתאמה יאבד והמנורה תיכבה. תוכנית הדוגמה המלאה של ESP32 BLE לשם כך ניתנת בסוף עמוד זה. למטה כאן אני אפרוס את הקוד לקטעים קטנים ואנסה להסביר אותם.

לאחר הכללת קובץ הכותרת, אנו מודיעים ל- ESP32 על כתובת ה- BLE, השירות וה- UUID האופייני שקיבלנו באמצעות יישום חיבור ה- nRF כמוסבר בכותרות לעיל. הקוד נראה כמו למטה

סטטי BLEUUID serviceUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // שירות UUID של כושר הגישה שהושג באמצעות יישום nRF connect יישום סטטי BLEUUID charUUID ("0000fee7-0000-1000-8000-00805f9b34fb"); // UUID אופייני ל- fitnessband המתקבל באמצעות יישום חיבור nRF String My_BLE_Address = "c7: f0: 69: f0: 68: 81"; // חומרה Bluetooth MAC של ה- fitnessband שלי , ישתנה לכל רצועה שמתקבלת באמצעות יישום חיבור nRF

אחריו בתוכנית יש לנו את connectToserver ו- MyAdvertisedDeviceCallback אליהם נחזור מאוחר יותר. ואז בתוך פונקציית ההתקנה , אנו מאתחלים את המסך הטורי ועושים את ה- BLE ב- ESP כדי לסרוק אחר המכשיר. לאחר השלמת הסריקה לכל מכשיר BLE שהתגלה, נקראת הפונקציה MyAdvertisedDeviceCallbacks .

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

הגדרת חלל () { Serial.begin (115200); // התחל צג סדרתי Serial.println ("תוכנית שרת ESP32 BLE"); // הודעת מבוא BLEDevice:: init (""); pBLEScan = BLEDevice:: getScan (); // צור סריקה חדשה pBLEScan-> setAdvertisedDeviceCallbacks (חדש MyAdvertisedDeviceCallbacks ()); // התקשר למחלקה שהוגדרה לעיל pBLEScan-> setActiveScan (true); // סריקה פעילה משתמשת בכוח רב יותר, אך משיגה תוצאות מהר יותר PinMode (13, OUTPUT); // הכריזו על סיכת ה- LED המובנית כפלט }

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

class MyAdvertisedDeviceCallbacks: public BLEAdvertisedDeviceCallbacks { void onResult (BLEAdvertisedDevice advertisedDevice) { Serial.printf ("תוצאת סריקה:% s \ n", advertisedDevice.toString (). c_str ()); Server_BLE_Address = BLEAddress חדש (advertisedDevice.getAddress ()); Scaned_BLE_Address = Server_BLE_Address-> toString (). C_str (); } };

בתוך פונקציית הלולאה אנו סורקים למשך 3 שניות ומכניסים את התוצאה ל- foundDevices שהוא אובייקט מ- BLEScanResults. אם אנו מוצאים מכשיר אחד או יותר על ידי סריקה, אנו מתחילים לבדוק אם כתובת ה- BLE שהתגלתה תואמת את זו שהזנו בתוכנית. אם ההתאמה חיובית והמכשיר לא הותאם קודם לכן, אנו מנסים להזדווג אליו באמצעות פונקציית connectToserver. השתמשנו גם בכמה הצהרות סדרתיות לצורך הבנת מטרה.

בעוד (foundDevices.getCount ()> = 1) { if (Scaned_BLE_Address == My_BLE_Address && paired == false) { Serial.println ("התקן נמצא: -)… מתחבר לשרת כלקוח"); אם (connectToserver (* Server_BLE_Address)) {

בתוך פונקציית connectToserver אנו משתמשים ב- UUID כדי להתאים לשרת BLE (פס הכושר). כדי להתחבר לשרת, על ה- ESP32 לפעול כלקוח, לכן אנו יוצרים לקוח באמצעות הפונקציה createClient () ואז מתחברים לכתובת שרת BLE. ואז אנו מחפשים את השירות ואת המאפיין באמצעות ערכי UUID ומנסים להתחבר אליו. כאשר החיבור מצליח הפונקציה מחזירה אמת ואם לא היא מחזירה שקר. שים לב כי אין חובה שיהיה שירות UUID אופייני לזווג עם שרת, זה נעשה רק להבנתך.

bool connectToserver (BLEAddress pAddress) { BLEClient * pClient = BLEDevice:: createClient (); Serial.println ("- לקוח נוצר"); // התחבר לשרת BLE. pClient-> התחבר (pAddress); Serial.println ("- מחובר ל- fitnessband"); // השג התייחסות לשירות שאנו מחפשים בשרת BLE המרוחק. BLERemoteService * pRemoteService = pClient-> getService (serviceUUID); אם (pRemoteService! = nullptr) { Serial.println ("- מצאנו את השירות שלנו"); לחזור אמיתי; } להחזיר אחר כוזב; // השג התייחסות למאפיין בשירות שרת ה- BLE המרוחק. pRemoteCharacteristic = pRemoteService->getCharacteristic (charUUID); אם (pRemoteCharacteristic! = nullptr) Serial.println ("- מצאנו את המאפיין שלנו"); לחזור אמיתי; }

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

אם (connectToserver (* Server_BLE_Address)) { paired = true; Serial.println ("******************** נורית LED מופעלת ********************** ** "); digitalWrite (13, HIGH); לשבור; }

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

אם (Scaned_BLE_Address == My_BLE_Address && paired == true) { Serial. println ("המכשיר שלנו יצא מהטווח"); זיווג = שקר; סידורי. println ("******************** LED OOOFFFFF ***********************"); digitalWrite (13, LOW); ESP.restart (); לשבור; }

עבודה ובדיקה

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

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

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