# فصل ۹ — منطق و تصمیم‌های ترکیبی

<div dir="rtl">

# فصل ۹ — منطق و تصمیم‌های ترکیبی

## در این فصل چه می‌سازی

فصل قبل دستگاهت گوش پیدا کرد، ولی `if` اش فقط یک سؤال بلد بود: دکمه فشرده است یا نه؟ در این فصل تصمیم‌هایش را **ترکیبی** می‌کنی و دو دستگاه می‌سازی: اول دستگاهی با دو دکمه و سه LED که مثل دو کلید آکورد پیانو، چهار حالت مختلف را از هم تشخیص می‌دهد؛ و بعد قولِ فصل قبل — **کلید لمسی**: دکمه‌ای که با یک ضربه روشن می‌ماند و با ضربهٔ بعد خاموش می‌شود، بدون اینکه انگشتت را نگه داری. سر راه، سه کلمهٔ جادویی `and` و `or` و `not`، نردبان `elif`، متغیر وضعیت و رازی به اسم Debounce را یاد می‌گیری. مدار کامل این فصل:

![سیم‌کشی این فصل: دو دکمهٔ فشاری سوار بر شکاف وسط Breadboard روی پایه‌های ۳۲ و ۳۳، سه LED قرمز و زرد و سبز با مقاومت ۲۲۰ اهم روی پایه‌های ۲۵ و ۲۶ و ۲۷، و ردیف GND مشترک برای همه](/lesson-assets/t1-s09-logic/prompt/04-image-two-buttons-wiring.png)

آخر این فصل می‌توانی:

- نتیجهٔ ترکیب‌های `and` و `or` و `not` را بدون اجرا پیش‌بینی کنی.
- با `elif` نردبان تصمیم چندپله‌ای بسازی — و بدانی چرا شرط سخت‌گیرتر باید پلهٔ اول باشد.
- با متغیر وضعیت و مقایسهٔ گذشته و حال، «لحظهٔ فشرده‌شدن» دکمه را شکار کنی.
- توضیح بدهی Debounce چه مشکلی را حل می‌کند و راه‌حل ساده‌اش چه محدودیتی دارد.

## قبل از شروع: چک‌لیست پیش‌نیاز

قبل از ادامه، این سه تا را چک کن — اگر یکی‌شان لنگ می‌زند، اول برگرد همان فصل:

- **از فصل ۶:** متغیر و مقداردهی — متغیر وضعیت و جعبه‌های `last` و `now` امروز دقیقاً همان جعبه‌های حافظه‌اند.
- **از فصل ۷:** مدار سه LED چراغ دونده (اگر نگهش داشته‌ای، نصف سیم‌کشی امروز حاضر است!) + دونقطه و تورفتگی — امروز بلوک‌های تو در تو داریم و تورفتگی حیاتی‌تر می‌شود.
- **از فصل ۸:** دکمه با `PULL_UP`، منطق وارونه (فشرده = ۰)، `if`/`else` و مقایسهٔ `==` — کل این فصل روی این‌ها سوار است.

لوازم این فصل:

| قطعه / ابزار | تعداد | جایگزین |
|---|---|---|
| برد ESP32 DevKit + کابل USB دیتا | ۱ | مسیر آزمایشگاه (پایین همین جدول) |
| Breadboard | ۱ | — |
| دکمهٔ فشاری چهارپایه | ۲ | دکمهٔ دوپایه هم کار می‌کند |
| LED قرمز، زرد، سبز | ۳ | هر سه یک رنگ هم باشند اشکالی ندارد |
| مقاومت ۲۲۰ اهم | ۳ | ۳۳۰ اهم هم قابل قبول است |
| سیم جامپر | حدود ۱۲ | سیم تلفنی تک‌رشته |
| کامپیوتر با Thonny | ۱ | همان تنظیمات فصل ۴ |

> 🧪 **آزمایشگاه:** قطعه کم داری؟ کد هر دو پروژهٔ این فصل در آزمایشگاه آماده است — همان‌جا مرورشان کن و مدار را با جدول اتصالات همین فصل بساز. [مدار را همین‌جا امتحان کن](/lab).

## ۱. قانون پرش: دو شرط با هم

به بازی مورد علاقه‌ات فکر کن: شخصیت بازی کی می‌پرد؟ فقط وقتی که روی زمین باشی **و** دکمهٔ پرش را زده باشی. وسط هوا هزار بار هم دکمه را بزنی، خبری نیست — دو شرط باید **با هم** درست باشند. یا گوشی‌ات: کی پیام «باتری کم است» می‌دهد؟ وقتی شارژ کم باشد **یا** برنامهٔ سنگینی روشن باشد — یکی‌اش کافی است.

![قانون پرش در بازی پلتفرمر: شخصیت روی زمین به‌اضافهٔ دکمهٔ پرش مساوی پرش؛ ولی وسط هوا با همان دکمه هیچ اتفاقی نمی‌افتد](/lesson-assets/t1-s09-logic/prompt/01-image-game-logic-hook.png)

این «و» و «یا» ستون فقرات همهٔ تصمیم‌های هوشمندند. Python هم دقیقاً همین دو کلمه را دارد: `and` و `or`، به‌اضافهٔ یک سومی به اسم `not`. اول با این سه‌تا در REPL بازی می‌کنیم، بعد می‌رویم سراغ ساختن.

## ۲. آزمایشگاه REPL: and، or، not

Thonny را باز کن و مستقیم برو سراغ REPL — برای این بخش نه سیم لازم داریم نه برنامه؛ فقط سؤال و جواب زنده. فصل قبل دیدی Python به هر مقایسه یا `True` می‌گوید یا `False`. حالا این جواب‌ها را ترکیب می‌کنیم. قبل از هر Enter خودت پیش‌بینی کن:

</div>

```text
>>> True and True
True
>>> True and False
False
>>> False or True
True
>>> False or False
False
>>> not True
False
```

<div dir="rtl">

قانون‌ها را جمع کنیم — ساده‌تر از چیزی که فکرش را بکنی:

- `and` سخت‌گیر است: فقط وقتی `True` می‌دهد که **هر دو** طرف `True` باشند. مثل قانون پرش بازی — یکی‌اش لنگ بزند، کل نتیجه `False`.
- `or` آسان‌گیر است: کافی است **یکی** از دو طرف `True` باشد. فقط وقتی `False` می‌دهد که هر دو `False` باشند.
- `not` برعکس‌کننده است: `True` را `False` می‌کند و `False` را `True`. به همین کوتاهی.

![سه جدول کوچک درستی برای and و or و not: ترکیب‌های True و False و نتیجهٔ هر کدام](/lesson-assets/t1-s09-logic/prompt/02-image-truth-tables.png)

حالا جالبش اینجاست: به‌جای `True` و `False` خام، می‌توانیم مقایسه بگذاریم. ادامه بده:

</div>

```text
>>> x = 5
>>> x == 5 and x == 7
False
>>> x == 5 or x == 7
True
```

<div dir="rtl">

می‌بینی چه اتفاقی افتاد؟ Python اول هر مقایسه را به `True` یا `False` تبدیل کرد، بعد ترکیبشان کرد: `x == 5` شد `True`، `x == 7` شد `False`؛ بعد `True and False` شد `False`. دقیقاً مثل حل کردن یک عبارت ریاضی، فقط با درست و غلط. فصل قبل `button.value() == 0` هم همین‌طوری `True` یا `False` می‌شد — پس می‌توانیم دوتایش را با `and` به هم بچسبانیم: «آیا دکمهٔ ۱ فشرده است **و** دکمهٔ ۲ فشرده است؟» چند دقیقهٔ دیگر دقیقاً همین کار را می‌کنیم.

## چالش: بدون اجرا جواب بده

`True and False` چه می‌شود؟ `False or True` چطور؟ و `not False`؟

---

**جواب:** به‌ترتیب: `False` (چون and هر دو را می‌خواهد)، `True` (چون or به یکی راضی است)، و `True` (چون not برعکس می‌کند). اگر هر سه را درست گفتی، آماده‌ای برای ساختن.

## ۳. elif: نردبان تصمیم

یک ابزار کوچک دیگر لازم داریم و بعد می‌رویم سراغ ساخت. فصل قبل تصمیم‌هایمان دوراهی بود: `if` یا `else`. ولی امروز **چهار** حالت داریم: هر دو دکمه فشرده، فقط دکمهٔ ۱، فقط دکمهٔ ۲، هیچ‌کدام. با فقط `if` و `else` چه کنیم؟ می‌شود داخل بلوک `else` دوباره یک `if` گذاشت، و داخل `else` آن یکی، باز یک `if` دیگر... ولی هر بار یک پله تورفتگی اضافه می‌شود و کد مثل پلکانی کج‌وکوله به سمت راست فرار می‌کند. زشت، سخت‌خوان، پر از جای اشتباه.

Python راه تمیزتری دارد: `elif` — مخفف else + if، یعنی «وگرنه اگر». با آن، تصمیم می‌شود یک **نردبان** صاف: Python از پلهٔ اول شروع می‌کند؛ اولین شرطی که `True` باشد، بلوکش اجرا می‌شود و **بقیهٔ نردبان کلاً بی‌خیال** می‌شود. اگر هیچ شرطی درست نبود، `else` آخر اجرا می‌شود. همهٔ پله‌ها هم‌ردیف‌اند، بدون پلکان کج.

![نردبان تصمیم elif: شرط‌ها مثل پله‌های یک نردبان زیر هم آمده‌اند و توپ از بالا می‌افتد و در اولین پله‌ای که شرطش درست است می‌ایستد](/lesson-assets/t1-s09-logic/prompt/03-image-elif-ladder.png)

یک نکتهٔ مهم دربارهٔ ترتیب پله‌ها که در پروژه به آن می‌رسیم: چون Python در اولین شرطِ درست متوقف می‌شود، **شرط سخت‌گیرتر باید بالاتر باشد**. چند دقیقهٔ دیگر با چشم خودت می‌بینی چرا.

## چالش: کدام پله اجرا می‌شود؟

در یک نردبان `elif`، اگر شرط پلهٔ اول و پلهٔ سوم هر دو درست باشند، کدام اجرا می‌شود؟

---

**جواب:** فقط پلهٔ اول. Python در اولین شرطِ درست می‌ایستد و بقیهٔ نردبان را حتی نگاه هم نمی‌کند — پلهٔ سوم با اینکه شرطش درست است، هیچ‌وقت نوبتش نمی‌رسد.

## ۴. پروژهٔ ۱: دو دکمه، سه LED

دستگاه اول: دو دکمه مثل دو کلید آکورد پیانو — هر ترکیبشان یک رنگ. هر دو فشرده: زرد. فقط دکمهٔ ۱: قرمز. فقط دکمهٔ ۲: سبز. هیچ‌کدام: همه خاموش.

> ⚠️ **مواظب باش:** مثل همیشه اول کابل USB را جدا کن، بعد سیم‌کشی.

قدم‌به‌قدم (تصویر مدار در بخش «در این فصل چه می‌سازی» را جلوی چشمت بگذار):

1. سه LED را دقیقاً مثل چراغ دوندهٔ فصل ۷ ببند: قرمز ۲۵، زرد ۲۶، سبز ۲۷، هر کدام با مقاومت ۲۲۰ اهم. اگر مدارش را نگه داشته‌ای، هیچ کاری نداری!
2. دکمهٔ فصل ۸ سر جایش بماند: یک پایه به ۳۲، پایهٔ آن‌طرفِ شکاف به GND.
3. دکمهٔ دوم را کنارش بنشان — باز هم سوار بر شکاف وسط برد — یک پایه به پایهٔ ۳۳ و پایهٔ آن‌طرف به GND.
4. چک کن پایهٔ GND **هر دو** دکمه و هر سه LED وصل باشد؛ ردیف آبی GND مشترک برای همه کافی است.

جدول دقیق اتصالات:

</div>

| Component | From | To |
|---|---|---|
| Button 1 | one leg | ESP32 GPIO 32 |
| Button 1 | leg on the opposite side of the gap | ESP32 GND |
| Button 2 | one leg | ESP32 GPIO 33 |
| Button 2 | leg on the opposite side of the gap | ESP32 GND |
| Red LED | anode (long leg) | 220 ohm resistor -> ESP32 GPIO 25 |
| Yellow LED | anode (long leg) | 220 ohm resistor -> ESP32 GPIO 26 |
| Green LED | anode (long leg) | 220 ohm resistor -> ESP32 GPIO 27 |
| All LED cathodes (short legs) | breadboard GND rail | ESP32 GND |

<div dir="rtl">

حالا کد. فایل جدید. اول همهٔ قطعه‌ها را معرفی کن — پنج خط آشنا:

</div>

```python
import machine
import time

button1 = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP)
button2 = machine.Pin(33, machine.Pin.IN, machine.Pin.PULL_UP)

led_red = machine.Pin(25, machine.Pin.OUT)
led_yellow = machine.Pin(26, machine.Pin.OUT)
led_green = machine.Pin(27, machine.Pin.OUT)
```

<div dir="rtl">

در حلقهٔ اصلی، اول هر دو دکمه را می‌خوانیم و در دو متغیر می‌گذاریم — دو جعبه با اسم‌های کوتاه `b1` و `b2`. چرا؟ چون در هر دور حلقه چهار بار به این مقدارها نیاز داریم؛ یک بار می‌خوانیم و بارها استفاده می‌کنیم — تمیزتر است. و یادت هست: فشرده یعنی ۰!

بعد نردبان تصمیم. پلهٔ اول، سخت‌گیرترین شرط: هر دو فشرده — با همان `and` امروز. و بیا مثل همیشه یک خرابکاری عمدی: دونقطهٔ `elif` را جا بینداز تا قیافهٔ خطایش را ببینی:

</div>

```python
while True:
    b1 = button1.value()
    b2 = button2.value()

    if b1 == 0 and b2 == 0:
        led_red.value(0)
        led_yellow.value(1)
        led_green.value(0)
    elif b1 == 0
        led_red.value(1)
        led_yellow.value(0)
        led_green.value(0)
```

<div dir="rtl">

Run و... بوم:

</div>

```text
Traceback (most recent call last):
  File "<stdin>", line 19
SyntaxError: invalid syntax
```

<div dir="rtl">

`SyntaxError: invalid syntax` — و شمارهٔ خط، همان خط `elif` (اگر خط‌های خالی یا کامنت‌های فایل تو فرق دارد، عددش هم فرق می‌کند؛ مهم این است که خطا انگشتش را روی خط `elif` گذاشته). دیگر می‌شناسیمش: هر خطی که بلوک باز می‌کند — `while`، `if`، `else` و حالا `elif` — دونقطه می‌خواهد. دونقطه را بگذار و نردبان را کامل کن. برنامهٔ کامل:

</div>

```python
# two_buttons_logic.py — jalase 9
# do dokme, se LED: tasmim-haye tarkibi ba and va elif
# dokme 1: GPIO 32 <-> GND / dokme 2: GPIO 33 <-> GND (pull-up dakheli)
# LED-ha: ghermez GPIO 25 / zard GPIO 26 / sabz GPIO 27
# har GPIO -> 220 ohm -> LED anode, cathode -> GND
# yadet bashad: feshorde = 0, raha = 1

import machine
import time

button1 = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP)
button2 = machine.Pin(33, machine.Pin.IN, machine.Pin.PULL_UP)

led_red = machine.Pin(25, machine.Pin.OUT)
led_yellow = machine.Pin(26, machine.Pin.OUT)
led_green = machine.Pin(27, machine.Pin.OUT)

while True:
    b1 = button1.value()   # 0 yani feshorde
    b2 = button2.value()

    if b1 == 0 and b2 == 0:
        # har do feshorde -> faghat zard
        led_red.value(0)
        led_yellow.value(1)
        led_green.value(0)
    elif b1 == 0:
        # faghat dokme 1 -> faghat ghermez
        led_red.value(1)
        led_yellow.value(0)
        led_green.value(0)
    elif b2 == 0:
        # faghat dokme 2 -> faghat sabz
        led_red.value(0)
        led_yellow.value(0)
        led_green.value(1)
    else:
        # hich kodam -> hame khamoosh
        led_red.value(0)
        led_yellow.value(0)
        led_green.value(0)

    time.sleep(0.05)   # nafas-e kootah baraye board
```

<div dir="rtl">

به تورفتگی‌ها دقت کن: `if` و دو `elif` و `else` همه هم‌ردیف‌اند — پله‌های یک نردبان — و بلوک هر کدام یک پله تورفته‌تر. در هر پله هر سه LED را صریح تنظیم می‌کنیم، حتی آن‌هایی که خاموش‌اند؛ این‌طوری هیچ LED ای از دور قبل «جا نمی‌ماند».

و حالا آن نکتهٔ ترتیب: چرا `b1 == 0 and b2 == 0` پلهٔ **اول** است؟ فکر کن چه می‌شد اگر `elif b1 == 0` بالا بود: وقتی هر دو دکمه را فشار می‌دهی، `b1 == 0` درست است، Python همان‌جا قرمز را روشن می‌کند و بقیهٔ نردبان را نگاه هم نمی‌کند — زرد هیچ‌وقت نمی‌آمد! پس قانون نردبان: **شرط خاص‌تر و سخت‌گیرتر، بالاتر.**

Run بزن و هر چهار حالت را امتحان کن.

✅ **چک کن:** دکمهٔ ۱: قرمز. دکمهٔ ۲: سبز. هر دو با هم: زرد. هیچ‌کدام: خاموش. این دستگاه دارد **ترکیب** ورودی‌ها را می‌فهمد — همان کاری که دستهٔ بازی موقع زدن دو دکمهٔ همزمان می‌کند.

> 🔧 **اگر کار نکرد:** با فشار همزمان دو دکمه فقط قرمز روشن می‌شود؟ ترتیب نردبانت غلط است — شرط `and` باید پلهٔ اول باشد. دکمهٔ ۲ اصلاً کار نمی‌کند ولی دکمهٔ ۱ سالم است؟ سیم GND دکمهٔ دوم را دنبال کن یا دکمه را ۹۰ درجه بچرخان — حتماً روی شکاف وسط سوار باشد. و اگر رفتار برنامه دقیقاً برعکس انتظار است، آرام بخوان: «هر دو فشرده» یعنی `and`؛ «حداقل یکی» یعنی `or`؛ و فشرده = ۰، نه ۱.

## چالش: نردبان به‌هم‌ریخته

اگر پلهٔ `b1 == 0 and b2 == 0` را ببریم آخر نردبان (بعد از دو elif)، با فشار همزمان دو دکمه چه رنگی روشن می‌شود؟

---

**جواب:** قرمز — نه زرد! چون Python از بالا شروع می‌کند، `elif b1 == 0` زودتر درست از آب درمی‌آید و نردبان همان‌جا تمام می‌شود؛ شرط `and` آخر هیچ‌وقت نوبتش نمی‌رسد. برای همین شرط سخت‌گیرتر همیشه باید بالاتر بنشیند.

## ۵. دستگاهی که به خاطر می‌سپارد: متغیر وضعیت و لبه

و حالا قول فصل قبل: دکمه‌ای که مثل کلید لمسی چراغ‌خواب عمل کند. یک ضربه: روشن **بماند**. ضربهٔ بعد: خاموش. انگشت نگه‌داشتن ممنوع!

اول بفهمیم چرا این با کارهای قبلی فرق دارد. در چراغ فشاری فصل ۸، LED فقط آینهٔ دکمه بود: فشرده روشن، رها خاموش. ولی حالا LED باید بعد از رها شدن دکمه هم روشن **بماند**. یعنی دستگاه باید چیزی را **به خاطر بسپارد**: «الان چراغم روشن است یا خاموش؟» و ابزار به‌خاطرسپاری را از فصل ۶ داری: متغیر! جعبه‌ای می‌سازیم به اسم `lamp_state` — حافظهٔ چراغ. مقدارش یا ۰ است (خاموش) یا ۱ (روشن). به این جور متغیرها می‌گویند متغیر وضعیت یا **State**: جعبه‌ای که «الانِ» دستگاه را نگه می‌دارد.

مشکل دوم ظریف‌تر است. کی باید `lamp_state` را برعکس کنیم؟ اولین جوابی که به ذهن می‌رسد: «وقتی دکمه فشرده است». ولی صبر کن — حلقهٔ ما در هر ثانیه ده‌ها بار می‌چرخد! تا انگشتت روی دکمه است، شرط در هر دور درست است و چراغ در هر دور برعکس می‌شود: روشن، خاموش، روشن، خاموش... دیوانه‌خانه! ما «فشرده **بودن**» را نمی‌خواهیم؛ «لحظهٔ فشرده **شدن**» را می‌خواهیم — همان یک لحظه‌ای که دکمه از رها به فشرده تغییر می‌کند. به این لحظهٔ تغییر می‌گویند **Edge** — لبه.

چطور یک «لحظهٔ تغییر» را با کد بگیریم؟ با مقایسهٔ گذشته و حال! دو جعبه: `last` یعنی خواندنِ دور قبل، `now` یعنی خواندنِ همین الان. اگر `now == 0 and last == 1` — الان فشرده ولی دور قبل رها — یعنی دقیقاً همین الان انگشت آمد پایین. این همان لبه است! و ببین `and` امروزمان چه به‌موقع به کار آمد.

## ۶. پروژهٔ ۲: کلید لمسی

سیم‌کشی همین است که هست — فقط دکمهٔ ۱ و LED قرمز را لازم داریم. فایل جدید. نسخهٔ اول را بنویسیم — که یک اشکال پنهانی دارد و قرار است خودت پیدایش کنی:

</div>

```python
import machine
import time

button = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP)
led = machine.Pin(25, machine.Pin.OUT)

lamp_state = 0
last = 1

while True:
    now = button.value()

    if now == 0 and last == 1:
        if lamp_state == 0:
            lamp_state = 1
        else:
            lamp_state = 0
        led.value(lamp_state)

    time.sleep(0.02)
```

<div dir="rtl">

خط‌به‌خط: قبل از حلقه، `lamp_state = 0` یعنی چراغ اول خاموش است، و `last = 1` یعنی فرض می‌کنیم قبل از شروع، دکمه رها بوده — منطقی است. داخل حلقه، اول دکمه را می‌خوانیم و در `now` می‌گذاریم. بعد سؤال طلایی: آیا همین الان فشرده شد؟ اگر بله، یک `if`/`else` کوچکِ تو در تو `lamp_state` را برعکس می‌کند — صفر بود یک، یک بود صفر — و همان را به LED می‌دهیم.

> 🔧 **اگر کار نکرد:** در بلوک‌های تو در تو، `IndentationError: unexpected indent` گرفتی؟ بلوک داخلی باید دقیقاً یک پله جلوتر از بلوک بیرونی باشد — از بیرونی‌ترین بلوک شروع کن و پله‌پله چک کن. در Thonny فقط از Tab استفاده کن، نه Space دستی.

اجرا کن... ضربه می‌زنی: روشن! ضربهٔ بعد... اِ؟ گاهی خاموش می‌شود، گاهی همان روشن می‌ماند، گاهی با یک ضربه دو بار عوض می‌شود. یک چیزی لنگ می‌زند. قبل از ادامه، خودت به کد نگاه کن — پیدایش می‌کنی؟

نگاه کن به حلقه: `now` را هر دور می‌خوانیم، ولی `last`... `last` را **هیچ‌وقت عوض نمی‌کنیم!** از اول تا ابد ۱ می‌ماند. پس تا وقتی انگشتت پایین است، در هر دور `now == 0 and last == 1` درست است و چراغ مدام برعکس می‌شود — همان دیوانه‌خانه، فقط این بار مخفی‌تر. اسم این بلا «مقدار کهنه» است: جعبه‌ای که یادت رفته به‌روزش کنی، بی‌صدا بهت دروغ می‌گوید. این یکی از رایج‌ترین باگ‌های تمام دوران برنامه‌نویسی‌ات خواهد بود — و حالا قیافه‌اش را دیده‌ای.

راه‌حل: آخر هر دور، حال را بکن گذشته. یک خط `last = now`، هم‌ردیف `if` بیرونی، درست قبل از sleep آخر. دوباره اجرا کن... ضربه: روشن، و روشن **می‌ماند**. ضربه: خاموش. حتی نگه می‌داری: فقط یک بار حساب می‌شود، چون بعد از دور اول `last` هم ۰ شده و دیگر لبه‌ای در کار نیست. عالی!

ولی هنوز یک شیطنت کوچک مانده. اگر زیاد امتحان کنی، هر چند ده ضربه یک بار، با یک ضربه چراغ دو بار عوض می‌شود — انگار دو ضربه زده باشی. تقصیر تو نیست؛ تقصیر فیزیک است! داخل دکمه دو تکه فلز به هم می‌خورند و مثل هر برخوردی، چند میلی‌ثانیه **می‌لرزند** — وصل، قطع، وصل، قطع — قبل از اینکه محکم بچسبند. حلقهٔ ما آن‌قدر سریع است که این لرزش را چند «فشار جدا» می‌بیند! به این پدیده می‌گویند **Bounce** — پرش — و به حلش: **Debounce**. راه‌حل سادهٔ ما: همان لحظه که لبه را گرفتیم و چراغ را عوض کردیم، `time.sleep(0.2)` — یک پلک‌زدن صبر، تا لرزش تمام شود.

برنامهٔ کامل نهایی با هر دو اصلاح:

</div>

```python
# toggle_lamp.py — jalase 9
# kelid-e lamsi: yek bar feshar = roshan bemanad, feshar-e badi = khamoosh
# state variable + edge detection (last / now) + debounce sade
# dokme: GPIO 32 <-> GND (pull-up dakheli) / LED: GPIO 25 -> 220 ohm -> GND
# yadet bashad: feshorde = 0, raha = 1

import machine
import time

button = machine.Pin(32, machine.Pin.IN, machine.Pin.PULL_UP)
led = machine.Pin(25, machine.Pin.OUT)

lamp_state = 0   # hafeze-ye cheragh: 0 = khamoosh, 1 = roshan
last = 1         # khandan-e ghabli-ye dokme (aval raha ast)

while True:
    now = button.value()   # khandan-e alan

    if now == 0 and last == 1:
        # hamin alan feshorde shod! (lahze-ye feshar = edge)
        if lamp_state == 0:
            lamp_state = 1
        else:
            lamp_state = 0
        led.value(lamp_state)
        time.sleep(0.2)    # debounce sade: larzesh-e kontakt ra rad kon

    last = now             # in khat ra faramoosh nakon! (dars-e "meghdar-e kohne")
    time.sleep(0.02)
```

<div dir="rtl">

✅ **چک کن:** ضربه = روشن می‌ماند؛ ضربهٔ بعد = خاموش؛ نگه‌داشتن = فقط یک بار حساب می‌شود؛ و پرش دوتایی هم دیگر تقریباً هیچ‌وقت پیش نمی‌آید.

> 🔧 **اگر کار نکرد:** هنوز گاهی یک ضربه دو بار حساب می‌شود؟ دکمه‌ات کهنه و پرلرزش است — Debounce را کمی بیشتر کن، مثلاً `time.sleep(0.3)`. و اگر رفتار کلاً شانسی است، اول از همه چک کن خط `last = now` سر جایش است — هم‌ردیف `if` بیرونی، آخر حلقه.

و بگذار مثل همیشه صادق باشیم: این ساده‌ترین Debounce دنیاست و محدودیت دارد — در آن یک‌پنجم ثانیه، برنامه کر است؛ اگر کسی فوق‌العاده سریع دو ضربه بزند، دومی گم می‌شود. برای کلید چراغ‌خواب هیچ اهمیتی ندارد، ولی برای دکمهٔ یک بازی رکوردی چرا. راه‌های حرفه‌ای‌تر هم هست که بعداً در دوره می‌بینیم — فعلاً همین ساده و صادقانه کارمان را عالی راه می‌اندازد.

اگر خواستی این کلید بدون کامپیوتر هم کار کند، مثل همیشه با اسم `main.py` روی برد ذخیره‌اش کن — یک کلید لمسی واقعی برای اتاقت!

## چالش: چرا بدون last = now کلید دیوانه می‌شود؟

با کلمات خودت توضیح بده — این یک خط کوچک چه چیزی را نجات می‌دهد؟

---

**جواب:** بدون آن، `last` برای همیشه ۱ می‌ماند. پس تا وقتی انگشتت روی دکمه است، شرط `now == 0 and last == 1` در **هر دور** حلقه درست است و چراغ ده‌ها بار در ثانیه برعکس می‌شود. `last = now` گذشته را هر دور به‌روز می‌کند تا «لحظهٔ فشرده شدن» فقط یک بار دیده شود — جعبهٔ به‌روزنشده (مقدار کهنه) بی‌صدا دروغ می‌گوید.

## واژه‌های تازه این فصل

| کلمه | تلفظ به حروف فارسی | یعنی چه |
|---|---|---|
| And | اَند | «و»؛ فقط وقتی True که هر دو طرف True باشند |
| Or | اُر | «یا»؛ True اگر حداقل یک طرف True باشد |
| Not | نات | «برعکس»؛ True را False می‌کند و برعکس |
| Elif | اِلیف | «وگرنه اگر»؛ پلهٔ میانی نردبان تصمیم |
| State | استِیت | وضعیت؛ متغیری که حافظهٔ «الانِ» دستگاه است |
| Toggle | تاگِل | با هر فرمان، بین دو حالت جابه‌جا شدن |
| Edge | اِج | لبه؛ لحظهٔ تغییر سیگنال از ۱ به ۰ (یا برعکس) |
| Debounce | دیباؤنس | نادیده‌گرفتن لرزش چندمیلی‌ثانیه‌ای کنتاکت دکمه |

## تمرین‌ها

اول چک‌لیست پایان فصل: جواب همهٔ ترکیب‌های پایهٔ `and`/`or`/`not` را بدون REPL درست می‌گویی؛ دستگاه دو دکمه و سه LED هر چهار حالت را درست نشان می‌دهد و می‌دانی چرا شرط `and` پلهٔ اول است؛ و کلید لمسی با یک ضربه روشن می‌ماند و می‌توانی بگویی `last = now` چه می‌کند و اگر نباشد چه می‌شود. اگر همه بله است، برو سراغ تمرین‌ها:

- **تمرین اجباری:** کلید لمسی را طوری تغییر بده که به‌جای روشن/خاموشِ ساده، بین دو LED جابه‌جا شود: هر ضربه، قرمز و سبز جایشان را عوض کنند (قرمز روشن بود، خاموش شود و سبز روشن شود؛ ضربهٔ بعد برعکس). اسم فایل: `two_color_toggle.py`. راهنمایی: همان `lamp_state`، فقط در بلوک تغییر، دو `led.value` بنویس.
- **تمرین ستاره‌دار ⭐:** «قفل مخفی» بساز: چراغ سبز فقط وقتی روشن شود که **اول** دکمهٔ ۱ را نگه داشته باشی **و بعد** (همان‌طور که دکمهٔ ۱ پایین است) لحظهٔ فشرده‌شدن دکمهٔ ۲ اتفاق بیفتد — یعنی ترکیب «فشرده بودنِ» یکی با «لبهٔ» دیگری: `button1.value() == 0 and now2 == 0 and last2 == 1`. هر ترتیب دیگری، چراغ قرمزِ خطا را یک ثانیه روشن کند.

## در فصل بعد

دستگاه‌های ما نور دارند، تصمیم دارند، حافظه دارند — ولی در این نُه فصل حتی یک بوق هم نزده‌اند؛ فصل ۱۰ قطعه‌ای به اسم Buzzer می‌آید و بردت نُت و ملودی می‌زند.

</div>

---
Source: https://yaadestan.com/courses/airo/lessons/t1/s09-logic (یادستان, Yaadestan)
