DuvelBot - רובוט הגשה לבירה ESP32 -CAM: 4 שלבים (עם תמונות)

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

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

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

הגיע הזמן לפרוץ את המגהץ והמקלדת …

DuvelBot היא מצלמת נהיגה מבוססת AI-Thinker ESP32-CAM ללא דחיפות, שתוכל לשלוט בה מהסמארטפון, הדפדפן או הטאבלט שלך.

קל להתאים או להרחיב את הפלטפורמה הזו לשימושים פחות אלכוהוליים (חשוב SpouseSpy, NeighbourWatch, KittyCam …).

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

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

אספקה

מה אתה צריך:

רשימת החלקים אינה מגולפת באבן וניתן להשיג חלקים רבים בהמון גרסאות שונות וממקומות רבים ושונים. הרכשתי ביותר מ- Ali-Express. כמו שאמר מאצ'טה: אלתר.

חוּמרָה:

• מודול ESP32-CAM של Thinker AI. זה כנראה יכול לעבוד עם מודולים אחרים של ESP32-CAM אבל בזה השתמשתי
• לוח נהג L298N,
• פלטפורמת רובוטיקה זולה עם 4 גלגלים,
• דיור בעל משטח שטוח גדול כגון Hammond Electronics 1599KGY,
• ממיר USB ל -3.3 V-TTL לתכנות.
• לתאורה: 3 נוריות לבנות, BC327 או טרנזיסטור למטרות כלליות אחרות NPN (Ic = 500mA), נגד 4k7k, 3 נגדים של 82Ohm, perfboard, כבלים (ראה סכמטי ותמונות).
• מתג הפעלה/כיבוי וכפתור פתוח בדרך כלל לתכנות.

אופציונאלי:

• מצלמת עין דג עם גמישות ארוכה יותר מהמצלמה הסטנדרטית OV2460 המסופקת עם מודול ESP32-CAM,
• אנטנת WiFi עם כבל ארוך במידה כזאת ומחבר קואקס מיניאטורי במיוחד. ל- ESP32-CAM יש אנטנה משולבת והדיור מפלסטיק, כך שאין צורך באמת באנטנה, אולם חשבתי שהיא נראית מגניבה, אז …
• נייר מדבקה להדפסה להזרקת דיו לעיצוב הכריכה העליונה.

כלי החומרה הרגילים: מלחם, מקדחות, מברגים, צבת …

שלב 1: בניית פלטפורמת הרובוט

סכמטי:

הסכימה אינה מיוחדת. מצלמת ה- ESP32 שולטת במנועים באמצעות לוח נהגי המנוע L298N, הכולל שני ערוצים. מנועי צד שמאל וימין ממוקמים במקביל וכל צד תופס ערוץ אחד. ארבעה קבלים קרמיים קטנים של 10..100nF הקרובים לסיכות המנוע רצוי כתמיד להתנגד להפרעות RF. כמו כן, מכסה אלקטרוליטי גדול (2200… 4700uF) על אספקת לוח המנועים כפי שמוצג בתרשים, אם כי אינו נחוץ בהחלט, יכול להגביל מעט את אדוות מתח האספקה (אם אתה רוצה לראות סרט אימה, בדוק את Vbat עם אוסצילוסקופ בזמן שהמנועים פעילים).

שים לב ששני סיכות ENABLE של ערוצי המנוע מונעים על ידי אותו פין שאופנן ברוחב הדופק (PWM) של ה- ESP32 (IO12). הסיבה לכך היא שלמודול ESP32-CAM אין המון GPIO (הסכימה של המודול כלולה לעיון). נוריות הנייד של הרובוט מונעות על ידי IO4, המניע גם את נורית הפלאש המשולבת, לכן הסר את Q1 כדי למנוע מנורת הפלאש להידלק בבית סגור.

לחצן תכנות, מתג הפעלה/כיבוי, מחבר טעינה ומחבר תכנות נגישים מתחת לרובוט. יכולתי לעשות עבודה הרבה יותר טובה עבור מחבר התכנות (שקע 3.5 מ מ?), אבל הבירה לא יכלה לחכות יותר. גם עדכוני אוויר (OTA) יהיו נחמדים להתקנה.

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

חשוב: כדי להטעין את סוללות ה- NiMH של הרובוט, השתמש במערך אספקה של המעבדה (נטען) לכ -14 וולט וזרם מוגבל ל- 250mA. המתח יסתגל למתח הסוללות. נתק אם הרובוט מרגיש חם או שמתח הסוללה מגיע לכ -12.5 וולט. שיפור ברור כאן יהיה שילוב מטען סוללות תקין, אך זה מחוץ להיקפו של מדריך זה.

החומרה:

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

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

הדפס את הלוגו העליון בקובץ DuvelBot.svg על נייר מדבקות הזרקת דיו (או עיצוב משלך), ואתה מוכן לצאת לדרך!

שלב 2: תכנת הרובוט

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

אתה צריך את כלי התוכנה הבאים:

• ה- Arduino IDE,
• ספריות ESP32, SPIFFS (מערכת קבצי פלאש היקפית טורי), ספריית שרת האינטרנט של ESPAsync.

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

הקוד:

ניתן למצוא את הקוד שלי בכתובת:

• סקיצה של Arduino DuvelBot.ino,
• תיקיית משנה של נתונים המחזיקה את הקבצים שעומדים להעלות לפלאש ה- ESP באמצעות SPIFFS. תיקיה זו מכילה את דף האינטרנט ש- ESP יגיש (index.html), תמונת לוגו המהווה חלק מדף האינטרנט (duvel.png) וגיליון סגנונות מדורג או קובץ CSS (style.css).

לתכנת הרובוט:

• חבר את ממיר ה- USB-TTL כפי שמוצג בסכימה,
• קובץ -> פתח -> עבור לתיקיה שבה DuvelBot.ino נמצא.
• שנה את אישורי הרשת שלך במערכון:

const char* ssid = "yourNetworkSSIDHere"; const char* password = "yourPasswordHere";

• כלים -> לוח -> "AI -Thinker ESP -32 CAM" ובחר את היציאה הטורית המתאימה למחשב האישי שלך (כלים -> יציאה -> משהו כמו /dev /ttyUSB0 או COM4),
• פתח את הצג הטורי ב- Arduino IDE, תוך לחיצה על כפתור PROG (המושך את IO0 נמוך), הפעל את הרובוט,
• בדוק על הצג הטורי שה- ESP32 מוכן להורדה,
• סגור את הצג הטורי (אחרת ההעלאה של SPIFFS נכשלה),
• כלים -> "העלאת נתוני סקיצה של ESP32" והמתן לסיום,
• כבה והפעל שוב והחזק את לחצן PROG כדי לחזור למצב תכנות,
• לחץ על החץ "העלה" כדי לתכנת את הסקיצה והמתן עד לסיומו,
• פתח את הצג הטורי ואפס את ESP32 על ידי כיבוי/הפעלה,
• לאחר האתחול, רשום את כתובת ה- ip (משהו כמו 192.168.0.121) ונתק את הרובוט מממיר ה- USB-TTL,
• פתח דפדפן בכתובת ip זו. אתה אמור לראות את הממשק כמו בתמונה.
• אופציונלי: הגדר את כתובת ה- mac של ה- ESP32 לכתובת ip קבועה בנתב שלך (תלוי בנתב כיצד לבצע).

זהו זה! המשך לקרוא אם אתה רוצה לדעת איך זה עובד …

שלב 3: איך זה עובד

עכשיו אנחנו מגיעים לחלק המעניין: איך הכל עובד יחד?

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

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

ואז המצלמה מוגדרת. שמרתי בכוונה על הרזולוציה די נמוכה (VGA או 640x480) כדי להימנע מתגובה איטית. שים לב שלוח ה- ESP32-CAM AI-Thinker כולל שבב RAM טורי (PSRAM) שבו הוא משתמש לאחסון מסגרות מצלמה ברזולוציה גדולה יותר:

if (psramFound ()) {Serial.println ("PSRAM נמצא."); config.frame_size = FRAMESIZE_VGA; config.jpg_quality = 12; config.fb_count = 2; // מספר חובבי מסגרות ראו: https://github.com/espressif/esp32-camera} else {Serial.println ("לא נמצא PSRAM."); config.frame_size = FRAMESIZE_QVGA; config.jpg_quality = 12; config.fb_count = 1; }

לאחר מכן המערכת מאתחלת את מערכת קובצי הפלאש ההיקפי הטורי (SPIFFS):

// אתחול SPIFFS אם (! SPIFFS.begin (true)) {Serial.println ("אירעה שגיאה בעת התקנת SPIFFS!"); לַחֲזוֹר; }

SPIFFS פועל כמו מערכת קבצים קטנה ב- ESP32. כאן הוא משמש לאחסון של שלושה קבצים: דף האינטרנט עצמו index.html, גיליון סגנונות של קבצים מדורגים style.css ולוגו תמונה-p.webp

בשלב הבא ה- ESP32 מתחבר לנתב שלך (אל תשכח להגדיר את האישורים שלך לפני ההעלאה):

// שנה את אישורי הנתב שלך chareconst char* ssid = "yourNetworkSSIDHere"; const char* password = "yourPasswordHere"; … // התחבר ל- WiFi Serial.print ("מתחבר ל- WiFi"); WiFi.begin (ssid, סיסמא); בעוד (WiFi.status ()! = WL_CONNECTED) {Serial.print ('.'); עיכוב (500); } // מחובר כעת לנתב: ל- ESP32 יש כעת כתובת IP

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

// צור אובייקט AsyncWebServer בשרת 80AsyncWebServer (80); … server.begin (); // התחל להאזין לחיבורים

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

ה- ESP32 יודע כיצד להגיב, מכיוון שבהגדרת התגובות לכל הבקשות המותרות האפשריות נרשמו באמצעות server.on (). לדוגמה, דף האינטרנט הראשי או האינדקס (/) מטופלים כך:

server.on ("/", HTTP_GET, (AsyncWebServerRequest *בקשה) {Serial.println ("/בקשה התקבלה!"); request-> שלח (SPIFFS, "/index.html", String (), false, מעבד);});

כך שאם הלקוח מתחבר, ה- ESP32 מגיב על ידי שליחת קובץ index.html ממערכת הקבצים SPIFFS. מעבד הפרמטרים הוא שם הפונקציה המעבדת את ה- html ומחליפה תגים מיוחדים:

// מחליף מצייני מיקום ב- html כמו %DATA %// במשתנים שאתה רוצה להציג //

נתונים: %DATA %

מעבד מחרוזת (const String & var) {if (var == "DATA") {//Serial.println("מעבד! "); מחרוזת החזרה (dutyCycleNow); } מחזור מחזור ();}

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

1. קוד HTML: אילו אלמנטים יש להציג (לחצנים/טקסט/מחוונים/תמונות וכו '),
2. קוד סגנון, בקובץ.css נפרד או בקטע …: כיצד על המרכיבים להיראות,
3. javascript a … קטע: כיצד דף האינטרנט צריך לפעול.

ברגע ש- index.html נטען בדפדפן (שיודע שהוא html בגלל השורה DOCTYPE), הוא נתקל בשורה זו:

זוהי בקשה לגיליון בסגנון css. המיקום של גיליון זה מופיע ב- href = "…". אז מה הדפדפן שלך עושה? נכון, היא משיקה בקשה נוספת לשרת, הפעם עבור style.css. השרת לוכד בקשה זו מכיוון שהיא נרשמה:

server.on ("/style.css", HTTP_GET, (AsyncWebServerRequest *בקשה) {Serial.println ("התקבלה בקשת css"); request-> שלח (SPIFFS, "/style.css", "text/css ");});

מסודר הא? אגב, זה יכול היה להיות href = "/some/file/on/the/other/side/of/the/moon", לכל הדפדפן שלך אכפת. זה היה הולך להביא את הקובץ הזה בשמחה. לא אסביר על גיליון הסגנונות מכיוון שהוא שולט רק במראה כך שזה לא ממש מעניין כאן, אבל אם אתה רוצה ללמוד עוד, בדוק את ההדרכה הזו.

כיצד מופיע הלוגו של DuvelBot? ב- index.html יש לנו:

שאליו מגיב ה- ESP32:

server.on ("/duvel", HTTP_GET, (AsyncWebServerRequest *request) {Serial.println ("התקבלה בקשת לוגו duvel!"); request-> שלח (SPIFFS, "/duvel.png", "image-p.webp

..קובץ SPIFFS אחר, הפעם תמונה מלאה, כפי שמציינת "image/png" בתגובה.

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

קָדִימָה

השם class = "…" הוא רק שם לקשר אותו לגליון הסגנונות להתאמה אישית של הגודל, הצבע וכו 'החלקים החשובים הם onmousedown = "toggleCheckbox (' קדימה ')" ו- onmouseup = "toggleCheckbox (' stop ') ". אלה מהווים את פעולות הכפתור (אותו הדבר לגבי ontouchstart/ontouchend אבל בשביל זה מסכי מגע/טלפונים). כאן, פעולת הלחצן קוראת פונקציה toggleCheckbox (x) בקטע javascript:

function toggleCheckbox (x) {var xhr = XMLHttpRequest חדש (); xhr.open ("GET", "/" + x, true); xhr.send (); // יכול לעשות משהו עם התגובה גם כשהוא מוכן, אבל אנחנו לא}

אז לחיצה על כפתור קדימה, גורמת מיד להתקשרות תיבת הסימון ('קדימה'). לאחר מכן פונקציה זו משיקה XML GttpRequest "GET", של המיקום "/קדימה", שפועל בדיוק כמו אם היית מקליד 192.168.0.121/forward בשורת הכתובת של הדפדפן שלך. ברגע שהבקשה הזו מגיעה ל- ESP32, היא מטופלת על ידי:

server.on ("/קדימה", HTTP_GET, (AsyncWebServerRequest *בקשה) {Serial.println ("התקבל/קדימה"); actionNow = FORWARD; request-> שלח (200, "טקסט/רגיל", "אישור קדימה. ");});

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

כשלעצמה במהלך תגובה זו, התוכנית קובעת רק משתנה actionNow = FORWARD, כתגובה ללחיצה על הכפתור. כעת במרכז הלופ של התוכנית, משתנה זה מנוטר במטרה להגביר/להוריד את ה- PWM של המנועים. ההיגיון הוא: כל עוד יש לנו פעולה שאינה STOP, הגבירו את המנועים בכיוון זה עד שמגיעים למספר מסוים (dutyCycleMax). לאחר מכן שמור על מהירות זו, כל עוד הפעולה עכשיו לא השתנתה:

לולאת חלל () {currentMillis = millis (); if (currentMillis - previousMillis> = dutyCycleStepDelay) {// שמור את הפעם האחרונה שביצעת את הלולאה previousMillis = currentMillis; // mainloop אחראית על העלאת/הורדת המנועים אם (actionNow! = previousAction) {// ramp down, ואז עצור, ואז שנה את הפעולה והגביר את dutyCycleNow = dutyCycleNow-dutyCycleStep; אם (dutyCycleNow <= 0) {// אם לאחר עלייה למטה dc הוא 0, הגדר לכיוון החדש, התחל ב- min dutycycle setDir (actionNow); previousAction = actionNow; dutyCycleNow = dutyCycleMin; }} else // actionNow == previousAction רמפה למעלה, למעט כאשר הכיוון הוא STOP {if (actionNow! = STOP) {dutyCycleNow = dutyCycleNow+dutyCycleStep; if (dutyCycleNow> dutyCycleMax) dutyCycleNow = dutyCycleMax; } else dutyCycleNow = 0; } ledcWrite (pwmChannel, dutyCycleNow); // התאם את אופנוע הדיוק}}

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

עכשיו אם נשחרר את כפתור ההעברה, הדפדפן שלך מתקשר toggleCheckbox ('עצור'), וכתוצאה מכך תבקש לקבל /להפסיק. ה- ESP32 מגדיר את actionNow ל- STOP (ומגיב עם "אישור עצור"), מה שמוביל את המרכב כדי לסובב את המנועים.

מה עם הנורות? אותו מנגנון, אבל עכשיו יש לנו מחוון:

ב- javascript, ההגדרות של המחוון מנוטרות, כך שבכל שינוי מתרחשת קריאה לקבל "/LED/xxx", כאשר xxx הוא ערך הבהירות שאליו יש להגדיר את הנורות:

var slide = document.getElementById ('slide'), sliderDiv = document.getElementById ("sliderAmount"); slide.onchange = function () {var xhr = XMLHttpRequest חדש (); xhr.open ("GET", "/LED/" + this.value, true); xhr.send (); sliderDiv.innerHTML = this.value; }

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

המטפל בסקיצה תופס את כל בקשות הבהירות באמצעות "/LED/*" ברישום המטפל. ואז החלק האחרון (מספר) מפוצל ויוצק לאינט:

server.on ("/LED/ *", HTTP_GET, (AsyncWebServerRequest *בקשה) {Serial.println ("בקשת לד התקבלה!"); setLedBrightness ((בקשה-> url ()). מחרוזת משנה (5).toInt ()); בקשה-> שלח (200, "טקסט/רגיל", "OK Leds.");});

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

… אז איך מתעדכנת תמונת המצלמה מבלי שתצטרך לרענן את הדף? לשם כך אנו משתמשים בטכניקה הנקראת AJAX (JavaScript אסינכרוני ו- XML). הבעיה היא שבדרך כלל חיבור לקוח-שרת עוקב אחר הליך קבוע: לקוח (דפדפן) מבקש בקשה, שרת (ESP32) מגיב, התיק נסגר. בוצע. שום דבר כבר לא קורה. אם רק איכשהו נוכל להערים על הדפדפן לבקש עדכונים באופן קבוע מ- ESP32 … וזה בדיוק מה שנעשה עם פיסת javascript זו:

setInterval (function () {var xhttp = new XMLHttpRequest (); xhttp.open ("GET", "/CAMERA", true); xhttp.responseType = "blob"; xhttp.timeout = 500; xhttp.ontimeout = function () {}; xhttp.onload = function (e) {if (this.readyState == 4 && this.status == 200) {// ראה: https://stackoverflow.com/questions/7650587/using… // https://www.html5rocks.com/en/tutorials/file/xhr2/ var urlCreator = window. URL || window.webkitURL; var imageUrl = urlCreator.createObjectURL (this.response); // ליצור אובייקט מהכפתור document.querySelector ("#camimage"). src = imageUrl; urlCreator.revokeObjectURL (imageurl)}}; xhttp.send ();}, 250);

setInterval לוקח כפרמטר פונקציה ומבצע אותה מדי פעם (כאן אחת לכל 250 ms וכתוצאה מכך 4 מסגרות לשנייה). הפונקציה המבוצעת מבקשת בקשה ל"בלוף "בינארי בכתובת /CAMERA. זה מטופל על ידי ESP32-CAM במערכון כמו (מתוך Randomnerdtutorials):

server.on ("/CAMERA", HTTP_GET, (AsyncWebServerRequest * request) {Serial.println ("התקבלה בקשת מצלמה!"); camera_fb_t * fb = NULL; // esp_err_t res = ESP_OK; size_t _jpg_buf_len = 0; uint8_ * _jpg_buf = NULL; // ללכוד מסגרת fb = esp_camera_fb_get (); אם (! fb) {Serial.println ("לא ניתן היה לרכוש מאגר מסגרת"); return;} if (fb-> פורמט! = PIXFORMAT_JPEG)/ /כבר בפורמט זה מתוך config {bool jpeg_converted = frame-j.webp

החלקים החשובים מקבלים את המסגרת fb = esp_camera_fb_get () המרתה ל--j.webp

לאחר מכן מחכה פונקציית javascript לתמונה זו שתגיע. ואז רק צריך קצת עבודה להמיר את ה"בלוב "שהתקבל לכתובת אתר שיכולה לשמש כמקור לעדכון התמונה בדף ה- html.

וואו, סיימנו!

שלב 4: רעיונות ושאריות

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

• יישום הזרמת מצלמות 'אמיתית' כפי שמוסבר כאן וכאן והעבר אותה לשרת שני כפי שמוסבר כאן על אותו ESP32, אך על ליבת המעבד האחרת, ולאחר מכן ייבא את מצלמת הזרם ל- html המוגש על ידי השרת הראשון באמצעות … זה אמור לגרום לעדכוני מצלמה מהירים יותר.
• השתמש במצב נקודת גישה (AP) כך שהרובוט יהיה עצמאי יותר כפי שמוסבר כאן.
• הרחב בעזרת מדידת מתח סוללה, יכולות שינה עמוקה וכו 'זה קצת קשה כרגע מכיוון של- ESP32-CAM AI-Thinker אין הרבה GPIOs; זקוק להרחבה באמצעות uart ולמשל ארדואינו לעבדים.
• הפוך לרובוט המחפש חתולים שמוציא מעת לעת פינוקים על לחצן כפתור על כפתור גדול, הזרם המון תמונות חתולים נחמדות במהלך היום …

אנא הגיב אם אהבת או שיש לך שאלות ותודה על הקריאה!