Կոդավորեք և փորձեք համակարգիչը մեքենայական լեզվով ՝ 6 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:47

Այս Instructable- ում ես ձեզ ցույց կտամ, թե ինչպես պետք է կոդավորել և ստուգել համակարգչային ծրագիրը մեքենայական լեզվով: Մեքենայական լեզուն համակարգիչների մայրենի լեզուն է: Քանի որ այն կազմված է 1s և 0s տողերից, այն հեշտությամբ չի ընկալվում մարդկանց կողմից: Այս խնդիրը լուծելու համար մենք ծրագրեր ենք կոդավորում նախ բարձր մակարդակի լեզվով, ինչպիսիք են C ++ կամ Java- ն, այնուհետև օգտագործում ենք հատուկ համակարգչային ծրագրեր `դրանք 1 -ին և 0 -երի համակարգիչներին հասկանալի թարգմանելու համար: Բարձր մակարդակի լեզվով ծածկագրել սովորելը, անշուշտ, անիմաստ է, բայց մեքենայական լեզվի կարճ ներածությունը կարող է արժեքավոր պատկերացում կազմել համակարգիչների աշխատանքի մասին և բարձրացնել այս շատ կարևոր տեխնոլոգիայի գնահատումը:

Մեքենայական լեզվով ծրագիր կոդավորելու և փորձարկելու համար մեզ անհրաժեշտ է մուտք ունենալ ոչ ծայրահեղ համակարգիչ, որի մեքենայական լեզուն հեշտությամբ ընկալելի է: Անհատական համակարգիչները չափազանց բարդ են նույնիսկ մտածելու համար: Լուծումը Logisim- ի ՝ տրամաբանական սիմուլյատորի օգտագործումն է, որն աշխատում է անհատական համակարգչով: Logisim- ի միջոցով մենք կարող ենք մոդելավորել համակարգիչ, որը բավարարում է մեր կարիքները: Վերոնշյալ տեսանյութը ձեզ որոշակի գաղափար է տալիս, թե ինչ կարող ենք անել Logisim- ի հետ:

Համակարգչային դիզայնի համար ես հարմարեցրի մեկը Kindle էլեկտրոնային գրքից Build Your Own Computer - From Scratch: Ես սկսեցի այնտեղ նկարագրված BYOC համակարգչից և այն կրճատեցի մինչև տարբեր հիմնական BYOC-I (I for Instructable), որը մենք կօգտագործենք այս Instructable- ում:

BYOC-I- ի մեքենայական լեզուն պարզ է և հեշտ ընկալելի: Ձեզ հարկավոր չեն համակարգիչների կամ ծրագրավորման հատուկ գիտելիքներ: Պահանջվում է միայն հետաքրքրասեր միտք և սովորելու ցանկություն:

Լրացուցիչ ընթերցում

Դուք կարող եք մտածել, թե ինչու ենք մենք օգտագործում «մեքենա» ՝ համակարգիչը նկարագրելու համար, երբ այն մեխանիկական սարք չէ: Պատճառը պատմական է. առաջին հաշվիչ սարքերը մեխանիկական էին, որոնք բաղկացած էին շարժակների և անիվներից: Ալան Շերմանի քնարերգությունը ՝ «Ամեն ինչ արագընթաց կերպով… Կարդացեք ավելին վաղ հաշվարկների մասին այստեղ:

Քայլ 1: Մասերի ցուցակ

Մասերի ցանկը կարճ է: Պահանջվում են միայն այս երկու տարրերը, երկուսն էլ անվճար ներբեռնվող.

1. «Logisim-win-2.7.1.exe»-Logisim- ը հանրաճանաչ և հեշտ օգտագործվող տրամաբանական սիմուլյատոր է: Ներբեռնեք Logisim գործարկվող ֆայլը այստեղից, այնուհետև ստեղծեք կարճ կտրվածք ձեր աշխատասեղանի նման հարմար վայրում: Կրկնակի կտտացրեք Logisim պատկերակին ՝ այն գործարկելու համար: Նշում. Logisim- ն օգտագործում է Java- ի գործարկման փաթեթը, որը գտնվում է այստեղ: Ձեզանից կարող է պահանջվել ներբեռնել այն:
2. BYOC-I-Full.cir »-Ներբեռնեք Logisim սխեմայի ֆայլը ստորև:

Գործարկեք Logisim- ը, այնուհետև կտտացրեք «Պատկեր-բացել» և բեռնեք BYOC-I-Full.cir ֆայլը: Վերևի պատկերը ցույց է տալիս Logisim- ի աշխատանքային միջավայրը: BYOC-I- ը ներկայացված է ենթաշրջանի բլոկով: Արտաքին կապ ունեն երկու մուտք ՝ Reset և Run և BYOC-I գրանցամատյանների և ծրագրային հիշողության վեցանկյուն ցուցադրումներ:

BYOC-I- ի ծրագրային հիշողությունը նախապես բեռնված է մի պարզ ծրագրով, որը հաշվում է 1-ից 5-ը A գրանցամատյանում: Programրագիրը գործարկելու (գործարկելու) համար հետևեք այս քայլերին:

Քայլ 1 - Կտտացրեք Poke գործիքին: Կուրսորը պետք է փոխվի դեպի ծակող «մատը»: Քայլ 2 - Երկու անգամ սեղմեք «Վերականգնել» մուտքագրումը ՝ մեկ անգամ այն փոխելով «1» -ի և կրկին «0» - ի: Սա վերականգնում է BYOC -I- ը `ծրագիրը 0 հասցեով սկսելու համար: Քայլ 3 - Մեկ անգամ սեղմեք Run մուտքագրումը` այն «1» փոխելու համար: A գրանցամատյանը պետք է ցույց տա, որ հաշվարկը փոխվում է 1 -ից 5 -ի, այնուհետև կրկնվում է: Քայլ 4 - Եթե ծրագիրը չի գործարկվում, սեղմեք control -K և այն պետք է սկսվի:

Եթե ցանկանում եք ուսումնասիրել Logisim- ի հնարավորությունները, կտտացրեք Մենյու բարում գտնվող Օգնության հղմանը: Այնտեղից կարող եք ուսումնասիրել Logisim «Tutorial», «User Guide» և «Library Reference»: Հիանալի տեսանյութի ներածություն կարելի է գտնել այստեղ:

Քայլ 2. Մեքենաների լեզվի հիերարխիա և ծածկագրեր

BYOC-I համակարգիչը կատարում է առաջադրանքներ ՝ հիմնված մեքենայական լեզվով գրված ծրագրերի վրա: BYOC-I ծրագրերն, իր հերթին, կազմված են հստակ սահմանված հաջորդականությամբ կատարված հրահանգներից: Յուրաքանչյուր հրահանգ կազմված է ֆիքսված երկարության կոդերից, որոնք ներկայացնում են BYOC-I- ի տարբեր գործառնական բաղադրիչներ: Ի վերջո, այս կոդերը բաղկացած են 1s և 0s տողերից, որոնք կազմում են մեքենայի լեզուն, որն իրականում իրականացնում է BYOC-I- ը:

Որպես բացատրություն, մենք կսկսենք ծածկագրերից և կանցնենք ծրագրի մակարդակին: Այնուհետև մենք կոդավորելու ենք մի պարզ ծրագիր, բեռնելու այն BYOC-I- ի հիշողության մեջ և գործարկելու այն:

Կոդերը բաղկացած են երկուական (1 և 0) թվանշաններից կամ կարճ բիթերից `կարճ: Օրինակ, ստորև բերված աղյուսակը ցույց է տալիս 4 բիթ լայնությամբ ծածկագրի բոլոր հնարավոր կոդերը (ընդհանրապես 16): Կոդի կողքին ցուցադրվում է տասնվեցական (հիմք 16) և տասնորդական համարժեքը: Վեցանկյունը օգտագործվում է երկուական արժեքներին հղում կատարելիս, քանի որ այն ավելի կոմպակտ է քան երկուական և ավելի հեշտ է փոխակերպվել երկուականից, քան տասնորդական: «0x» նախածանցը թույլ է տալիս իմանալ, թե որ թիվը հաջորդում է տասնվեցական կամ կարճ «վեցանկյուն»:

Երկուական - տասնվեցական - տասնորդական 10000 0x0000 00001 0x0001 10010 0x0002 20011 0x0003 30100 0x0004 40101 0x0005 50111 0x0007 71000 0x0008 81001 0x0009 91010 0x000A 101011 0x000B 111100 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000C 121101 0x000 C

Կոդի լայնությունը որոշում է, թե քանի տարր կարող է ներկայացվել: Ինչպես նշվեց, վերը նշված 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 ծածկագրերը `յուրաքանչյուրի հակիրճ բացատրությամբ:

Հրահանգի տիպի ծածկագիր (tt) Կան չորս տեսակի հրահանգներ. (1) MVI - Տեղափոխեք անհապաղ 8 -բիթանոց մշտական արժեքը հիշողության գրանցամատյանում: Հիշողության գրանցամատյանը մի սարք է, որը պահում է տվյալներ, որոնք պետք է օգտագործվեն հաշվարկման համար, հաջորդ հրահանգով շարունակելու փոխարեն այլ հրահանգի: Ընդունված BYOC-I հրահանգի տիպի կոդերը հետևյալն են.

00 MVI01 MOV10 RRC11 JMP

Գրանցման կոդ (dd և ss) BYOC-I- ն ունի չորս 8-բիթանոց գրանցամատյաններ, որոնք ունակ են պահպանել 0-ից 255-ի արժեքները: Երկու բիթանոց կոդը բավարար է չորս գրանցամատյանները նշանակելու համար.

00 F գրանցամատյան 01 գրանցամատյան 10 D գրանցամատյան 11 A գրանցամատյան

Հաշվարկման ծածկագիր (ccc) BYOC-I- ն ապահովում է թվաբանական/տրամաբանական չորս գործողություն: Ապագա ընդլայնումը ութ հաշվարկների համար օգտագործվում է 3-բիթանոց ծածկագիր.

000 ADD, նշանակված գրանցամատյաններում ավելացրեք երկու 8-բիթանոց արժեք և արդյունքը պահեք 001 SUB գրանցամատյաններից մեկում, նշանակված գրանցամատյաններում հանեք երկու 8-բիթանոց արժեքներ և արդյունքը պահեք 010-011 գրանցամատյաններից մեկում: Վերապահված է հետագա օգտագործման համար 100 ԵՎ, տրամաբանորեն ԵՎ երկու 8 բիթանոց նշանակված գրանցամատյաններում և արդյունքը պահեք գրանցամատյաններից մեկում 101 ԿԱՄ, տրամաբանորեն կամ երկու 8 բիթանոց արժեք նշանակված գրանցամատյաններում և արդյունքը պահեք գրանցամատյաններից մեկում ՝ 110-ից 111-ը, վերապահված է հետագա օգտագործման համար

Jump Code (j) 1-բիթանոց կոդ, որը ցույց է տալիս, թե արդյոք ցատկումը անվերապահ է (j = 1), թե՞ ոչ զրոյական հաշվարկման արդյունքով (j = 0):

Տվյալներ/Հասցեի ծածկագիր (v… v)/(a… a) 8-բիթանոց տվյալները կարող են ներառվել 00000000-ից մինչև 11111111 կամ 0-ից 255 տասնորդական արժեքներ ներկայացնող որոշ հրահանգների մեջ: Այս տվյալները 8-բիթանոց են BYOC-I- ի 8-բիթանոց գրանցամատյաններում պահելու համար: Տասնորդական թվաբանությամբ մենք չենք ցուցադրում առաջատար զրոներ: Համակարգչային թվաբանությամբ մենք ցույց ենք տալիս առաջատար զրոները, բայց դրանք չեն ազդում արժեքի վրա: 00000101 թվային առումով նույնն է 101 կամ 5 տասնորդական:

Առաջարկվող հղումներ

Երկուական նշում - https://learn.sparkfun.com/tutorials/binaryHexadecimal Notation -

Լրացուցիչ ընթերցում

Գործընթացը վարելու համար ծածկագրեր օգտագործելու գաղափարը հեռու է գնում: Հետաքրքիր օրինակ է quակարդ Լումը: Ավտոմատ ջուլհակը կառավարվում էր փայտե քարտերի շղթայով, որոնցում ծակվում էին հյուսվածքների տարբեր գույնի մանվածքների ծածկագրեր: Ես տեսա իմ առաջինը Շոտլանդիայում, որտեղ այն օգտագործվում էր գունավոր տարտաններ պատրաստելու համար: Moreակարդ Լոուսի մասին ավելին կարդացեք այստեղ:

Քայլ 3. BYOC-I հրահանգների անատոմիա

Հաշվի առնելով BYOC-I- ի ծածկագրերը ՝ մենք անցնում ենք հաջորդ մակարդակին ՝ հրահանգներին: BYOC-I- ի համար հրահանգ ստեղծելու համար մենք տեղադրում ենք կոդերը միասին ՝ ըստ հերթականության և հրահանգի որոշակի վայրերում: Ոչ բոլոր կոդերն են հայտնվում բոլոր հրահանգներում, բայց երբ դրանք հայտնվում են, նրանք զբաղեցնում են որոշակի վայր:

MVI հրահանգի տեսակը պահանջում է ամենաշատ բիթերը ՝ ընդհանրապես 12: 12 բիթ երկարությամբ դարձնելով ուսուցողական բառը, մենք տեղավորում ենք բոլոր հրահանգները: Չօգտագործված (այսպես կոչված ՝ «մի հոգա») բիթերին տրվում է 0. արժեքը: Ահա BYOC-I հրահանգների հավաքածուն:

1. Տեղափոխել անհապաղ (MVI) - 00 օր vvvvvvvv Ֆունկցիա. Տեղափոխել 8 բիթանոց տվյալների արժեքը V = vvvvvvvv դեպի նշանակման գրանցամատյան dd: Կատարումից հետո dd գրանցամատյանը կունենա vvvvvvvv արժեքը: Հապավում. MVI R, V, որտեղ R- ն A, D, E, կամ F. Օրինակ: 00 10 00000101 - MVI D, 5 - 5 արժեքը տեղափոխեք D գրանցամատյան:
2. Տեղափոխել գրանցումը գրանցման համար (MOV) - 01 dd ss 000000 Գործառույթ. Տեղափոխեք տվյալները աղբյուրի գրանցամատյանի ss- ից desd գրանցման dd: Կատարումից հետո երկու գրանցամատյաններն ունեն նույն արժեքը, ինչ աղբյուրի գրանցամատյանը: Հապավում ՝ MOV Rd, Rs, որտեղ Rd- ը A, D, E կամ F- ի նշանակման գրանցամատյան է, իսկ Rs- ը ՝ A, D, E, կամ F. աղբյուրի գրանցամատյան: Օրինակ ՝ 01 11 01 000000 - MOV A, E - Տեղափոխել արժեքը գրանցամատյանում E գրանցելու համար Ա.
3. Գրանցվել գրանցման հաշվառում (RRC) - 10 dd ss ccc 000 Գործառույթ. Կատարել նշանակված հաշվարկ ccc ՝ օգտագործելով սկզբնաղբյուրի ss և նշանակման գրանցամատյան dd, այնուհետև արդյունքը պահել նպատակակետի գրանցամատյանում: հապավումներ. ADD Rd, Rs (ccc = 000 Rd + Rs պահված Rd); 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. Անցնել տարբեր հրահանգների (JMP) - 11 j 0 aaaaaaa գործառույթ. Փոփոխել կատարումը aaaaaaaa (a) հասցեում գտնվող մեկ այլ հրահանգի `անվերապահորեն (j = 1) -11 1 0 aaaaaaaa հապավում. JMP L, որտեղ L- ն հասցե է aaaa aaaa Օրինակ: 11 1 0 00001000 - JMP 8 - Փոխել կատարումը հասցեի 8. (բ) Պայմանականորեն (j = 0), երբ նախորդ հաշվարկը հանգեցրել է ոչ զրո արդյունքի - 11 0 0 աաաաաաաա Հակասություն. JNZ L որտեղ L հասցեն աաաա աաաա: Օրինակ `11 0 0 00000100 NՆ 4 Եթե վերջին հաշվարկը տվել է ոչ զրոյական արժեք, կատարումը փոխեք հասցեի 4-ի:

Ուղեցույցի բառերի բիթերը համարակալված են ձախից (ամենակարևոր բիթը ՝ MSB) դեպի աջ (նվազագույն նշանակալի բիթը ՝ LSB) ՝ 11 -ից մինչև 0. Կոդերի ֆիքսված կարգը և տեղերը հետևյալն են.

Բիթեր-Կոդ 11-10 Հրահանգի տիպ 9-8 Ուղղությունների գրանցամատյան 7-6 Աղբյուրի գրանցամատյան 5-3 Հաշվարկ ՝ 000-ավելացնել; 001 - հանել; 100 - տրամաբանական AND; 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, 1 Պարտադիր կոդեր ՝ Տեսակ MVI - 00; Նշանակման գրանցամատյան A - 11; Արժեք - 00000001 Ուղեցույց բառ ՝ 00 11 00000001

2. Տեղափոխեք A գրանցամատյանի բովանդակությունը D. գրանցամատյանում: Կատարումից հետո երկու ռեգիստրները կունենան սկզբնաղբյուր A արժեք:

Հապավում ՝ MOV D, A (Հիշեք, նպատակակետը առաջինն է, իսկ աղբյուրը ՝ ցուցակում երկրորդը) Պահանջվող ծածկագրեր. Մուտքագրեք MOV - 01; Նշանակման գրանցամատյան D - 10; Աղբյուրը գրանցամատյան Ա - 11 Ուղեցույց բառ ՝ 01 10 11 000000

3. A գրանցամատյանում ավելացրեք D գրանցամատյանի բովանդակությունը և պահեք A գրանցամատյանում, կատարումից հետո գրանցամատյանի A արժեքը կլինի A գրանցամատյանի սկզբնական արժեքի և D գրանցման գումարը:

Հապավում ՝ ADD A, D (Արդյունքը պահվում է նպատակակետերի գրանցամատյանում) Պահանջվող ծածկագրեր. Մուտքագրեք RRC - 10; Նշանակման գրանցամատյան A - 11; Աղբյուրի գրանցամատյան D - 10; Հաշվարկի հավելում - 000 Ուղեցույց բառ ՝ 10 11 10 000 000 (ccc առաջին 000 - ավելացնել)

4. Անցնել ոչ զրոյի հասցեով 3. Եթե վերջին հաշվարկի արդյունքը զրո չէր, կատարումը կփոխվի տվյալ հասցեում տրված հրահանգի: Եթե զրո է, կատարումը վերսկսվում է հետևյալ հրահանգով:

Հապավում `JNZ 3 Պարտադիր կոդեր. Տեսակ JMP - 11; Անցման տեսակը `0; Հասցե - 00000003 Ուսուցման բառ ՝ 11 0 0 00000003 (Անցման տեսակը առաջին 0 -ն է)

5. Անցնել անվերապահ ՝ հասցեով 0. Կատարումից հետո կատարումը փոխվում է տվյալ հասցեում գտնվող հրահանգի:

Հապավում `JMP 0 Պարտադիր կոդ. Մուտքագրեք JMP - 11; Անցման տեսակը - 1; Հասցե - 00000000 Ուղեցույց Word; 11 1 0 00000000

Չնայած մեքենայի կոդավորումը որոշ չափով հոգնեցուցիչ է, դուք կարող եք տեսնել, որ դա անհնարին դժվար չէ: Եթե դուք մեքենայորեն կոդավորեիք, դուք համակարգչային ծրագրով կօգտագործեիք հավաքող կոչվող հապավումը (որը կոչվում է հավաքման կոդ) մեքենայական կոդի:

Քայլ 5. Համակարգչային ծրագրի անատոմիա

Համակարգչային ծրագիրը հրահանգների ցանկ է, որոնք համակարգիչը կատարում է ՝ սկսելով ցուցակի սկզբից ՝ շարունակելով ցուցակից մինչև վերջ: JNZ- ի և JMP- ի նման հրահանգները կարող են փոխել այն հրահանգը, որը հաջորդը կկատարվի: Theանկի յուրաքանչյուր ցուցում զբաղեցնում է մեկ հասցե համակարգչի հիշողության մեջ `սկսած 0-ից:

Համակարգչային ծրագրերը նախատեսված են տվյալ առաջադրանքը կատարելու համար: Մեր ծրագրի համար մենք կընտրենք մի պարզ առաջադրանք ՝ հաշվելով 1-ից 5-ը: Ակնհայտ է, որ «հաշվելու» հրահանգ չկա, ուստի առաջին քայլը առաջադրանքը բաժանել քայլերի, որոնք կարող են վարվել BYOC-I- ի կողմից սահմանափակ հրահանգների հավաքածու:

Քայլ 1 Տեղափոխել 1 գրանցվելու համար Քայլ 2 Տեղափոխել գրանցամատյանը A գրանցելու համար Քայլ 3 Ավելացնել գրանցամատյան D գրանցման համար A և գրանցել արդյունքը գրանցամատյանում Քայլ 4 Տեղափոխել 5 գրանցել EStep 5 Հանել գրանցամատյանը A գրանցամատյանից E և արդյունքը պահել գրանցամատյանում EStep 6 If հանման արդյունքը զրո չէր, վերադառնա Քայլ 4 և շարունակիր հաշվել Քայլ 7 Եթե հանումի արդյունքը զրո էր, հետ գնա և սկսիր նորից

Հաջորդ քայլը այս քայլերը թարգմանելն է BYOC-I հրահանգների: BYOC-I ծրագրերը սկսվում են 0 և հաջորդական համարներից հաջորդաբար: Անցման թիրախային հասցեները ավելացվում են վերջին ՝ բոլոր հրահանգների տեղում լինելուց հետո:

Հասցե ՝ Հրահանգ - հապավում; Նկարագրություն 0: 00 11 00000001 - MVI A, 1; Տեղափոխել 1 ՝ գրանցելու համար A1: 01 10 11 000000 - MOV D, A; տեղափոխել գրանցամատյանը A գրանցելու համար D2: 10 11 10 000 000 000 - ADD A, D; A գրանցելու համար ավելացրեք D գրանցամատյանը և արդյունքը պահեք A3: 00 01 00 00000101 - MVI E, 5; Տեղափոխեք 5 գրանցամատյանը E4: 10 01 11 001 000 - SUB E, A; E գրանցամատյանից հանեք գրանցամատյանը և պահեք արդյունքում գրանցվեք E5: 11 0 0 00000010 - JNZ 2; Եթե հանման արդյունքը զրո չէր, վերադարձեք 3 հասցե և շարունակեք հաշվել 6: 11 1 0 00000000 - JMP 0; Եթե հանման արդյունքը զրո էր, հետ գնացեք և սկսեք նորից

Նախքան ծրագիրը հիշողություն փոխանցելը, երկուական հրահանգների ծածկագիրը պետք է փոխվի վեցանկյունականի `Logisim Hex խմբագրիչի հետ օգտագործելու համար: Նախ, հրահանգը բաժանեք երեք խմբի ՝ յուրաքանչյուրը 4 բիթանոց: Այնուհետև խմբերը թարգմանեք տասնվեցականի ՝ օգտագործելով Քայլ 2 -ի աղյուսակը: Կօգտագործվեն միայն վերջին երեք տասնվեցական թվանշանները (ստորև ՝ համարձակ):

Հասցե - Ուսուցում Երկուական - Հրահանգ Երկուական պառակտում - Հրահանգ (Վեցանկյուն) 0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101000000000000000000000000000000000000000000000100000000000000000000000000000000010001000100000000000000000000000900000000000900000000900000ական0100000000000000000000000000000000090009000900000000000000000000000000000009000000000000900090009000օտասօտէ 111000000010 1110 0000 0000 - 0x0E00

It'sամանակն է ծրագիրը փոխանցել BYOC-I- ի հիշատակին `փորձարկման համար:

Քայլ 6. ferringրագիրը փոխանցել հիշողության և փորձարկման

Նայելով Logisim «հիմնական» շղթային ՝ ցուցադրված BYOC-I բլոկը Explorer- ի պատուհանում «BYOC-I» պիտակավորված իրական համակարգչային սխեմայի խորհրդանիշն է: BYOC-I հիշողության մեջ ծրագիր մուտքագրելու համար.

1. Աջ սեղմեք BYOC-I բլոկի վրա (որը կոչվում է «ենթաշրջան») և ընտրեք (սավառնել վերև և ձախ կտտոց) «Դիտել BYOC-I»:
2. BYOC-I- ի միացումը կհայտնվի աշխատանքային տարածքում: Աջ սեղմեք «Memրագրի հիշողություն» խորհրդանիշի վրա և ընտրեք «Խմբագրել բովանդակությունը..»:
3. Logisim Hex Editor- ի միջոցով մուտքագրեք տասնվեցերորդ ծածկագիրը (միայն համարձակ), ինչպես ցույց է տրված վերևում:

Այժմ դուք պատրաստ եք գործարկել ծրագիրը: Վերադառնալ հիմնական սխեմա ՝ Explorer- ի պատուհանում կրկնակի սեղմելով «BYOC-I»: Սկսելու և գործարկելու համար մուտքերը պետք է լինեն «0»: Օգտագործելով Poke Tool- ը ՝ սկզբում փոխեք Reset- ը «1» -ի, այնուհետև վերադառնաք «0»: Սա դարձնում է մեկնարկային հասցեն 0x0000 և պատրաստում BYOC-I սխեման կատարման համար: Այժմ սեղմեք «Run» մուտքագրումը «1» -ին, և ծրագիրը կկատարվի: (Նշում. Հիմնականում անհրաժեշտ է մեկ անգամ հպել Control-K- ին ՝ Logisim ժամացույցը գործարկելու համար: Սա այն հնարավորությունն է, որը թույլ է տալիս կանգնեցնել Logisim ժամացույցը և մի քանի անգամ հպելով Control-T- ին անցնել ծրագրի միջով: Փորձեք այն երբեմն):

Logisim ժամացույցը կարգավորելի է հաճախականությունների լայն շրջանակի համար: Ներբեռնման դեպքում այն 8 Հց է (վայրկյանում 8 ցիկլ): Ինչպես BYOC-I համակարգիչը նախագծված է, այնպես էլ յուրաքանչյուր հրահանգի համար պահանջվում է չորս ժամացույցի ցիկլ: Այսպիսով, BYOC-I արագությունը հաշվարկելու համար ժամացույցի հաճախականությունը բաժանեք 4.-ի 8 Հց-ով, դրա արագությունը վայրկյանում 2 հրահանգ է: Դուք կարող եք փոխել ժամացույցը ՝ գործիքի տողում սեղմելով «Սիմուլյացիա» և ընտրելով «Տիզերի հաճախականությունը»: Հնարավոր միջակայքը 0.25 Հց -ից 4100 Հց է: Դանդաղ արագությունը 8 Հց -ով ընտրված է, որպեսզի կարողանաք դիտել հաշվարկը A գրանցամատյանում:

BYOC-I մոդելավորման առավելագույն արագությունը (~ 1000 հրահանգ վայրկյանում) շատ դանդաղ է ՝ համեմատած ժամանակակից համակարգիչների հետ: Իմ գրքում նկարագրված BYOC համակարգչի ապարատային տարբերակը կատարում է վայրկյանում ավելի քան 12 միլիոն հրահանգ:

Հուսով եմ, որ այս Instructable- ը ապահամայնացրել է մեքենայական լեզվի ծրագրավորումը և ձեզ պատկերացում է տվել, թե ինչպես են համակարգիչներն աշխատում իրենց ամենատարրական մակարդակում: Ձեր հասկացողությունը ամրապնդելու համար փորձեք կոդավորել ստորև նշված երկու ծրագրերը:

1. Գրեք ծրագիր, որը սկսվում է 5 -ից և հաշվում է մինչև 0. (ANS. Count5to0.txt ստորև)
2. Սկսած 2 -ից, հաշվեք 3 -ով, մինչև թիվը գերազանցի 7 -ը: Կարող եք մի փոքր մտավոր թվաբանություն անել, ստուգեք 8 -ի համար `իմանալով, որ այն այնտեղ վայրէջք կկատարի, այնուհետև կվերագործարկվի: Գրեք ձեր ծրագիրը ավելի ընդհանուր ձևով, որն իսկապես ստուգում է, եթե հաշվարկը «գերազանցում է» որոշակի թիվը: Հուշում. Ուսումնասիրեք, թե ինչ է տեղի ունենում, երբ հանումը տալիս է բացասական արժեք, ասենք 8 - 9 = -1, օրինակ: Այնուհետև փորձարկեք տրամաբանական AND- ը ՝ ստուգելու համար, թե արդյոք 8-բիթանոց MSB- ն «1» է: (ANS. ExceedsCount.txt)

Կարո՞ղ եք այլ դժվար խնդիրներ ունենալ BYOC-I համակարգչի համար: Հաշվի առնելով դրա սահմանափակումները, էլ ի՞նչ կարող է անել: Կիսվեք ինձ հետ ձեր փորձով [email protected] հասցեով: Եթե դուք հետաքրքրված եք միկրոպրոցեսորների կոդավորմամբ, այցելեք իմ կայքը ՝ www.whippleway.com:Այնտեղ ես մեքենայական կոդավորում եմ հասցնում ժամանակակից պրոցեսորներին, ինչպիսիք են ATMEL Mega շարքը, որն օգտագործվում է Արդուինոսում: