TXP2027 / שיעור שלישי

מהלוח אל הקוד

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

Arduino Nanosetup ו־loopWokwiמשתניםלוגיקהif / else

תקצירהשיעור בהקשר של physical computing

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

  • חומרההצ׳יפ שעל הלוח הוא מיקרו־בקר: מעבד, זיכרון וכניסות ויציאות בשבב אחד. אחרי הצריבה הלוח עובד לבד, בלי המחשב. מפת הפינים (pinout) מראה מה כל פין יודע לעשות: מצב דיגיטלי, עמעום (~) או קריאה אנלוגית.
  • פעולהלנורית יש כיוון, ונגד של 220 אום מגביל את הזרם ומגן עליה ועל הלוח. הרמזור ב־Wokwi הראה איך רצף פקודות ותזמון הופכים להתנהגות.
  • מבנהsetup ו־loop עובדים כמו המלכודת: דורכים פעם אחת, ומחכים שוב ושוב.
  • זיכרוןמשתנה הוא תא בזיכרון עם שם, סוג וערך: int, float, char, bool או String. משתנה שמוכרז מחוץ ל־loop זוכר את הערך שלו מסיבוב לסיבוב.
  • החלטההשוואה היא שאלה שהתשובה עליה היא true או false. &&, || ו־! מחברים כמה תנאים, ו־if ו־else פותחים שער לפי התשובה. הסף שבו טמפרטורה רציפה הופכת ל״חם״ הוא החלטה עיצובית.
  • דיבאגאין לנו דרך לראות מה קורה בתוך הלוח. Serial Monitor מראה מה הוא עושה ברגע זה, ולכן הוא הכלי הראשון כשמשהו לא עובד.
  • למידהגלילה ברשת היא מצב חיפוש, לא מצב למידה. וכדי שצ׳אט יכתוב קוד שאתם יכולים לקרוא, ספרו לו קודם מה כבר למדתם.

השאלה של השיעור: מה הלוח צריך לזכור, על מה הוא צריך לשאול, ומי קובע את הסף?

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

02 · מה עשיתם עם הלדים

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

מה ראינו

  • שירים ומקצבים. כמה מכם תרגמו מנגינה לקצב של הבהובים, למשל את הפתיחה של Eye of the Tiger, ואחת הפעילה את הלדים יחד עם צליל. בכיתה עלה המושג סינסתזיה: ערבוב בין חושים, כמו לראות צבע כששומעים מילה.
  • רמזור. מי שבנתה רמזור פירקה את הבעיה לשלבים, וכתבה ליד כל שורה הערה שמסבירה מה היא עושה.
  • סורק. שלושה לדים שאור רץ ביניהם הלוך ושוב, כמו הפס האדום בחזית של KITT, המכונית המדברת מהסדרה Knight Rider.
  • לד שמתעמעם. מישהו עקף את מה שלמדנו והשתמש בפונקציה אחרת, שיודעת לעמעם. זה PWM, ונלמד אותו בהמשך.
קריאה לתיעוד
סרטון קצר של התרגיל שלכם עם הלדים

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

אור הוא חומר

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

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

קודם ההיגיון, אחר כך הקוד

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

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

ומה עם הצ'אט?

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

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

פרומפט לפני שמתחילים

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

פרומפט לדוגמה
אני סטודנט/ית לעיצוב תעשייתי בקורס מבוא למחשוב פיזי (TXP2027), ואני בתחילת הדרך בתכנות Arduino.

הציוד שלי: Arduino Nano (תואם), Arduino IDE 2, מטריצה, נוריות, נגדים וכפתור לחיצה.

מה למדנו עד עכשיו, ורק בזה מותר לך להשתמש:
- setup ו־loop
- pinMode, digitalWrite ו־delay
- משתנים מהסוגים int, float, char, bool ו־String
- חשבון: + - * / %
- השוואה: == != < > <= >=
- לוגיקה: && || !
- if, else ו־else if
- Serial.begin ו־Serial.println
- digitalRead, INPUT ו־INPUT_PULLUP (רק היכרות ראשונה)

מה עוד לא למדנו, ולכן אל תשתמש בו: לולאות for ו־while, מערכים, פונקציות שאני כותב/ת בעצמי, millis, analogRead, analogWrite, ספריות ו־switch.

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

השאלה שלי:

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

יש אינסוף דרכים

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

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

03 · מה יש בתוך הצ'יפ

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

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

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

זום פנימה

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

גם ברזולוציה הכי גבוהה יש היגיון בגבולות. זה לא קסם.

04 · הלוח: Arduino Nano

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

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

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

מפת הפינים של Arduino Nano
מפת הפינים של ה־Nano. כדי למצוא מפה כזו לכל לוח, חפשו את שם הלוח ואת המילה pinout.
סימון מה זה למה זה חשוב לנו
D0–D13 פינים דיגיטליים יודעים להדליק ולכבות, מהר מאוד. בקוד מגדירים אותם כקלט או כפלט.
~ פינים שמסומנים בגל רק הם יודעים לעמעם לד (PWM): D3, D5, D6, D9, D10, D11. כשרוצים לעמעם, חובה לחבר לאחד מהם.
A0–A7 פינים אנלוגיים קוראים ערכים בטווח, ולא רק כן או לא. נדבר עליהם בהמשך.
5V מתח העבודה הפלוס.
GND אדמה המינוס. יש שניים על הלוח.
VIN כניסת מתח חיצוני לספק כוח שאינו USB, בדרך כלל של 7 עד 12 וולט. הלוח מוריד אותו בעצמו ל־5.
RX / TX פיני התקשורת הטורית הם גם D0 ו־D1. כשמשתמשים ב־Serial Monitor, עדיף להשאיר אותם פנויים.

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

05 · סביבת העבודה

מסך Arduino IDE 2 עם תוויות לכפתורים
Arduino IDE 2 והכפתורים העיקריים.

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

כפתור מה הוא עושה
Verify ✓ בודק את הקוד, גם בלי לוח מחובר. אם הכול תקין, למטה תופיע הודעה מרגיעה. אם לא, תופיע שגיאה, ואפשר להתחיל לתקן.
Upload → פותח את השער ללוח, מעביר אליו את הקוד וסוגר. עובד רק כשמחובר הלוח הנכון ונבחרה הכניסה הנכונה. בלוח שלנו, כל צריבה מוחקת לגמרי את הקוד הקודם.
Serial Monitor הזכוכית המגדלת בצד ימין למעלה. נפתח חלון שבו הלוח והמחשב מדברים, שנקרא גם קונסולה. הוא מציג רק מה שהקוד שלנו אומר ללוח להדפיס.
Library Manager הלשונית של הספריות, בסרגל שבצד.

ספריות: מתורגמן

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

servo_example.ino
1#include <Servo.h>   // מכניסים את הספרייה
2
3Servo myServo;       // עכשיו יש סוג חדש: מנוע סרוו

שמירה, ולמה זה נקרא sketch

קוד הוא מסמך טקסט, ושומרים אותו כמו כל מסמך: File ← Save. ארדואינו שומר תיקייה שלמה, ובתוכה קובץ באותו שם עם הסיומת .ino. כדי לפתוח שוב, לוחצים פעמיים על הקובץ. התיקייה שבה ארדואינו מציע לשמור נקראת Sketchbook, וקובץ חדש נפתח מ־File ← New Sketch. דבר אחד קצת מעצבן: כל קובץ נפתח בחלון משלו, והתוכנה זוכרת את כל החלונות הפתוחים.

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

כמה כללי כתיבה

  • רווחים ושורות ריקות לא מעניינים את הלוח. השתמשו בהם בחופשיות כדי לחלק את הקוד לבלוקים. אבל רווח בתוך שם, כמו my Number, שובר את השם לשתי מילים.
  • איפה אסור לשבור שורה. פקודה ארוכה אפשר לפצל לכמה שורות, כי ללוח לא משנה איפה יורדים שורה. אבל אסור לשבור באמצע שם, באמצע טקסט שבין מרכאות, או אחרי //, כי כל מה שבהמשך השורה הוא הערה.
  • הזחה (indentation): כל מה שנמצא בתוך סוגריים מסולסלים מוזח פנימה. ללוח זה לא משנה, אבל זה עושה סדר לעין. אחת השגיאות הכי נפוצות היא לשכוח לסגור סוגר מסולסל, והשגיאה לא תמיד מצביעה למקום הנכון. ההזחה עוזרת לראות איפה אתם נמצאים.
  • הערה כמתג. רוצים לבדוק מה קורה בלי שורה מסוימת? אל תמחקו אותה. הוסיפו לפניה //, והיא הופכת להערה. הקיצור הוא בדרך כלל Ctrl + / (במק Cmd + /): מסמנים שורות, לוחצים, והן הופכות להערות. לוחצים שוב, והן חוזרות. בחלק מהמחשבים, בגלל פריסת המקלדת, הקיצור שונה. אם הוא לא עובד, חפשו את הפקודה בתפריט Edit.

06 · setup ו־loop: לדרוך ולחכות

sketch.ino
1void setup() {
2  // רץ פעם אחת: דורכים את המלכודת
3}
4
5void loop() {
6  // רץ שוב ושוב: מחכים
7}

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

במלכודת: לדרוך את הקשת זה setup. לחכות לציפור זה loop.

ומה קורה כשמנתקים את החשמל באמצע? הלוח שוכח הכול. כשהחשמל חוזר, הוא מתחיל שוב מ־setup, ואחריו את loop מההתחלה. הדבר היחיד שנשאר הוא הקוד עצמו.

שתי מילים על הדקדוק. setup ו־loop הן פונקציות: קפסולות שבתוכן יש יכולת. המילה void לפני השם אומרת שהפונקציה לא מחזירה כלום. זוכרים את ה־return מהשיעור הראשון, את הפונקציה שמחזירה משהו? כאן אין return: הפונקציה פשוט פועלת. ארדואינו מחייב את שתי הפונקציות האלה, ולכן לא צריך לקרוא להן, הן פשוט רצות. וכל מה שבין הסוגריים המסולסלים { } הוא העולם של הפונקציה: הוא מתחיל בסוגר הפותח ונגמר בסוגר הסוגר.

07 · תרגיל: רמזור בסימולטור

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

הרמזור בסימולטור Wokwi: לוח Arduino UNO, מטריצה, שלוש נוריות, שלושה נגדים וחוטים לפינים 9, 10 ו-11
הרמזור ב־Wokwi. בסימולטור הלוח הוא UNO, אבל הפינים והקוד זהים ל־Nano: הירוקה לפין 9, הצהובה ל־10 והאדומה ל־11, וכל נגד מחובר לפס האדמה.

המטריצה (breadboard)

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

הנורית והנגד

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

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

פין 9 ← נורית (רגל ארוכה) ← נגד ← אדמה. מעבר עם העכבר על חוט או רגל מדגיש את כל מה שמחובר אליו.

הקוד שכתבנו יחד

בסימולטור, הירוקה מחוברת לפין 9, הצהובה לפין 10 והאדומה לפין 11:

traffic_light.ino
1void setup() {
2  pinMode(9, OUTPUT);    // ירוק
3  pinMode(10, OUTPUT);   // צהוב
4  pinMode(11, OUTPUT);   // אדום
5}
6
7void loop() {
8  digitalWrite(11, HIGH);   // אדום
9  delay(3000);
10
11  digitalWrite(10, HIGH);   // אדום וצהוב
12  delay(1000);
13
14  digitalWrite(11, LOW);
15  digitalWrite(10, LOW);
16  digitalWrite(9, HIGH);    // ירוק
17  delay(3000);
18
19  digitalWrite(9, LOW);
20  digitalWrite(10, HIGH);   // צהוב
21  delay(1000);
22  digitalWrite(10, LOW);    // מסיימים בחושך
23}

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

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

איך סוגרים את הלולאה?

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

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

08 · משתנים: תא בזיכרון

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

חשבו על הקורס הזה. כדי שייפתח, המערכת צריכה מרצה אחד ומספר מינימלי של סטודנטים. היא לא שואלת אם נרשמו הוא, היא או הם. היא שואלת כמה סטודנטים נרשמו. ״סטודנט״ הוא קבוצה, הפשטה (abstraction), ומשתנה הוא מקום שבו שמים ערך מסוג מסוים. כמו בנוסחה a + b = c: אפשר להכניס ל־a ול־b מה שרוצים, והנוסחה תמיד תחזיר את c הנכון.

variables.ino
1int myNumber;        // הכרזה: תא ריק
2
3int myNumber = 10;   // הכרזה עם ערך התחלתי
4
5myNumber = 20;       // שינוי הערך
  • הכרזה: int myNumber; בורא תא בשם myNumber שמחזיק רק מספרים שלמים. זה מדף ריק.
  • הכרזה עם ערך: int myNumber = 10; בורא את התא ומכניס לתוכו 10.
  • שינוי: myNumber = 20; בלי int, כי התא כבר קיים. מחליפים רק את מה שבתוכו. במשתנה מסוג int יש תמיד מספר אחד בלבד.

איפה מכריזים

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

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

שמות

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

סוגי משתנים

סוג מה הוא מחזיק דוגמה מהעולם
int מספר שלם (integer), בלוח שלנו בין -32,768 ל־32,767 מונה כניסות: אין חצי אדם.
float מספר עשרוני (floating point). את 1 הוא רואה כ־1.0 קליבר, או טמפרטורה עם ספרה אחרי הנקודה.
char תו אחד (character): אות, ספרה, סימן שאלה, פסיק. בין מרכאות בודדות ציון: 'A'.
bool שני מצבים בלבד: true או false כן או לא, HIGH או LOW.
String מחרוזת: הרבה תווים בשורה. בין מרכאות כפולות הטקסט שיופיע על מסך קטן בתפריט של מכשיר.

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

דוגמאות:
סוג המשתנה

variables.ino

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

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

09 · חשבון והשוואה

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

arithmetic.ino
1int a = 10;
2int b = 3;
3
4int sum       = a + b;   // 13  חיבור
5int diff      = a - b;   // 7   חיסור
6int product   = a * b;   // 30  כפל
7int quotient  = a / b;   // 3   חילוק שלם
8int remainder = a % b;   // 1   שארית
  • החילוק נחתך. 10 חלקי 3 בתוך int הוא 3, לא 3.33. הלוח לא טועה: התוצאה נכנסת לתא שמחזיק רק מספרים שלמים, והשבר פשוט נחתך. אם צריך שבר, משתמשים ב־float.
  • השארית, %, היא מה שנשאר אחרי חילוק שלם: 10 חלקי 3 הוא 3, ונשאר 1. זה נשמע כמו משהו מבית הספר היסודי, אבל זה כלי חזק מאוד. ספירה עם שארית של 4 נותנת 0, 1, 2, 3, 0, 1, 2, 3: מחזור של ארבעה מצבים. כמו רמזור.

שווה אחד, שווה שניים

comparison.ino
1int x = 5;
2int y = 10;
3
4bool r1 = (x == y);   // false  שווים?
5bool r2 = (x != y);   // true   שונים?
6bool r3 = (x <  y);   // true   קטן?
7bool r4 = (x >= y);   // false  גדול או שווה?

השוואה היא שאלה, והתשובה שלה תמיד בוליאנית. x < y לא קובע ש־x קטן מ־y. הוא שואל אם הוא קטן.

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

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

10 · לוגיקה: וגם, או, לא

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

סימן קוראים התשובה היא true כש… דוגמה: האם לפתוח את הקורס?
&& וגם (AND) כל התנאים נכונים נרשמו לפחות שמונה סטודנטים, וגם כולם מהמחלקה לעיצוב תעשייתי, וגם כולם סיימו את שנה ב'.
|| או (OR) לפחות אחד מהתנאים נכון הסטודנט גר בירושלים או בתל אביב. מספיק אחד מהם.
! לא (NOT) התנאי לא נכון: הוא הופך את התשובה הסטודנט לא בוגר. בוגר לא יכול להירשם.

בכיתה עלתה שאלה: למה true || false שווה true? כי ״או״ שואל אם לפחות אחד מהצדדים נכון, ואחד מהם אכן נכון. ו־true && false שווה false, כי ״וגם״ דורש ששניהם יהיו נכונים. הנה כל האפשרויות:

a b a && b a || b
true true true true
true false false true
false true false true
false false false false

בפועל, כך תשתמשו בזה: תכתבו תנאי, ותצמידו לו עוד תנאי.

logic.ino
1int students = 9;
2bool isIndustrialDesign = true;
3
4if (students >= 8 && isIndustrialDesign) {
5  // פותחים את הקורס
6}
  • && ו־|| נכתבים תמיד בזוגות. סימן אחד בודד, & או |, עושה משהו אחר לגמרי.
  • את הקו הישר | מקלידים במקלדת באנגלית עם Shift ועם הלוכסן ההפוך \.
  • אפשר לחבר כמה תנאים שרוצים. אבל בתנאי ארוך מאוד, קל לטעות בתחביר.

11 · תנאים: if ו־else

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

מד חוםגררו את המד או את המחוון
25°C
if_temperature.ino
1int temperature = 25;   // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6  if (temperature > 30) {7    Serial.println("חם מאוד!");8  }9  delay(1000);   // סיבוב בכל שנייה10}
Serial Monitor9600 baud

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

נסו: גררו את מד החום. כל עוד הטמפרטורה 30 או פחות, התנאי הוא false, ושום דבר לא מודפס. עברו את 30, והשורה ״חם מאוד!״ מתחילה להופיע ב־Serial Monitor, שוב ושוב, פעם בכל סיבוב של loop. השעה שליד כל שורה (timestamp) מראה שזו הדפסה חדשה, ולא אותה שורה שנשארה על המסך. השורות שרצו בסיבוב האחרון מסומנות בקוד, וליד כל תנאי שנבדק מופיעה תווית ״תשובה״. התווית היא לא חלק מהקוד: היא מראה מה הלוח ענה על השאלה בסיבוב האחרון. Serial.println שולחת שורת טקסט ל־Serial Monitor, החלון שבו הלוח מדבר עם המחשב, ו־Serial.begin(9600) ב־setup פותחת את הקו.

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

״אבל למה להגדיר משתנה ואז לשאול עליו?״

השאלה הזו מהכיתה מדויקת: אם הטמפרטורה תמיד 25, הקוד בתוך התנאי לא ירוץ אף פעם. הסיבה היחידה לכתוב כך היא שעוד לא למדנו לחבר חיישן. בסימולציה, מד החום ממלא את תפקיד החיישן: הוא משנה את הערך של temperature. בפרויקט אמיתי, הקוד יקרא את החיישן ויעדכן את המשתנה בכל סיבוב, ואז, ברגע שהטמפרטורה תעבור את 30, הלוח יכתוב ״חם מאוד״. נהוג אפילו להתחיל משתנה כזה בערך שלא יכול לקרות, כמו -1, כדי לדעת שעוד לא הגיעה קריאה.

ההיגיון של קוד הוא לא אינטואיטיבי. עד שהוא אינטואיטיבי.

else: ואם לא?

מד חוםגררו את המד או את המחוון
25°C
if_else.ino
1int temperature = 25;   // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6  if (temperature > 30) {7    Serial.println("חם מאוד!");8  } else {9    Serial.println("מזג אוויר נעים");10  }11  delay(1000);   // סיבוב בכל שנייה12}
Serial Monitor9600 baud

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

טווח

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

מד חוםגררו את המד או את המחוון
25°C
range.ino
1int temperature = 25;   // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6  if (temperature > 22 && temperature < 28) {7    Serial.println("מזג אוויר נעים");8  }9  delay(1000);   // סיבוב בכל שנייה10}
Serial Monitor9600 baud

איפה שמים את הספים

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

12 · מה לא הספקנו: הצצה

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

else if: כמה מצבים

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

מד חוםגררו את המד או את המחוון
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

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

קלט: הלוח מתחיל להקשיב

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

כפתור מחובר לפין 2, עם נגד לאדמה וחיבור ל-5V
כפתור לפין 2: צד אחד ל־5V, והצד השני לפין ודרך נגד לאדמה.
digital_read.ino
1void setup() {
2  pinMode(2, INPUT);   // פין 2 מקשיב
3}
4
5void loop() {
6  int buttonState = digitalRead(2);   // קוראים את הכפתור
7  if (buttonState == HIGH) {          // הכפתור לחוץ
8    // ???
9  }
10  delay(100);   // השהיה קצרה נגד ״רעש״
11}

הנגד לאדמה מחזיק את הפין ב־LOW כל עוד לא לוחצים (pull-down). כשלוחצים, הכפתור מחבר את הפין ל־5V והוא קורא HIGH. בלי הנגד, פין שלא מחובר לכלום ״מרחף״ וקורא רעש מהסביבה. ההשהיה הקצרה בסוף עוזרת להתגבר על כך שמגעי הכפתור קופצים לרגע כשלוחצים.

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

מטלת הבית

כל אחד מכם קיבל כפתור לחיצה (מתג רגעי).

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

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

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

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

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

טיפים למעגל

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

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

טיפים לבונוס עם קוד

  • החיבור: לפי ההצצה לקלט: כפתור לפין 2, עם נגד אל GND שמחזיק את הפין ב־LOW כשלא לוחצים (pull-down). פין שלא מחובר לכלום ״מרחף״, וקורא רעש.
  • דרך קצרה יותר: pinMode(2, INPUT_PULLUP) מפעיל נגד שנמצא בתוך הלוח, ואז מחברים את הכפתור בין פין 2 ל־GND, בלי נגד חיצוני. שימו לב שההיגיון מתהפך: לחוץ הוא LOW.
  • קודם תקשיבו לכפתור. לפני שאתם מנסים להדליק משהו, הדפיסו את מה שהלוח קורא: Serial.begin(9600) ב־setup, ו־Serial.println(buttonState) ב־loop. פתחו את Serial Monitor ולחצו. אם אתם רואים 0 ו־1 מתחלפים, אפשר להתקדם.
  • לחיצה היא שינוי, לא מצב. הלוח קורא את הכפתור שוב ושוב, פעמים רבות בשנייה, וכל עוד האצבע עליו, הוא רואה ״לחוץ״. כדי שלחיצה אחת תספר כאחת, שמרו במשתנה מחוץ ל־loop את המצב מהסיבוב הקודם, ופעלו רק ברגע המעבר מ״לא לחוץ״ ל״לחוץ״.
  • הלוח עיוור בזמן delay. בזמן השהיה הלוח לא קורא כלום. הבהוב עם השהיות של שנייה יגרום לו לפספס לחיצות. התחילו עם השהיות קצרות.
  • מתג הפוך: isBlinking = !isBlinking; הופך משתנה בוליאני מ־true ל־false ובחזרה.
  • כתבו את ההיגיון לפני הקוד. לדוגמה, השלד הזה כתוב רק בהערות. את השורות עצמן תכתבו אתם:
bonus_sketch.ino
1// משתנה מחוץ ל-loop: האם מהבהבים עכשיו
2// משתנה מחוץ ל-loop: מה היה הכפתור בסיבוב הקודם
3
4void setup() {
5  // הנורית: פלט. הכפתור: קלט
6}
7
8void loop() {
9  // לקרוא את הכפתור
10  // אם עכשיו לחוץ, ובסיבוב הקודם לא היה לחוץ:
11  //   להפוך את מצב ההבהוב
12  // לזכור את מצב הכפתור לסיבוב הבא
13
14  // אם מהבהבים: להדליק, לחכות קצת, לכבות, לחכות קצת
15  // אחרת: לכבות
16}
שאלות עזר למטלה
  • מה ההבדל בין מעגל שהכפתור סוגר, לבין לוח שקורא כפתור? מה מרוויחים כשהלוח באמצע?
  • במלכודת מהשיעור הראשון: מה הכפתור, מה התנאי ומה הפעולה?
  • אילו מצבים יש לחפץ שלכם, ומה מעביר ממצב למצב?
  • מה צריך לזכור מסיבוב לסיבוב, ואיפה זה נשמר?
  • אם השתמשתם בצ'אט: האם אתם יכולים להסביר כל שורה בקוד שקיבלתם?

מפת המושגים של השיעור

קופסת סקינר
ניסוי התנהגות שבו תגמול לא צפוי יוצר לחיצה עיקשת. מודל למצב חיפוש, שאינו מצב למידה.
מפזר (diffuser)
חומר שמסתיר את מקור האור ומרכך אותו לענן.
מיקרו־בקר
מעבד, זיכרון וכניסות ויציאות בשבב אחד. המוח של הלוח.
טרנזיסטור
מתג זעיר שמתח פותח וסוגר. אבן הבניין של שערים לוגיים ושל כל שבב.
צריבה (upload)
תרגום הקוד ושליחתו ללוח. בלוח שלנו כל צריבה מחליפה את הקודמת.
open source
שרטוטים וקוד פתוחים לכולם, שמותר לייצר מהם ולמכור.
pinout
מפת הפינים של לוח: מה כל פין יודע לעשות.
ספרייה
קוד מוכן שמוסיפים עם #include, מעין מתורגמן לרכיב מורכב.
sketch / Sketchbook
קובץ קוד של ארדואינו, והתיקייה שבה הקבצים נשמרים. מהיר ומלוכלך, בכוונה.
הזחה
הזזת שורות פנימה לפי המבנה, כדי לראות מה שייך למה.
מטריצה (breadboard)
לוח חיבורים: חמישה חורים בשורה מחוברים, והפסים שבצדדים מחוברים לכל אורכם.
נגד
רכיב שמגביל את הזרם. לנורית: 220 אום.
אמולציה
הרצה אמיתית של קוד הלוח במחשב, כמו ב־Wokwi.
משתנה
תא בזיכרון עם שם, סוג וערך.
int · float · char · bool · String
מספר שלם, עשרוני, תו, אמת או שקר, וטקסט.
= מול ==
הצבה מול שאלה.
%
שארית החילוק. מייצרת מחזורים.
&& · || · !
וגם, או, לא.
if / else
שער שנפתח רק כשהתנאי נכון, וחלופה למקרה שהוא לא.
Serial.println
שורת טקסט שהלוח שולח ל־Serial Monitor.
השאלה שמלווה את השיעור: מה הלוח צריך לזכור, על מה הוא צריך לשאול, ומי קובע את הסף?

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