תקצירהשיעור בהקשר של physical computing
בשיעור הזה הלוח הפסיק להיות רק רשימת פקודות. בעזרת משתנים, השוואות ותנאים הוא יכול להחזיק מידע ולהחליט לפיו. זה החלק האמצעי בכל מערכת של פיזיקל קומפיוטינג, בין החישה לבין הפעולה. בשיעור הבא נחבר אליו את החלק הראשון: קלט מהעולם.
- חומרההצ׳יפ שעל הלוח הוא מיקרו־בקר: מעבד, זיכרון וכניסות ויציאות בשבב אחד. אחרי הצריבה הלוח עובד לבד, בלי המחשב. מפת הפינים (pinout) מראה מה כל פין יודע לעשות: מצב דיגיטלי, עמעום (~) או קריאה אנלוגית.
- פעולהלנורית יש כיוון, ונגד של 220 אום מגביל את הזרם ומגן עליה ועל הלוח. הרמזור ב־Wokwi הראה איך רצף פקודות ותזמון הופכים להתנהגות.
- מבנה
setupו־loopעובדים כמו המלכודת: דורכים פעם אחת, ומחכים שוב ושוב. - זיכרוןמשתנה הוא תא בזיכרון עם שם, סוג וערך:
int,float,char,boolאוString. משתנה שמוכרז מחוץ ל־loopזוכר את הערך שלו מסיבוב לסיבוב. - החלטההשוואה היא שאלה שהתשובה עליה היא
trueאוfalse.&&,||ו־!מחברים כמה תנאים, ו־ifו־elseפותחים שער לפי התשובה. הסף שבו טמפרטורה רציפה הופכת ל״חם״ הוא החלטה עיצובית. - דיבאגאין לנו דרך לראות מה קורה בתוך הלוח.
Serial Monitorמראה מה הוא עושה ברגע זה, ולכן הוא הכלי הראשון כשמשהו לא עובד. - למידהגלילה ברשת היא מצב חיפוש, לא מצב למידה. וכדי שצ׳אט יכתוב קוד שאתם יכולים לקרוא, ספרו לו קודם מה כבר למדתם.
השאלה של השיעור: מה הלוח צריך לזכור, על מה הוא צריך לשאול, ומי קובע את הסף?
על הסיכום: מבוסס על תמלול השיעור השלישי. לא הספקנו את כל החומר שתוכנן: את else if ואת הקלט נעשה בשיעור הבא. בסוף הסיכום יש הצצה קצרה אליהם, כי הם עוזרים במטלה. בסעיף על תנאים ובהצצה, דוגמאות הקוד הן סימולציות: מד חום שאפשר להזיז, הקוד שרץ, ו־Serial Monitor שמדפיס. שווה לשחק איתן. ובסעיף על משתנים יש כלי קטן שמזהה איזה סוג משתנה מתאים לכל ערך. גם כאן יש מסגרות של קריאה לתיעוד, שממתינות לסרטונים ולתמונות שלכם.
01 · לפני שמתחילים: מצב חיפוש
השיעור נפתח בשיחה על רשתות חברתיות. חלק מכם מחפשים השראה ורפרנסים בפינטרסט ובאינסטגרם, ויש שם גם ידע אמיתי: יוצרים שמראים תהליך, ולא רק תוצאה. הטענה בכיתה הייתה שהבעיה היא לא כמה ידע יש שם, וגם לא מה הרמה שלו. הבעיה היא המצב שבו אנחנו פוגשים אותו.
קופסת סקינר
החוקר B. F. Skinner בנה, משנות השלושים, כלובים לניסויי התנהגות שנקראים היום ״קופסת סקינר״. בכלוב יש ידית. בגרסה אחת כל לחיצה על הידית מוציאה אוכל: החולדה לומדת מהר, לוחצת כשהיא רעבה, אוכלת וממשיכה בחייה. בגרסה אחרת הידית מוציאה אוכל רק לפעמים, בלי סדר צפוי. כאן קורה משהו מפתיע: החולדה לוחצת הרבה יותר, ובהתמדה שקשה לעצור. הלחיצה עצמה הופכת למה שהיא עושה.
עכשיו חשבו על הגלילה. סרטון טוב הוא אוכל. סרטון לא טוב, מעבירים הלאה, ואולי הבא יהיה טוב. זה בדיוק התגמול הלא צפוי של הכלוב השני. זה מצב של חיפוש, וזה לא מצב שבו לומדים: מקבלים פיסות מנותקות מההקשר, ורואים מישהו עושה משהו מגניב מבחוץ. כמו הקופסה השחורה מהשיעור הראשון, מקבלים אולי מתכון, אבל נשארים בחוץ.
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 לא מקורי. הוא לא יוצר באיטליה, אבל הוא העתק של התצורה המקורית. הרכיבים לרוב פחות איכותיים, ולפעמים יש בו פחות הגנות. היתרון הוא שהוא זול הרבה יותר, ומבחינת השימוש שלנו הוא כמעט אחד לאחד.
| סימון | מה זה | למה זה חשוב לנו |
|---|---|---|
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 · סביבת העבודה
האזור הגדול עם השורות הממוספרות הוא המקום שבו כותבים טקסט. כשכותבים בו טקסט כמו שהוא מצפה לו, הוא צובע אותו: פונקציה בצבע אחד, הערה בצבע אחר, משתנה בשלישי. הצבעים הם הסימן הראשון שמשהו כתוב נכון.
| כפתור | מה הוא עושה |
|---|---|
| Verify ✓ | בודק את הקוד, גם בלי לוח מחובר. אם הכול תקין, למטה תופיע הודעה מרגיעה. אם לא, תופיע שגיאה, ואפשר להתחיל לתקן. |
| Upload → | פותח את השער ללוח, מעביר אליו את הקוד וסוגר. עובד רק כשמחובר הלוח הנכון ונבחרה הכניסה הנכונה. בלוח שלנו, כל צריבה מוחקת לגמרי את הקוד הקודם. |
| Serial Monitor | הזכוכית המגדלת בצד ימין למעלה. נפתח חלון שבו הלוח והמחשב מדברים, שנקרא גם קונסולה. הוא מציג רק מה שהקוד שלנו אומר ללוח להדפיס. |
| Library Manager | הלשונית של הספריות, בסרגל שבצד. |
ספריות: מתורגמן
ספרייה היא קוד שמישהו אחר כבר כתב, ושאפשר להוסיף לקוד שלנו. חלק מהספריות כתבו אנשי ארדואינו, וחלק כתבו אנשים מכל העולם. חברה שמייצרת חיישן תכתוב לרוב ספרייה בשבילו. בעוד כמה שיעורים נחבר מנוע סרוו. אפשר לשלוט בו גם בלי ספרייה, אבל זה מסובך הרבה יותר מלד. אז נכניס ספרייה שיודעת, ורק נלמד לדבר איתה. השורה הראשונה מכניסה את הספרייה, ומאותו רגע יש לנו פונקציות שלא היו קודם:
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: לדרוך ולחכות
1void setup() {
2 // רץ פעם אחת: דורכים את המלכודת
3}
4
5void loop() {
6 // רץ שוב ושוב: מחכים
7}
setup רץ פעם אחת, ברגע שהלוח מקבל מתח. אחרי זה הלוח
צריך לדעת כל מה שנחוץ כדי להריץ את הלולאה. loop רץ שוב
ושוב, כל עוד יש מתח, ולא חוזרים ל־setup.
ומה קורה כשמנתקים את החשמל באמצע? הלוח שוכח הכול. כשהחשמל חוזר, הוא מתחיל שוב מ־setup, ואחריו את loop מההתחלה. הדבר היחיד שנשאר הוא הקוד עצמו.
שתי מילים על הדקדוק. setup ו־loop הן
פונקציות: קפסולות שבתוכן יש יכולת. המילה
void לפני השם אומרת שהפונקציה לא מחזירה כלום. זוכרים את
ה־return מהשיעור הראשון, את הפונקציה שמחזירה משהו? כאן
אין return: הפונקציה פשוט פועלת. ארדואינו מחייב את שתי
הפונקציות האלה, ולכן לא צריך לקרוא להן, הן פשוט רצות. וכל מה שבין
הסוגריים המסולסלים { } הוא העולם של הפונקציה: הוא מתחיל
בסוגר הפותח ונגמר בסוגר הסוגר.
07 · תרגיל: רמזור בסימולטור
את הרמזור בנינו ב־Wokwi, סימולטור ארדואינו שרץ בדפדפן. למעשה זו אמולציה: הוא באמת מריץ את קוד הארדואינו. אם משהו קורס, הוא יקרוס גם שם. אם משהו עובד, הוא יעבוד שם. הקישור לתרגיל נמצא גם בקבוצה.
המטריצה (breadboard)
- כל חמישה חורים באותה שורה מחוברים ביניהם, כאילו הלחמתם אותם. מה שנכנס לשורה מחובר לכל מה שבה.
-
לאורך הצדדים יש שני פסים, פלוס ומינוס, שמחוברים לכל אורכם. (בחלק
מהמטריצות הגדולות הפס מפוצל באמצע. אם משהו לא נדלק, בדקו גם את
זה.) מחברים את
5Vלפס הפלוס ואתGNDלפס המינוס, וכך כל הפס הופך למעין מפצל. אפשר גם לא לכבד את הסימון, אבל כדאי, כי אחרת זה מבלבל.
הנורית והנגד
(ובעברית: ללד קוראים נורית.) לנורית יש כיוון. הרגל הארוכה היא הפלוס, והיא מקבלת את המתח מהפין. הרגל הקצרה היא המינוס, ומשם ממשיכים לנגד ולאדמה. נורית שמחוברת הפוך לא תידלק.
הנגד מוסיף התנגדות למעגל, ובכך מגביל את הזרם שעובר בנורית. בלי נגד, הנורית מושכת כמה זרם שהיא יכולה, ועלולה להישרף ולקחת איתה את הפין. כלל האצבע לנורית: נגד של 220 אום. לא משנה אם הוא לפני הנורית או אחריה, העיקר שהוא באותו מסלול. לרכיבים אחרים, בדרך כלל כתוב באיזה נגד להשתמש.
הקוד שכתבנו יחד
בסימולטור, הירוקה מחוברת לפין 9, הצהובה לפין 10 והאדומה לפין 11:
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 הנכון.
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, עד שתכתבו בעצמכם שורה שמשנה אותו, או עד שהלוח יופעל מחדש.
שמות
השם הוא בשבילכם. הלוח לא קורא את myNumber ומבין שמחכים
למספר. הוא קורא רק את הערך. לכן תנו שמות שיעזרו לכם להבין מה קורה:
אם הנוסחה עוסקת בגילאים, קראו למשתנה age, ותמיד תדעו מה
תפקידו. עדיף לא לסיים שם במספר, כמו myNumber2, אלא לתאר
במילים.
סוגי משתנים
| סוג | מה הוא מחזיק | דוגמה מהעולם |
|---|---|---|
int |
מספר שלם (integer), בלוח
שלנו בין -32,768 ל־32,767
|
מונה כניסות: אין חצי אדם. |
float |
מספר עשרוני (floating point). את 1 הוא רואה כ־1.0
|
קליבר, או טמפרטורה עם ספרה אחרי הנקודה. |
char |
תו אחד (character): אות, ספרה, סימן שאלה, פסיק. בין מרכאות בודדות | ציון: 'A'. |
bool |
שני מצבים בלבד: true או false
|
כן או לא, HIGH או LOW. |
String |
מחרוזת: הרבה תווים בשורה. בין מרכאות כפולות | הטקסט שיופיע על מסך קטן בתפריט של מכשיר. |
נסו בעצמכם: הקלידו ערך, ותראו איזה סוג משתנה מתאים לו ואיך מכריזים עליו בקוד.
בוליאני והמלכודת. במלכודת, הלולאה מחכה לתשובה
בוליאנית אחת: האם התולעת זזה. אבל תולעת יכולה לזוז קצת. אז מה זה
״זזה״? אנחנו מגדירים את הטווח שנחשב false ואת הטווח
שנחשב true. תולעת שזזה, אבל לא מספיק כדי להזיז את ההדק,
היא עדיין false. המנגנון רואה תנועה רק מעבר לסף.
שם של בוליאני כדאי לנסח כשאלה, כמו
isOn, ״האם דולק״. כך ברור מה המשמעות של
true. על אותה מלכודת אפשר לשאול ״האם התולעת זזה?״ או
״האם המצב סטטי?״, ותשובה true תגיד דבר הפוך בכל אחת
מהן.
09 · חשבון והשוואה
כשיש מידע במשתנים, אפשר להתחיל לחשב איתו:
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: מחזור של ארבעה מצבים. כמו רמזור.
שווה אחד, שווה שניים
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 |
בפועל, כך תשתמשו בזה: תכתבו תנאי, ותצמידו לו עוד תנאי.
1int students = 9;
2bool isIndustrialDesign = true;
3
4if (students >= 8 && isIndustrialDesign) {
5 // פותחים את הקורס
6}
-
&&ו־||נכתבים תמיד בזוגות. סימן אחד בודד,&או|, עושה משהו אחר לגמרי. -
את הקו הישר
|מקלידים במקלדת באנגלית עםShiftועם הלוכסן ההפוך\. - אפשר לחבר כמה תנאים שרוצים. אבל בתנאי ארוך מאוד, קל לטעות בתחביר.
11 · תנאים: if ו־else
בסעיף הזה כל דוגמת קוד היא סימולציה קטנה. מד החום מחליף את החיישן שעוד לא חיברנו, הקוד רץ פעם בשנייה, ומה שהוא מדפיס מופיע למטה, ב־Serial Monitor.
1int temperature = 25; // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6 if (temperature > 30) {7 Serial.println("חם מאוד!");8 }9 delay(1000); // סיבוב בכל שנייה10}
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: ואם לא?
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}
if עונה רק על המקרה שהתנאי נכון. else נותן
תשובה גם למקרה ההפוך. תמיד יקרה בדיוק אחד מהשניים: הזיזו את המד,
ותראו שבכל סיבוב מודפסת שורה, אף פעם לא שתיים ואף פעם לא אפס.
טווח
ואם ״נעים״ הוא רק בין 22 ל־28? בקוד אי אפשר לכתוב 22 עד 28 כמו במתמטיקה. אז מנסחים במילים: המספר גדול מ־22, וגם קטן מ־28. רק מספר שבתוך הטווח עונה ״כן״ על שתי השאלות. שימו לב ש־22 ו־28 עצמם מחוץ לטווח, כי השאלה היא ״גדול מ־״ ולא ״גדול או שווה ל־״:
1int temperature = 25; // המד משנה את הערך23void setup() { Serial.begin(9600); }45void loop() {6 if (temperature > 22 && temperature < 28) {7 Serial.println("מזג אוויר נעים");8 }9 delay(1000); // סיבוב בכל שנייה10}
איפה שמים את הספים
אם כל התפקיד של מכונה הוא לחוות דעה על הטמפרטורה, כדאי להגדיר את הספים כמשתנים בראש הקוד, עם שמות ברורים. כך מי שמשתמש בה יכול לשנות מה נחשב נעים ומה קר, בלי לחפש בתוך התנאים. ואת התנאים עצמם כותבים בתוך הפונקציה.
12 · מה לא הספקנו: הצצה
את שני החלקים האלה נעשה בשיעור הבא. הנה הצצה, כי הם עוזרים במטלה.
else if: כמה מצבים
כשיש יותר משני מצבים, משתמשים ב־else if: אם זה, אחרת אם
זה, אחרת אם זה, כמה שרוצים. בתרשים זרימה זה נראה כמו עץ. חשבו על
תפריט של מענה קולי: אם לחצת 1, עוברים לשירות לקוחות. אם לחצת 2,
לתמיכה הטכנית. ובכל ענף יש שאלות נוספות.
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}
הלוח בודק מלמעלה למטה, ועוצר בתנאי הראשון שנכון. הזיזו את המד ועקבו
אחרי תוויות התשובה שליד התנאים: אחרי התנאי הראשון שעונה
true, האחרים כבר לא נבדקים. לכן הסדר קובע: אם היינו
בודקים קודם ״מעל 10״, ביום של 35 מעלות הלוח היה כותב ״קריר״, כי 35
באמת גדול מ־10. וכך גם טמפרטורה רציפה הופכת לארבע קטגוריות. איפה
חותכים? זו החלטה עיצובית.
קלט: הלוח מתחיל להקשיב
עד עכשיו הלוח רק דיבר: digitalWrite כותבת מצב לפין.
כפתור הוא מתג, שסוגר מעגל או פותח אותו. כשהכפתור מחובר בטור עם
הנורית, כמו בחלק החובה של המטלה, המעגל עצמו הוא ההיגיון, והלוח לא
יודע על זה כלום. כשהכפתור מחובר לפין, הלוח
קורא אותו בעזרת digitalRead, ומחליט
בעצמו מה לעשות.
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ובחזרה. - כתבו את ההיגיון לפני הקוד. לדוגמה, השלד הזה כתוב רק בהערות. את השורות עצמן תכתבו אתם:
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.