Logic Gates (Logic gate များ)
A1.2.3 - Describe the purpose and use of logic gates. A1.2.4 - Construct and analyse truth tables (including Karnaugh maps and algebraic simplification). A1.2.5 - Construct logic diagrams.
မြန်မာလို: A1.2.3: logic gate (digital circuit တွေကို တည်ဆောက်တဲ့ အခြေခံ အစိတ်အပိုင်း) တွေရဲ့ ရည်ရွယ်ချက်နဲ့ အသုံးပြုပုံကို ဖော်ပြရှင်းပြနိုင်ရပါမယ်။ A1.2.4: Karnaugh map (Boolean expression ကို ရိုးရှင်းအောင် လုပ်တဲ့ ဇယားကွက်) တွေနဲ့ algebra နည်းနဲ့ ရိုးရှင်းအောင် လုပ်တာ အပါအဝင် truth table (input အားလုံးနဲ့ output ကို ပြတဲ့ ဇယား) တွေကို ကိုယ်တိုင် တည်ဆောက်နိုင်ပြီး ခွဲခြမ်းစိတ်ဖြာနိုင်ရပါမယ်။ A1.2.5: logic diagram (logic gate တွေနဲ့ ဆွဲထားတဲ့ circuit ပုံ) တွေကို ကိုယ်တိုင် တည်ဆောက်နိုင်ရပါမယ်။
အဓိက အယူအဆများ
အခြေခံ gate ခုနစ်မျိုး (A1.2.3)
Logic gate ဆိုတာ electronic အစိတ်အပိုင်း တစ်ခုပါ။ Binary (0 နဲ့ 1 ကိုပဲ သုံးတဲ့ ဂဏန်းစနစ်) input (ဝင်လာတဲ့ တန်ဖိုး) တစ်ခု ဒါမှမဟုတ် တစ်ခုထက်ပို (0 ဒါမှမဟုတ် 1) ကို ယူပြီး ပုံသေ စည်းမျဉ်း တစ်ခုအတိုင်း binary output (ထွက်လာတဲ့ တန်ဖိုး) တစ်ခုတည်းကို ထုတ်ပေးပါတယ်။ ဂဏန်းတွက်စက်ကနေ supercomputer (အလွန် စွမ်းအားမြင့်တဲ့ ကွန်ပျူတာ) အထိ digital circuit (0 နဲ့ 1 နဲ့ အလုပ်လုပ်တဲ့ လျှပ်စစ် ပတ်လမ်း) တိုင်းကို ဒီ gate ခုနစ်မျိုးကို ပေါင်းစပ်ပြီး တည်ဆောက်ထားပါတယ်။
AND Gate (input နှစ်ခုလုံး 1 မှ 1 ထွက်တဲ့ gate)
AND gate က input နှစ်ခုလုံး 1 ဖြစ်မှသာ 1 ကို ထုတ်ပေးပါတယ်။ Series (တစ်ခုနောက် တစ်ခု တန်းဆက်ထားခြင်း) ဆက်ထားတဲ့ switch (ခလုတ်) နှစ်ခုလို့ မြင်ကြည့်ပါ: current (လျှပ်စီးကြောင်း) စီးဖို့ switch နှစ်ခုလုံး ON ဖြစ်နေ (ဆက်ထား) ရပါမယ်။
Boolean expression (AND၊ OR၊ NOT တို့နဲ့ ရေးထားတဲ့ logic ပုံသေနည်း): Q = A AND B ဒါမှမဟုတ် Q = A · B
| A | B | A AND B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
OR Gate (input တစ်ခုခု 1 ဆိုရင် 1 ထွက်တဲ့ gate)
OR gate က input အနည်းဆုံး တစ်ခု 1 ဖြစ်ရင် 1 ကို ထုတ်ပေးပါတယ်။ Parallel (ဘေးချင်းယှဉ်ပြီး ပြိုင်တူ ဆက်ထားခြင်း) ဆက်ထားတဲ့ switch နှစ်ခုလို့ မြင်ကြည့်ပါ: ဘယ်တစ်ခု ON ဖြစ်ဖြစ် current စီးပါတယ်။
Boolean expression: Q = A OR B ဒါမှမဟုတ် Q = A + B
| A | B | A OR B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 1 |
NOT Gate (Inverter၊ input ကို ပြောင်းပြန်လှန်တဲ့ gate)
NOT gate မှာ input တစ်ခုတည်း ရှိပြီး အဲဒီ input ကို ပြောင်းပြန်လှန်ပါတယ်။ Input 0 က 1 ဖြစ်သွားပြီး input 1 က 0 ဖြစ်သွားပါတယ်။ Input တစ်ခုတည်း ရှိတဲ့ gate က NOT တစ်ခုပဲ ရှိပါတယ်။
Boolean expression: Q = NOT A၊ Q = ¬A ဒါမှမဟုတ် Q = A'
| A | NOT A |
|---|---|
| 0 | 1 |
| 1 | 0 |
NAND Gate (AND ရဲ့ ပြောင်းပြန် gate)
NAND gate က AND gate နောက်မှာ NOT တစ်ခု ဆက်ထားတာပါ: input နှစ်ခုလုံး 1 ဖြစ်မှသာ 0 ကို ထုတ်ပေးပါတယ်။ တခြား အခြေအနေ အားလုံးမှာ 1 ကို ထုတ်ပေးပါတယ်။
Boolean expression: Q = NOT (A AND B) ဒါမှမဟုတ် Q = ¬(A · B)
| A | B | A NAND B |
|---|---|---|
| 0 | 0 | 1 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
NOR Gate (OR ရဲ့ ပြောင်းပြန် gate)
NOR gate က OR gate နောက်မှာ NOT တစ်ခု ဆက်ထားတာပါ: input နှစ်ခုလုံး 0 ဖြစ်မှသာ 1 ကို ထုတ်ပေးပါတယ်။
Boolean expression: Q = NOT (A OR B) ဒါမှမဟုတ် Q = ¬(A + B)
| A | B | A NOR B |
|---|---|---|
| 0 | 0 | 1 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 0 |
XOR Gate (Exclusive OR၊ input တစ်ခုတည်း 1 ဆိုမှ 1 ထွက်တဲ့ gate)
XOR gate က input တွေ မတူတဲ့အခါ 1 ကို ထုတ်ပေးပါတယ်။ နှစ်ခုလုံး တူနေရင် 0 ကို ထုတ်ပေးပါတယ်။
Boolean expression: Q = A XOR B ဒါမှမဟုတ် Q = A ⊕ B
| A | B | A XOR B |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 1 |
| 1 | 0 | 1 |
| 1 | 1 | 0 |
XNOR Gate (Exclusive NOR၊ input နှစ်ခု တူရင် 1 ထွက်တဲ့ gate)
XNOR gate က XOR ရဲ့ ပြောင်းပြန်ပါ: input နှစ်ခုလုံး တူတဲ့အခါ 1 ကို ထုတ်ပေးပါတယ်။
Boolean expression: Q = NOT (A XOR B) ဒါမှမဟုတ် Q = ¬(A ⊕ B)
| A | B | A XNOR B |
|---|---|---|
| 0 | 0 | 1 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |
Introduction to AND, OR, NOT gates - how they work and their truth tables.
ကွန်ပျူတာထဲက logic gate များ (A1.2.3)
ကွန်ပျူတာထဲမှာ bit (0 ဒါမှမဟုတ် 1 ဖြစ်တဲ့ binary ဂဏန်း တစ်လုံး) တစ်ခုစီက ဝါယာကြိုး တစ်ကြောင်းပေါ်က voltage (ဗို့အား) တစ်ခုပါ: voltage နိမ့်ရင် 0 ကို၊ voltage မြင့်ရင် 1 ကို ကိုယ်စားပြုပါတယ်။ Gate တစ်ခုက transistor (input voltage တွေက ဖွင့်လိုက် ပိတ်လိုက် လုပ်ပေးတဲ့ အလွန်သေးငယ်တဲ့ switch လေးတွေ) တွေနဲ့ ဖွဲ့ထားတဲ့ circuit အသေးလေး တစ်ခုဖြစ်ပြီး သူ့ output ကလည်း 0 ဒါမှမဟုတ် 1 ပဲ ပြန်ဖြစ်ပါတယ်။ ဒါကြောင့် gate တစ်ခုရဲ့ output ကို နောက် gate တစ်ခုရဲ့ input အဖြစ် ဆက်ပေးလို့ရပြီး gate တွေကို ပေါင်းစပ်ကာ ပိုကြီးတဲ့ circuit တွေ တည်ဆောက်နိုင်ပါတယ်။ Circuit က voltage အဆင့် နှစ်ဆင့်ကိုပဲ ခွဲခြားသိဖို့ လိုပါတယ်။ Voltage နည်းနည်း လွဲသွားရင်တောင် ဒါကို စိတ်ချရစွာ ခွဲခြားနိုင်ပါတယ်။ ဒါက ကွန်ပျူတာတွေ binary နဲ့ အလုပ်လုပ်ရတဲ့ အကြောင်းရင်း တစ်ခုပါ။
Processor (CPU၊ ကွန်ပျူတာရဲ့ အဓိက processor) နဲ့ memory (မှတ်ဉာဏ်) ထဲက အလုပ်တွေကို gate တွေ ပေါင်းစပ်ထားတဲ့ circuit တွေက လုပ်ပေးပါတယ်:
- ပေါင်းခြင်း။ Bit နှစ်ခုကို ပေါင်းတဲ့အခါ XOR gate က sum bit (ပေါင်းလဒ် bit) ကို ပေးပြီး AND gate က carry (နောက် column ကို ဆောင်ရတဲ့ ဂဏန်း) ကို ပေးပါတယ်။ နှစ်ခုပေါင်းရင် half adder (bit နှစ်ခုကို ပေါင်းပေးတဲ့ circuit) ဖြစ်ပါတယ်။ Half adder နှစ်ခုနဲ့ OR gate တစ်ခုကို ပေါင်းရင် full adder ဖြစ်ပါတယ်။ Full adder က အရင် ပေါင်းခဲ့တဲ့ column (ဂဏန်းနေရာ) ကနေ လာတဲ့ carry ကိုပါ ထည့်ယူပါတယ်။ Full adder တွေကို carry တွေကနေတစ်ဆင့် တန်းဆက်ထားလို့ ALU (တွက်ချက်ပြီး နှိုင်းယှဉ်ပေးတဲ့ CPU အပိုင်း) က binary ဂဏန်း အပြည့်အစုံတွေကို ပေါင်းနိုင်ပါတယ် (Half Adder နဲ့ Full Adder ကို ကြည့်ပါ)။
- နှိုင်းယှဉ်ခြင်း။ XNOR gate က သူ့ input bit နှစ်ခု တူရင် 1 ကို ထုတ်ပေးပါတယ်။ ဂဏန်း နှစ်ခုထဲက bit အတွဲ တစ်တွဲချင်းကို နှိုင်းယှဉ်ပြီး ရလဒ်တွေကို AND နဲ့ ပေါင်းလိုက်ရင် ဂဏန်း နှစ်ခု တူမတူကို ALU က သိနိုင်ပါတယ်။
- ဆုံးဖြတ်ခြင်း။ Java မှာ
&&၊||နဲ့!(Python မှာand၊orနဲ့not) က condition (မှန်လား မှားလား စစ်တဲ့ အခြေအနေ) တွေကို ပေါင်းစပ်သလိုပဲ AND၊ OR နဲ့ NOT က hardware ထဲမှာ condition တွေကို ပေါင်းစပ်ပေးပါတယ်။ နေ့စဉ် သုံးတဲ့ စက်ပစ္စည်းတွေထဲက ထိန်းချုပ်ရေး circuit တွေကို ဒီလို တည်ဆောက်ထားပါတယ်၊ ဥပမာ 4 ထဲက quiz buzzer circuit လိုမျိုးပါ။ - Instruction (processor လုပ်ဆောင်ရမယ့် ညွှန်ကြားချက်) တွေကို decode (ဘယ် instruction လဲ ခွဲခြားဖတ်ခြင်း) လုပ်ခြင်း။ Control unit (CPU ထဲက ညွှန်ကြားချက် ထိန်းချုပ်ရေး အပိုင်း) က input တချို့မှာ NOT gate တပ်ထားတဲ့ AND gate တွေကို သုံးပါတယ်။ အဲဒီ gate တွေက bit pattern (0 နဲ့ 1 တွေ စီထားပုံ) တစ်ခုတည်းအတွက်ပဲ 1 ကို ထုတ်ပေးပါတယ်။ ဥပမာ
A AND (NOT B) AND Cက pattern 101 အတွက်ပဲ 1 ဖြစ်တာကြောင့် အဲဒီ code ရှိတဲ့ instruction အတွက် circuit ကို ဖွင့်ပေးနိုင်ပါတယ်။ - Bit တွေကို သိမ်းခြင်း။ တစ်ခုရဲ့ output က နောက်တစ်ခုရဲ့ input ထဲ အပြန်အလှန် ပြန်ဝင်နေတဲ့ gate နှစ်ခုက 0 ဒါမှမဟုတ် 1 ကို မပြောင်းမချင်း ထိန်းထားနိုင်ပါတယ်။ Register (CPU ထဲက အမြန်ဆုံး သိမ်းဆည်းရာ) တွေနဲ့ cache (CPU နဲ့ RAM ကြားက မြန်တဲ့ memory) memory ကို ဒီလို circuit တွေနဲ့ တည်ဆောက်ထားပါတယ် (Flip-Flops ကို ကြည့်ပါ)။
Boolean Algebra စည်းမျဉ်းများ (A1.2.5)
သာမန် algebra (အက္ခရာသင်္ချာ) က ဂဏန်း expression တွေကို ရိုးရှင်းအောင် လုပ်ပေးသလိုပဲ Boolean algebra (1 နဲ့ 0 ကို သုံးတဲ့ logic သင်္ချာ) က logic expression တွေကို ရိုးရှင်းအောင် လုပ်ဖို့ စည်းမျဉ်း အစုတစ်ခု ပေးပါတယ်။ အဓိက ကွာခြားချက်က variable (A၊ B လို တန်ဖိုး တစ်ခုကို ကိုယ်စားပြုတဲ့ စာလုံး) တွေက 0 ဒါမှမဟုတ် 1 ပဲ ဖြစ်နိုင်တာပါ။
ဥပဒေများ အကျဉ်းချုပ်
| ဥပဒေ | AND ပုံစံ | OR ပုံစံ |
|---|---|---|
| Identity (တန်ဖိုး မပြောင်းစေတဲ့ ဥပဒေ) | A · 1 = A | A + 0 = A |
| Null (ရလဒ်ကို ပုံသေ ဖြစ်စေတဲ့ ဥပဒေ) | A · 0 = 0 | A + 1 = 1 |
| Complement (ပြောင်းပြန်နဲ့ တွဲတဲ့ ဥပဒေ) | A · ¬A = 0 | A + ¬A = 1 |
| Idempotent (ကိုယ်နဲ့ ကိုယ် တွဲရင် မပြောင်းတဲ့ ဥပဒေ) | A · A = A | A + A = A |
| Commutative (အစဉ် ဖလှယ်လို့ရတဲ့ ဥပဒေ) | A · B = B · A | A + B = B + A |
| Associative (ကွင်း ပြောင်းစုလို့ရတဲ့ ဥပဒေ) | (A · B) · C = A · (B · C) | (A + B) + C = A + (B + C) |
| Distributive (ကွင်းကို ဖြန့်လို့ရတဲ့ ဥပဒေ) | A · (B + C) = A·B + A·C | A + (B · C) = (A+B) · (A+C) |
De Morgan’s Theorems (De Morgan ရဲ့ သီအိုရမ်များ)
ဒီ theorem နှစ်ခုက expression တွေကို ရိုးရှင်းအောင် လုပ်ဖို့နဲ့ gate အမျိုးအစား တစ်ခုကနေ တစ်ခုကို ပြောင်းဖို့ မရှိမဖြစ် လိုအပ်ပါတယ်:
- Theorem 1:
¬(A · B) = ¬A + ¬B: AND ရဲ့ complement (ပြောင်းပြန် တန်ဖိုး) က complement တွေရဲ့ OR နဲ့ ညီပါတယ် - Theorem 2:
¬(A + B) = ¬A · ¬B: OR ရဲ့ complement က complement တွေရဲ့ AND နဲ့ ညီပါတယ်
ရိုးရိုးလေး ပြောရရင် “break the bar, change the sign” (NOT ကို ပြတဲ့ အပေါ်မျဉ်းကို ခွဲရင် သင်္ကေတကို ပြောင်းပါ) ပါ။ Expression တစ်ခုလုံးကို negate (NOT နဲ့ ပြောင်းပြန်လှန်) လုပ်တဲ့အခါ variable တစ်ခုချင်းစီကို သီးခြား negate လုပ်ပြီး AND ကို OR နဲ့ (ဒါမှမဟုတ် OR ကို AND နဲ့) လဲပါတယ်။
Karnaugh Maps (Boolean expression ကို ရိုးရှင်းအောင် လုပ်တဲ့ ဇယားကွက်၊ A1.2.4)
Karnaugh map (K-map) ဆိုတာ Boolean expression တွေကို ပုံနဲ့ မြင်ရအောင် ရိုးရှင်းအောင် လုပ်တဲ့ နည်းလမ်း တစ်ခုပါ။ Truth table ရဲ့ output တွေကို ဘေးချင်းကပ် အကွက်တွေ variable တစ်ခုတည်းပဲ ကွာအောင် ဇယားကွက်ထဲမှာ စီထားလို့ ရိုးရှင်းစေနိုင်တဲ့ အုပ်စုတွေကို အလွယ်တကူ မြင်နိုင်ပါတယ်။
Variable 2 ခုပါတဲ့ K-map
Variable နှစ်ခု A နဲ့ B အတွက် K-map က 2x2 ဇယားကွက် ဖြစ်ပါတယ်:
B=0 B=1
┌──────┬──────┐
A=0 │ m0 │ m1 │
├──────┼──────┤
A=1 │ m2 │ m3 │
└──────┴──────┘
အကွက် တစ်ကွက်စီမှာ truth table ကနေ ရတဲ့ output တန်ဖိုး (0 ဒါမှမဟုတ် 1) ကို ထည့်ပါတယ်။ Minterm (truth table ရဲ့ row တစ်ခုကို ကိုယ်စားပြုတဲ့ AND term) တွေက: m0 = ¬A·¬B၊ m1 = ¬A·B၊ m2 = A·¬B၊ m3 = A·B။
Variable 3 ခုပါတဲ့ K-map
Variable သုံးခု A, B, C အတွက် K-map က 2x4 ဇယားကွက် ဖြစ်ပါတယ်။ ဘေးချင်းကပ် အကွက်တွေ variable တစ်ခုပဲ ကွာအောင် column တွေကို Gray code (ဘေးချင်းကပ် တန်ဖိုးတွေမှာ bit တစ်ခုပဲ ကွာအောင် စီတဲ့ အစဉ်) အစဉ်နဲ့ စီထားပါတယ်:
BC=00 BC=01 BC=11 BC=10
┌──────┬──────┬──────┬──────┐
A=0 │ m0 │ m1 │ m3 │ m2 │
├──────┼──────┼──────┼──────┤
A=1 │ m4 │ m5 │ m7 │ m6 │
└──────┴──────┴──────┴──────┘
Column အစဉ်ကို သတိထားပါ: 00, 01, 11, 10 ပါ (00, 01, 10, 11 မဟုတ်ပါဘူး)။ ဒီ Gray code အစဉ်က ဘေးချင်းကပ် အကွက်တွေမှာ variable တစ်ခုပဲ ကွာအောင် လုပ်ပေးပါတယ်။
အုပ်စုဖွဲ့ စည်းမျဉ်းများ
- 1 တွေကိုပဲ အုပ်စုဖွဲ့ပါ: 1 ပါတဲ့ အကွက်တွေကို အုပ်စုလိုက် ဝိုင်းပါ
- အုပ်စု အရွယ်အစားက 2 ရဲ့ ထပ်ကိန်း ဖြစ်ရပါမယ်: အကွက် 1၊ 2၊ 4 ဒါမှမဟုတ် 8 ကွက် အုပ်စုတွေ
- အုပ်စုတွေက စတုဂံပုံ ဖြစ်ရပါမယ်: အလျားလိုက် ဒါမှမဟုတ် ဒေါင်လိုက် စတုဂံ
- အုပ်စုတွေက အစွန်းကနေ ပတ်ပြီး ဆက်နိုင်ပါတယ်: ဘယ်ဘက် အစွန်းက ညာဘက် အစွန်းနဲ့ ဘေးချင်းကပ်ပါတယ်၊ အပေါ်နဲ့ အောက်လည်း ဒီအတိုင်းပါ
- အုပ်စုတွေကို ဖြစ်နိုင်သမျှ ကြီးအောင် ဖွဲ့ပါ: အုပ်စု ကြီးလေ expression ပိုရိုးရှင်းလေ ဖြစ်ပါတယ်
- 1 တိုင်းက အနည်းဆုံး အုပ်စု တစ်ခုထဲမှာ ပါရပါမယ်: အုပ်စုတွေ ထပ်နေလို့ ရပါတယ်
ရိုးရှင်းသွားတဲ့ expression ကို ဖတ်ခြင်း
အုပ်စု တစ်ခုစီအတွက် အုပ်စုထဲက အကွက် အားလုံးမှာ ဘယ် variable တွေ မပြောင်းဘဲ (constant) ရှိနေလဲ ရှာပါ:
- Variable တစ်ခုက အုပ်စုထဲက အကွက်တိုင်းမှာ 1 ဖြစ်နေရင် အဲဒီ variable ကို ဒီအတိုင်း ထည့်ပါ (ဥပမာ
A) - Variable တစ်ခုက အုပ်စုထဲက အကွက်တိုင်းမှာ 0 ဖြစ်နေရင် NOT တပ်ပြီး ထည့်ပါ (ဥပမာ
¬A) - Variable တစ်ခုက အုပ်စုထဲမှာ ပြောင်းနေရင် အဲဒါ ပျက်ပြယ်သွားလို့ ချန်ထားပါ
နောက်ဆုံး expression က အုပ်စု တစ်ခုစီက ရတဲ့ term တွေ အားလုံးကို OR နဲ့ ပေါင်းထားတာပါ။
How to use K-maps to simplify Boolean expressions and minimise logic circuits.
Operator Precedence (ဘယ် operator ကို အရင် တွက်မလဲ ဆိုတဲ့ စည်းမျဉ်း၊ A1.2.5)
ဂဏန်းသင်္ချာမှာ ပေါင်းခြင်းထက် မြှောက်ခြင်းကို အရင် တွက်သလိုပဲ ပေါင်းစပ်ထားတဲ့ Boolean expression တွေကို တွက်တဲ့အခါ operator (တန်ဖိုးတွေကို တွက်ချက်တဲ့ သင်္ကေတ) တွေက တိကျတဲ့ precedence (အရင် တွက်ရမယ့် အစဉ်) တစ်ခုကို လိုက်နာပါတယ်:
- NOT ကို အရင်ဆုံး တွက်ပါတယ် (precedence အမြင့်ဆုံး)
- AND ကို နောက်မှာ တွက်ပါတယ်
- OR ကို နောက်ဆုံးမှ တွက်ပါတယ် (precedence အနိမ့်ဆုံး)
ဥပမာ A AND B OR NOT A AND C ဆိုတဲ့ expression ကို (A AND B) OR ((NOT A) AND C) အဖြစ် တွက်ပါတယ်၊ A AND (B OR NOT A) AND C အဖြစ် မဟုတ်ပါဘူး။ ဒီ ဖတ်ပုံ နှစ်မျိုးက မတူတဲ့ truth table တွေ ပေးပါတယ်: မှန်တဲ့ ဖတ်ပုံက row ရှစ်ခုထဲက လေးခုမှာ 1 ထုတ်ပေးပြီး မှားတဲ့ ဖတ်ပုံက တစ်ခုမှာပဲ 1 ထုတ်ပေးပါတယ်။
Boolean logic မှာ operator precedence က မှားလွယ်တဲ့ နေရာ တစ်ခုပါ။ NOT ကို အမြဲ အရင် တွက်ပါ၊ ပြီးမှ AND၊ ပြီးမှ OR ကို တွက်ပါ။ မသေချာရင် အစဉ်ကို ရှင်းရှင်းလင်းလင်း မြင်ရအောင် ကွင်းတွေ ထည့်ပါ။
အဆင့်ဆင့် ဥပမာ: A=1, B=1, C=0 ဖြစ်တဲ့အခါ A AND B OR NOT A AND C ကို တွက်ပါ:
- NOT A = NOT 1 = 0
- A AND B = 1 AND 1 = 1 (OR မတိုင်ခင် AND)
- NOT A AND C = 0 AND 0 = 0 (OR မတိုင်ခင် AND)
- (A AND B) OR (NOT A AND C) = 1 OR 0 = 1
အဖြစ်များတဲ့ အမှားက precedence ကို မလိုက်ဘဲ ဘယ်ကနေ ညာကို တွက်သွားတာပါ: A AND B = 1၊ ပြီးတော့ 1 OR NOT A = 1 OR 0 = 1၊ ပြီးတော့ 1 AND C = 1 AND 0 = 0။ ဘယ်ကနေ ညာကို တွက်ရင် မှန်တဲ့ အဖြေ 1 အစား 0 ရလို့ precedence ကို လျစ်လျူရှုရင် ရလဒ် ပြောင်းသွားပါတယ်။
Logic Diagrams (logic gate တွေနဲ့ ဆွဲထားတဲ့ circuit ပုံများ၊ A1.2.5)
Logic diagram (circuit diagram) က input တွေကို output တွေအဖြစ် ပြောင်းဖို့ gate တွေ ဘယ်လို ချိတ်ဆက်ထားလဲ ပြပါတယ်။ ဒီ diagram တွေကို ဖတ်တတ်၊ ဆွဲတတ်တာက IB Computer Science (နိုင်ငံတကာ ကျောင်းတွေမှာ သင်တဲ့ ကွန်ပျူတာသိပ္ပံ သင်ရိုး) မှာ အဓိက ကျွမ်းကျင်မှု တစ်ခုပါ။
Expression ကနေ diagram ဆွဲခြင်း
Q = (A + B) · ¬C ကနေ diagram ဆွဲဖို့:
သင်္ကေတတွေ အောက်က gate နာမည်တွေက ဖတ်ရလွယ်အောင် ထည့်ပေးထားတာပါ၊ logic diagram အစစ်မှာ သင်္ကေတတွေပဲ ပါပါတယ်။
အဆင့်များ:
- အပြင်ဆုံး operation (လုပ်ဆောင်ချက်) ကို ရှာပါ (ဒီမှာတော့ AND): ဒါက output မတိုင်ခင် နောက်ဆုံး gate ပါ
- အထဲဘက်ကို ဆက်သွားပါ: AND gate က input နှစ်ခု ယူပါတယ်:
A + Bရဲ့ ရလဒ် (OR gate) နဲ့¬C(NOT gate) - Input ဝါယာကြိုး A နဲ့ B ကို OR gate နဲ့ ဆက်ပြီး C ကို NOT gate နဲ့ ဆက်ပါ
Diagram ကနေ expression ရေးခြင်း
Input တွေကနေ output ဆီ ဖတ်သွားပြီး gate တစ်ခုစီမှာ operation ကို ရေးပါ:
- Input ဝါယာကြိုး တစ်ကြောင်းစီကို အဲဒီ ကြိုး ပထမဆုံး ဝင်တဲ့ gate အထိ လိုက်ကြည့်ပါ
- အဲဒီ gate ရဲ့ operation ကို သူ့ input တွေနဲ့ ရေးပါ
- Output ကို ရောက်တဲ့အထိ ဆက်လုပ်ပါ
ထပ်ဆောင်း လေ့လာရန်: NAND Universality (NAND gate တစ်မျိုးတည်းနဲ့ gate အားလုံး တည်ဆောက်နိုင်ခြင်း)
ဒီအပိုင်းက IB syllabus (IB သင်ရိုး) ထက် ကျော်လွန်တဲ့ အကြောင်းအရာ ဖြစ်လို့ IB က အမှတ်ပေး စစ်ဆေးတာ မရှိပါဘူး။
NAND gate တွေကိုပဲ သုံးပြီး တခြား ဘယ် gate ကိုမဆို တည်ဆောက်နိုင်လို့ NAND gate ကို universal gate (gate အားလုံးကို တည်ဆောက်ပေးနိုင်တဲ့ gate) လို့ ခေါ်ပါတယ်:
- NAND နဲ့ NOT လုပ်ခြင်း: NAND gate ရဲ့ input နှစ်ခုလုံးကို signal (လျှပ်စစ် အချက်ပြ) တစ်ခုတည်းနဲ့ ဆက်ပါ:
¬A = A NAND A - NAND နဲ့ AND လုပ်ခြင်း: NAND gate တစ်ခုရဲ့ output ကို NOT အဖြစ် ဆက်ထားတဲ့ ဒုတိယ NAND gate ထဲ ထည့်ပါ:
A AND B = NOT(A NAND B)၊ NAND gate နှစ်ခု လိုပါတယ် - NAND နဲ့ OR လုပ်ခြင်း: De Morgan’s theorem အရ
A + B = ¬(¬A · ¬B)ဖြစ်ပါတယ်၊ NAND gate သုံးခု လိုပါတယ် (နှစ်ခုက ပြောင်းပြန်လှန်ဖို့၊ တစ်ခုက ပေါင်းဖို့)
Gate အမျိုးအစား တစ်မျိုးတည်း သုံးရင် chip ထုတ်လုပ်ရတာ ပိုရိုးရှင်းလို့ ဒီ ဂုဏ်သတ္တိက chip ထုတ်လုပ်ရေးမှာ အရေးပါပါတယ်။ လက်တွေ့ processor တွေကို NAND နဲ့ NOR gate တွေနဲ့ အဓိက တည်ဆောက်လေ့ ရှိပါတယ်။
ထပ်ဆောင်း လေ့လာရန်: Flip-Flops (bit တစ်ခုကို မှတ်ထားနိုင်တဲ့ circuit များ)
ဒီအပိုင်းက IB syllabus ထက် ကျော်လွန်တဲ့ အကြောင်းအရာ ဖြစ်လို့ IB က အမှတ်ပေး စစ်ဆေးတာ မရှိပါဘူး။
အခုထိ ကြည့်ခဲ့တဲ့ circuit တွေ အားလုံးက combinational circuit တွေပါ: output က လက်ရှိ input တွေပေါ်မှာပဲ မူတည်ပါတယ်။ Flip-flop ဆိုတာ bit တစ်ခုကို “မှတ်ထား” နိုင်တဲ့ sequential circuit (output က ယခင် အခြေအနေပေါ်မှာပါ မူတည်တဲ့ circuit) တစ်ခုပါ။
အရိုးရှင်းဆုံး အမျိုးအစားက SR (Set-Reset) flip-flop ပါ (တိတိကျကျ ပြောရရင် SR latch ပါ)။ Cross-coupled (တစ်ခုရဲ့ output ကို နောက်တစ်ခုရဲ့ input ထဲ အပြန်အလှန် ဆက်ထားတဲ့) NOR gate နှစ်ခုနဲ့ တည်ဆောက်ထားပါတယ်:
ပုံထဲက S နဲ့ R က Set နဲ့ Reset input တွေ ဖြစ်ပြီး Q နဲ့ Q’ က gate နှစ်ခုရဲ့ output တွေပါ။
Gate တစ်ခုစီရဲ့ output က တခြား gate ရဲ့ input ထဲကို ပြန်ဝင်ပါတယ်။ NOR gate ရဲ့ input မှာ 1 ရှိရင် အဲဒီ gate ရဲ့ output က မဖြစ်မနေ 0 ဖြစ်ပါတယ်။ ဒါကြောင့် S=1 က Q’ ကို 0 ဖြစ်စေပြီး အဲဒါက Q ကို 1 ဖြစ်ခွင့် ပေးပါတယ်။
- S=1, R=0 လို့ ထားရင် 1 ကို သိမ်းပါတယ် (Q=1)
- S=0, R=1 လို့ ထားရင် 0 ကို သိမ်းပါတယ် (Q=0)
- S=0, R=0 လို့ ထားရင် ယခင် တန်ဖိုးကို ဆက်ထိန်းထားပါတယ်: circuit က “မှတ်ထား” ပါတယ်
Flip-flop တွေက CPU ထဲက register တွေနဲ့ SRAM (cache မှာ သုံးတဲ့ static RAM) တို့ကို တည်ဆောက်တဲ့ အခြေခံ အစိတ်အပိုင်းတွေပါ။ ဒါက logic gate တွေနဲ့ primary memory (ပင်မ မှတ်ဉာဏ်၊ CPU က တိုက်ရိုက် ယူသုံးတဲ့ memory) ကြားက ဆက်စပ်မှုပါ။
ကြည့်ရန်: ဗီဒီယို အရင်းအမြစ်များ
How logic gates combine to perform binary addition - from transistors to arithmetic.
TED-Ed animation showing how transistors switch on and off to process binary data.
How the ALU uses logic gates to perform arithmetic and logical operations.
From individual transistors to logic gates to a full CPU - the building blocks explained.
How billions of transistors are etched onto chips using extreme ultraviolet light.
ကိုယ်တိုင် စမ်းကြည့်ပါ: binary & logic playground (binary နဲ့ logic ကို လက်တွေ့ စမ်းလို့ရတဲ့ နေရာ) မှာ bit အစစ်တွေကို ပြောင်းကြည့်နိုင်တယ်၊ ဂဏန်းစနစ် ပြောင်းတာကို ကိုယ့်ရဲ့ အကောင်းဆုံး streak (ဆက်တိုက် မှန်ခဲ့တဲ့ အကြိမ်ရေ) နဲ့ ပြိုင်ပြီး လေ့ကျင့်နိုင်တယ်၊ truth table တွေကို တကယ် အလုပ်လုပ်နေတဲ့ circuit နဲ့ တိုက်စစ်နိုင်ပါတယ်။
အဆင့်ဆင့် ရှင်းပြထားတဲ့ ဥပမာများ
ဥပမာ 1: Truth table တစ်ခု တည်ဆောက်ခြင်း
ပြဿနာ: Q = (A AND C) OR (B NOR C) အတွက် truth table ကို Construct (ကိုယ်တိုင် တည်ဆောက်ပါ) လုပ်ပါ။
အဆင့် 1: Input ပေါင်းစပ်ပုံ အားလုံးကို စာရင်းပြုစုပါ။ Input 3 ခု ရှိရင် row 2^3 = 8 ခု ရှိပါတယ်။
အဆင့် 2: ကြားခံ တန်ဖိုးတွေကို column တစ်ခုချင်း တွက်ပါ။ A AND C က A နဲ့ C နှစ်ခုလုံး 1 ဖြစ်မှသာ 1 ဖြစ်ပါတယ်။ B NOR C က B နဲ့ C နှစ်ခုလုံး 0 ဖြစ်မှသာ 1 ဖြစ်ပါတယ်။
| A | B | C | A AND C | B NOR C | (A AND C) OR (B NOR C) |
|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 | 1 |
| 0 | 0 | 1 | 0 | 0 | 0 |
| 0 | 1 | 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 0 | 0 | 0 |
| 1 | 0 | 0 | 0 | 1 | 1 |
| 1 | 0 | 1 | 1 | 0 | 1 |
| 1 | 1 | 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 | 0 | 1 |
အဓိက သင်ခန်းစာ: ပေါင်းစပ်ထားတဲ့ expression တွေကို ကြားခံ column တွေအဖြစ် ခွဲပါ။ အတွင်းဘက် operation တွေ (AND, NOR) ကို အရင် တွက်ပြီးမှ အပြင်ဘက် operation (OR) နဲ့ ပေါင်းပါ။
ဥပမာ 2: K-map နဲ့ ရိုးရှင်းအောင် လုပ်ခြင်း
ပြဿနာ: Q = ¬A·¬B·C + ¬A·B·C + A·¬B·C + A·B·C ကို ရိုးရှင်းအောင် လုပ်ပါ။
အဆင့် 1: ဘယ် minterm တွေက output 1 ကို ထုတ်ပေးလဲ ရှာပါ။ ဒီ expression မှာ Q=1 ဖြစ်တဲ့ minterm လေးခု ရှိပါတယ်:
| A | B | C | Q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 0 | 1 | 1 |
| 0 | 1 | 0 | 0 |
| 0 | 1 | 1 | 1 |
| 1 | 0 | 0 | 0 |
| 1 | 0 | 1 | 1 |
| 1 | 1 | 0 | 0 |
| 1 | 1 | 1 | 1 |
အဆင့် 2: Variable 3 ခုပါတဲ့ K-map ကို ဖြည့်ပါ:
BC=00 BC=01 BC=11 BC=10
┌──────┬──────┬──────┬──────┐
A=0 │ 0 │ 1 │ 1 │ 0 │
├──────┼──────┼──────┼──────┤
A=1 │ 0 │ 1 │ 1 │ 0 │
└──────┴──────┴──────┴──────┘
အဆင့် 3: 1 တွေကို အုပ်စုဖွဲ့ပါ။ 1 လေးခုလုံးက 4 ကွက် အုပ်စု တစ်ခုတည်း ဖြစ်ပါတယ် (row နှစ်ခုလုံးမှာ ရှိတဲ့ အလယ် column နှစ်ခု)။
အဆင့် 4: ရိုးရှင်းသွားတဲ့ expression ကို ဖတ်ပါ။ ဒီ အုပ်စုထဲမှာ:
- A က ပြောင်းနေပါတယ် (0 နဲ့ 1): A ကို ဖယ်ပါ
- B က ပြောင်းနေပါတယ် (0 နဲ့ 1): B ကို ဖယ်ပါ
- C က အကွက် အားလုံးမှာ 1 ဖြစ်နေပါတယ်: C ကို ထားပါ
ရလဒ်: Q = C
Term လေးခုပါတဲ့ မူလ expression က variable တစ်ခုတည်း ဖြစ်အောင် ရိုးရှင်းသွားပါတယ်။ ဒါက သဘာဝကျပါတယ်: A နဲ့ B ဘယ်လိုပဲ ဖြစ်ဖြစ် C က 1 ဖြစ်တိုင်း Q က 1 ဖြစ်ပါတယ်။
ဥပမာ 3: Logic diagram ဆွဲခြင်း
ပြဿနာ: Q = (A + B) · ¬C အတွက် logic diagram ကို ဆွဲပါ။
အဆင့် 1: အပြင်ဆုံး operation ကို ရှာပါ။ ဒီ expression က sub-expression (expression အပိုင်းငယ်) နှစ်ခု ဖြစ်တဲ့ (A + B) နဲ့ ¬C ကို AND လုပ်ထားတာပါ။
အဆင့် 2: Sub-expression တစ်ခုစီကို ခွဲကြည့်ပါ:
A + Bအတွက် input A နဲ့ B ပါတဲ့ OR gate တစ်ခု လိုပါတယ်¬Cအတွက် input C ပါတဲ့ NOT gate တစ်ခု လိုပါတယ်
အဆင့် 3: အဲဒါတွေကို AND gate နဲ့ ဆက်ပါ:
OR gate နဲ့ NOT gate က input တွေကို အရင် တွက်ပြီး AND gate က သူတို့ရဲ့ output တွေကို ပေါင်းပါတယ်။
ပြန်ဖတ်ကြည့်ခြင်း: Input A နဲ့ B က OR gate ထဲ ဝင်ပါတယ်။ Input C က NOT gate ထဲ ဝင်ပါတယ်။ OR gate နဲ့ NOT gate ရဲ့ output တွေက AND gate ထဲ ဝင်ပြီး Q ကို ထုတ်ပေးပါတယ်။ ဒါက Q = (A + B) · ¬C ဖြစ်ကြောင်း အတည်ပြုပါတယ်။
ဥပမာ 4: ပြဿနာ ဖော်ပြချက်ကနေ truth table ဆီ
ပြဿနာ: အတန်းထဲက quiz ပြိုင်ပွဲ တစ်ခုမှာ အသင်း သုံးသင်း ရှိပြီး အသင်း တစ်သင်းစီမှာ buzzer (နှိပ်ရင် အသံမြည်တဲ့ ခလုတ်) တစ်ခုစီ ရှိပါတယ်။ မေးခွန်း ဖတ်ပြီးတဲ့နောက် အသင်း တစ်သင်းတည်းက buzzer ကို နှိပ်ခဲ့ရင် အဖြေပေးဖို့ မီး L လင်းရပါမယ်။ အသင်း နှစ်သင်း ဒါမှမဟုတ် သုံးသင်းက တစ်ချိန်တည်း နှိပ်ရင် မီး မလင်းဘဲ မေးခွန်းကို ပြန်ဖတ်ပါတယ်။ L အတွက် truth table ကို Construct လုပ်ပြီး Boolean expression တစ်ခု ရေးပါ။
အဆင့် 1: Input တွေနဲ့ output ကို နာမည်ပေးပြီး တစ်ခုစီအတွက် 1 က ဘာကို ဆိုလိုလဲ ပြောပါ။
A,B,C: 1 က အဲဒီ အသင်းက buzzer ကို နှိပ်ခဲ့တယ်လို့ ဆိုလိုပြီး 0 က မနှိပ်ခဲ့ဘူးလို့ ဆိုလိုပါတယ်။L(output): 1 က အဖြေပေးဖို့ မီး လင်းနေတယ်လို့ ဆိုလိုပြီး 0 က မီး ပိတ်နေတယ်လို့ ဆိုလိုပါတယ်။
အဆင့် 2: ဖော်ပြချက်က ဘယ်လို စည်းမျဉ်းမျိုး ပေးထားလဲ ဆုံးဖြတ်ပါ။ ဒီ စည်းမျဉ်းက ဘယ် input တွေ 1 ဖြစ်လဲ ဆိုတာပေါ် မမူတည်ဘဲ input ဘယ်နှစ်ခု 1 ဖြစ်လဲ ဆိုတာပေါ် မူတည်ပါတယ်။ ဒါကြောင့် ဇယားကို အမြန်ဆုံး တည်ဆောက်နည်းက row တစ်ခုစီမှာ 1 ဘယ်နှစ်ခု ရှိလဲ ရေတွက်ပြီး အဲဒီ အရေအတွက်ပေါ်မှာ စည်းမျဉ်းကို သုံးတာပါ။
အဆင့် 3: Input ပေါင်းစပ်ပုံ အားလုံးကို စာရင်းပြုစုပါ (input သုံးခုဆိုရင် row 2^3 = 8 ခု)၊ နှိပ်ထားတဲ့ buzzer တွေကို ရေတွက်ပြီး L ကို ဖြည့်ပါ။
| Row | A | B | C | နှိပ်ထားတဲ့ buzzer အရေအတွက် | L |
|---|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 0 | 0 |
| 2 | 0 | 0 | 1 | 1 | 1 |
| 3 | 0 | 1 | 0 | 1 | 1 |
| 4 | 0 | 1 | 1 | 2 | 0 |
| 5 | 1 | 0 | 0 | 1 | 1 |
| 6 | 1 | 0 | 1 | 2 | 0 |
| 7 | 1 | 1 | 0 | 2 | 0 |
| 8 | 1 | 1 | 1 | 3 | 0 |
အဆင့် 4: L = 1 ဖြစ်တဲ့ row တွေကနေ expression ကို ရေးပါ။ အဲဒီ row တစ်ခုစီက input သုံးခုလုံးကို AND လုပ်ထားတဲ့ term ဖြစ်လာပြီး အဲဒီ row မှာ 0 ဖြစ်နေတဲ့ input တိုင်းမှာ NOT တပ်ပါတယ်။ ပြီးရင် row တွေကို OR နဲ့ ပေါင်းပါတယ်။
- Row 2 က
¬A · ¬B · Cကို ပေးပါတယ် - Row 3 က
¬A · B · ¬Cကို ပေးပါတယ် - Row 5 က
A · ¬B · ¬Cကို ပေးပါတယ်
L = ¬A · ¬B · C + ¬A · B · ¬C + A · ¬B · ¬C
K-map ပေါ်မှာ ဒီ အကွက် သုံးကွက်ထဲက ဘယ်နှစ်ကွက်မှ ဘေးချင်းကပ် မဖြစ်လို့ အုပ်စုဖွဲ့လည်း ဒီ expression က မတိုသွားပါဘူး။
အဆင့် 5: အဖြေကို ဖော်ပြချက်နဲ့ တိုက်စစ်ပါ၊ မှန်ပုံရပေမယ့် မှားနေတဲ့ အဖြေနဲ့လည်း တိုက်စစ်ပါ။ “တစ်သင်းတည်း” (exactly one) ဆိုတာ XOR နဲ့ တူသလို ထင်ရနိုင်ပြီး A XOR B XOR C က row 2, 3 နဲ့ 5 မှာ 1 ကို တကယ် ပေးပါတယ်။ ဒါပေမယ့် XOR gate တွေကို တန်းဆက်ထားရင် 1 ဖြစ်နေတဲ့ input အရေအတွက်က မကိန်း ဖြစ်တိုင်း 1 ကို ထုတ်ပေးလို့ အသင်း သုံးသင်းလုံး တစ်ပြိုင်နက် နှိပ်တဲ့ row 8 မှာလည်း 1 ကို ပေးပါတယ်။ ဖော်ပြချက်အရ အဲဒီအခါ မီး မလင်းရပါဘူး၊ ဒါကြောင့် ဒီ ပြဿနာအတွက် A XOR B XOR C က မှားပါတယ်။
အဓိက သင်ခန်းစာ: ဖော်ပြချက်ကနေ truth table ရဖို့ နည်းလမ်း နှစ်မျိုး ရှိပါတယ်။ ဖော်ပြချက်က condition တွေကို “နဲ့” (and)၊ “ဒါမှမဟုတ်” (or)၊ “မ…ဘူး” (not)၊ “…မဟုတ်ရင်” (unless) လို စကားလုံးတွေနဲ့ ဆက်ထားရင် condition တစ်ခုစီကို gate အဖြစ် ပြောင်းပြီး column တွေကို တွက်ပါ။ စည်းမျဉ်းက input တွေကို ရေတွက်တာ ဒါမှမဟုတ် နှိုင်းယှဉ်တာ ဆိုရင် (“တစ်ခုတည်း” (exactly one)၊ “အနည်းဆုံး နှစ်ခု” (at least two)၊ “တိုင်းထားတဲ့ တန်ဖိုး နှစ်ခု မတူ” (the two readings differ)) စည်းမျဉ်းအတိုင်း output ကို row တစ်ခုချင်း ဖြည့်ပြီး output 1 ဖြစ်တဲ့ row တွေကနေ expression ကို ဖတ်ယူပါ။ ဘယ်နည်းပဲ သုံးသုံး မပြီးခင် row တချို့ကို မူလ ဖော်ပြချက်နဲ့ တိုက်စစ်ပါ။
Quick Check (အမြန် စစ်ဆေးမေးခွန်း)
Q1. Gate တစ်ခုမှာ ဒီ truth table ရှိပါတယ်။ ဘယ် gate လဲ။
| A | B | Q |
|---|---|---|
| 0 | 0 | 0 |
| 0 | 1 | 0 |
| 1 | 0 | 0 |
| 1 | 1 | 1 |Q2. A=1 နဲ့ B=0 ဖြစ်တဲ့အခါ XOR gate ရဲ့ output က ဘာလဲ။
Q3. De Morgan's theorem အရ ¬(A · B) က ဘာနဲ့ ညီမျှသလဲ:
Q4. Karnaugh map မှာ အောက်ပါထဲက ဘယ်ဟာက မှန်ကန်တဲ့ အုပ်စု အရွယ်အစား မဟုတ်သလဲ။
Q5. Input 4 ခုပါတဲ့ circuit တစ်ခုအတွက် truth table မှာ row ဘယ်နှစ်ခု ရှိသလဲ။
Complete the Truth Table (truth table ကို ပြည့်အောင် ဖြည့်ခြင်း)
Gate အများပါတဲ့ အောက်က circuit ကို input ပေါင်းစပ်ပုံ 8 မျိုးလုံးအတွက် Trace (တစ်ဆင့်ချင်း လိုက်ပြီး မှတ်ပါ) လုပ်ပါ။ ဒီ circuit မှာ ကြားခံ signal နှစ်ခု ရှိပါတယ်:
X = A AND BY = X OR C
Row တစ်ခုစီအတွက် X နဲ့ Y ရဲ့ တန်ဖိုးတွေကို (0 ဒါမှမဟုတ် 1) ဖြည့်ပါ။
| A | B | C | X = A AND B | Y = X OR C |
|---|---|---|---|---|
| 0 | 0 | 0 | ||
| 0 | 0 | 1 | ||
| 0 | 1 | 0 | ||
| 0 | 1 | 1 | ||
| 1 | 0 | 0 | ||
| 1 | 0 | 1 | ||
| 1 | 1 | 0 | ||
| 1 | 1 | 1 |
Spot the Error (အမှား ရှာခြင်း)
ကျောင်းသား တစ်ယောက်က De Morgan's theorem ကို သုံးပြီး Boolean expression တစ်ခုကို ရိုးရှင်းအောင် လုပ်နေပါတယ်။ သူ ရေးခဲ့တဲ့ အဆင့်တွေက အောက်ပါအတိုင်းပါ။ အမှားပါတဲ့ line ကို ရွေးပါ၊ ပြီးရင် ပြင်နည်းကို ရွေးပါ။
Line တွေထဲက Original က မူလ expression၊ Step က အဆင့်၊ Result က ရလဒ်ပါ။ "Apply De Morgan's to ¬(A + B)" က ¬(A + B) ပေါ်မှာ De Morgan's theorem ကို သုံးပါတယ် လို့ ဆိုလိုပါတယ်။
De Morgan's theorem သုံးတဲ့ အဆင့်အတွက် မှန်ကန်တဲ့ ပြင်နည်းကို ရွေးပါ:
Fill in the Blanks (ကွက်လပ် ဖြည့်ခြင်း)
ကွက်လပ်ပါတဲ့ စာကြောင်းတွေက English နဲ့ ဖြစ်ပြီး အဖြေတွေကိုလည်း gate နာမည်၊ သင်္ကေတ ဒါမှမဟုတ် English စကားလုံး တစ်လုံးနဲ့ ရိုက်ထည့်ရပါမယ်။ “Gate Summary” က gate အကျဉ်းချုပ် ဖြစ်ပြီး မြှား (→) နောက်က စာတွေရဲ့ အဓိပ္ပာယ်က အောက်ပါအတိုင်းပါ:
- “output 1 only when BOTH inputs are 1”: input နှစ်ခုလုံး 1 ဖြစ်မှသာ 1 ထွက်ပါတယ်
- “output 1 when AT LEAST ONE input is 1”: input အနည်းဆုံး တစ်ခု 1 ဖြစ်ရင် 1 ထွက်ပါတယ်
- “flips the input”: input ကို ပြောင်းပြန်လှန်ပါတယ်
- “output 0 only when __ inputs are 1”: input __ 1 ဖြစ်မှသာ 0 ထွက်ပါတယ်
- “output 1 only when both inputs are __”: input နှစ်ခုလုံး __ ဖြစ်မှသာ 1 ထွက်ပါတယ်
- “output 1 when inputs are DIFFERENT”: input တွေ မတူရင် 1 ထွက်ပါတယ်
- “output 1 when inputs are __”: input တွေ __ ဖြစ်ရင် 1 ထွက်ပါတယ်
Gate နာမည် ဒါမှမဟုတ် Boolean သင်္ကေတကို ဖြည့်ပြီး အခြေခံ logic gate ခုနစ်မျိုးရဲ့ အကျဉ်းချုပ်ကို ပြည့်စုံအောင် လုပ်ပါ:
Gate Summary
============
1. gate: Q = A · B → output 1 only when BOTH inputs are 1
2. gate: Q = A + B → output 1 when AT LEAST ONE input is 1
3. NOT gate: Q = → flips the input
4. NAND gate: Q = ¬(A · B) → output 0 only when inputs are 1
5. NOR gate: Q = ¬(A + B) → output 1 only when both inputs are
6. XOR gate: Q = A B → output 1 when inputs are DIFFERENT
7. XNOR gate: Q = ¬(A ⊕ B) → output 1 when inputs are
De Morgan's Theorems
====================
Theorem 1: ¬(A · B) = ¬A ¬B
Theorem 2: ¬(A + B) = ¬A ¬BPredict the Output (output ကို ကြိုခန့်မှန်းခြင်း)
Circuit တစ်ခုက Q = (A XOR B) AND C ကို အကောင်အထည်ဖော်ထားပါတယ်။ Input A=1, B=0, C=1 ဖြစ်ရင် output Q က ဘာလဲ။
Inputs: A = 1, B = 0, C = 1
Circuit: Q = (A XOR B) AND C
Step 1: A XOR B = ?
Step 2: Q = (result) AND C = ?Q ရဲ့ တန်ဖိုးက ဘာလဲ။
Practice Exercises (လေ့ကျင့်ခန်းများ)
Core (အခြေခံ အဆင့်)
-
[Core]Truth tables[7 marks]အခြေခံ gate 7 မျိုး (AND, OR, NOT, NAND, NOR, XOR, XNOR) တစ်ခုစီအတွက် truth table ကို ဆွဲပါ။ Input နှစ်ခုပါတဲ့ gate တွေအတွက် ဇယား တစ်ခုစီမှာ row 4 ခု ရှိရပြီး NOT အတွက် row 2 ခု ရှိရပါမယ်။ -
[Core]Truth tables[4 marks]Q = (A OR B) AND (NOT A)အတွက် truth table ကို Construct လုပ်ပါ။ Input ပေါင်းစပ်ပုံ 4 မျိုးလုံးကို စာရင်းပြုစုပြီး ဘယ် row တွေက Q = 1 ကို ထုတ်ပေးလဲ identify (ဖြစ်နိုင်တဲ့ အဖြေတွေထဲက ရွေးပြီး ဖော်ပြပါ) လုပ်ပါ။ -
[Core]Simplification[6 marks]အောက်ပါ တစ်ခုစီကို De Morgan’s theorem သုံးပြီး ရိုးရှင်းအောင် လုပ်ပါ:¬(X · Y)¬(P + Q)¬(¬A · B)
Extension (တိုးချဲ့ အဆင့်)
-
[Extension]Truth tables[5 marks]Q = (A AND B) OR (B AND C) OR (A AND C)circuit အတွက် ပြည့်စုံတဲ့ truth table (row 8 ခု) ကို တည်ဆောက်ပါ။ ဒီ circuit ကို majority gate (အများစု gate) လို့ ခေါ်ပါတယ်။ ဒီနာမည်က ဘာကြောင့် သင့်တော်လဲ explain (ရှင်းပြပါ) လုပ်ပါ။ -
[Extension]Simplification[6 marks]အောက်က truth table က variable သုံးခုပါတဲ့ Boolean function (input တန်ဖိုးတွေကနေ output ကို သတ်မှတ်ပေးတဲ့ စည်းမျဉ်း) တစ်ခုကို သတ်မှတ်ပါတယ်။ K-map ကို သုံးပြီး ရိုးရှင်းသွားတဲ့ Boolean expression ကို ရှာပါ။A B C Q 0 0 0 1 0 0 1 1 0 1 0 0 0 1 1 1 1 0 0 1 1 0 1 1 1 1 0 0 1 1 1 1 -
[Extension]Logic diagrams[4 marks]အောက်က logic diagram က circuit တစ်ခုကို ပြထားပါတယ်။ အဲဒီ diagram က ကိုယ်စားပြုတဲ့ Boolean expression ကို ရေးပါ:
Challenge (စိန်ခေါ်မှု အဆင့်)
[Challenge]Logic diagrams[9 marks]အိမ်သုံး alarm (သတိပေး အချက်ပေးသံ) စနစ် တစ်ခုမှာ binary input သုံးခု ရှိပါတယ်:D(တံခါး sensor၊ တံခါး ပွင့်မပွင့် ထောက်လှမ်းတဲ့ ကိရိယာ: 1 = တံခါး ပွင့်နေ)၊W(ပြတင်းပေါက် sensor: 1 = ပြတင်းပေါက် ပွင့်နေ)၊S(စနစ် armed: 1 = armed၊ စောင့်ကြည့်ဖို့ ဖွင့်ထား)။ စနစ်ကို armed လုပ်ထားပြီး (AND) တံခါး ဒါမှမဟုတ် ပြတင်းပေါက် တစ်ခုခု ပွင့်နေရင် alarmQမြည်ရပါမယ်။ Boolean expression ကို ရေးပါ၊ truth table (row 8 ခု) ကို ဆွဲပါ၊ Boolean algebra ဒါမှမဟုတ် K-map ကို သုံးပြီး ရိုးရှင်းအောင် လုပ်ပါ၊ ပြီးရင် logic diagram ကို describe (ဖော်ပြရှင်းပြပါ) လုပ်ပါ။
ဆက်စပ် ခေါင်းစဉ်များ
- အရင် လေ့လာထားရမယ့် ခေါင်းစဉ်များ: မရှိပါ (အခြေခံ ခေါင်းစဉ်)
- နောက်ထပ် လေ့လာမယ့် ခေါင်းစဉ်: CPU Architecture (CPU ရဲ့ ဖွဲ့စည်းပုံ): gate တွေက processor ကို ဘယ်လို တည်ဆောက်လဲ (ALU, CU, register)
- ဆက်စပ် ခေါင်းစဉ်: Primary Memory (ပင်မ မှတ်ဉာဏ်): memory က ဒေတာကို ဘယ်လို သိမ်းလဲ ဆိုတာကို flip-flop တွေက ရှင်းပြပါတယ်
- နောက်ပိုင်းမှာ: Information Layer (အချက်အလက် အလွှာ): ဂဏန်းစနစ်တွေက gate တွေ လုပ်ဆောင်တဲ့ binary ကို သုံးပါတယ်