TXP2027 / שיעור רביעי

כפתורים, קלט ודיבאגינג

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

digitalReadpull-downINPUT_PULLUPSerial Monitortoggledebounceבניית מתג

תקצירהשיעור בהקשר של 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.

אם הבנתם משהו ב־90%, ונשארו 10% מעורפלים, זה מצב מעולה להתקדם ממנו. קשה מאוד להבין משהו עד הסוף לפני שהתנסיתם בו. החלק החסר נסגר כשמחברים, מריצים ורואים. ואם הוא לא נסגר, תפסו אותי בהפסקה.
קריאה לתיעוד
צילום או סרטון של תרגיל הכפתור שלכם

שלחו בוואטסאפ או במייל, והם ייכנסו לסיכומים.

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, קראו את השגיאה, ולחצו שוב כדי לתקן ולקמפל מחדש.

oops.ino
1void setup() {2  pinMode(9, OUTPUT);3}45void loop() {6  digitalwrite(9, HIGH)7  delay(500);8  digitalWrite(9, LOW);9  delay(500);
לחצו Verify כדי לקמפל

04 · else if: יותר משתי אפשרויות

חזרנו לקוד של מד החום מהסיכום הקודם, הפעם עם else if. הלוח בודק את התנאים לפי הסדר, מלמעלה למטה. ברגע שתנאי אחד מתקיים, הוא מריץ את הבלוק שלו ולא בודק את השאר. ה־else שבסוף רץ רק אם אף תנאי לא התקיים, ולכן הוא לא צריך תנאי משלו. גררו את מד החום ועקבו אחרי השורות.

מד חוםגררו את המד או את המחוון
25°C
else_if.ino
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}
Serial Monitor9600 baud
  • הסדר חשוב. אם נבדוק קודם > 20, גם 35 מעלות ייעצרו שם ויודפס ״נעים״.
  • מה עם 30 בדיוק? temperature > 30 הוא false כש־temperature שווה 30. אם רוצים ש־30 ייחשב חם מאוד, כותבים >=, ״גדול או שווה״.
  • כאן אנחנו ״מרמים״. בקוד הערך של temperature קבוע. מד החום בסימולציה רק מראה מה היה קורה אילו חיישן היה משנה אותו. כשנחבר חיישן, הוא יעשה את זה בעצמו.

מה delay עושה, ולמה הוא שם

כשהלוח מגיע ל־delay, הוא קופא. הוא לא מודד ולא מחשב, רק מחכה. אחר כך הוא ממשיך לשורה הבאה, ובסוף loop מתחיל מחדש ועובר שוב על כל השאלות.

למה לחכות בכלל? כי הלוח מהיר מאוד, ולרוב אין סיבה לבדוק משהו אלפי פעמים בשנייה. האורך של ה־delay הוא החלטה עם משמעות: טמפרטורה בחדר לא משתנה כל אלפית שנייה, ולכן מספיק למדוד פעם בשנייה, ואפילו פעם בדקה. אגב, 9600 שב־Serial.begin הוא משהו אחר לגמרי: מהירות התקשורת עם המחשב. נגיע אליו בסעיף על Serial.

05 · הכפתור והמטריצה

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

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

ABCD

הכפתור על המטריצה

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

123456789101112

עמודה 5 עמודה 7 · לחצו והחזיקו את הכפתור

  • הכפתור לא נכנס? הרגליים שלו מתוכננות להלחמה על מעגל מודפס, לא למטריצה. מותר לכופף אותן קצת. הרכיבים האלה זולים, ובגלל זה כיף לשחק בהם: מותר לשבור.
  • הנורית דולקת גם בלי ללחוץ? חיברתם שתי רגליים מאותו זוג, או שהכפתור מסובב ברבע סיבוב. חברו באלכסון.

06 · מעגל בלי קוד, פעמון ומתג אור

במטלה החובה, הכפתור, הנגד והלד היו מחוברים בטור, והלוח שימש רק כמקור מתח: לוקחים מתח מ־5V או מ־3.3V, הוא מגיע לכפתור ונעצר שם. כשלוחצים, הכפתור בונה גשר זמני, הזרם עובר לנגד, ללד, ומשם חוזר ל־GND. אין כאן קוד. גם סוללה הייתה עושה בדיוק את אותה עבודה.

הכפתור סוגר את המעגל, והלוח רק נותן מתח.
  • למה חייבים לחזור ל־GND? דמיינו מים בצינור. אם הצינור נסתם לפני הקצה, המים מגיעים עד המקום הסתום ונעצרים. בלי דרך חזרה, אין זרימה, והלד לא נדלק.
  • איפה שמים את הנגד? במעגל של לד, הנגד יכול להיות לפני הלד או אחריו. כל עוד הוא איפשהו בדרך בין הפלוס למינוס, הוא מגביל את הזרם.

פעמון או מתג אור

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

🔔 פעמון

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

דוגמאות: הכפתור שקיבלתם, מקש במקלדת, קליק בעכבר

לחצו והחזיקו
💡 מתג אור

Latching: נשאר במצב שבו השארנו אותו, דולק או כבוי, עד הלחיצה הבאה.

דוגמאות: מתג אור בקיר, כפתור ההפעלה של רמקול

לחצו פעם אחת

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

07 · מה הלוח קורא בפין

מחברים חוט מפין 2 ישירות ל־5V, בלי כפתור, וקוראים אותו עם digitalRead: מקבלים HIGH. מחברים את אותו פין ל־GND: מקבלים LOW. ומה אם לא מחברים אותו לכלום? בחרו:

מה מחובר לפיןמה הלוח קורא
5VHIGH (1)
GNDLOW (0)
שום דברערך אקראי
פין 2 מחובר ל:
digitalRead(2) ← HIGH (1)
read.ino
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 והכול ברור. אבל כשלא לוחצים, בתוך הכפתור יש נתק, והפין לא מחובר לשום דבר. המעגל נראה סגור על המטריצה, אבל בפועל הפין צף. פין צף מתנהג כמו אנטנה: הוא קולט את השדה החשמלי שסביבו, את הפינים האחרים, את המחשב ואת היד שלכם, והלוח קורא ערכים אקראיים. לחצו כאן על הכפתור, ואחר כך חברו את הנגד ולחצו שוב:

כפתור
Serial Monitor9600 baud
אותו ניסוי על לוח אמיתי: פין 2 עם חוט פתוח, והדפסה ל־Serial Monitor.

הפתרון: נגד שמושך למטה

הכפתור בין 5V לפין 2. נגד של 10kΩ בין פין 2 ל־GND.

מוסיפים נגד של 10kΩ בין פין 2 ל־GND. עכשיו, כשלא לוחצים, הנגד ״מושך״ את הפין ל־GND, והלוח קורא LOW. כשלוחצים, הפין מחובר ישירות ל־5V. החיבור הישיר חזק יותר מהמשיכה דרך הנגד, ולכן הלוח קורא HIGH. לזה קוראים pull-down resistor.

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

הפין מחובר:
לחצו והחזיקו
הלוח קורא LOW

  • למה צריך נגד, ולא סתם חוט ל־GND? כי אז, כשלוחצים, 5V ו־GND היו מחוברים ישירות זה לזה. זה קצר: שני כוחות שווים שמושכים כל אחד לכיוון שלו, וזרם גדול שעובר בלי שום דבר בדרך. הנגד הופך את המשיכה ל״עדינה״, כך שהלחיצה גוברת עליה.
  • ואם מחברים את הנגד ל־5V, והכפתור ל־GND? גם זה עובד, רק הפוך: כשלא לוחצים קוראים HIGH, וכשלוחצים LOW. זה בדיוק pull-up.

09 · INPUT_PULLUP

בתוך הלוח יש נגד מובנה שמחובר ל־5V, ואפשר להפעיל אותו מהקוד: pinMode(2, INPUT_PULLUP). כך לא צריך נגד חיצוני בכלל. הכפתור מחובר בין פין 2 ל־GND, וזהו. בנינו את זה יחד בסימולטור.

הכפתור בין פין 2 ל־GND, בלי נגד. הנורית בפין 9 דרך נגד של 220Ω לאדמה, כמו בקוד.
לחצו והחזיקו
לד בפין 9
הערך בפין 2LOW
pullup.ino
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, בלי נגד
לא לוחציםLOWHIGH
לוחציםHIGHLOW ⚠️

שתי הדרכים עובדות. צריך רק לזכור באיזו בחרתם, כי ב־INPUT_PULLUP הלחיצה היא LOW. כלומר, HIGH מהפין הוא לא תמיד ״לוחצים״ מבחינת הלוגיקה. לתרגיל הבית מומלץ INPUT_PULLUP: הכי קל, ולא צריך נגדים.

ואל תשכחו את הטריק של ה־pull-down. נשתמש בו עוד הרבה, בכל מיני וריאציות.

10 · digitalRead בתוך תנאי

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

לחצו והחזיקו
לד בפין 9
הערך בפין 2LOW
button_led.ino
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? אפשר לכתוב את אותו דבר בשני שלבים, ולשמור את התשובה במשתנה קודם:

two_steps.ino
1bool isPressed = digitalRead(buttonPin);   // שומרים את התשובה
2if (isPressed) {
3  digitalWrite(ledPin, HIGH);
4}
  • == שואל, = מציב. digitalRead(buttonPin) == HIGH הוא שאלה. שווה אחד היה מנסה להכניס ערך.
  • למה לשמור את מספר הפין במשתנה? כי אם תעבירו את הכפתור מפין 2 לפין 7, תשנו שורה אחת למעלה, וכל הקוד יתעדכן. לקוד זה לא משנה. לנו זה משנה מאוד.

11 · Serial Monitor: לשאול את הלוח

אנחנו לא רואים מה הלוח קורא בפין. אבל אפשר לבקש ממנו לספר לנו. ה־Serial Monitor הוא לא בדיוק פלט ולא בדיוק קלט: הוא שער של המתכנת לתוך הלוח. שם רואים אם הלוגיקה עובדת. להדליק לד או להפעיל מנוע זה כבר עניין טכני.

לחצו והחזיקו
הערך בפין 2LOW
debug.ino
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 Monitor9600 baud
  • Serial בעברית זה ״טורי״: תקשורת שמעבירה ערך אחד בכל פעם, זה אחרי זה. מורס, למשל, הוא תקשורת טורית.
  • Serial.begin(9600) פותח את הערוץ, וכותבים אותו ב־setup. רק אחרי שהשער פתוח אפשר לכתוב אליו. 9600 היא מהירות התקשורת, בביטים לשנייה. זה בערך 960 תווים בשנייה, הרבה יותר ממה שאנחנו מסוגלים לקרוא.
  • Serial.println מדפיס ויורד שורה. Serial.print מדפיס בלי לרדת שורה. בדרך כלל עדיף println, כדי שהערכים לא יידחסו זה לתוך זה.
  • החלון נפתח מהאייקון של זכוכית המגדלת בפינה של ה־IDE, או מ־Tools > Serial Monitor. המהירות שבוחרים בחלון צריכה להיות 9600, כמו בקוד.
  • הלוח כותב רק כשיש מי שמקשיב. כשהוא מחובר ב־USB, הלוח והמחשב עושים ״לחיצת יד״ ופותחים ערוץ. מחובר לסוללה, אין לאן לכתוב.
  • ה־delay(100) בקוד הוא לא כדי שנספיק לראות. בלי השהיה, הלוח מדפיס אלפי שורות בשנייה ומציף את החלון, וקשה לקרוא בו משהו.

להדפיס כדי לדבג

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

debug.ino
1if (ledOn) {
2  Serial.println("התנאי התקיים: מדליק");
3  digitalWrite(9, HIGH);
4} else {
5  Serial.println("התנאי לא התקיים: מכבה");
6  digitalWrite(9, LOW);
7}

12 · לזכור מצב: toggle

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

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

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

ledOn = false
  • ledOn = !ledOn; נקרא: ״ledOn שווה ההפך של ledOn״. משהו שבמציאות לא נהוג לעשות, ובקוד זה טריק חזק. אותו עיקרון מאפשר גם x = x + 1;: לקחת את הערך הנוכחי, לשנות אותו, ולהכניס אותו חזרה לאותו משתנה.
  • אפשר להפוך רק בוליאני. למשתנה int אי אפשר להגיד ״תהיה ההפך שלך״. צריך משהו שיש לו בדיוק שני מצבים.
  • if (ledOn), בלי ==. כל מה שנכנס לסוגריים של if הופך בסוף ל־true או false. משתנה בוליאני כבר הוא תשובה כזו, ולכן אפשר להכניס אותו ישירות. if (ledOn == true) יעשה בדיוק אותו דבר.

13 · למה הלד מתהפך באקראי

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

לחצו והחזיקו
לד בפין 9
הערך בפין 2LOW
היפוכים בלחיצה האחרונה0
toggle_v1.ino
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}
Serial Monitor9600 baud

הבעיה היא ש־loop רצה מהר מאוד, מאות ואלפי פעמים בשנייה. לחיצה קצרה של אדם נמשכת בערך עשירית שנייה. בזמן הזה הקוד בודק את הכפתור עשרות פעמים, ובכל פעם מוצא אותו לחוץ והופך את הלד. אם מספר ההיפוכים זוגי, הלד חוזר למצב שבו התחיל. אם אי־זוגי, הוא מתהפך. זו הגרלה.

לחצו לחיצה קצרה
הלחיצה נמשכה
0 ms
כמה פעמים loop מצאה את הכפתור לחוץ
0
התוצאה
…

החישוב לפי הקוד מהשקופית הקודמת: כל סיבוב של loop עם הדפסה לוקח כ־3 אלפיות שנייה.

הקוד בודק מצב: האם הכפתור לחוץ עכשיו? אבל מה שאנחנו רוצים לזהות הוא שינוי: האם הכפתור עבר ממצב ״לא לחוץ״ למצב ״לחוץ״?

14 · רטט מגעים

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

לחיצה: 12 אלפיות השנייה הראשונות
עזיבה: 12 אלפיות השנייה הראשונות
לחצו ועזבו
כמה פעמים לחצתם
0
כמה לחיצות הלוח זיהה
0

הלוח מזהה לחיצה בכל פעם שהמתח עולה מ־0V ל־5V, ולכן כל קפיצה נספרת כלחיצה חדשה.

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

זה מה שקורה כשעוברים מהעולם התיאורטי של true ו־false לעולם של זרם. העולם שאנחנו חיים בו רועש, ובקוד קוראים לזה רעש. כדי לעבוד איתו, בונים מנגנונים שמסננים אותו. לבעיה קוראים bounce, ולפתרון debounce.

15 · פתרון ראשון: לחכות

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

לחצו והחזיקו
לד בפין 9
הערך בפין 2LOW
היפוכים בלחיצה האחרונה0
toggle_v2.ino
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}
Serial Monitor9600 baud
  • בזמן ה־delay הלוח קפוא. הוא לא מודד ולא יודע כלום. רק כשהוא ״מתעורר משנת היופי״, הוא ממשיך ומדליק או מכבה את הלד.
  • יש מחיר. מי שמחזיק את הכפתור יותר משליש שנייה, הופך את הלד שוב.

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

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

16 · פתרון שני: לזכור מה היה קודם

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

קודם (lastState)עכשיו (state)מה קרה
LOWLOWאין שינוי
LOWHIGHנלחץ: הופכים את הלד
HIGHHIGHאין שינוי
HIGHLOWשוחרר

לחצו כמה פעמים, קצר וארוך, ועקבו אחרי הטבלה, אחרי המשתנים ואחרי מונה ההיפוכים. בהילוך איטי רואים גם את ה־delay(50) הקצר, שמחכה לסוף הרטט:

לחצו והחזיקו
לד בפין 9
הערך בפין 2LOW
היפוכים בלחיצה האחרונה0
toggle_v3.ino
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 = false
lastState = 1ledOn = true
lastState = 1ledOn = true
סיבוב 1 של loopstate = 0לא לוחצים
סיבוב 2state = 1לחיצה: יש שינוי
סיבוב 3state = 1עדיין לוחצים
גלובלי: אותו תא, והערך נשמר. מקומי: state נוצר מחדש בתחילת כל סיבוב ונמחק בסופו.
  • משתנה מקומי מוגדר בתוך פונקציה, למשל int state בתוך loop. הוא נולד כשהסיבוב מתחיל ומת כשהוא נגמר. בכל סיבוב יש state חדש, שלא יודע מה היה קודם.
  • משתנה גלובלי מוגדר למעלה, מחוץ לכל הפונקציות, כמו ledOn ו־lastState. הוא נוצר כשהלוח מקבל חשמל, וחי עד שמנתקים אותו. אם משנים אותו, הלוח זוכר את השינוי. לכן lastState יכול לזכור את הסיבוב הקודם.
  • תנו תמיד ערך התחלתי. משתנה גלובלי בלי ערך מתחיל מ־0. אבל משתנה מקומי בלי ערך מכיל את מה שהיה במקרה באותו מקום בזיכרון, מין ״רחש בראשית״. הדפיסו אותו, ותקבלו מספר מוזר. כשכותבים int lastState = LOW;, אין ספק.
  • int עם LOW? כן. LOW הוא שם ל־0, ולכן אפשר להכניס אותו ל־int. אנחנו כותבים מילים באנגלית, והמערכת מתרגמת אותן למספרים. השכבה הזו קיימת בשבילנו.

18 · מתג הוא שני מוליכים

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

מצוף פתוח, ובתוכו מתג וכדור מתכת
מצוף: המים לוחצים על המתג. צילום: Wikimedia Commons
בסיס פתוח של מעבד מזון, עם מתג הבטיחות מסומן בעיגול
מעבד מזון: הקערה הנעולה לוחצת על מתג נסתר. צילום: Guy Moore, iFixit · CC BY-NC-SA 3.0
פגוש קדמי של שואב אבק רובוטי, מנותק מגוף הרובוט
שואב רובוטי: הפגוש כולו הוא הכפתור. צילום: Hannah Neuendorf, iFixit · CC BY-NC-SA 3.0
  • מצוף: כשהמים עולים, המצוף משנה תנוחה, וכדור בתוכו לוחץ על לשונית של מתג. בקוד רואים ״כפתור נלחץ״, ובמציאות המשמעות היא ״המכל התמלא״.
  • בלנדר או מעבד מזון: המנוע לא יפעל עד שהקערה במקום. יש שם גאומטריה מורכבת, אבל בסוף היא לוחצת על מתג קטן, רק כשאין גישה לסכין.
  • שואב רובוטי: כשהוא נתקל בקיר, הפגוש הקדמי זז פנימה ומפעיל חיישן שמאחוריו. התגובה של הרובוט נראית מורכבת, אבל היא מתחילה בתזוזה פשוטה של פלסטיק.

איך בונים מתג

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

לחצו והחזיקו ▼
לחיצהשתי שכבות של נייר כסף, עם ספוג מחורר ביניהן. הלחיצה מקרבת אותן, והספוג מחזיר.
NS
מגנטמתג reed: שתי לשוניות מתכת נמשכות זו לזו כשמקרבים מגנט. כך עובדים חיישני דלת באזעקה.
הטיהכדור מתכת מתגלגל לצד הנמוך של הצינור ומגשר בין שני מוליכים.
הברגהבורג מתכת מתקדם בכל סיבוב, עד שהקצה שלו נוגע בפלטה. המגע נשאר עד שמסובבים חזרה.
כוח המשיכהמשקולת תלויה בתוך טבעת מתכת. טלטלה מקרבת אותה לטבעת וסוגרת מגע לרגע: חיישן רעידות.
₪
גישורשני מגעים נפרדים, ועצם מוליך שנכנס ביניהם וסוגר את המעגל: מטבע, מפתח, תקע.
  • הטיה: קפסולה עם כדור מתכת ושני מגעים. כשמטים אותה, הכדור מתגלגל ומגשר ביניהם.
  • מגנט: כמו החיישנים שעל דלתות וחלונות של אזעקה. שני מוליכים דקיקים, קרובים אבל לא נוגעים, נמשכים זה לזה כשהמגנט עובר לידם. את זה אפשר לבנות בעצמכם עם פיסות מתכת דקות ומגנט.
  • מטבע: עצם מוליך שנכנס בין שני מגעים וסוגר את המעגל.
  • הברגה: בורג שסוגר מעגל בסוף המהלך שלו. או בורג שבכל סיבוב שלם נוגע במגע לרגע, ועושה ״קליק״. כך אפשר לספור סיבובים. הלוח לא יבין מה זה בורג, אבל במציאות לזה יכולה להיות משמעות מעניינת.

ה־micro switch

מתג מוכן עם לשונית קפיצית. יש לו שלוש רגליים:

  • COM: הרגל המשותפת. משתמשים בה תמיד.
  • NO (Normally Open): מתחבר ל־COM רק כשלוחצים.
  • NC (Normally Closed): מחובר ל־COM, והחיבור נפתח כשלוחצים.

מחברים COM ו־NO, והוא מתנהג בדיוק כמו הכפתור. רוצים שהלחיצה תנתק? משתמשים ב־NC. לחצו והחזיקו את הלשונית:

COMNONC
לחצו והחזיקו את הלשונית
מוכן: micro switchלשונית קפיצית לוחצת על מגע בתוך הגוף. COM היא הרגל המשותפת: NO מתחבר רק בלחיצה, ו־NC מתנתק בלחיצה. הנורית מראה את החיבור COM–NO.

מה מוליך?

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

19 · לקראת המפגש הבא

מטלת הבית: לבנות מתג

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

  • קלט: המתג שבניתם, או micro switch, מחובר לפין קלט.
  • ממשק: מה המשתמש עושה בפועל, ואיך הפעולה שלו סוגרת את המגע.
  • פלט: לד, הודעה ב־Serial Monitor (״פתחו את הדלת״, ״התיישבו על הכיסא״), או שניהם.

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

קוד בסיס

מומלץ INPUT_PULLUP: המתג מחובר בין פין 2 ל־GND, בלי נגד. הקוד מזהה כל שינוי, מדפיס הודעה ומדליק או מכבה את הלד. העתיקו, ואז קראו מה הדבקתם. רוצים שכל לחיצה תהפוך מצב? שלבו את ledOn = !ledOn מסעיף 16.

שני המוליכים של המתג: אחד לפין 2 והשני ל־GND. הנורית בפין 9, כמו בקוד הבסיס.
my_switch.ino
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 נפתח בלחיצה.
היוריסטיקה
הלוח לא רואה אצבע. הוא מודד מתח ומניח שמישהו לוחץ.