מתג אור — if, ריטוט מגעים וזיכרון מצב

מה נלמד כאן

• משפט if על כל צורותיו
• אופרטורים לוגיים והשוואה
• שתי שיטות שליטה: רגעית ומתחלפת
• ריטוט מגעים ואיך מתגברים עליו

שתי דרכים לכבות אור

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

ובשיעור הזה נגלה ששתי הפעולות האלה עובדות אחרת לגמרי:

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

נבנה את שתיהן.

הידע שצריך

1. משפט if

if הוא משפט תנאי — הוא בודק אם ביטוי נכון, ואם כן מריץ קוד. זה הבסיס לכל היגיון בתוכנית.

ענף יחיד

if (תנאי) {
  // רץ אם התנאי נכון
}

אם התנאי לא נכון — פשוט מדלגים.

שני ענפים

if (תנאי) {
  // אם נכון
} else {
  // אם לא
}

ריבוי ענפים

if (תנאי1) {
  // ...
} else if (תנאי2) {
  // ...
} else {
  // אם אף אחד לא התקיים
}

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

2. תנאים

אופרטורי השוואה:

⚠️ = מול ==. סימן אחד משווה ערך, שניים בודקים שוויון. if (x = 5) תמיד יהיה נכון — כי זו השמה, לא שאלה. זו אחת הטעויות הוותיקות בתכנות.

אופרטורים לוגיים:

3. שתי שיטות השליטה

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

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

4. ריטוט מגעים — הבעיה שלא רואים

וכאן נכנסת בעיה שהיא פיזיקלית, לא תכנותית.

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

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

הפתרון

if (digitalRead(buttonPin) == LOW) {    // זוהתה לחיצה
  delay(200);                           // ממתינים שהריטוט ייגמר
  while (digitalRead(buttonPin) == LOW); // ממתינים לשחרור
  // רק עכשיו מבצעים
}

שלוש שורות, שלוש משימות:

1. זיהוי — הלחצן נלחץ
2. delay(200) — נותנים לריטוט להסתיים
3. while — ממתינים שהמשתמש ישחרר. בלי זה, החזקה ממושכת תיספר כלחיצות רבות

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

ניסוי 1 — שליטה רגעית

המטרה: לוחצים — הנורית דולקת. משחררים — כבית.

רשימת רכיבים

התרשים החשמלי

החיבור

הקוד

#define ledPin 5
#define buttonPin 16

void setup() {
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {           // לחוץ (זוכרים? Pull-Up)
    digitalWrite(ledPin, HIGH);
  } else if (buttonState == HIGH) {
    digitalWrite(ledPin, LOW);
  }
}

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

ניסוי 2 — שליטה מתחלפת

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

הקוד

#define ledPin 5
#define buttonPin 16

bool light_state = false;     // המצב הנוכחי: false = כבוי

void setup() {
  pinMode(ledPin, OUTPUT);
  pinMode(buttonPin, INPUT);
}

void loop() {
  if (digitalRead(buttonPin) == 0) {
    delay(200);                            // המתנה לסיום הריטוט
    while (digitalRead(buttonPin) == 0);   // המתנה לשחרור
    light_state = !light_state;            // היפוך המצב
  }

  if (light_state) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

שתי נקודות מפתח:

bool light_state — הרגע הוספתם לתוכנית זיכרון. עד עכשיו כל תוכנית הגיבה רק למה שקורה כרגע; כאן היא זוכרת מה קרה קודם.

light_state = !light_state — סימן הקריאה הוא "לא". המשתנה מקבל את ההפך מעצמו: true הופך ל-false ולהפך. שורה אחת שמחליפה מצב.

נסו בעצמכם

• הסירו את delay(200) ואת ה-while מניסוי 2 והריצו. זה התרגיל החשוב בשיעור — תראו את הריטוט במו עיניכם.
• שנו את ההשהיה ל-50 ואז ל-20. איפה זה מתחיל להישבר?
• הוסיפו לחצן שני: אחד מדליק, אחד מכבה. צריך טיפול בריטוט?
• שלבו עם שיעור 18: לחיצה מחליפה בין אור רץ לכיבוי מלא.
• מה קורה אם תכתבו if (light_state = true) במקום ==? נסו והסבירו.