תקצירהשיעור בהקשר של physical computing
בשיעור הזה הלוח התחיל להקשיב. עד עכשיו הוא רק פעל על העולם, לפי לוח זמנים שכתבנו מראש. עכשיו הוא חש משהו מבחוץ, לחיצה על כפתור, ומחליט לפיה. נסגר המעגל של פיזיקל קומפיוטינג: חישה, החלטה ופעולה.
- חישהפין קלט מודד מתח ומתרגם אותו ל־
HIGHאוLOW. הלוח לא רואה את האצבע: הוא מניח שמישהו לוחץ כשהמתח מגיע. היוריסטיקה, שוב. - חשמלפין שלא מחובר לכלום הוא אנטנה. נגד pull-down, או INPUT_PULLUP, קובע לו ערך ברירת מחדל, והלחיצה גוברת עליו.
- זיכרוןכדי שכפתור רגעי יתנהג כמו מתג אור, הלוח צריך לזכור מצב: משתנה בוליאני גלובלי, שמתהפך עם
!. - החלטהמצב אינו שינוי. loop רצה אלפי פעמים בשנייה, ולכן כדי להגיב ללחיצה צריך להשוות לסיבוב הקודם.
- רעשהמגעים בתוך הכפתור רוטטים, והעולם הפיזי רועש. הקוד צריך לסנן את הרעש (debounce).
- דיבאגSerial Monitor הוא השער שלנו לתוך הלוח: הדרך לראות מה הוא קורא ואיפה הוא נמצא בקוד.
- מעטפתמתג הוא שני מוליכים ומנגנון שמחבר ביניהם. מצוף, פגוש או קערה נעולה הופכים פעולה בעולם למשמעות בקוד.
השאלה של השיעור: מה הלוח צריך לזכור כדי להבין שמשהו קרה, ומה בעולם יכול להיות כפתור?
על הסיכום: מבוסס על תמלול השיעור הרביעי ועל המצגת. בגרסה המקוונת (itaylaniado.github.io/txp2027/lessons/04) רוב הסעיפים כוללים הדגמות שאפשר להפעיל, וכפתורים להעתקת הקוד. רוב הסעיפים כוללים הדגמות: כפתור וירטואלי שלוחצים ומחזיקים, קוד שמסמן את השורות שרצות, משתנים ו־Serial Monitor. בחלק מהן יש גם הילוך איטי, שמראה מה הלוח עושה באלפיות השנייה שאנחנו לא רואים. שווה לשחק איתן. החלקים הקשים, הפין הצף, pull-down וזיהוי שינוי, מוסברים כאן לאט יותר מאשר בכיתה.
01 · לפני שמתחילים: לשאול כדי ללמוד
השיעור נפתח בסיכום של השיעור הקודם. הסיכומים כאן כדי לסגור פינות: בכיתה מדברים בעל פה, ואת זה אי אפשר לקרוא אחר כך. הם גם מקום לחזור אליו, להעמיק, או לבדוק משהו ששכחתם.
אחד מכם ניגש לבונוס 2 בעזרת הצ'אט, עם הפרומפט מהסיכום הקודם, והצליח לחלק את הבעיה לפעולות קטנות. זו בדיוק הדרך הנכונה להשתמש בו. הצ'אט הכי רוצה לכתוב קוד, גם כשלא ביקשתם. כששואלים אותו שאלה שקשורה למקום שלכם בלמידה, ולא לפרויקט, הרבה פעמים התשובה שלו לא מלמדת. הטריק הוא לשאול כך שאפשר ללמוד מהתשובה, ולא רק לקבל אותה. הפרומפט נמצא בסיכום של שיעור 3.
שלחו בוואטסאפ או במייל, והם ייכנסו לסיכומים.
02 · קלט ופלט: לדבר ולהקשיב
עד עכשיו הלוח רק דיבר: הוא הדליק וכיבה לד לפי הקוד, בלי לדעת מה קורה מחוץ לו. הוא ידע שאחרי כך וכך אלפיות שנייה צריך לכבות, אבל לא היה לו ״שער החוצה״. הקלט פותח את השער הזה.
| pinMode | מה הפין עושה |
|---|---|
OUTPUT | מדבר. כותב לפין HIGH (מתח) או LOW (בלי מתח), עם digitalWrite. |
INPUT | מקשיב. בודק אם המתח שמגיע לפין גבוה או נמוך, עם digitalRead. |
INPUT_PULLUP | מקשיב, עם נגד פנימי. נגיע אליו בהמשך. |
פין קלט לא צריך זרם כדי לעבוד. הוא מודד מתח: האם מה שמגיע אליו קרוב ל־5V או קרוב ל־0V. אפשר לחשוב עליו כעל חיישן קטן של מתח. ובגלל שזה digitalRead, אין תחום אפור: מתח שהוא לא בדיוק 5V עדיין ייקרא HIGH. בלוח שלנו, כל מה שמעל בערך 3V נקרא HIGH, וכל מה שמתחת לבערך 1.5V נקרא LOW. לתחום האפור, הקריאה האנלוגית, נגיע בהמשך.
כל חיישן הוא מידע מהעולם שנכנס למערכת, והמדידה הופכת אותו לנתון. בינתיים אנחנו פותחים את השער בדרך הכי פשוטה: מתג, on או off. וגם כשנגיע לחיישנים מורכבים, הרבה פעמים נצטרך למצוא דרך להפוך אותם ל־on-off. זו שוב היוריסטיקה: מודדים משהו פשוט ומסיקים ממנו על העולם.
03 · שלוש טעויות נפוצות
קוד שלא מתקמפל קורה לכולם, כל הזמן. לפני שמוחקים שורות או שולחים לצ'אט, כדאי לבדוק שלושה חשודים קבועים:
- אותיות גדולות וקטנות. פונקציה שאתם כותבים בעצמכם יכולה להיקרא איך שתרצו. אבל לפונקציות מוכנות קוראים בשם המדויק:
digitalwriteהיא לאdigitalWrite, מבחינת הקומפיילר זו פונקציה אחרת לגמרי, שלא קיימת. - נקודה־פסיק. הקומפיילר קורא את הקוד לפי הסדר. כשחסרה
;בסוף שורה, הוא מגלה את זה רק כשהוא מגיע לשורה הבאה, ולכן השגיאה מסומנת שם. - סוגריים. כל סוגר שנפתח צריך להיסגר. כשיש תנאים בתוך תנאים, קל לפספס אחד. סדר בהזחה עוזר למצוא אותו מהר.
ובכל מקרה, קראו את הודעת השגיאה. זה נשמע מובן מאליו, אבל ברוב הפעמים כתוב בה פחות או יותר מה צריך לתקן. נסו כאן: לחצו Verify, קראו את השגיאה, ולחצו שוב כדי לתקן ולקמפל מחדש.
1void setup() {2 pinMode(9, OUTPUT);3}45void loop() {6 digitalwrite(9, HIGH)7 delay(500);8 digitalWrite(9, LOW);9 delay(500);1void setup() {2 pinMode(9, OUTPUT);3}45void loop() {6 digitalWrite(9, HIGH)7 delay(500);8 digitalWrite(9, LOW);9 delay(500);1void setup() {2 pinMode(9, OUTPUT);3}45void loop() {6 digitalWrite(9, HIGH);7 delay(500);8 digitalWrite(9, LOW);9 delay(500);1void setup() {2 pinMode(9, OUTPUT);3}45void loop() {6 digitalWrite(9, HIGH);7 delay(500);8 digitalWrite(9, LOW);9 delay(500);10}04 · else if: יותר משתי אפשרויות
חזרנו לקוד של מד החום מהסיכום הקודם, הפעם עם else if. הלוח בודק את התנאים לפי הסדר, מלמעלה למטה. ברגע שתנאי אחד מתקיים, הוא מריץ את הבלוק שלו ולא בודק את השאר. ה־else שבסוף רץ רק אם אף תנאי לא התקיים, ולכן הוא לא צריך תנאי משלו. גררו את מד החום ועקבו אחרי השורות.
1int temperature = 25; // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6 if (temperature > 30) {7 Serial.println("חם מאוד!");8 } else if (temperature > 20) {9 Serial.println("נעים");10 } else if (temperature > 10) {11 Serial.println("קריר");12 } else {13 Serial.println("קר!");14 }15 delay(1000); // סיבוב בכל שנייה16}- הסדר חשוב. אם נבדוק קודם
> 20, גם 35 מעלות ייעצרו שם ויודפס ״נעים״. - מה עם 30 בדיוק?
temperature > 30הואfalseכש־temperatureשווה 30. אם רוצים ש־30 ייחשב חם מאוד, כותבים>=, ״גדול או שווה״. - כאן אנחנו ״מרמים״. בקוד הערך של
temperatureקבוע. מד החום בסימולציה רק מראה מה היה קורה אילו חיישן היה משנה אותו. כשנחבר חיישן, הוא יעשה את זה בעצמו.
מה delay עושה, ולמה הוא שם
כשהלוח מגיע ל־delay, הוא קופא. הוא לא מודד ולא מחשב, רק מחכה. אחר כך הוא ממשיך לשורה הבאה, ובסוף loop מתחיל מחדש ועובר שוב על כל השאלות.
למה לחכות בכלל? כי הלוח מהיר מאוד, ולרוב אין סיבה לבדוק משהו אלפי פעמים בשנייה. האורך של ה־delay הוא החלטה עם משמעות: טמפרטורה בחדר לא משתנה כל אלפית שנייה, ולכן מספיק למדוד פעם בשנייה, ואפילו פעם בדקה. אגב, 9600 שב־Serial.begin הוא משהו אחר לגמרי: מהירות התקשורת עם המחשב. נגיע אליו בסעיף על Serial.
06 · מעגל בלי קוד, פעמון ומתג אור
במטלה החובה, הכפתור, הנגד והלד היו מחוברים בטור, והלוח שימש רק כמקור מתח: לוקחים מתח מ־5V או מ־3.3V, הוא מגיע לכפתור ונעצר שם. כשלוחצים, הכפתור בונה גשר זמני, הזרם עובר לנגד, ללד, ומשם חוזר ל־GND. אין כאן קוד. גם סוללה הייתה עושה בדיוק את אותה עבודה.
- למה חייבים לחזור ל־GND? דמיינו מים בצינור. אם הצינור נסתם לפני הקצה, המים מגיעים עד המקום הסתום ונעצרים. בלי דרך חזרה, אין זרימה, והלד לא נדלק.
- איפה שמים את הנגד? במעגל של לד, הנגד יכול להיות לפני הלד או אחריו. כל עוד הוא איפשהו בדרך בין הפלוס למינוס, הוא מגביל את הזרם.
פעמון או מתג אור
הכפתור שקיבלתם הוא מתג רגעי (momentary): הוא סוגר את המעגל רק כל עוד לוחצים, כמו פעמון. מתג אור בקיר הוא מתג ננעל (latching): לחיצה אחת מדליקה, והוא נשאר במצב הזה עד הלחיצה הבאה. נסו את שניהם:
Momentary: סוגר את המעגל רק כל עוד לוחצים עליו. כשעוזבים, המעגל נפתח.
דוגמאות: הכפתור שקיבלתם, מקש במקלדת, קליק בעכבר
Latching: נשאר במצב שבו השארנו אותו, דולק או כבוי, עד הלחיצה הבאה.
דוגמאות: מתג אור בקיר, כפתור ההפעלה של רמקול
בהמשך השיעור כתבנו קוד שגורם לפעמון להתנהג כמו מתג אור. זו סיבה טובה להכניס קוד לסיפור: לגרום לרכיב לעשות משהו שהוא לא יודע לעשות לבד.
07 · מה הלוח קורא בפין
מחברים חוט מפין 2 ישירות ל־5V, בלי כפתור, וקוראים אותו עם digitalRead: מקבלים HIGH. מחברים את אותו פין ל־GND: מקבלים LOW. ומה אם לא מחברים אותו לכלום? בחרו:
| מה מחובר לפין | מה הלוח קורא |
|---|---|
| 5V | HIGH (1) |
| GND | LOW (0) |
| שום דבר | ערך אקראי |
digitalRead(2) ← 1void setup() {
2 pinMode(2, INPUT); // פין 2 הוא קלט
3}
4
5void loop() {
6 int state = digitalRead(2); // 1 או 0
7}HIGHו־LOWהם רק שמות ל־1 ול־0. הם נוחים לנו לקריאה, אבל הלוח רואה מספרים. לכן אפשר להכניס את התשובה שלdigitalReadלתוךint.- השם
stateלא אומר כלום לקוד. אפשר היה לקרוא למשתנהshaul. השם הוא בשבילנו, ושם טוב עוזר לקרוא את הקוד. - למה צריך
pinMode(2, INPUT)? נשאלה בכיתה שאלה טובה: אם הכפתור ממילא סוגר את המעגל, למה להגדיר משהו? כי המעגל החשמלי והקריאה הם שני דברים שונים.pinModeנותן לפין ״תפקיד״: אתה פין שמקשיב, ואני אשאל אותך רקHIGHאוLOW. בלי ההגדרה, ייתכן שהפין עסוק בתפקיד אחר, והקריאה לא תהיה אמינה.
08 · הפין הצף ונגד pull-down
זה החלק שהכי הרבה אנשים לא הבינו בכיתה, אז נלך לאט.
מחברים כפתור בין 5V לפין 2. כשלוחצים, הפין מחובר ל־5V והכול ברור. אבל כשלא לוחצים, בתוך הכפתור יש נתק, והפין לא מחובר לשום דבר. המעגל נראה סגור על המטריצה, אבל בפועל הפין צף. פין צף מתנהג כמו אנטנה: הוא קולט את השדה החשמלי שסביבו, את הפינים האחרים, את המחשב ואת היד שלכם, והלוח קורא ערכים אקראיים. לחצו כאן על הכפתור, ואחר כך חברו את הנגד ולחצו שוב:
הפתרון: נגד שמושך למטה
מוסיפים נגד של 10kΩ בין פין 2 ל־GND. עכשיו, כשלא לוחצים, הנגד ״מושך״ את הפין ל־GND, והלוח קורא LOW. כשלוחצים, הפין מחובר ישירות ל־5V. החיבור הישיר חזק יותר מהמשיכה דרך הנגד, ולכן הלוח קורא HIGH. לזה קוראים pull-down resistor.
בכיתה זה התבהר עם משל הנדנדה. הנגד הוא ילד קל שיושב בצד אחד: כשאף אחד אחר לא יושב, הצד שלו למטה. הלחיצה היא מבוגר כבד שמתיישב בצד השני, והנדנדה עוברת אליו. נסו את שלושת המצבים:
- למה צריך נגד, ולא סתם חוט ל־GND? כי אז, כשלוחצים, 5V ו־GND היו מחוברים ישירות זה לזה. זה קצר: שני כוחות שווים שמושכים כל אחד לכיוון שלו, וזרם גדול שעובר בלי שום דבר בדרך. הנגד הופך את המשיכה ל״עדינה״, כך שהלחיצה גוברת עליה.
- ואם מחברים את הנגד ל־5V, והכפתור ל־GND? גם זה עובד, רק הפוך: כשלא לוחצים קוראים
HIGH, וכשלוחציםLOW. זה בדיוק pull-up.
09 · INPUT_PULLUP
בתוך הלוח יש נגד מובנה שמחובר ל־5V, ואפשר להפעיל אותו מהקוד: pinMode(2, INPUT_PULLUP). כך לא צריך נגד חיצוני בכלל. הכפתור מחובר בין פין 2 ל־GND, וזהו. בנינו את זה יחד בסימולטור.
delay: הלוח ממתין ולא קורא את הכפתור1void setup() {2 pinMode(2, INPUT_PULLUP); // נגד פנימי ל־5V3 pinMode(9, OUTPUT);4}56void loop() {7 if (digitalRead(2) == LOW) { // לוחצים = LOW8 digitalWrite(9, HIGH);9 } else {10 digitalWrite(9, LOW);11 }12}| נגד pull-down חיצוני | INPUT_PULLUP | |
|---|---|---|
| הקוד | pinMode(2, INPUT) | pinMode(2, INPUT_PULLUP) |
| החיבור | כפתור בין 5V לפין, נגד 10kΩ בין הפין ל־GND | כפתור בין הפין ל־GND, בלי נגד |
| לא לוחצים | LOW | HIGH |
| לוחצים | HIGH | LOW ⚠️ |
שתי הדרכים עובדות. צריך רק לזכור באיזו בחרתם, כי ב־INPUT_PULLUP הלחיצה היא LOW. כלומר, HIGH מהפין הוא לא תמיד ״לוחצים״ מבחינת הלוגיקה. לתרגיל הבית מומלץ INPUT_PULLUP: הכי קל, ולא צריך נגדים.
ואל תשכחו את הטריק של ה־pull-down. נשתמש בו עוד הרבה, בכל מיני וריאציות.
10 · digitalRead בתוך תנאי
עכשיו מחברים את הקלט ללד, ״בצורה לוגית״: אין חוט בין הכפתור לבין הלד, הקוד הוא שמחבר ביניהם. לחצו והחזיקו, ועקבו אחרי השורות:
delay: הלוח ממתין ולא קורא את הכפתור1int buttonPin = 2;2int ledPin = 9;34void setup() {5 pinMode(buttonPin, INPUT);6 pinMode(ledPin, OUTPUT);7}89void loop() {10 if (digitalRead(buttonPin) == HIGH) {11 digitalWrite(ledPin, HIGH); // לוחצים: מדליקים12 } else {13 digitalWrite(ledPin, LOW); // לא לוחצים: מכבים14 }15}שימו לב לשורה 10: בתוך התנאי יש פונקציה. דמיינו שברגע שהיא רצה, היא נעלמת, ובמקומה מופיעה התשובה שלה, HIGH או LOW. ואז התנאי שואל: האם התשובה שווה ל־HIGH? אפשר לכתוב את אותו דבר בשני שלבים, ולשמור את התשובה במשתנה קודם:
1bool isPressed = digitalRead(buttonPin); // שומרים את התשובה
2if (isPressed) {
3 digitalWrite(ledPin, HIGH);
4}==שואל,=מציב.digitalRead(buttonPin) == HIGHהוא שאלה. שווה אחד היה מנסה להכניס ערך.- למה לשמור את מספר הפין במשתנה? כי אם תעבירו את הכפתור מפין 2 לפין 7, תשנו שורה אחת למעלה, וכל הקוד יתעדכן. לקוד זה לא משנה. לנו זה משנה מאוד.
11 · Serial Monitor: לשאול את הלוח
אנחנו לא רואים מה הלוח קורא בפין. אבל אפשר לבקש ממנו לספר לנו. ה־Serial Monitor הוא לא בדיוק פלט ולא בדיוק קלט: הוא שער של המתכנת לתוך הלוח. שם רואים אם הלוגיקה עובדת. להדליק לד או להפעיל מנוע זה כבר עניין טכני.
delay: הלוח ממתין ולא קורא את הכפתור1void setup() {2 Serial.begin(9600); // פותחים ערוץ3 pinMode(2, INPUT);4}56void loop() {7 int state = digitalRead(2);8 Serial.println(state); // מדפיסים9 delay(100);10}- Serial בעברית זה ״טורי״: תקשורת שמעבירה ערך אחד בכל פעם, זה אחרי זה. מורס, למשל, הוא תקשורת טורית.
Serial.begin(9600)פותח את הערוץ, וכותבים אותו ב־setup. רק אחרי שהשער פתוח אפשר לכתוב אליו. 9600 היא מהירות התקשורת, בביטים לשנייה. זה בערך 960 תווים בשנייה, הרבה יותר ממה שאנחנו מסוגלים לקרוא.Serial.printlnמדפיס ויורד שורה.Serial.printמדפיס בלי לרדת שורה. בדרך כלל עדיףprintln, כדי שהערכים לא יידחסו זה לתוך זה.- החלון נפתח מהאייקון של זכוכית המגדלת בפינה של ה־IDE, או מ־Tools > Serial Monitor. המהירות שבוחרים בחלון צריכה להיות 9600, כמו בקוד.
- הלוח כותב רק כשיש מי שמקשיב. כשהוא מחובר ב־USB, הלוח והמחשב עושים ״לחיצת יד״ ופותחים ערוץ. מחובר לסוללה, אין לאן לכתוב.
- ה־
delay(100)בקוד הוא לא כדי שנספיק לראות. בלי השהיה, הלוח מדפיס אלפי שורות בשנייה ומציף את החלון, וקשה לקרוא בו משהו.
להדפיס כדי לדבג
זו הדרך הכי טובה לדבג: כתבתם קוד שלא עושה מה שציפיתם? פזרו בו הדפסות, ובקשו מהלוח לספר איפה הוא נמצא. אפשר לכתוב ממש בעברית:
1if (ledOn) {
2 Serial.println("התנאי התקיים: מדליק");
3 digitalWrite(9, HIGH);
4} else {
5 Serial.println("התנאי לא התקיים: מכבה");
6 digitalWrite(9, LOW);
7}12 · לזכור מצב: toggle
טוגל הוא כפתור שהמשמעות שלו תלויה במצב. הכפתור בשלט של המזגן הוא בעצם שני כפתורים: כשהמזגן כבוי הוא כפתור ״הדלק״, וכשהמזגן פועל הוא הופך לכפתור ״כבה״. הלחיצה הפיזית זהה. מה שמשתנה הוא המצב בקוד.
יש גם טוגל מכני, בלי שום לוגיקה חשמלית: עט כדורי עם קליק. לחיצה אחת מוציאה את החוד, ואותה לחיצה בדיוק מכניסה אותו. שימו לב: המצב של העט מוגדר ביחס למערכת, לא ביחס לכפתור עצמו.
בקוד, כדי לזכור אם הלד דולק, משתמשים במשתנה בוליאני, שיכול להיות רק true או false. ובכל לחיצה הופכים אותו עם הסימן !, שפירושו ״לא״, או ״ההפך של״:
ledOn = falseledOn = !ledOn;נקרא: ״ledOn שווה ההפך של ledOn״. משהו שבמציאות לא נהוג לעשות, ובקוד זה טריק חזק. אותו עיקרון מאפשר גםx = x + 1;: לקחת את הערך הנוכחי, לשנות אותו, ולהכניס אותו חזרה לאותו משתנה.- אפשר להפוך רק בוליאני. למשתנה
intאי אפשר להגיד ״תהיה ההפך שלך״. צריך משהו שיש לו בדיוק שני מצבים. if (ledOn), בלי==. כל מה שנכנס לסוגריים שלifהופך בסוף ל־trueאוfalse. משתנה בוליאני כבר הוא תשובה כזו, ולכן אפשר להכניס אותו ישירות.if (ledOn == true)יעשה בדיוק אותו דבר.
13 · למה הלד מתהפך באקראי
הניסיון הראשון בכיתה: אם הכפתור לחוץ, הפוך את ledOn. נשמע הגיוני. לחצו לחיצה אחת קצרה, ובדקו כמה פעמים הלד התהפך. אחר כך נסו בהילוך איטי.
delay: הלוח ממתין ולא קורא את הכפתור1bool ledOn = false;23void loop() {4 if (digitalRead(2) == HIGH) {5 ledOn = !ledOn;6 Serial.println(ledOn);7 }89 if (ledOn) {10 digitalWrite(9, HIGH);11 } else {12 digitalWrite(9, LOW);13 }14}הבעיה היא ש־loop רצה מהר מאוד, מאות ואלפי פעמים בשנייה. לחיצה קצרה של אדם נמשכת בערך עשירית שנייה. בזמן הזה הקוד בודק את הכפתור עשרות פעמים, ובכל פעם מוצא אותו לחוץ והופך את הלד. אם מספר ההיפוכים זוגי, הלד חוזר למצב שבו התחיל. אם אי־זוגי, הוא מתהפך. זו הגרלה.
- הלחיצה נמשכה
- 0 ms
- כמה פעמים
loopמצאה את הכפתור לחוץ - 0
- התוצאה
- …
החישוב לפי הקוד מהשקופית הקודמת: כל סיבוב של loop עם הדפסה לוקח כ־3 אלפיות שנייה.
14 · רטט מגעים
ויש בעיה נוספת. בתוך הכפתור יש שני מגעי מתכת. כשהם נפגשים, הם לא נצמדים מיד: בהילוך איטי מאוד, הם קופצים זה על זה כמה פעמים, חיבור, ניתוק, חיבור, ניתוק, ורק אז נצמדים. אותו דבר קורה כשעוזבים. כל רטט כזה נמשך אלפיות שנייה בודדות, והלוח מהיר מספיק כדי לראות כל אחד מהם כלחיצה נפרדת.
- כמה פעמים לחצתם
- 0
- כמה לחיצות הלוח זיהה
- 0
הלוח מזהה לחיצה בכל פעם שהמתח עולה מ־0V ל־5V, ולכן כל קפיצה נספרת כלחיצה חדשה.
זה מה שקורה כשעוברים מהעולם התיאורטי של true ו־false לעולם של זרם. העולם שאנחנו חיים בו רועש, ובקוד קוראים לזה רעש. כדי לעבוד איתו, בונים מנגנונים שמסננים אותו. לבעיה קוראים bounce, ולפתרון debounce.
15 · פתרון ראשון: לחכות
הפתרון הפשוט: אחרי שהקוד מזהה לחיצה, הוא הופך את הלד, ואז מחכה 300 אלפיות שנייה. שליש שנייה הוא זמן שנותן לכפתור להתייצב ולאצבע לעזוב. נסו לחיצה קצרה, ואחר כך לחצו והחזיקו:
delay: הלוח ממתין ולא קורא את הכפתור1bool ledOn = false;23void loop() {4 if (digitalRead(2) == HIGH) {5 ledOn = !ledOn;6 Serial.println(ledOn);7 delay(300); // מחכים שהלחיצה תיגמר8 }910 if (ledOn) {11 digitalWrite(9, HIGH);12 } else {13 digitalWrite(9, LOW);14 }15}- בזמן ה־
delayהלוח קפוא. הוא לא מודד ולא יודע כלום. רק כשהוא ״מתעורר משנת היופי״, הוא ממשיך ומדליק או מכבה את הלד. - יש מחיר. מי שמחזיק את הכפתור יותר משליש שנייה, הופך את הלד שוב.
זה לא מושלם, אבל זה גם בסדר. בכל קוד יש משא ומתן: משהו שעובד בתרחיש אחד יכול להישבר בתרחיש אחר, והשאלה היא אם אתם מוכנים לשלם את המחיר. לתרגיל הבית, הפתרון הזה מספיק.
ועוד הערה, על היוריסטיקה: הלוח לא יכול לראות אצבע. הוא שולח מתח בצד אחד ובודק אם הוא מגיע לצד השני. אם הוא מקבל HIGH, הוא מניח שמישהו לוחץ. ייתכן שהוא טועה. זו היוריסטיקה.
16 · פתרון שני: לזכור מה היה קודם
הפתרון המדויק: בכל סיבוב, משווים את הקריאה של עכשיו לקריאה מהסיבוב הקודם, ופועלים רק כשיש שינוי. את הקריאה הקודמת שומרים במשתנה lastState.
| קודם (lastState) | עכשיו (state) | מה קרה |
|---|---|---|
| LOW | LOW | אין שינוי |
| LOW | HIGH | נלחץ: הופכים את הלד |
| HIGH | HIGH | אין שינוי |
| HIGH | LOW | שוחרר |
לחצו כמה פעמים, קצר וארוך, ועקבו אחרי הטבלה, אחרי המשתנים ואחרי מונה ההיפוכים. בהילוך איטי רואים גם את ה־delay(50) הקצר, שמחכה לסוף הרטט:
delay: הלוח ממתין ולא קורא את הכפתור1int buttonPin = 2;2int ledPin = 9;3bool ledOn = false; // הלד דולק?4int lastState = LOW; // הקריאה מהסיבוב הקודם56void setup() {7 pinMode(buttonPin, INPUT);8 pinMode(ledPin, OUTPUT);9}1011void loop() {12 int state = digitalRead(buttonPin);1314 if (state != lastState) { // משהו השתנה15 if (state == HIGH) { // רגע הלחיצה16 ledOn = !ledOn;17 }18 delay(50); // מחכים לסוף הרטט19 }20 lastState = state; // שומרים לסיבוב הבא2122 if (ledOn) {23 digitalWrite(ledPin, HIGH);24 } else {25 digitalWrite(ledPin, LOW);26 }27}!=פירושו ״שונה מ־״.state != lastStateשואל: האם משהו השתנה?- למה אין
elseבין שני התנאים? כי הם לא שתי אפשרויות. התנאי השני נמצא בתוך הראשון: קודם בודקים אם היה שינוי, ורק אם היה, בודקים אם הוא לחיצה. שני התנאים צריכים להתקיים כדי להפוך את הלד. - הקוד לא כותב ללד ישירות. בתוך התנאים הוא רק הופך את
ledOn. אחר כך, בכל סיבוב, הוא שואל מה הערך שלledOn, ומדליק או מכבה לפיו.ledOnמייצג את הלד. lastState = state;בסוף, תמיד: מעדכנים את הקריאה האחרונה, כדי שבסיבוב הבא נשווה אליה.
ככה עובדים הרבה מכשירים אלקטרוניים: בתוכם רצה לולאה ששואלת כל הזמן ״משהו השתנה? משהו השתנה?״. כשהם נראים שקטים, הם בעצם עונים לעצמם שוב ושוב: לא, אין שינוי.
17 · משתנים גלובליים ומקומיים
הקוד הקודם עובד רק בגלל הבדל חשוב בין שני סוגי משתנים:
lastState = 0ledOn = falselastState = 1ledOn = truelastState = 1ledOn = truestate = 0לא לוחציםstate = 1לחיצה: יש שינויstate = 1עדיין לוחציםstate נוצר מחדש בתחילת כל סיבוב ונמחק בסופו.- משתנה מקומי מוגדר בתוך פונקציה, למשל
int stateבתוךloop. הוא נולד כשהסיבוב מתחיל ומת כשהוא נגמר. בכל סיבוב ישstateחדש, שלא יודע מה היה קודם. - משתנה גלובלי מוגדר למעלה, מחוץ לכל הפונקציות, כמו
ledOnו־lastState. הוא נוצר כשהלוח מקבל חשמל, וחי עד שמנתקים אותו. אם משנים אותו, הלוח זוכר את השינוי. לכןlastStateיכול לזכור את הסיבוב הקודם. - תנו תמיד ערך התחלתי. משתנה גלובלי בלי ערך מתחיל מ־0. אבל משתנה מקומי בלי ערך מכיל את מה שהיה במקרה באותו מקום בזיכרון, מין ״רחש בראשית״. הדפיסו אותו, ותקבלו מספר מוזר. כשכותבים
int lastState = LOW;, אין ספק. intעםLOW? כן.LOWהוא שם ל־0, ולכן אפשר להכניס אותו ל־int. אנחנו כותבים מילים באנגלית, והמערכת מתרגמת אותן למספרים. השכבה הזו קיימת בשבילנו.
18 · מתג הוא שני מוליכים
בסוף השיעור עברנו מהכפתור לעולם. הרבה דברים שקורים בעולם האמיתי צריך לפשט לפני שאפשר להכניס אותם לקוד. וכשמסתכלים מאחורי הפלסטיק של מוצרים, הרבה פעמים יש שם מתג פשוט:



- מצוף: כשהמים עולים, המצוף משנה תנוחה, וכדור בתוכו לוחץ על לשונית של מתג. בקוד רואים ״כפתור נלחץ״, ובמציאות המשמעות היא ״המכל התמלא״.
- בלנדר או מעבד מזון: המנוע לא יפעל עד שהקערה במקום. יש שם גאומטריה מורכבת, אבל בסוף היא לוחצת על מתג קטן, רק כשאין גישה לסכין.
- שואב רובוטי: כשהוא נתקל בקיר, הפגוש הקדמי זז פנימה ומפעיל חיישן שמאחוריו. התגובה של הרובוט נראית מורכבת, אבל היא מתחילה בתזוזה פשוטה של פלסטיק.
איך בונים מתג
מתג הוא שני מוליכים שלא נוגעים זה בזה, ומנגנון שמחבר ביניהם או מפריד אותם. מוליך אחד מחובר לפין הקלט, והשני ל־GND. כל השאר הוא עבודה שלכם: איך גורמים לשני המוליכים להיפגש, או למשהו שיתווך ביניהם. נסו את המנגנונים:
- הטיה: קפסולה עם כדור מתכת ושני מגעים. כשמטים אותה, הכדור מתגלגל ומגשר ביניהם.
- מגנט: כמו החיישנים שעל דלתות וחלונות של אזעקה. שני מוליכים דקיקים, קרובים אבל לא נוגעים, נמשכים זה לזה כשהמגנט עובר לידם. את זה אפשר לבנות בעצמכם עם פיסות מתכת דקות ומגנט.
- מטבע: עצם מוליך שנכנס בין שני מגעים וסוגר את המעגל.
- הברגה: בורג שסוגר מעגל בסוף המהלך שלו. או בורג שבכל סיבוב שלם נוגע במגע לרגע, ועושה ״קליק״. כך אפשר לספור סיבובים. הלוח לא יבין מה זה בורג, אבל במציאות לזה יכולה להיות משמעות מעניינת.
ה־micro switch
מתג מוכן עם לשונית קפיצית. יש לו שלוש רגליים:
- COM: הרגל המשותפת. משתמשים בה תמיד.
- NO (Normally Open): מתחבר ל־COM רק כשלוחצים.
- NC (Normally Closed): מחובר ל־COM, והחיבור נפתח כשלוחצים.
מחברים COM ו־NO, והוא מתנהג בדיוק כמו הכפתור. רוצים שהלחיצה תנתק? משתמשים ב־NC. לחצו והחזיקו את הלשונית:
מה מוליך?
הדרך הכי פשוטה לבדוק: בנו מעגל של לד, השאירו בו רווח, ושימו בו את החומר. אם הלד נדלק, החומר מוליך מספיק בשבילנו. לא רק מתכות מוליכות: גם מים (בזהירות) וגם הגרפיט של עיפרון. שווה לעשות מחקר קטן על דברים מפתיעים שמוליכים.
19 · לקראת המפגש הבא
מטלת הבית: לבנות מתג
בנו מתג משלכם, משני מוליכים, ״שיהיה מגניב לכם״. הוא לא חייב להיות משהו שלוחצים עליו כמו כפתור: אפשר לשבת עליו, לדרוך עליו, לפתוח אותו, להטות אותו. כפתור הוא רק מה שהארדואינו מבין. המשמעות היא שלכם.
- קלט: המתג שבניתם, או micro switch, מחובר לפין קלט.
- ממשק: מה המשתמש עושה בפועל, ואיך הפעולה שלו סוגרת את המגע.
- פלט: לד, הודעה ב־Serial Monitor (״פתחו את הדלת״, ״התיישבו על הכיסא״), או שניהם.
זו ההזמנה להסתכל על דברים שקורים מאחורי הפלסטיק: אינטראקציה שנראית מורכבת מבחוץ, ובפנים יש מתג פשוט.
קוד בסיס
מומלץ INPUT_PULLUP: המתג מחובר בין פין 2 ל־GND, בלי נגד. הקוד מזהה כל שינוי, מדפיס הודעה ומדליק או מכבה את הלד. העתיקו, ואז קראו מה הדבקתם. רוצים שכל לחיצה תהפוך מצב? שלבו את ledOn = !ledOn מסעיף 16.
1int switchPin = 2;
2int ledPin = 9;
3int lastState = HIGH; // כשהמתג פתוח, הפין קורא HIGH
4
5void setup() {
6 Serial.begin(9600);
7 pinMode(switchPin, INPUT_PULLUP); // המתג: בין פין 2 ל־GND
8 pinMode(ledPin, OUTPUT);
9}
10
11void loop() {
12 int state = digitalRead(switchPin);
13
14 if (state != lastState) { // משהו השתנה
15 if (state == LOW) {
16 Serial.println("המתג נסגר"); // כתבו כאן הודעה משלכם
17 digitalWrite(ledPin, HIGH);
18 } else {
19 Serial.println("המתג נפתח");
20 digitalWrite(ledPin, LOW);
21 }
22 delay(50); // מחכים לסוף הרטט
23 }
24 lastState = state;
25}טיפים
- קודם על השולחן. בדקו את המעגל ואת הקוד, ורק אחר כך העבירו אותם לתוך המעטפת.
- שורות אדומות? עמדו בפיתוי להתעצבן או לרוץ לצ'אט, וקראו מה כתוב. בדרך כלל כתוב שם מה צריך לסדר.
- הדפיסו את מה שהלוח קורא. לפני שמחברים לד, ודאו ב־Serial Monitor שהלחיצה מזוהה.
- הלד מתנהג מוזר? בדקו שהפין לא צף: יש נגד, או שהגדרתם INPUT_PULLUP.
- שני סוגי נגדים. 10kΩ לנגד pull-down, ו־220Ω ללד. ה־K הוא ״קילו״, כלומר 10kΩ הם 10,000 אום. הצבעים על הנגד הם קוד. הכי קל לצלם ולבדוק במחשבון קוד צבעים ברשת.
- חוט חד־גידי (חוט אחד בפנים): מקלפים קצה קצר, בעדינות, כדי לא לחתוך את המתכת עצמה, ומכניסים למטריצה.
צילום או סרטון קצר. שלחו, והם ייכנסו לכאן.
מפת המושגים של השיעור
INPUT·OUTPUT- פין שמקשיב, ופין שמדבר.
digitalRead- קורא פין ומחזיר
HIGHאוLOW, כלומר 1 או 0. - פין צף
- פין קלט שלא מחובר לכלום. מתנהג כמו אנטנה וקורא ערכים אקראיים.
- pull-down
- נגד בין פין הקלט ל־GND. כשלא לוחצים, הפין קורא
LOW. INPUT_PULLUP- נגד פנימי ל־5V. כשלא לוחצים
HIGH, וכשלוחציםLOW. - קצר
- חיבור ישיר בין 5V ל־GND, בלי שום דבר בדרך. אסור.
- מתג רגעי · מתג ננעל
- פעמון, שעובד רק כל עוד לוחצים, ומתג אור, שנשאר במצב שבו השארנו אותו.
- toggle
- כפתור שהמשמעות שלו תלויה במצב: לחיצה מדליקה, הלחיצה הבאה מכבה.
bool·!- משתנה של אמת או שקר, והסימן שהופך אותו.
!=- ״שונה מ־״. שואל אם משהו השתנה.
- Serial
- תקשורת טורית: ערך אחד בכל פעם. השער שלנו לתוך הלוח.
println·print- מדפיס ויורד שורה, ומדפיס בלי לרדת שורה.
- baud
- מהירות התקשורת, בביטים לשנייה. אצלנו 9600.
- bounce · debounce
- רטט המגעים, שהופך לחיצה אחת לכמה, והמנגנון שמסנן אותו.
- זיהוי שינוי
- השוואה בין הקריאה של עכשיו לקריאה הקודמת, כדי להגיב רק לרגע הלחיצה.
- משתנה גלובלי · מקומי
- משתנה שחי כל עוד יש חשמל, ומשתנה שנוצר ונמחק בכל סיבוב.
- מתג
- שני מוליכים, ומנגנון שמחבר או מפריד ביניהם.
- reed switch
- שני מוליכים דקים שנמשכים זה לזה כשמגנט מתקרב.
- micro switch
- מתג מוכן עם לשונית. COM משותפת, NO נסגר בלחיצה, NC נפתח בלחיצה.
- היוריסטיקה
- הלוח לא רואה אצבע. הוא מודד מתח ומניח שמישהו לוחץ.