รหัสและทดสอบคอมพิวเตอร์ในภาษาเครื่อง: 6 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:04

ในคำแนะนำนี้ ฉันจะแสดงวิธีเขียนโค้ดและทดสอบโปรแกรมคอมพิวเตอร์ในภาษาเครื่อง ภาษาเครื่องเป็นภาษาแม่ของคอมพิวเตอร์ เนื่องจากประกอบด้วยสตริงของ 1s และ 0s จึงไม่สามารถเข้าใจได้ง่ายโดยมนุษย์ เพื่อแก้ปัญหานี้ เราเขียนโปรแกรมด้วยภาษาระดับสูงเช่น C++ หรือ Java ก่อน จากนั้นจึงใช้โปรแกรมคอมพิวเตอร์พิเศษเพื่อแปลเป็นคอมพิวเตอร์ 1s และ 0s ที่คอมพิวเตอร์เข้าใจ การเรียนรู้การเขียนโค้ดในภาษาระดับสูงไม่ใช่เรื่องง่าย แต่การแนะนำสั้น ๆ เกี่ยวกับภาษาเครื่องสามารถให้ข้อมูลเชิงลึกอันมีค่าเกี่ยวกับวิธีการทำงานของคอมพิวเตอร์และเพิ่มความซาบซึ้งในเทคโนโลยีที่สำคัญมากนี้

ในการโค้ดและทดสอบโปรแกรมภาษาเครื่อง เราต้องเข้าถึงคอมพิวเตอร์ที่เข้าใจง่ายซึ่งภาษาเครื่องเข้าใจได้ง่าย คอมพิวเตอร์ส่วนบุคคลนั้นซับซ้อนเกินกว่าจะพิจารณาได้ วิธีแก้ไขคือใช้ Logisim ซึ่งเป็นโปรแกรมจำลองตรรกะที่ทำงานบนคอมพิวเตอร์ส่วนบุคคล ด้วย Logisim เราสามารถจำลองคอมพิวเตอร์ที่ตรงกับความต้องการของเรา วิดีโอด้านบนช่วยให้คุณทราบถึงสิ่งที่เราสามารถทำได้ด้วย Logisim

สำหรับการออกแบบคอมพิวเตอร์ ฉันได้ดัดแปลงจาก Kindle e-book สร้างคอมพิวเตอร์ของคุณเอง - ตั้งแต่เริ่มต้น ฉันเริ่มต้นด้วยคอมพิวเตอร์ BYOC ที่อธิบายไว้ที่นั่นและตัดแต่งให้เป็น BYOC-I พื้นฐานที่แตกต่างกัน (I สำหรับคำแนะนำ) เราจะใช้ในคำแนะนำนี้

ภาษาเครื่องของ BYOC-I นั้นเรียบง่ายและเข้าใจง่าย คุณไม่จำเป็นต้องมีความรู้พิเศษเกี่ยวกับคอมพิวเตอร์หรือการเขียนโปรแกรม ทั้งหมดที่จำเป็นคือจิตใจที่อยากรู้อยากเห็นและความปรารถนาที่จะเรียนรู้

อ่านเพิ่มเติม

คุณอาจสงสัยว่าทำไมเราใช้ "เครื่อง" เพื่ออธิบายคอมพิวเตอร์เมื่อไม่ใช่อุปกรณ์เชิงกล เหตุผลคือประวัติศาสตร์ อุปกรณ์คอมพิวเตอร์เครื่องแรกเป็นแบบกลไกที่ประกอบด้วยเฟืองและล้อ เนื้อเพลงของ Allan Sherman "มันเป็นเกียร์ทั้งหมดที่มีเสียงดังก้อง … " อยู่ห่างออกไปเพียงหนึ่งหรือสองศตวรรษ อ่านเพิ่มเติมเกี่ยวกับการคำนวณเบื้องต้นได้ที่นี่

ขั้นตอนที่ 1: รายการชิ้นส่วน

รายการชิ้นส่วนสั้น ต้องใช้เพียงสองรายการนี้เท่านั้น ทั้งสองรายการสามารถดาวน์โหลดได้ฟรี:

1. "Logisim-win-2.7.1.exe" - Logisim เป็นโปรแกรมจำลองตรรกะที่ได้รับความนิยมและใช้งานง่าย ดาวน์โหลดไฟล์ปฏิบัติการ Logisim จากที่นี่ จากนั้นสร้างทางลัดในที่ที่สะดวก เช่น เดสก์ท็อปของคุณ ดับเบิลคลิกที่ไอคอน Logisim เพื่อเปิดใช้งาน หมายเหตุ: Logisim ใช้ Java Runtime Package ซึ่งอยู่ที่นี่ คุณอาจถูกขอให้ดาวน์โหลด
2. BYOC-I-Full.cir" - ดาวน์โหลดไฟล์วงจร Logisim ด้านล่าง

เรียกใช้ Logisim จากนั้นคลิก "เปิดไฟล์" และโหลดไฟล์ BYOC-I-Full.cir ภาพด้านบนแสดงสภาพแวดล้อมการทำงานของ Logisim BYOC-I แสดงโดยบล็อกวงจรย่อย เชื่อมต่อภายนอกเป็นสองอินพุต คือ รีเซ็ตและเรียกใช้ และแสดงเลขฐานสิบหกสำหรับรีจิสเตอร์และหน่วยความจำโปรแกรมของ BYOC-I

หน่วยความจำโปรแกรมของ BYOC-I โหลดไว้ล่วงหน้าด้วยโปรแกรมง่ายๆ ที่นับตั้งแต่ 1 ถึง 5 ในการลงทะเบียน A ในการดำเนินการ (เรียกใช้) โปรแกรม ให้ทำตามขั้นตอนเหล่านี้

ขั้นตอนที่ 1 - คลิกที่เครื่องมือกระตุ้น เคอร์เซอร์ควรเปลี่ยนเป็น "นิ้ว" ที่จิ้ม ขั้นตอนที่ 2 - กระตุ้นอินพุตรีเซ็ตสองครั้ง เมื่อเปลี่ยนเป็น "1" และอีกครั้งเพื่อเปลี่ยนกลับเป็น "0" สิ่งนี้จะรีเซ็ต BYOC-I เพื่อเริ่มโปรแกรมตามที่อยู่ 0 ขั้นตอนที่ 3 - กระตุ้นอินพุตการเรียกใช้หนึ่งครั้งเพื่อเปลี่ยนเป็น "1" การลงทะเบียน A ควรแสดงการนับที่เปลี่ยนจาก 1 เป็น 5 แล้วทำซ้ำ ขั้นตอนที่ 4 - หากโปรแกรมไม่ทำงาน ให้กด control-K และโปรแกรมควรเริ่มทำงาน

หากคุณต้องการสำรวจความสามารถของ Logisim ให้คลิกลิงก์วิธีใช้ในแถบเมนู จากที่นั่น คุณสามารถสำรวจ "บทช่วยสอน" ของ Logisim "คู่มือผู้ใช้" และ "การอ้างอิงไลบรารี" ของ Logisim พบวิดีโอแนะนำที่ยอดเยี่ยมได้ที่นี่

ขั้นตอนที่ 2: ลำดับชั้นและรหัสภาษาเครื่อง

คอมพิวเตอร์ BYOC-I ทำงานตามโปรแกรมที่เขียนด้วยภาษาเครื่อง ในทางกลับกัน โปรแกรม BYOC-I จะประกอบด้วยคำสั่งที่ดำเนินการตามลำดับที่กำหนดไว้อย่างดี แต่ละคำสั่งประกอบด้วยรหัสความยาวคงที่ซึ่งแสดงถึงส่วนประกอบการทำงานต่างๆ ของ BYOC-I สุดท้าย รหัสเหล่านี้ประกอบด้วยสตริง 1 และ 0 ที่ประกอบเป็นภาษาเครื่องที่ BYOC-I ดำเนินการจริง

โดยวิธีการอธิบาย เราจะเริ่มต้นด้วยรหัสและดำเนินการจนถึงระดับโปรแกรม จากนั้นเราจะเขียนโค้ดโปรแกรมอย่างง่าย โหลดลงในหน่วยความจำของ BYOC-I และดำเนินการ

รหัสประกอบด้วยเลขฐานสองคงที่ (1 และ 0) หลักหรือบิต สั้น ๆ ตัวอย่างเช่น ตารางด้านล่างแสดงรหัสที่เป็นไปได้ทั้งหมด (16 ทั้งหมด) สำหรับโค้ดที่มีความกว้าง 4 บิต โค้ดที่แสดงด้านข้างคือเลขฐานสิบหก (ฐาน 16) และค่าเทียบเท่าทศนิยม เลขฐานสิบหกใช้ในการอ้างถึงค่าไบนารีเนื่องจากมีขนาดกะทัดรัดกว่าเลขฐานสองและแปลงจากเลขฐานสองได้ง่ายกว่าทศนิยม คำนำหน้า "0x" ช่วยให้คุณรู้ว่าตัวเลขที่ตามมาคือเลขฐานสิบหกหรือ "ฐานสิบหก" สั้นๆ

ไบนารี - เลขฐานสิบหก - ทศนิยม0000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000ED 14111110 0x000E

ความกว้างของรหัสกำหนดจำนวนรายการที่สามารถแสดงได้ ตามที่ระบุไว้ โค้ดกว้าง 4 บิตด้านบนสามารถแสดงได้ถึง 16 รายการ (0 ถึง 15); นั่นคือ 2 คูณ 2 ถ่ายสี่ครั้งหรือ 2 ถึง 4 ยกกำลังเท่ากับ 16 โดยทั่วไป จำนวนของรายการที่แทนได้คือ 2 ยกกำลังที่ n นี่คือรายการสั้นๆ ของความจุโค้ด n-bit

n - จำนวนรายการ1 22 43 84 165 326 647 1288 256

ความกว้างของรหัสคอมพิวเตอร์ BYOC-I ถูกเลือกเพื่อรองรับจำนวนรายการที่จะแสดงด้วยรหัส ตัวอย่างเช่น มีสี่ประเภทคำสั่ง ดังนั้นรหัสกว้าง 2 บิตจึงเหมาะสม นี่คือรหัส BYOC-I พร้อมคำอธิบายสั้น ๆ ของแต่ละรหัส

Instruction Type Code (tt) มีคำสั่งสี่ประเภท: (1) MVI - ย้ายค่าคงที่ 8 บิตทันทีไปยังหน่วยความจำรีจิสเตอร์ รีจิสเตอร์หน่วยความจำเป็นอุปกรณ์ที่เก็บข้อมูลเพื่อใช้ในการคำนวณ (2) MOV - ย้ายข้อมูลจากรีจิสเตอร์หนึ่งไปยังอีกรีจิสเตอร์หนึ่ง (3) RRC - ทำการคำนวณ register-to-register และ (4) JMP - Jump ไปเป็นคำสั่งอื่นแทนการทำตามคำสั่งถัดไป BYOC-I Instruction Type Codes ที่นำมาใช้มีดังนี้:

00 MVI01 MOV10 RRC11 JMP

Register Code (dd and ss) BYOC-I มีรีจิสเตอร์ 8 บิตสี่ตัวที่สามารถจัดเก็บค่าได้ตั้งแต่ 0 ถึง 255 รหัส 2 บิตเพียงพอที่จะกำหนดรีจิสเตอร์สี่ตัว:

00 F register01 E register10 D register11 A register

รหัสการคำนวณ (ccc) BYOC-I รองรับการดำเนินการทางคณิตศาสตร์/ตรรกะสี่อย่าง เพื่อให้สามารถขยายการคำนวณได้ถึงแปดครั้งในอนาคต จะใช้รหัส 3 บิต:

000 เพิ่ม เพิ่มค่า 8 บิตสองค่าในรีจิสเตอร์ที่กำหนด และเก็บผลลัพธ์ไว้ในรีจิสเตอร์ 001 SUB ตัวใดตัวหนึ่ง ลบค่า 8 บิตสองค่าในรีจิสเตอร์ที่กำหนด และเก็บผลลัพธ์ไว้ในรีจิสเตอร์ตัวใดตัวหนึ่ง 010 - 011 สงวนไว้สำหรับใช้ในอนาคต100 และ ตามหลักเหตุผลและค่า 8 บิตสองค่าในรีจิสเตอร์ที่กำหนดและเก็บผลลัพธ์ไว้ในรีจิสเตอร์101ตัวใดตัวหนึ่ง OR ตามหลักตรรกะหรือค่า 8 บิตสองค่าในรีจิสเตอร์ที่กำหนด และเก็บผลลัพธ์ไว้ในรีจิสเตอร์110 ถึง 111 ตัวใดตัวหนึ่ง สงวนไว้สำหรับใช้ในอนาคต

Jump Code (j) รหัส 1 บิตที่ระบุว่าการกระโดดไม่มีเงื่อนไข (j = 1) หรือมีเงื่อนไขกับผลการคำนวณที่ไม่เป็นศูนย์ (j = 0)

ข้อมูล/รหัสที่อยู่ (v…v)/(a…a) ข้อมูล 8 บิตสามารถรวมไว้ในคำแนะนำบางอย่างที่แสดงค่าได้ตั้งแต่ 00000000 ถึง 11111111 หรือ 0 ถึง 255 ทศนิยม ข้อมูลนี้มีความกว้าง 8 บิตสำหรับการจัดเก็บในรีจิสเตอร์ 8 บิตของ BYOC-I ด้วยเลขคณิตทศนิยม เราจะไม่แสดงเลขศูนย์นำหน้า ด้วยเลขคณิตของคอมพิวเตอร์ เราจะแสดงเลขศูนย์นำหน้าแต่ไม่มีผลกับค่า 00000101 เป็นตัวเลขเหมือนกับทศนิยม 101 หรือ 5

ข้อมูลอ้างอิงที่แนะนำ

สัญลักษณ์ไบนารี - https://learn.sparkfun.com/tutorials/binaryHexadecimal Notation -

อ่านเพิ่มเติม

แนวคิดในการใช้รหัสเพื่อขับเคลื่อนกระบวนการมีมานานแล้ว ตัวอย่างที่น่าสนใจอย่างหนึ่งคือ Jacquard Loom เครื่องทอผ้าอัตโนมัติถูกควบคุมโดยโซ่ของการ์ดไม้ซึ่งเจาะรูแทนรหัสสำหรับเส้นด้ายสีต่างๆ สำหรับการทอ ฉันเห็นร้านแรกในสกอตแลนด์ที่ใช้ทำผ้าตาหมากรุกหลากสี อ่านเพิ่มเติมเกี่ยวกับ Jacquard Looms ที่นี่

ขั้นตอนที่ 3: กายวิภาคของคำสั่ง BYOC-I

ด้วยรหัสของ BYOC-I เราจึงก้าวไปสู่ระดับถัดไป คำแนะนำ ในการสร้างคำสั่งสำหรับ BYOC-I เราวางรหัสไว้ด้วยกันในลำดับที่ระบุและในตำแหน่งเฉพาะภายในคำสั่ง รหัสบางรหัสไม่ปรากฏในคำแนะนำทั้งหมด แต่เมื่อพวกเขาทำ รหัสเหล่านั้นจะครอบครองตำแหน่งเฉพาะ

ประเภทคำสั่ง MVI ต้องการบิตมากที่สุด โดยทั้งหมด 12 บิต โดยการสร้างคำคำสั่งให้มีความยาว 12 บิต เรารองรับคำสั่งทั้งหมดได้ บิตที่ไม่ได้ใช้ (เรียกว่า "ไม่สนใจ") จะได้รับค่า 0 นี่คือชุดคำสั่ง BYOC-I

1. Move Immediate (MVI) - 00 dd vvvvvvvvvFunction: ย้ายค่าข้อมูล 8 บิต V = vvvvvvvvv ไปยังรีจิสเตอร์ปลายทาง dd หลังจากดำเนินการแล้ว register dd จะมีค่า vvvvvvvv ตัวย่อ: MVI R, V โดยที่ R คือ A, D, E หรือ F ตัวอย่าง: 00 10 00000101 - MVI D, 5 - ย้ายค่า 5 ไปยังการลงทะเบียน D
2. ย้าย Register to Register (MOV) - 01 dd ss 000000Function: ย้ายข้อมูลจากแหล่ง register ss ไปยัง desination register dd หลังจากดำเนินการ รีจิสเตอร์ทั้งสองมีค่าเท่ากันกับรีจิสเตอร์ต้นทาง ตัวย่อ: MOV Rd, Rs โดยที่ Rd คือรีจิสเตอร์ปลายทาง A, D, E หรือ F และ Rs คือรีจิสเตอร์ต้นทาง A, D, E หรือ F ตัวอย่าง: 01 11 01 000000 - MOV A, E - ย้ายค่า ในการลงทะเบียน E เพื่อลงทะเบียน A
3. Register to Register Calculation (RRC) - 10 dd ss ccc 000Function: ดำเนินการคำนวณที่กำหนด ccc โดยใช้ ss register ที่มาและ register dd ปลายทาง จากนั้นเก็บผลลัพธ์ไว้ใน register ปลายทาง คำย่อ: ADD Rd, Rs (ccc=000 Rd + Rs เก็บไว้ใน ถ.); SUB Rd, Rs (ccc=001 Rd - Rs เก็บไว้ใน Rd); AND Rd, Rs (ccc=100 Rd AND Rs เก็บไว้ใน Rd); OR Rd, Rs (ccc=101 Rd OR Rs ที่จัดเก็บไว้ใน Rd) ตัวอย่าง: 10 00 11 001 000 - SUB F, A - ลบค่าในรีจิสเตอร์ A จากรีจิสเตอร์ F พร้อมผลลัพธ์ในรีจิสเตอร์ F
4. Jump to Different Instruction (JMP) - 11 j 0 aaaaaaaaFunction: Change operation เป็นคำสั่งอื่นที่อยู่ที่ aaaa aaaa(a) ไม่มีเงื่อนไข (j=1) -11 1 0 aaaaaaaa ตัวย่อ: JMP L โดยที่ L คือ address aaaa aaaaExample: 11 1 0 00001000 - JMP 8 - เปลี่ยนการดำเนินการเป็นที่อยู่ 8.(b) แบบมีเงื่อนไข (j=0) เมื่อการคำนวณครั้งก่อนให้ผลลัพธ์ไม่เป็นศูนย์ - 11 0 0 aaaaaaaa ตัวย่อ: JNZ L โดยที่ L คือที่อยู่ aaaa aaaa. Example: 11 0 0 00000100 JNZ 4 หากการคำนวณครั้งล่าสุดให้ค่าที่ไม่เป็นศูนย์ ให้เปลี่ยนการดำเนินการเป็นที่อยู่ 4

บิตของคำคำสั่งจะเรียงลำดับจากซ้าย (บิตที่สำคัญที่สุด MSB) ไปทางขวา (บิตที่มีนัยสำคัญน้อยที่สุด LSB) จาก 11 ถึง 0 ลำดับคงที่และตำแหน่งของรหัสมีดังนี้:

Bits - Code11-10 Instruction Type9-8 Destination Register7-6 Source Register5-3 การคำนวณ: 000 - เพิ่ม; 001 - ลบ; 100 - ตรรกะและ; 101 - ตรรกะ OR7-0 ค่าคงที่ v…v และ a…a (0 ถึง 255)

ชุดคำสั่งสรุปไว้ในรูปด้านบน สังเกตลักษณะที่มีโครงสร้างและเป็นระเบียบของรหัสในแต่ละคำสั่ง ผลลัพธ์ที่ได้คือการออกแบบที่เรียบง่ายขึ้นสำหรับ BYOC-I และทำให้มนุษย์เข้าใจคำสั่งได้ง่ายขึ้น

ขั้นตอนที่ 4: การเข้ารหัสคำสั่งคอมพิวเตอร์

ก่อนย้ายไปยังระดับโปรแกรม เรามาสร้างตัวอย่างคำแนะนำโดยใช้ชุดคำสั่ง BYOC-I ด้านบนกัน

1. ย้ายค่า 1 เพื่อลงทะเบียน A การลงทะเบียน BYOC-I สามารถเก็บค่าได้ตั้งแต่ 0 ถึง 255 ในกรณีนี้ การลงทะเบียน A จะมีค่า 1 (00000001 ไบนารี) หลังจากดำเนินการตามคำสั่ง

ตัวย่อ: MVI A, 1Codes Required: Type MVI - 00; ปลายทาง ลงทะเบียน A - 11; ค่า - 00000001คำคำสั่ง: 00 11 00000001

2. ย้ายเนื้อหาของรีจิสเตอร์ A ไปยังรีจิสเตอร์ D หลังจากดำเนินการ รีจิสเตอร์ทั้งสองจะมีค่าเดิมในรีจิสเตอร์ A

ตัวย่อ: MOV D, A (โปรดจำไว้ว่าปลายทางเป็นที่หนึ่งและแหล่งที่มาที่สองในรายการ) รหัสที่ต้องการ: ประเภท MOV - 01; ปลายทางลงทะเบียน D - 10; แหล่งลงทะเบียน A - 11คำคำสั่ง: 01 10 11 000000

3. เพิ่มเนื้อหาของรีจิสเตอร์ D เพื่อรีจิสเตอร์ A และเก็บไว้ในรีจิสเตอร์ A หลังจากดำเนินการ ค่าของ register A จะเป็นผลรวมของค่าเดิมของ register A และ register D

ตัวย่อ: ADD A, D (ผลลัพธ์ถูกเก็บไว้ในการลงทะเบียนปลายทาง) รหัสที่ต้องการ: ประเภท RRC - 10; ปลายทาง ลงทะเบียน A - 11; แหล่งลงทะเบียน D - 10; การคำนวณ เพิ่ม - 000คำแนะนำ: 10 11 10 000 000 (ccc เป็น 000 แรก - เพิ่ม)

4. ข้ามไปที่ไม่เป็นศูนย์ไปยังที่อยู่ 3. หากผลลัพธ์ของการคำนวณครั้งสุดท้ายไม่เป็นศูนย์ การดำเนินการจะเปลี่ยนเป็นคำสั่งตามที่อยู่ที่ระบุ หากเป็นศูนย์ การดำเนินการจะดำเนินต่อตามคำสั่งต่อไปนี้

ตัวย่อ: JNZ 3Codes Required: Type JMP - 11; ประเภทกระโดด - 0; ที่อยู่ - 00000003คำสั่งสอน: 11 0 0 00000003 (ประเภทการกระโดดเป็น 0)

5. ข้ามโดยไม่มีเงื่อนไขไปยังที่อยู่ 0 หลังจากดำเนินการ การดำเนินการจะเปลี่ยนคำสั่งตามที่อยู่ที่กำหนด

ตัวย่อ: JMP 0Code Required: Type JMP - 11; ประเภทกระโดด - 1; ที่อยู่ - 00000000 คำสั่ง; 11 1 0 00000000

แม้ว่าการเข้ารหัสด้วยเครื่องจะค่อนข้างน่าเบื่อ แต่คุณจะเห็นว่ามันไม่ยากอย่างที่คิด หากคุณเป็นเครื่องเข้ารหัสจริง คุณจะใช้โปรแกรมคอมพิวเตอร์ที่เรียกว่าแอสเซมเบลอร์เพื่อแปลจากตัวย่อ (ซึ่งเรียกว่ารหัสแอสเซมบลี) เป็นรหัสเครื่อง

ขั้นตอนที่ 5: กายวิภาคของโปรแกรมคอมพิวเตอร์

โปรแกรมคอมพิวเตอร์คือรายการคำสั่งที่คอมพิวเตอร์ดำเนินการตั้งแต่เริ่มต้นของรายการ ต่อเนื่องไปจนถึงรายการสิ้นสุด คำแนะนำเช่น JNZ และ JMP สามารถเปลี่ยนแปลงคำสั่งที่จะดำเนินการต่อไปได้ แต่ละคำสั่งในรายการใช้ที่อยู่เดียวในหน่วยความจำของคอมพิวเตอร์โดยเริ่มต้นที่ 0 หน่วยความจำ BYOC-I สามารถเก็บรายการคำสั่ง 256 คำสั่ง ซึ่งมากเกินเพียงพอสำหรับวัตถุประสงค์ของเรา

โปรแกรมคอมพิวเตอร์ถูกออกแบบมาเพื่อทำงานที่กำหนด สำหรับโปรแกรมของเรา เราจะเลือกงานง่าย ๆ นับ 1 ถึง 5 เห็นได้ชัดว่าไม่มีคำสั่ง "นับ" ดังนั้นขั้นตอนแรกคือแบ่งงานออกเป็นขั้นตอนที่ BYOC-I จัดการได้ ชุดคำสั่งจำกัด

ขั้นตอนที่ 1 ย้าย 1 เพื่อลงทะเบียน AStep 2 ย้ายการลงทะเบียน A เพื่อลงทะเบียน DStep 3 เพิ่มการลงทะเบียน D เพื่อลงทะเบียน A และเก็บผลลัพธ์ในการลงทะเบียน AStep 4 ย้าย 5 เพื่อลงทะเบียน EStep 5 ลบการลงทะเบียน A จากการลงทะเบียน E และเก็บผลลัพธ์ในการลงทะเบียน EStep 6 ถ้า ผลการลบไม่เป็นศูนย์ ให้กลับไปที่ขั้นตอนที่ 4 แล้วนับต่อขั้นตอนที่ 7 หากผลการลบเป็นศูนย์ ให้กลับไปเริ่มใหม่

ขั้นตอนต่อไปคือการแปลขั้นตอนเหล่านี้เป็นคำแนะนำ BYOC-I โปรแกรม BYOC-I เริ่มต้นที่ที่อยู่ 0 และหมายเลขตามลำดับ ที่อยู่เป้าหมายการข้ามจะถูกเพิ่มล่าสุดหลังจากมีคำแนะนำทั้งหมดแล้ว..

ที่อยู่:คำแนะนำ - ตัวย่อ;Description0:00 11 00000001 - MVI A, 1;ย้าย 1 เพื่อลงทะเบียน A1:01 10 11 000000 - MOV D, A;ย้าย register A เพื่อลงทะเบียน D2:10 11 10 000 000 - ADD A, D;เพิ่ม register D เพื่อ register A และเก็บผลลัพธ์ไว้ใน register A3:00 01 00 00000101 - MVI E, 5;Move 5 register E4:10 01 11 001 000 - SUB E, A;ลบ register A จาก register E และเก็บ ส่งผลให้รีจิสเตอร์ E5:11 0 0 00000010 - JNZ 2;หากผลการลบไม่เป็นศูนย์ ให้กลับไปที่ที่อยู่ 3 และนับต่อ 6:11 1 0 00000000 - JMP 0 หากผลการลบเป็นศูนย์ ให้กลับไปเริ่มต้นใหม่

ก่อนถ่ายโอนโปรแกรมไปยังหน่วยความจำ จะต้องเปลี่ยนรหัสคำสั่งไบนารีเป็นเลขฐานสิบหกเพื่อใช้กับ Logisim Hex Editor ขั้นแรก แบ่งคำสั่งออกเป็นสามกลุ่ม กลุ่มละ 4 บิต จากนั้นแปลกลุ่มต่างๆ เป็นเลขฐานสิบหกโดยใช้ตารางในขั้นตอนที่ 2 จะใช้เฉพาะเลขฐานสิบหกสามหลักสุดท้าย (ตัวหนาด้านล่าง)

ที่อยู่ - Instruction Binary - Instruction Binary Split - Instruction (Hex)0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101 - 0x01054 100111002 - 1001000000 011085 110085 111000000010 1110 0000 0000 - 0x0E00

ได้เวลาโอนโปรแกรมไปยังหน่วยความจำของ BYOC-I เพื่อทำการทดสอบ

ขั้นตอนที่ 6: การถ่ายโอนโปรแกรมไปยังหน่วยความจำและการทดสอบ

เมื่อดูที่วงจร "หลัก" ของ Logisim บล็อก BYOC-I ที่แสดงจะเป็นสัญลักษณ์สำหรับวงจรคอมพิวเตอร์จริงที่มีป้ายกำกับ "BYOC-I" ในบานหน้าต่างสำรวจ ในการเข้าสู่โปรแกรมลงในหน่วยความจำ BYOC-I:

1. คลิกขวาที่บล็อก BYOC-I (เรียกว่า "วงจรย่อย") และเลือก (วางเมาส์เหนือและคลิกซ้าย) "ดู BYOC-I"
2. วงจร BYOC-I จะปรากฏในพื้นที่ทำงาน คลิกขวาที่สัญลักษณ์ "Program Memory" และเลือก "Edit Contents.."
3. ใช้ Logisim Hex Editor ป้อนรหัสฐานสิบหก (ตัวหนาเท่านั้น) ดังที่แสดงด้านบน

ตอนนี้คุณพร้อมที่จะรันโปรแกรมแล้ว กลับไปที่วงจรหลักโดยดับเบิลคลิก "BYOC-I" ใน Explorer Pane อินพุตเรียกใช้และรีเซ็ตควรเป็น "0" เพื่อเริ่มต้น ใช้ Poke Tool ขั้นแรกให้เปลี่ยน Reset เป็น "1" แล้วเปลี่ยนกลับเป็น "0" ซึ่งจะทำให้ที่อยู่เริ่มต้น 0x0000 และเตรียมวงจร BYOC-I สำหรับการดำเนินการ ตอนนี้กระตุ้นอินพุต Run ไปที่ "1" และโปรแกรมจะทำงาน (หมายเหตุ: คุณต้องแตะ Control-K หนึ่งครั้งเพื่อเริ่มนาฬิกา Logisim นี่เป็นคุณสมบัติที่ให้คุณหยุดนาฬิกา Logisim และก้าวผ่านโปรแกรมโดยแตะ Control-T ซ้ำๆ ลองทำดู!)

นาฬิกา Logisim สามารถตั้งค่าได้สำหรับความถี่ที่หลากหลาย เมื่อดาวน์โหลดเป็น 8 Hz (8 รอบต่อวินาที) วิธีการออกแบบคอมพิวเตอร์ BYOC-I แต่ละคำสั่งจะใช้เวลาสี่รอบนาฬิกาจึงจะเสร็จสมบูรณ์ ดังนั้น ในการคำนวณความเร็ว BYOC-I ให้หารความถี่สัญญาณนาฬิกาด้วย 4 ที่ 8 Hz ความเร็วของมันคือ 2 คำสั่งต่อวินาที คุณสามารถเปลี่ยนนาฬิกาได้โดยคลิก "จำลอง" บนแถบเครื่องมือและเลือก "ติ๊กความถี่" ช่วงที่เป็นไปได้คือ 0.25 Hz ถึง 4100 Hz เลือกความเร็วช้าที่ 8 Hz เพื่อให้คุณสามารถดูการนับในการลงทะเบียน A

ความเร็วสูงสุดของการจำลอง BYOC-I (~1000 คำสั่งต่อวินาที) นั้นช้ามากเมื่อเทียบกับคอมพิวเตอร์สมัยใหม่ เวอร์ชันฮาร์ดแวร์ของคอมพิวเตอร์ BYOC ที่อธิบายไว้ในหนังสือของฉันทำงานด้วยคำสั่งมากกว่า 12 ล้านคำสั่งต่อวินาที!

ฉันหวังว่าคำแนะนำนี้จะทำให้การเขียนโปรแกรมภาษาเครื่องกระจ่างและให้ข้อมูลเชิงลึกเกี่ยวกับวิธีการทำงานของคอมพิวเตอร์ในระดับพื้นฐานที่สุด เพื่อทำความเข้าใจ ให้ลองเขียนโค้ดสองโปรแกรมด้านล่างนี้

1. เขียนโปรแกรมที่เริ่มต้นที่ 5 และนับถอยหลังถึง 0 (ANS. Count5to0.txt ด้านล่าง)
2. เริ่มต้นที่ 2 นับด้วย 3 จนกว่าจำนวนจะเกิน 7 คุณสามารถคิดเลขในใจได้เล็กน้อย ตรวจดูว่าเลข 8 จะลงจอดที่นั่นแล้วเริ่มใหม่ เขียนโปรแกรมของคุณให้กว้างขึ้นเพื่อทดสอบว่าการนับนั้น "เกิน" ตัวเลขที่ระบุจริงหรือไม่ คำแนะนำ: สำรวจว่าเกิดอะไรขึ้นเมื่อการลบให้ค่าลบ เช่น 8 - 9= -1 เป็นต้น จากนั้นทดสอบด้วยตรรกะ AND เพื่อทดสอบว่า MSB ในตัวเลข 8 บิตเป็น "1" หรือไม่ (ANS. ExceedsCount.txt)

คุณนึกถึงปัญหาที่ท้าทายอื่นๆ สำหรับคอมพิวเตอร์ BYOC-I ได้ไหม ด้วยข้อจำกัดของมัน มันสามารถทำอะไรได้อีก? แบ่งปันประสบการณ์ของคุณกับฉันที่ [email protected] หากคุณสนใจที่จะเขียนโค้ดไมโครโปรเซสเซอร์ เข้าไปที่เว็บไซต์ของฉัน www.whippleway.comที่นั่นฉันพกการเข้ารหัสเครื่องไปยังโปรเซสเซอร์ที่ทันสมัยเช่น ATMEL Mega series ที่ใช้ใน Arduinos