ENGCE200 – ปฏิบัติการวิศวกรรมคอมพิวเตอร์

ปฏิบัติการที่ 3

4-Bit Magnitude Comparator ด้วย 4:1 Multiplexer

วิธี Variable Entering Map (VEM) – ลดตัวแปรให้เหลือ 2 ตัวต่อ MUX

ผศ.ดร.สมนึก สุระธง · มหาวิทยาลัยเทคโนโลยีราชมงคลล้านนา

? เราจะออกแบบอะไร?

เป้าหมาย: ออกแบบวงจรที่รับตัวเลข 2 ตัว (A และ B ขนาด 4 บิตแต่ละตัว) แล้วบอกว่า A มากกว่า, น้อยกว่า หรือเท่ากับ B
อุปกรณ์ที่ใช้: IC 4:1 Multiplexer เท่านั้น (ไม่ใช้ logic gate อื่น)
วิธีการ: ใช้เทคนิค Variable Entering Map (VEM) เพื่อ "ยุบ" สมการบูลีนให้เหลือแค่ 2 ตัวแปรต่อ MUX 1 ตัว

อินพุต

A₃A₂A₁A₀ , B₃B₂B₁B₀

→

เอาท์พุต

A>B, A<B, A=B

→

ใช้ทั้งหมด

9 MUX (4:1)

ส่วนที่ 1

VEM คืออะไร และทำงานยังไง?

ปัญหา: สมการบูลีนมีตัวแปรเยอะ (เช่น 8 ตัว) แต่ 4:1 MUX มีขาเลือกแค่ 2 ขา (S₁, S₀)

VEM แก้ปัญหาด้วย: เลือกตัวแปร 2 ตัวมาเป็นขาเลือก แล้วแทนค่าตัวแปรที่เลือกลงสมการ ผลลัพธ์ที่ได้ 4 ค่า (สำหรับ 00, 01, 10, 11) คือค่าที่ต้องต่อเข้าขา I₀, I₁, I₂, I₃ ของ MUX

        กฎ Shannon's Expansion:

        f(S₁,S₀,...) = S̄₁S̄₀·f(0,0,...) + S̄₁S₀·f(0,1,...) + S₁S̄₀·f(1,0,...) + S₁S₀·f(1,1,...)

        → f(0,0,...) คือค่าที่ต่อเข้า I₀

        → f(0,1,...) คือค่าที่ต่อเข้า I₁

        → f(1,0,...) คือค่าที่ต่อเข้า I₂

        → f(1,1,...) คือค่าที่ต่อเข้า I₃

สรุปขั้นตอน VEM:
1️⃣ เขียนสมการออกมา
2️⃣ เลือกตัวแปร 2 ตัว → เป็น S₁ และ S₀ ของ MUX
3️⃣ แทนค่า 4 ชุด (00, 01, 10, 11) ลงสมการ → ได้ 4 ผลลัพธ์
4️⃣ ผลลัพธ์แต่ละชุด → ต่อเข้าขา I₀, I₁, I₂, I₃ ตามลำดับ
5️⃣ ถ้าผลลัพธ์ยังซับซ้อน → ทำ VEM รอบใหม่ด้วย MUX ตัวถัดไป

ส่วนที่ 2

สมการ K-VEM ตั้งต้น & ที่มาอย่างละเอียดจากตาราง 256 แถว

🔍 สมการพวกนี้ได้มายังไง? (ถอดรหัสวิธีคิดทีละขั้นตอน)

สมการเปรียบเทียบทั้ง 3 กรณี (A>B, A<B, A=B) ไม่ได้เกิดจากการเดาสุ่มหรือสูตรลอยๆ แต่เกิดจาก "หลักตรรกะการเปรียบเทียบเลขของมนุษย์" ที่นำมาจัดกลุ่มมินเทอม (Minterms) จากตารางความจริงขนาด 8 อินพุต (256 แถว):

1. เปรียบเทียบจาก MSB → LSB

เราต้องตรวจบิตซ้ายสุดก่อนเสมอ (A₃ เทียบ B₃) ถ้าหลักใหญ่รู้ผลแพ้ชนะแล้ว หลักย่อยด้านขวา (บิต 2, 1, 0) จะไม่มีผลใดๆ อีกเลย

2. สภาวะของแต่ละบิต (4 แบบ)

• ชนะที่บิตนี้: AᵢB̄ᵢ (A=1, B=0)
• แพ้ที่บิตนี้: ĀᵢBᵢ (A=0, B=1)
• เสมอกัน: Aᵢ⊙Bᵢ (0=0 หรือ 1=1)

3. การส่งไม้ต่อ (Cascade Chain)

เมื่อบิตปัจจุบัน "เสมอกัน" (Aᵢ⊙Bᵢ=1) ผลลัพธ์จะถูกส่งต่อไปยังบิตต่ำกว่า (fᵢ₋₁) เพื่อตัดสินแทน

📊 แจกแจง 256 แถว เข้าสู่แต่ละพจน์ของสมการ (Minterm Partitioning)

ตารางความจริงมี 2⁸ = 256 กรณี (A = 0..15 จับคู่กับ B = 0..15) ถูกแบ่งออกเป็น 3 กลุ่มตามหลักคณิตศาสตร์อย่างแม่นยำ:

เอาท์พุต	จำนวนแถว	เงื่อนไขเหตุการณ์	พจน์บูลีนที่ทำงาน (Active Term)	ฟังก์ชันที่รองรับ
🟢 A > B รวม 120 แถว	64 แถว	บิต 3 ชนะขาด (A₃=1, B₃=0)	A₃B̄₃	MUX_X3 (บิต 3)
	32 แถว	บิต 3 เสมอ (A₃=B₃) และบิต 2 ชนะ (A₂=1, B₂=0)	(A₃⊙B₃) · A₂B̄₂	MUX_X2 (บิต 2)
	16 แถว	บิต 3,2 เสมอ และบิต 1 ชนะ (A₁=1, B₁=0)	(A₃⊙B₃)(A₂⊙B₂) · A₁B̄₁	MUX_X1 (บิต 1)
	8 แถว	บิต 3,2,1 เสมอ และบิต 0 ชนะ (A₀=1, B₀=0)	(A₃⊙B₃)(A₂⊙B₂)(A₁⊙B₁) · A₀B̄₀	MUX_X0 (บิต 0)
🔴 A < B รวม 120 แถว	64 แถว	บิต 3 แพ้ขาด (A₃=0, B₃=1)	Ā₃B₃	MUX_Y3 (บิต 3)
	32 แถว	บิต 3 เสมอ (A₃=B₃) และบิต 2 แพ้ (A₂=0, B₂=1)	(A₃⊙B₃) · Ā₂B₂	MUX_Y2 (บิต 2)
	16 แถว	บิต 3,2 เสมอ และบิต 1 แพ้ (A₁=0, B₁=1)	(A₃⊙B₃)(A₂⊙B₂) · Ā₁B₁	MUX_Y1 (บิต 1)
	8 แถว	บิต 3,2,1 เสมอ และบิต 0 แพ้ (A₀=0, B₀=1)	(A₃⊙B₃)(A₂⊙B₂)(A₁⊙B₁) · Ā₀B₀	MUX_Y0 (บิต 0)
🟡 A = B รวม 16 แถว	16 แถว	ทุกบิตตรงกันเป๊ะ (0=0, 1=1, ..., 15=15)	(A₃⊙B₃)(A₂⊙B₂)(A₁⊙B₁)(A₀⊙B₀)	MUX_Z (ตัวตัดสิน)
รวมทั้งหมด	256 แถว	120 แถว (A>B) + 120 แถว (A<B) + 16 แถว (A=B) = 256 แถว ครบถ้วน 100%

🔄 การดึงตัวประกอบร่วม (Factoring) สู่สมการลูกโซ่ (Chain)

เมื่อนำทั้ง 4 กรณีของ A > B มารวมกัน (OR):

A > B = A₃B̄₃ + (A₃⊙B₃)A₂B̄₂ + (A₃⊙B₃)(A₂⊙B₂)A₁B̄₁ + (A₃⊙B₃)(A₂⊙B₂)(A₁⊙B₁)A₀B̄₀

สังเกตว่ามีตัวประกอบร่วม (Aᵢ⊙Bᵢ) ซ้อนกันอยู่ เราจึงดึงตัวร่วมออกมาทีละชั้นแบบ Nested:

A > B = A₃B̄₃ + (A₃⊙B₃) · [ A₂B̄₂ + (A₂⊙B₂) · [ A₁B̄₁ + (A₁⊙B₁) · (A₀B̄₀) ] ]

นี่คือที่มาของการตั้งชื่อตัวแปรย่อยเพื่อส่งต่อสัญญาณทีละ MUX:

บิต 0 (MUX_X0) f₀ = A₀B̄₀

บิต 1 (MUX_X1) f₁ = A₁B̄₁ + (A₁⊙B₁)·f₀

บิต 2 (MUX_X2) f₂ = A₂B̄₂ + (A₂⊙B₂)·f₁

บิต 3 (MUX_X3) A>B = A₃B̄₃ + (A₃⊙B₃)·f₂

🔢 แยกวิเคราะห์การทำงานทีละบิตให้เห็นชัดเจน 100% (บิต 0, บิต 1, บิต 2, บิต 3)

แต่ละบิตมีหน้าที่ชัดเจนและสอดคล้องกับแถวในตารางความจริง 256 แถวดังนี้:

บิต 0 (LSB - บิตขวาสุด) MUX_X0 / MUX_Y0

• ตัวแปรที่พิจารณา: ดูเฉพาะบิตคู่แรก A₀ และ B₀

• ทำไมไม่มีบิตก่อนหน้า? เพราะเป็นบิตต่ำสุด ไม่มีใครต่ำกว่าให้ส่งต่อแล้ว (f₋₁ = 0)

• สมการที่ได้: f₀ = A₀B̄₀ (A>B) และ g₀ = Ā₀B₀ (A<B)

• ในตาราง 256 แถว: มีผลตัดสินใน 8 แถว (เฉพาะกรณีที่บิต 3, 2, 1 ดันเสมอกันหมด)

บิต 1 (บิตกลางล่าง) MUX_X1 / MUX_Y1

• ตัวแปรที่พิจารณา: ดูคู่ A₁, B₁ ร่วมกับผลลัพธ์จากบิต 0 (f₀ / g₀)

• หลักการตัดสิน: ถ้า A₁ ชนะ (1,0) จบที่ 1 ทันที | ถ้าเสมอ (0,0 หรือ 1,1) ให้ดึงค่า f₀ มาใช้

• สมการที่ได้: f₁ = A₁B̄₁ + (A₁⊙B₁)·f₀ และ g₁ = Ā₁B₁ + (A₁⊙B₁)·g₀

• ในตาราง 256 แถว: มีผลตัดสินใน 16 แถว (กรณีที่บิต 3, 2 เสมอกัน แต่บิต 1 มีผลต่างกัน)

บิต 2 (บิตกลางบน) MUX_X2 / MUX_Y2

• ตัวแปรที่พิจารณา: ดูคู่ A₂, B₂ ร่วมกับผลลัพธ์จากบิต 1 (f₁ / g₁)

• หลักการตัดสิน: ถ้า A₂ ชนะ (1,0) จบที่ 1 ทันที | ถ้าเสมอ ให้ดึงผลลัพธ์สะสม f₁ มาใช้

• สมการที่ได้: f₂ = A₂B̄₂ + (A₂⊙B₂)·f₁ และ g₂ = Ā₂B₂ + (A₂⊙B₂)·g₁

• ในตาราง 256 แถว: มีผลตัดสินใน 32 แถว (กรณีที่บิต 3 เสมอกัน แต่บิต 2 มีผลต่างกัน)

บิต 3 (MSB - บิตซ้ายสุด ทรงพลังที่สุด) MUX_X3 / MUX_Y3

• ตัวแปรที่พิจารณา: ดูคู่หลักสูงสุด A₃, B₃ ร่วมกับผลลัพธ์สะสม f₂ / g₂

• หลักการตัดสิน: ถ้า A₃ ชนะ (1,0) จะชนะขาดทันที 64 แถว! ถ้าแพ้ (0,1) แพ้ทันที 64 แถว! ถ้าเสมอจึงยอมดู f₂

• สมการที่ได้ (Final Output): A>B = A₃B̄₃ + (A₃⊙B₃)·f₂ และ A<B = Ā₃B₃ + (A₃⊙B₃)·g₂

• ในตาราง 256 แถว: ตัดสินขาดทันทีถึง 64 แถว ในฝั่ง A>B และอีก 64 แถว ในฝั่ง A<B

🟢 โครงสร้างฟังก์ชัน A > B

บิต 0: f₀ = A₀B̄₀
บิต 1: f₁ = A₁B̄₁ + (A₁⊙B₁)·f₀
บิต 2: f₂ = A₂B̄₂ + (A₂⊙B₂)·f₁
บิต 3: A>B = A₃B̄₃ + (A₃⊙B₃)·f₂

🔴 โครงสร้างฟังก์ชัน A < B

บิต 0: g₀ = Ā₀B₀
บิต 1: g₁ = Ā₁B₁ + (A₁⊙B₁)·g₀
บิต 2: g₂ = Ā₂B₂ + (A₂⊙B₂)·g₁
บิต 3: A<B = Ā₃B₃ + (A₃⊙B₃)·g₂

🟡 โครงสร้างฟังก์ชัน A = B

ใช้วิธีพิเศษ (กฎตัดตัวเลือก):
S₁ = Output A>B
S₀ = Output A<B
A=B = NOT(A>B) AND NOT(A<B)
(ประหยัด MUX ได้ถึง 3 ตัว!)

ส่วนที่ 3

ขั้นตอน VEM สำหรับ A > B → ได้ MUX 4 ตัว

X0

MUX_X0 – เปรียบเทียบบิตที่ 0 (A₀ vs B₀) ไม่มีค่าก่อนหน้า

สมการ:

f₀ = A₀B̄₀
(ไม่มี fₓ₋₁ เพราะบิตแรก)

เลือก: S₁ = A₀, S₀ = B₀

ตาราง VEM (แทนค่าลงสมการ):

A₀ \ B₀	B₀=0	B₀=1
A₀=0	0·1=0	0·0=0
A₀=1	1·1=1	1·0=0

ผลลัพธ์ → ขา MUX_X0:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	0	GND
I₁	01	0	GND
I₂	10	1	VCC
I₃	11	0	GND
Output Y			→ f₀

อ่านตาราง: ช่อง (A₀=0,B₀=0): แทน A₀=0, B₀=0 ลง A₀·B̄₀ = 0·1 = 0 → ต่อ GND | ช่อง (1,0): 1·1 = 1 → ต่อ VCC

X1

MUX_X1 – เปรียบเทียบบิตที่ 1 (A₁ vs B₁) รับ f₀ จาก MUX_X0

สมการ:

f₁ = A₁B̄₁ + (A₁⊙B₁)·f₀

เลือก: S₁ = A₁, S₀ = B₁

f₀ = ตัวแปรแทรก (entering variable)

ตาราง VEM:

A₁ \ B₁	B₁=0	B₁=1
A₁=0	0+1·f₀=f₀	0+0=0
A₁=1	1+...=1	0+1·f₀=f₀

เสมอ(00,11) → ผ่าน f₀ | แพ้(01) → 0 | ชนะ(10) → 1

ผลลัพธ์ → ขา MUX_X1:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	f₀	สาย f₀
I₁	01	0	GND
I₂	10	1	VCC
I₃	11	f₀	สาย f₀
Output Y			→ f₁

X2

MUX_X2 – เปรียบเทียบบิตที่ 2 (A₂ vs B₂) รับ f₁ จาก MUX_X1

สมการ:

f₂ = A₂B̄₂ + (A₂⊙B₂)·f₁

เลือก: S₁ = A₂, S₀ = B₂

ตาราง VEM:

A₂ \ B₂	B₂=0	B₂=1
A₂=0	f₁	0
A₂=1	1	f₁

ผลลัพธ์ → ขา MUX_X2:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	f₁	สาย f₁
I₁	01	0	GND
I₂	10	1	VCC
I₃	11	f₁	สาย f₁
Output Y			→ f₂

X3

MUX_X3 – บิตสำคัญที่สุด (A₃ vs B₃) → ผลสุดท้าย A>B

สมการ:

A>B = A₃B̄₃ + (A₃⊙B₃)·f₂

เลือก: S₁ = A₃, S₀ = B₃

ตาราง VEM:

A₃ \ B₃	B₃=0	B₃=1
A₃=0	f₂	0
A₃=1	1	f₂

ผลลัพธ์ → ขา MUX_X3:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	f₂	สาย f₂
I₁	01	0	GND
I₂	10	1	VCC
I₃	11	f₂	สาย f₂
Output Y			→ LED A>B 🟢

🔑 รูปแบบที่ซ้ำกันทุก MUX สำหรับ A>B:

I₀(00) = ผลจาก MUX ก่อนหน้า I₁(01) = GND I₂(10) = VCC I₃(11) = ผลจาก MUX ก่อนหน้า

ยกเว้น MUX_X0: I₀=GND, I₃=GND (เพราะไม่มี MUX ก่อนหน้า)

ส่วนที่ 4

ขั้นตอน VEM สำหรับ A < B → ได้ MUX 4 ตัว

Y0

MUX_Y0 – บิตที่ 0 ไม่มีค่าก่อนหน้า

g₀ = Ā₀B₀
(A₀ น้อยกว่า B₀)

เลือก: S₁ = A₀, S₀ = B₀

ตาราง VEM:

A₀ \ B₀	B₀=0	B₀=1
A₀=0	1·0=0	1·1=1
A₀=1	0·0=0	0·1=0

ผลลัพธ์ → ขา MUX_Y0:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	0	GND
I₁	01	1	VCC
I₂	10	0	GND
I₃	11	0	GND
Output Y			→ g₀

Y1 Y2 Y3

MUX_Y1, Y2, Y3 – บิตที่ 1, 2, 3 (รูปแบบเดียวกัน)

gᵢ = ĀᵢBᵢ + (Aᵢ⊙Bᵢ)·gᵢ₋₁
(เลือก S₁=Aᵢ, S₀=Bᵢ)

Aᵢ \ Bᵢ	Bᵢ=0	Bᵢ=1
Aᵢ=0	gᵢ₋₁	1
Aᵢ=1	0	gᵢ₋₁

ขา MUX (เหมือนกันทุกตัว Y1–Y3):

ขา	S₁S₀	ค่า	ต่อ
I₀	00	gᵢ₋₁	สาย g ก่อนหน้า
I₁	01	1	VCC
I₂	10	0	GND
I₃	11	gᵢ₋₁	สาย g ก่อนหน้า
Y3 Output			→ LED A<B 🔴

รูปแบบ A<B: I₀=gᵢ₋₁, I₁=VCC, I₂=GND, I₃=gᵢ₋₁
(กลับกับ A>B: ขา I₁ กับ I₂ สลับกัน)

ส่วนที่ 5

ขั้นตอน VEM สำหรับ A = B → ใช้ MUX เพียง 1 ตัว

เทคนิคพิเศษ: แทนที่จะคำนวณ A=B จากตัวแปรใหม่ เราใช้ผลลัพธ์ที่คำนวณไปแล้วมาใช้ต่อ
A=B เป็นจริง ก็ต่อเมื่อ A>B เป็นเท็จ AND A<B เป็นเท็จ

A=B = NOT(A>B) · NOT(A<B)

เลือก: S₁ = Output A>B
S₀ = Output A<B

ตาราง VEM:

A>B \ A<B	A<B=0	A<B=1
A>B=0	1 (เสมอ!)	0
A>B=1	0	0 (เป็นไปไม่ได้)

ผลลัพธ์ → ขา MUX_Z:

ขา	S₁S₀	ค่า	ต่อ
I₀	00	1	VCC
I₁	01	0	GND
I₂	10	0	GND
I₃	11	0	GND
Output Y			→ LED A=B 🟡

ส่วนที่ 6

ตารางสรุปการต่อสาย MUX ทั้ง 9 ตัว

MUX	สมการ	S₁	S₀	I₀(00)	I₁(01)	I₂(10)	I₃(11)	Output Y
MUX_X0	f₀=A₀B̄₀	A₀	B₀	GND	GND	VCC	GND	f₀
MUX_X1	f₁=A₁B̄₁+(A₁⊙B₁)f₀	A₁	B₁	f₀	GND	VCC	f₀	f₁
MUX_X2	f₂=A₂B̄₂+(A₂⊙B₂)f₁	A₂	B₂	f₁	GND	VCC	f₁	f₂
MUX_X3	A>B=A₃B̄₃+(A₃⊙B₃)f₂	A₃	B₃	f₂	GND	VCC	f₂	🟢 A>B
MUX_Y0	g₀=Ā₀B₀	A₀	B₀	GND	VCC	GND	GND	g₀
MUX_Y1	g₁=Ā₁B₁+(A₁⊙B₁)g₀	A₁	B₁	g₀	VCC	GND	g₀	g₁
MUX_Y2	g₂=Ā₂B₂+(A₂⊙B₂)g₁	A₂	B₂	g₁	VCC	GND	g₁	g₂
MUX_Y3	A<B=Ā₃B₃+(A₃⊙B₃)g₂	A₃	B₃	g₂	VCC	GND	g₂	🔴 A<B
MUX_Z	A=B=¬(A>B)·¬(A<B)	A>B	A<B	VCC	GND	GND	GND	🟡 A=B

ส่วนที่ 7

แผนผังวงจรสมบูรณ์

วงจรด้านล่างแสดงการต่อ MUX ทั้ง 9 ตัวใน CircuitVerse (ลูกศร = ทิศทางสัญญาณ)

ส่วนที่ 8

คู่มือต่อสายใน CircuitVerse ทีละขั้นตอน

⚙️ เตรียมอุปกรณ์

①เปิด circuitverse.org → New Project

②วาง Input (Toggle Switch) จำนวน 8 ตัว สำหรับ A₃,A₂,A₁,A₀, B₃,B₂,B₁,B₀

③วาง Output (LED) จำนวน 3 ตัว: A>B, A<B, A=B

④วาง Multiplexer 4:1 จำนวน 9 ตัว จาก Components → Misc → Multiplexer

⑤ตรวจสอบ: MUX ใน CircuitVerse จะมีขา I₀, I₁, I₂, I₃ และขาเลือก S (เลือก bit size = 1)

🟢 โซ่ A > B: ต่อ MUX_X0 → X1 → X2 → X3

MUX_X0 (เริ่มต้น — บิต 0)

• S₁ = ต่อ A₀

• S₀ = ต่อ B₀

• I₀ = ต่อ GND (0)

• I₁ = ต่อ GND (0)

• I₂ = ต่อ VCC (1)

• I₃ = ต่อ GND (0)

• Y = f₀ → ไปต่อ I₀ และ I₃ ของ MUX_X1

MUX_X1 (บิต 1)

• S₁ = ต่อ A₁

• S₀ = ต่อ B₁

• I₀ = ต่อ สาย f₀ (output ของ MUX_X0)

• I₁ = ต่อ GND

• I₂ = ต่อ VCC

• I₃ = ต่อ สาย f₀ เช่นกัน (ต่อพ่วงจาก I₀)

• Y = f₁ → ไปต่อ I₀ และ I₃ ของ MUX_X2

MUX_X2 (บิต 2) — ทำเหมือน X1 แต่เปลี่ยนสัญญาณ

• S₁=A₂, S₀=B₂, I₀=I₃=f₁, I₁=GND, I₂=VCC, Y=f₂

MUX_X3 (บิต 3 — ผลสุดท้าย)

• S₁=A₃, S₀=B₃, I₀=I₃=f₂, I₁=GND, I₂=VCC

• Y → ต่อเข้า LED สีเขียว (A>B)

🔴 โซ่ A < B: ต่อ MUX_Y0 → Y1 → Y2 → Y3

MUX_Y0 (บิต 0 — ต่างจาก X0 ตรงที่ I₁=VCC, I₂=GND)

• S₁=A₀, S₀=B₀

• I₀ = GND | I₁ = VCC | I₂ = GND | I₃ = GND

• Y = g₀ → I₀ และ I₃ ของ MUX_Y1

MUX_Y1, Y2 (บิต 1, 2 — รูปแบบเดียวกัน)

• S₁=Aᵢ, S₀=Bᵢ, I₀=I₃=gᵢ₋₁, I₁=VCC, I₂=GND

MUX_Y3 (บิต 3 — ผลสุดท้าย)

• S₁=A₃, S₀=B₃, I₀=I₃=g₂, I₁=VCC, I₂=GND

• Y → ต่อเข้า LED สีแดง (A<B)

🟡 MUX_Z: วงจร A = B (ใช้ผลจาก X3 และ Y3)

• S₁ = ต่อ Output ของ MUX_X3 (สาย A>B)

• S₀ = ต่อ Output ของ MUX_Y3 (สาย A<B)

• I₀ = ต่อ VCC (1)

• I₁ = ต่อ GND (0)

• I₂ = ต่อ GND (0)

• I₃ = ต่อ GND (0)

• Y → ต่อเข้า LED สีเหลือง (A=B)

เหตุผล: A=B เป็น 1 ก็ต่อเมื่อ A>B=0 และ A<B=0 (เลือก I₀=VCC เฉพาะ state 00)

ส่วนที่ 9

ตัวอย่างตรวจสอบวงจร

ลองป้อนค่าต่อไปนี้เพื่อตรวจสอบว่าวงจรทำงานถูกต้อง:

A₃A₂A₁A₀	B₃B₂B₁B₀	A (ทศนิยม)	B (ทศนิยม)	🟢 A>B	🔴 A<B	🟡 A=B
1010	0101	10	5	1	0	0
0011	1100	3	12	0	1	0
0111	0111	7	7	0	0	1
1111	1110	15	14	1	0	0
0000	0001	0	1	0	1	0

ปฏิบัติการที่ 3

4-Bit Magnitude Comparator ด้วย 4:1 Multiplexer

? เราจะออกแบบอะไร?

VEM คืออะไร และทำงานยังไง?

สมการ K-VEM ตั้งต้น & ที่มาอย่างละเอียดจากตาราง 256 แถว

🔍 สมการพวกนี้ได้มายังไง? (ถอดรหัสวิธีคิดทีละขั้นตอน)

📊 แจกแจง 256 แถว เข้าสู่แต่ละพจน์ของสมการ (Minterm Partitioning)

🔢 แยกวิเคราะห์การทำงานทีละบิตให้เห็นชัดเจน 100% (บิต 0, บิต 1, บิต 2, บิต 3)

ตารางความจริงครบทั้ง 256 แถว (แยกบิต A₃, A₂, A₁, A₀ และ B₃, B₂, B₁, B₀ เต็มตาราง ไม่มีกรอบย่อ)

📋 ตารางความจริง 256 แถว แสดงแยกแต่ละบิตชัดเจน (Bit 3, 2, 1, 0)

ขั้นตอน VEM สำหรับ A > B → ได้ MUX 4 ตัว

ขั้นตอน VEM สำหรับ A < B → ได้ MUX 4 ตัว

ขั้นตอน VEM สำหรับ A = B → ใช้ MUX เพียง 1 ตัว

ตารางสรุปการต่อสาย MUX ทั้ง 9 ตัว

แผนผังวงจรสมบูรณ์

คู่มือต่อสายใน CircuitVerse ทีละขั้นตอน

⚙️ เตรียมอุปกรณ์

🟢 โซ่ A > B: ต่อ MUX_X0 → X1 → X2 → X3

🔴 โซ่ A < B: ต่อ MUX_Y0 → Y1 → Y2 → Y3

🟡 MUX_Z: วงจร A = B (ใช้ผลจาก X3 และ Y3)

ตัวอย่างตรวจสอบวงจร