המעבדה החיה
כל מה שבונים בשיעור, צעד אחרי צעד. האתר גדל איתנו: כל נושא חדש מקבל כאן עמוד משלו, עם לוח חי, קוד והסבר.
🚗 מכונית אוטונומית🚗 מכונית אוטונומית
כל השלבים בבניית המכונית, לפי הסדר שבו בנינו אותם בשיעור.
📡 חיישנים
📶 ESP32-S3
הבקר של החלק השני בקורס. קטן כמו אצבע, אבל חזק פי כמה מהארדואינו, ועם Wi-Fi ובלוטות' בפנים, כך שהפרויקטים יכולים לדבר עם הטלפון, עם האינטרנט ואחד עם השני.
הנושאים
ארדואינו מול ESP32
| ארדואינו אונו | ESP32-S3 | |
|---|---|---|
| מהירות | 16MHz, מעבד אחד | 240MHz, שני מעבדים |
| זיכרון עבודה | 2KB | 512KB (ועוד PSRAM) |
| מתח הפינים | 5V | 3.3V |
| אלחוטי | אין | Wi-Fi ו־BLE |
⚠️ הפינים של ESP32 עובדים ב־3.3V. לא מחברים אליהם ישר חיישן שמוציא 5V (למשל פין Echo של חיישן המרחק): צריך מחלק מתח או מודול שעובד ב־3.3V.
🔍 הכרת הלוח
מה יש על הלוח ESP32-S3-N16R8 שבערכה, ולמה צריך כל חלק.
מה הלוח יודע לעשות
🎤 מיקרופון INMP441
מיקרופון דיגיטלי קטן כמו מטבע. הוא לא שולח "חשמל שרועד" כמו מיקרופון רגיל, אלא מספרים: 16,000 פעמים בשנייה הוא מודד כמה חזק האוויר לוחץ עליו ושולח את התוצאה לבקר. זו האוזן של הצ'טבוט שנבנה.
למה דווקא ESP32 ולא ארדואינו אונו?
קול זה הרבה מידע. 16,000 מדידות בשנייה, כל אחת של 2 בתים, זה 32,000 בתים בכל שנייה. לארדואינו אונו יש בסך הכול 2,000 בתים של זיכרון, כלומר הוא היה מתמלא אחרי שישים אלפיות שנייה של דיבור. ל־ESP32-S3 יש כל מה שחסר לאונו: רכיב I2S מובנה שקורא את המיקרופון לבד ברקע, 8MB של PSRAM שמספיקים לכמה דקות הקלטה, מעבד מהיר מספיק לעבד קול, ו־Wi-Fi כדי לשלוח את ההקלטה לבינה מלאכותית ולקבל תשובה.
החיבור ל־ESP32-S3
| פין במיקרופון | מה הוא עושה | לאן ב־ESP32-S3 |
|---|---|---|
| SCK | השעון: קצב שהבקר מכתיב, "עכשיו ביט, עכשיו ביט" | GPIO 17 |
| WS | בחירת ערוץ: אומר מתי מתחילה מדידה חדשה, שמאל או ימין | GPIO 16 |
| SD | הנתונים: דרכו יוצאים המספרים של הקול | GPIO 18 |
| L/R | קובע אם המיקרופון הוא הערוץ השמאלי או הימני | GPIO 15 (הקוד שם בו LOW, כלומר ערוץ שמאל) |
| VDD | חשמל | 3V3, לא 5V |
| GND | אדמה | GND |
פינים 15 עד 18 יושבים ברצף בצד שמאל של הלוח, כך שכל ארבעת החוטים יוצאים מאותו מקום. במקום פין 15 אפשר לחבר את L/R ישר ל־GND ולמחוק מהקוד את שתי השורות שלו. לא להשתמש בפינים 19, 20, 35 עד 37 או 48 (ראו תרשים הפינים). הרמקול מתחבר לפינים 10 עד 13, ראו מגבר MAX98357A.
נסו בעצמכם: ככה מיקרופון רואה קול
הגל הוא הקול, והמספרים למטה הם בדיוק מה שה־INMP441 שולח: מספר לכל רגע, חיובי כשהאוויר נדחף ושלילי כשהוא נמשך. הפס הצבעוני הוא העוצמה, אותו חישוב שעושה הקוד הראשון.
הקוד
דורש את חבילת ESP32 של Espressif בגרסה 3 ומעלה ב־Arduino IDE. פותחים Tools ואז Serial Plotter על 115200.
שקט מוחלט, רק אפסים? בודקים שהחוטים של SCK ו־WS לא הפוכים, ושה־L/R מחובר לפין 15 (או ל־GND). אם ה־L/R מחובר ל־3V3, צריך לשנות בקוד את I2S_STD_SLOT_LEFT ל־I2S_STD_SLOT_RIGHT.
🤖 היעד: צ'טבוט שמדבר
ה־ESP32 לא מספיק חזק להריץ בינה מלאכותית בעצמו, אבל הוא לא צריך: הוא האוזניים והפה, והמוח נמצא בענן. ככה נראית שיחה אחת:
חשבון קטן: עשר שניות של דיבור ב־16,000 מדידות בשנייה הן כ־320KB. באונו זה בלתי אפשרי, ב־ESP32-S3 זה פחות מ־4% מה־PSRAM. אפשר גם להדליק את לד ה־RGB בצבע אחר בכל שלב, כך שרואים מתי הוא מקשיב, חושב ומדבר.
🔑 מפתח ה־API של שירות ה־AI הוא כמו כרטיס אשראי. לא כותבים אותו בקוד שעל הלוח: הלוח מדבר עם שרת קטן שלנו, והשרת מחזיק את המפתח.
🔊 מגבר MAX98357A
הפה של הצ'טבוט. ה־ESP32 שולח אליו את הקול כמספרים, באותה שפת I2S של המיקרופון, והמגבר הופך אותם בחזרה לגל חשמלי חזק מספיק כדי להזיז רמקול. המיקרופון שומע, הבקר חושב, המגבר מדבר.
למה צריך מגבר? אי אפשר לחבר רמקול ישר לבקר?
אי אפשר, משתי סיבות. הראשונה: פין של ESP32 נותן בערך 40 מיליאמפר ב־3.3V, ורמקול צריך פי עשרה ויותר. חיבור ישיר נותן קול חלש מאוד, ועלול לשרוף את הפין. השנייה: פין רגיל יודע רק דלוק או כבוי, וקול הוא גל שעולה ויורד בעדינות. ל־ESP32 הרגיל היה ממיר קטן (DAC) שיודע לייצר גל כזה, אבל ב־ESP32-S3 שלנו אין אותו בכלל. ה־MAX98357A פותר את שתי הבעיות: מקבל את הקול כמספרים, בונה ממנו גל, ומגביר אותו מהחשמל של ה־5V ולא מהפין.
החיבור ל־ESP32-S3
| פין במגבר | מה הוא עושה | לאן ב־ESP32-S3 |
|---|---|---|
| LRC | בחירת ערוץ: מתי מתחילה דגימה חדשה, שמאל או ימין (כמו WS במיקרופון) | GPIO 12 |
| BCLK | השעון של הביטים (כמו SCK במיקרופון) | GPIO 11 |
| DIN | הנתונים: המספרים של הקול נכנסים כאן | GPIO 10 |
| GAIN | עוצמת ההגברה | GND (12 דציבל) |
| SD | הפעלה וכיבוי, ובחירת ערוץ | GPIO 13 (HIGH = דולק) |
| GND | אדמה | GND |
| VIN | חשמל למגבר ולרמקול | 5V |
| + − | הרמקול, בשקע הבורג למעלה | רמקול 4 או 8 אוהם, 3W |
⚠️ שני חוטי הרמקול הולכים רק לשקע של המגבר. לא מחברים את המינוס של הרמקול ל־GND: המגבר דוחף וגם מושך בשני הצדדים, וחיבור לאדמה יכול לשרוף אותו.
בעוצמה גבוהה המגבר מושך הרבה זרם. אם הלוח מתאפס בדיוק כשהוא מדבר, מחליפים לכבל USB טוב יותר או למטען חזק, או מורידים את העוצמה בקוד.
פין GAIN: כמה חזק?
| מחברים את GAIN ל... | הגברה |
|---|---|
| GND דרך נגד 100K | 15dB, הכי חזק |
| GND ישירות | 12dB (החיבור שלנו) |
| לא מחברים כלום | 9dB |
| VIN ישירות | 6dB |
| VIN דרך נגד 100K | 3dB, הכי שקט |
הקוד
דורש את חבילת ESP32 של Espressif בגרסה 3 ומעלה ב־Arduino IDE.
🤖 המיקרופון והמגבר ביחד
עם שני הרכיבים האלה ל־ESP32 יש אוזניים ופה. קוד 2 (התוכי) כבר עושה חצי מהעבודה של צ'טבוט: מקליט כשמחזיקים את BOOT ומשמיע. בצ'טבוט האמיתי, בין ההקלטה להשמעה ההקלטה נשלחת ב־Wi-Fi לבינה מלאכותית, וחוזרת תשובה מדוברת שמתנגנת בדיוק באותה דרך. השרשרת המלאה מופיעה בעמוד המיקרופון.
🧩 מיקרופון ורמקול על אותו ESP32
החיבור המלא של הצ'טבוט: המיקרופון בפינים 15 עד 18, המגבר בפינים 10 עד 13. מחברים בכבלי סרבו (שחור, אדום ולבן צמודים) ובכבל זוגי (שחור ואדום), כך שכמה פינים נכנסים בתנועה אחת. לוחצים על כבל כדי לראות רק אותו.
שני סוגי חיבור בלוח ההרחבה
הכבלים, אחד אחד
| כבל | החוטים | איך הוא יושב |
|---|---|---|
| 🎤 1. אותות המיקרופון | L/R → GPIO 15WS → GPIO 16SCK → GPIO 17 | השורה העליונה של המיקרופון. שני הקצוות שטוחים: שלושה פינים שכנים בכל צד. |
| 🎤 2. חשמל ונתונים של המיקרופון | GND → GNDVDD → 3V3SD → GPIO 18 | השורה התחתונה של המיקרופון, בדיוק בסדר שחור־אדום־לבן. הצד השני נכנס שלם לשלישייה של IO18 בצד שמאל של הלוח: שחור ל־GND, אדום ל־3.3V, לבן לפין האות הצהוב. בלי לפצל חוטים. |
| 🔊 3. אותות המגבר | LRC → GPIO 12BCLK → GPIO 11DIN → GPIO 10 | שני הקצוות שטוחים. בבקר הסדר מלמעלה הוא לבן, אדום, שחור (10, 11, 12), כלומר הכבל פשוט הפוך. |
| 🔊 4. החשמל של המגבר | GND → GNDVIN → 5V | כבל זוגי. נכנס לשורה העליונה בעמודת ה־5V בצד שמאל של הלוח: שחור על השחור, אדום על האדום. |
| 5. שני חוטים בודדים | SD → GPIO 13GAIN → GND | SD של המגבר לפין 13 (מדלגים על 14). GAIN לשחור בשורה השנייה של עמודת ה־5V, ממש מתחת לכבל 4, וקובע הגברה של 12dB. אם אין חוט פנוי, אפשר להשאיר את GAIN באוויר ולקבל 9dB. |
הבקר יושב על לוח ההרחבה. כבלי האותות 1 ו־3 וחוט ה־SD נכנסים לשורת הפינים הצהובה שצמודה לבקר, שמסודרת בדיוק כמו הפינים שלו. כבל 2 נכנס לשלישייה של IO18 שמביאה איתה גם GND ו־3.3V, וכבל 4 לעמודת ה־5V. ככה אף חוט חשמל לא צריך לחצות את הלוח.
⚠️ בכבלים 1 ו־3 החוט האדום הוא אות, לא חשמל. בכבלים 2 ו־4 האדום הוא חשמל: 3V3 למיקרופון ו־5V למגבר. אם מחליפים ביניהם, 5V במיקרופון שורף אותו.
🎤 ה־L/R של המיקרופון מחובר לפין 15 ולא ל־GND, אז הקוד חייב להוריד את פין 15 ל־LOW בתחילת setup. בלי זה המיקרופון לא יודע באיזה ערוץ לשדר, ושומעים שקט.
בודקים שהכול עובד
מריצים את קוד 2 בעמוד המגבר, התוכי: מחזיקים את BOOT, מדברים, משחררים, והלוח משמיע בחזרה את מה ששמע. אם שומעים את עצמכם, כל חמשת הכבלים במקום. ה־ESP32-S3 בונה שני ערוצי I2S נפרדים, אחד לכל רכיב, ולכן הם עובדים יחד באותו זמן.
🤖 Voice Assistant: צ׳טבוט שמדבר
הפרויקט המלא: מחזיקים את BOOT, שואלים שאלה בקול, והלוח עונה בקול. ה־ESP32 הוא האוזניים והפה, והמוח נמצא בענן של OpenAI. בלי ספריות חיצוניות, רק מה שמגיע עם חבילת ESP32.
ב־ZIP יש תיקייה בשם voice_assistant ובה שני הקבצים. פותחים את התיקייה כמו שהיא ב־Arduino IDE, כי שם התיקייה חייב להיות זהה לשם קובץ ה־ino.
שיחה אחת, שלב אחרי שלב
בכל שלב הלוח כותב ב־Serial Monitor מה הוא עושה וכמה זמן זה לקח. צפצוף קצר = "שמעתי אותך". צפצוף נמוך וארוך = משהו נכשל, והסיבה כתובה ב־Serial.
לפני שמעלים
| מה | איך |
|---|---|
| החיבורים | מיקרופון בפינים 15 עד 18, מגבר בפינים 10 עד 13, בדיוק כמו בעמוד מיקרופון + רמקול. אם התוכי עבד, גם זה יעבוד. |
| Arduino IDE | חבילת esp32 של Espressif בגרסה 3 ומעלה. לוח: ESP32S3 Dev Module. |
| תפריט Tools | Flash Size = 16MB, ו־PSRAM = OPI PSRAM. בלי זה ההקלטה לא נכנסת לזיכרון והלוח נעצר עם הודעה. |
| Serial Monitor | 115200. אם מחוברים לשקע USB ולא ל־COM, מגדירים USB CDC On Boot = Enabled. |
| Wi-Fi | רשת 2.4GHz בלבד. ESP32 לא רואה רשתות 5GHz. |
הקובץ secrets.h
הסיסמאות לא נכתבות בתוך הקוד עצמו אלא בקובץ נפרד שיושב באותה תיקייה. ככה אפשר לשתף את הקוד, להעלות אותו לאתר או לשלוח לחבר, בלי לחשוף את סיסמת הבית ואת המפתח ל־OpenAI. זה המבנה, ואת הערכים ממלאים כל אחד אצלו:
🔑 מפתח OpenAI שווה כסף: כל שאלה עולה אגורות בודדות, אבל מי שמחזיק את המפתח יכול להשתמש בו על חשבונכם. לא מצלמים אותו, לא מדביקים בקבוצות, ואם הוא דלף, מבטלים אותו באתר של OpenAI ויוצרים חדש.
הקוד, חלק אחרי חלק
לוחצים על חלק כדי לסמן אותו בקוד ולקרוא מה הוא עושה.
341 שורות. דורש esp32 גרסה 3 ומעלה ו־PSRAM = OPI PSRAM.
הורדהמשנים ומשחקים
📍 תרשים הפינים
לוח ESP32-S3 בפורמט DevKitC-1, 44 פינים, מבט מלמעלה כשכבלי ה־USB למטה. לוחצים על פין כדי לראות מה הוא יודע לעשות. המספר בריבוע הוא מספר ה־GPIO, וזה המספר שכותבים בקוד.
בחרו פין
לוחצים על אחד הריבועים בתרשים.
יש כמה יצרנים ללוחות האלה. אם ההדפסה על הלוח שלכם שונה מהתרשים, ההדפסה על הלוח קובעת.
הקוד
רגל ארוכה (+) לפין 13, רגל קצרה (−) ל־GND שצמוד אליו. נכנס ישר ללוח בלי חוטים.
ג'אמפר אדום מפין 8 לרגל הארוכה, ג'אמפר שחור מהרגל הקצרה ל־GND בשורת המתח.
בכיתה עדיף להוסיף נגד של 220Ω בטור לכל לד. בלי נגד הלד מקבל יותר זרם ממה שהוא צריך, והוא והפין עלולים להיפגע.
שני לדים על לוח ההרחבה
לד אדום לפין 8, לד כחול לפין 9. כל לד מתחבר בשני ג'אמפרים: הרגל הארוכה לשורה S (סיגנל), הרגל הקצרה לשורה G (גראונד). השורה האמצעית V לא בשימוש.
הקוד
מעתיקים, מדביקים ב־Arduino IDE ומעלים ללוח.
לוח ההרחבה יושב על הארדואינו. לכל פין יש טור של שלושה: G גראונד, V 5 וולט, S הסיגנל עצמו.
לרגל הארוכה של הלד קוראים אנודה (+), והיא הולכת ל־S. הרגל הקצרה, קתודה (−), הולכת ל־G. לד שחובר הפוך פשוט לא יידלק, ולא יקרה לו כלום. הופכים ומנסים שוב.
לד אדום: טור 8, חוט אדום לשורה S וחוט חום לשורה G. לד כחול: אותו דבר בטור 9. סופרים טורים מימין לשמאל: 8 הוא הראשון בקבוצה 11 10 9 8.
שנו את הקוד כך ששני הלדים יהבהבו יחד. ואחר כך: אדום דולק שנייה, כחול רק רבע שנייה, כמו אורות של ניידת.
גשר H: שני מנועים ביציאה אחת
כרטיס L298N יודע לסובב מנועים קדימה ואחורה. כאן שני מנועים מחוברים יחד ליציאה הימנית, כמו שני הגלגלים של צד אחד במכונית.
המנועים עומדים. לחצו "קדימה" או "אחורה".
איך מחברים
ארבעה חוטי ג׳אמפר נכנסים לארבעת הפינים האמצעיים בשורת הפינים הקטנה ליד בורגי החשמל: מתחילים מהפינה: שחור ל־IN4, לבן ל־IN3, אפור ל־IN2, סגול ל־IN1. בפינים שבקצוות, ENA ו־ENB, משאירים את הכובעונים השחורים במקום.
שני חוטי חשמל נכנסים לבורגי החשמל: האדום לבורג שהכי קרוב לפינה, +12V, והחום לבורג האמצעי, GND. הבורג השלישי, +5V, נשאר ריק.
ומשם ללוח ההרחבה של הארדואינו: שחור לפין 4, לבן ל־5, אפור ל־6, סגול ל־7. האדום נכנס ל־VIN והחום ל־GND. כך הארדואינו מקבל את החשמל שלו מאותה סוללה של המנועים.
שני החוטים השחורים נכנסים יחד לבורג OUT1, הבורג שקרוב יותר לצלעות הקירור.
שני החוטים האדומים נכנסים יחד לבורג OUT2, הבורג שרחוק יותר מצלעות הקירור.
כל מנוע מקבל חוט אדום אחד וחוט שחור אחד. כך שני המנועים מקבלים בדיוק את אותו חשמל ומסתובבים יחד.
בצד השמאלי, מנועים 3 ו־4, עושים אותו דבר: שני השחורים ל־OUT4 (קרוב לצלעות) ושני האדומים ל־OUT3.
החיבור בצד של לוח ההרחבה
הכרטיס יכול להפוך את כיוון החשמל במנוע. כשהחשמל זורם מהאדום לשחור המנוע מסתובב לכיוון אחד, וכשהוא זורם מהשחור לאדום, לכיוון השני.
מסובבים את שני הקצוות החשופים יחד, מכניסים לחור ורק אז מהדקים את הבורג. אחרת אחד החוטים משתחרר בנסיעה.
לא נוגעים בגשר. מחליפים בין האדום לשחור בקצה של אותו מנוע, וזהו.
מחברים ומנתקים חוטים רק כשהסוללה מנותקת. קצר בין חוט אדום לשחור עלול לחמם את הסוללה ואת הכרטיס.
קדימה ואחורה
המכונית נוסעת שנייה קדימה ושנייה אחורה, וחוזר חלילה. פינים 4 ו־6 מסובבים את הגלגלים קדימה, ופינים 5 ו־7 מסובבים אותם אחורה.
לחצו "הפעלה" כדי לראות את הקוד רץ.
הקוד
מעתיקים, מדביקים ב־Arduino IDE ומעלים ללוח.
4 ו־6 ב־HIGH, 5 ו־7 ב־LOW. בכל צד של המכונית זוג פינים אחד דלוק, והחשמל זורם במנועים לכיוון אחד.
מחליפים: 5 ו־7 ב־HIGH, 4 ו־6 ב־LOW. החשמל זורם הפוך, והגלגלים מסתובבים לכיוון השני.
אם 4 ו־5 (או 6 ו־7) דלוקים באותו זמן, המנוע לא יודע לאן להסתובב ועומד. לכן תמיד אחד HIGH והשני LOW.
הוסיפו עצירה של חצי שנייה בין קדימה לאחורה: כל ארבעת הפינים ב־LOW ו־delay(500). זה גם שומר על המנועים.
גלגל אחד מסתובב הפוך מהשאר? לא משנים את הקוד. מחליפים בין האדום לשחור בקצה של אותו מנוע.
פנייה ימינה ופנייה שמאלה
כדי לפנות, מסובבים רק צד אחד של המכונית. לפנייה ימינה נוסעים רק שני הגלגלים של צד שמאל, ולפנייה שמאלה רק שני הגלגלים של צד ימין. בין הפניות יש עצירה.
לחצו "הפעלה" כדי לראות את הקוד רץ.
הקוד
מעתיקים, מדביקים ב־Arduino IDE ומעלים ללוח.
רק פין 4 ב־HIGH. הגלגלים של צד שמאל דוחפים קדימה, צד ימין עומד, והמכונית מסתובבת ימינה.
רק פין 6 ב־HIGH. עכשיו צד ימין דוחף וצד שמאל עומד, והמכונית מסתובבת שמאלה.
כל ארבעת הפינים ב־LOW. אף מנוע לא מקבל חשמל, והמכונית עומדת.
סימן שאצלכם 4 ו־5 מחוברים לצד ימין. מחליפים בקוד בין 4 ל־6 בשתי הפניות, וזהו.
אתגר: פנייה חדה יותר. במקום לעצור את הצד השני, סובבו אותו אחורה (פין 7 ב־HIGH בפנייה ימינה). המכונית תסתובב במקום.
עוקב קו עם חיישן אחד
החיישן לא נוסע על הקו, אלא על הגבול שלו: חצי על שחור וחצי על לבן. רואה לבן? פונים שמאלה חזרה לקו. רואה שחור? פונים ימינה החוצה. באמצע? ישר.
הגלגלים שנוסעים נצבעים בצהוב. הנקודה האדומה היא החיישן, והקו האדום הוא הדרך שהוא עבר. פעמיים־שלוש בסיבוב המכונית סוטה בכוונה, ורואים איך הקוד מחזיר אותה לגבול.
חיישן מרחק: צהוב (Trig) לפין 12, כתום (Echo) לפין 13, כמו בחיישן מרחק. באזר: פלוס לשורה S בפין 11, מינוס לשורה G. המדידה קורית רק פעם ב־50 אלפיות שנייה, ומחכה להד לכל היותר 3 אלפיות שנייה, כך שהמכונית ממשיכה לעקוב אחרי הקו בלי הפרעה. משהו קרוב מ־20 ס"מ? המכונית עוצרת, הבאזר מצפצף שתי שניות, ואז ממשיכים לנסוע.
לד אדום לפין 8 ולד כחול לפין 9 בלוח ההרחבה, בדיוק כמו בשני לדים בלוח ההרחבה. לבן ופונים שמאלה: אדום. שחור ופונים ימינה: כחול. ישר: שניהם כבויים.
מעתיקים, מדביקים ב־Arduino IDE ומעלים ללוח.
לאן מחברים? כל הפינים של המכונית
רגל קצרה ← G
רגל קצרה ← G
מינוס ← G
Vcc ← V
GND ← G
אדום ← V
חום ← G
ימין: 4 קדימה, 5 אחורה
הכול על לוח ההרחבה. בכל טור: S = הסיגנל (הפין עצמו), V = 5 וולט, G = גראונד. חוט אדום תמיד לפלוס, חוט חום תמיד לגראונד.
הסבר מפורט: איך חיישן אחד מחזיק מכונית על הקו
כל הסוד בשלוש שורות של if. אבל כדי להבין למה הן עובדות, צריך להבין קודם מה החיישן רואה, למה הוא נוסע דווקא על הגבול, ולמה המכונית תמיד קצת מתנדנדת.
1מה החיישן רואה?
החיישן לא רואה נקודה אחת, אלא עיגול קטן על הרצפה (העיגול האדום). הוא שולח אור אינפרה אדום ומודד כמה ממנו חזר. לבן מחזיר הרבה אור, שחור בולע אותו. analogRead(A0) הופך את זה למספר: ככה שיותר שחור בתוך העיגול, המספר גבוה יותר.
שימו לב למשהו חשוב: כשהעיגול בדיוק על הגבול, חצי שחור וחצי לבן, המספר באמצע. זה מה שהופך חיישן אחד לחכם: הוא לא רק אומר "שחור" או "לבן", הוא אומר גם "אני על הגבול".
2שלושה מצבים, שלוש פעולות
המכונית נוסעת למעלה, הקו השחור משמאל לה והרצפה הלבנה מימין. החיישן יושב על הצד הימני של הקו. אם הוא רואה לבן, המכונית זזה ימינה מדי, אז פונים שמאלה חזרה לקו: הגלגלים השמאליים עוצרים והימניים ממשיכים. אם הוא רואה שחור, המכונית נכנסה שמאלה מדי, אז פונים ימינה. ואם הוא באמצע, נוסעים ישר.
3הזיגזג: ככה זה נראה בתנועה
חיישן: —
השביל האדום הוא הדרך שהחיישן עבר. הוא אף פעם לא ישר לגמרי: המכונית יוצאת קצת ללבן, מתקנת, נכנסת קצת לשחור, מתקנת שוב. זה בסדר גמור, ככה עובד עוקב קו. בארדואינו אמיתי הלולאה loop() רצה אלפי פעמים בשנייה, אז התיקונים קטנים מאוד והנסיעה נראית כמעט חלקה.
עכשיו לחצו "להתחיל בצד השני" וראו מה קורה כשהחיישן על הצד השמאלי של הקו, עם אותו קוד בדיוק.
4למה לא באמצע הקו?
משמאל: חיישן שנוסע באמצע הקו רואה שחור כל הזמן. ברגע שהמכונית סוטה, הוא רואה לבן, אבל לבן בצד ימין ולבן בצד שמאל נראים בדיוק אותו דבר. המכונית לא יודעת לאן לחזור. מימין: על הגבול, לבן יכול להיות רק בצד אחד ושחור רק בצד השני. הצבע עצמו אומר לאן לפנות. בגלל זה עם שני חיישנים אפשר לנסוע באמצע הקו, אבל עם חיישן אחד נוסעים על הגבול.
5בדקו את עצמכם: מה המכונית תעשה?
החיישן קורא: —
נכון: 0 מתוך 0
חיבור החיישן ללוח ההרחבה
שלושת החוטים נכנסים לאותו טור, A0 (המסומן בקו צהוב), כל חוט לשורה שלו: הכתום לשורה S (הסיגנל, מה שהקוד קורא ב־analogRead(A0)), האדום לשורה V (5 וולט), והחום לשורה G (גראונד). אותו סדר בדיוק גם בצד של החיישן.
החיישן יצא מהקו. turnLeft: צד שמאל עוצר, צד ימין נוסע, והמכונית חוזרת לגבול.
החיישן נכנס עמוק לקו. turnRight: צד ימין עוצר, והמכונית יוצאת החוצה לגבול.
החיישן בדיוק על הגבול. driveForward: שני הצדדים נוסעים ישר.
פותחים Serial Monitor על 115200, מעבירים את החיישן מעל לבן ומעל שחור, ומעדכנים את 20 ו־100 לפי המספרים שרואים.
המכונית בורחת מהקו במקום לחזור אליו? היא על הצד השני של הגבול. שמים אותה בצד השני, או מחליפים בקוד בין turnLeft ל־turnRight.
חיישן מרחק אולטרסוני
החיישן צועק צעקה שאנחנו לא שומעים, ומודד כמה זמן לוקח לה לחזור. כמו עטלף. מהזמן הזה הארדואינו מחשב את המרחק לקיר.
למעלה: הגלים יוצאים מה־T, פוגעים בקיר וחוזרים ל־R. למטה: מה הארדואינו רואה בפינים. הקו הכתום של ECHO נשאר למעלה בדיוק כל זמן שהקול בדרך.
הקוד
מעתיקים, מדביקים ב־Arduino IDE, מעלים ופותחים Serial Monitor על 115200.
חיבור החיישן ללוח ההרחבה
שלושה חוטים נכנסים לטור 12: החום לשורה G, האדום לשורה V והצהוב (Trig) לשורה S. הכתום (Echo) הולך לשורה S בטור 13. כל החיישן יושב בקבוצה 13 12. פין 11 שמור לבאזר, עם פלוס ל־S ומינוס ל־G.
שתי "עיניים" שהן בעצם רמקול ומיקרופון. T (Transmitter) שולח, R (Receiver) מקשיב.
הארדואינו מעלה את Trig ל־HIGH לעשר מיליוניות שנייה. החיישן שולח שמונה "ציוצים" של 40,000 הרץ, גבוה מדי בשביל האוזן שלנו.
ברגע הצעקה החיישן מעלה את Echo ל־HIGH, ומוריד אותו כשההד חוזר. pulseIn(echoPin, HIGH) מודד כמה מיקרו־שניות הוא היה למעלה.
הקול עובר 0.034 ס"מ בכל מיקרו־שנייה. כופלים בזמן ומחלקים ב־2, כי הקול הלך לקיר וגם חזר. 1,000 מיקרו־שניות הן בערך 17 ס"מ.
עובד טוב מ־2 ס"מ ועד כ־4 מטר. בד, ספוג או וילון בולעים את הקול, וקיר עקום מקפיץ אותו הצידה. אז לפעמים יוצאים מספרים מוזרים.
מחברים גם את הלדים מפין 8 ו־9: כחול כשהקיר רחוק מ־20 ס"מ, אדום כשהוא קרוב יותר. והשלב הבא: מכונית שעוצרת לפני קיר.
חיישן קו 4 ערוצים
כרטיס בקרה אחד וארבעה ראשי חיישן קטנים. כל ראש מסתכל על הרצפה ואומר רק דבר אחד: לבן או שחור. עם ארבעה ראשים המכונית יודעת בדיוק איפה הקו נמצא.
לחצו על ריבוע הרצפה מתחת לכל ראש כדי להחליף בין לבן לשחור, וראו מה קורה לנורית וליציאה.
Serial Monitor: 0 0 0 0
הקוד: קריאה של ארבעת החיישנים
מעתיקים, מדביקים ב־Arduino IDE ומעלים ללוח.
איך החיישן יודע אם זה לבן או שחור?
בכל ראש יש שני רכיבים: המשדר (השחור) שולח אור אינפרה אדום שהעין שלנו לא רואה, והמקלט (הכחול) בודק כמה ממנו חזר. משטח לבן מחזיר את האור כמו מראה עמומה, ומשטח שחור בולע אותו. טיפ לכיתה: מצלמת טלפון רואה אינפרה אדום, אז אפשר לכוון אותה אל המשדר ולראות אותו דולק בסגול.
להרחבה: פרויקט רובוט עוקב קו ב־Arduino Project Hub (באנגלית), עם שני חיישנים, גשר H ושליטה במהירות.
בכל ראש יש שני "עיניים": נורית אינפרה אדום ששולחת אור לרצפה, ומקלט שבודק כמה אור חזר. לבן מחזיר הרבה אור, שחור בולע אותו.
השבב במרכז משווה את האור שחזר לגבול שקבענו, ומוציא תשובה פשוטה: 0 או 1. לכל ערוץ יש נורית קטנה שנדלקת על לבן.
פוטנציומטר לכל ערוץ. מסובבים עם מברג קטן עד שהנורית נדלקת על לבן ונכבית על הקו השחור. כל ערוץ מכוונים בנפרד.
VCC ל־5V, GND ל־GND, ו־OUT1 עד OUT4 לפינים 8, 9, 10, 11 בשורת S של לוח ההרחבה. פינים 4 עד 7 כבר תפוסים על ידי הגשר.
הראשים עובדים הכי טוב בגובה של כחצי עד סנטימטר וחצי מהרצפה. גבוה מדי, הם כבר לא מבחינים בין לבן לשחור. אם בחיישן שלכם 0 ו־1 הפוכים, זה בסדר: בודקים ב־Serial Monitor ומתאימים את הקוד.