Кодирайте и тествайте компютър на машинен език: 6 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:51

В тази инструкция ще ви покажа как да кодирате и тествате компютърна програма на машинен език. Машинният език е родният език на компютрите. Тъй като е съставен от низове от 1s и 0s, той не се разбира лесно от хората. За да заобиколим това, първо кодираме програми на език на високо ниво като C ++ или Java, след което използваме специални компютърни програми, за да ги преведем на компютри 1s и 0s, които компютрите разбират. Да се научиш да кодираш на език на високо ниво със сигурност е безсмислено, но краткото въведение в машинния език може да даде ценна представа за това как работят компютрите и да повиши оценката на тази много важна технология.

За да кодираме и тестваме програма за машинен език, се нуждаем от достъп до безпроблемен компютър, чийто машинен език е лесно разбираем. Персоналните компютри са твърде сложни, за да се обмислят дори. Решението е да се използва Logisim, логически симулатор, който работи на персонален компютър. С Logisim можем да симулираме компютър, който отговаря на нашите нужди. Видеото по -горе ви дава представа какво можем да постигнем с Logisim.

За компютърния дизайн адаптирах една от моята електронна книга Kindle Build Your Own Computer - From Scratch. Започнах с компютъра BYOC, описан там, и го отрязах до различните базови BYOC-I (I за Instructable), които ще използваме в този Instructable.

Машинният език на BYOC-I е прост и лесен за разбиране. Няма да ви трябват специални познания по компютри или програмиране. Всичко, което се изисква, е любознателен ум и желание за учене

Допълнителна информация

Може би се чудите защо използваме „машина“, за да опишем компютър, когато той не е механично устройство. Причината е историческа; първите изчислителни устройства са механични, състоящи се от зъбни колела и колела. Текстът на Алън Шърман, „Всичко беше като предавки, щракащи-щракащи …“, излезе само след век или два. Прочетете повече за ранните изчисления тук.

Стъпка 1: Списък на частите

Списъкът с части е кратък. Изискват се само тези два елемента, като и двата могат да се изтеглят безплатно:

1. "Logisim-win-2.7.1.exe"-Logisim е популярен и лесен за използване логически симулатор. Изтеглете изпълнимия файл на Logisim оттук, след което създайте пряк път на удобно място като вашия работен плот. Щракнете двукратно върху иконата Logisim, за да я стартирате. Забележка: Logisim използва Java Runtime Package, намиращ се тук. Може да бъдете помолени да го изтеглите.
2. BYOC-I-Full.cir "-Изтеглете файла на веригата Logisim по-долу.

Стартирайте Logisim, след това щракнете върху "File-Open" и заредете файла BYOC-I-Full.cir. Изображението по -горе показва работната среда Logisim. BYOC-I е представен от подсхемата. Външно са свързани два входа, нулиране и изпълнение и шестнадесетичен дисплей за регистрите и паметта на програмата BYOC-I.

Паметта на програмата на BYOC-I е предварително заредена с проста програма, която брои от 1 до 5 в регистъра А. За да изпълните (стартирате) програмата, следвайте тези стъпки.

Стъпка 1 - Щракнете върху инструмента Poke. Курсорът трябва да се промени на тласкащ „пръст“. Стъпка 2 - Избутайте входа за нулиране два пъти, като веднъж го промените на "1" и отново, за да го промените обратно на "0". Това нулира BYOC -I, за да стартира програмата на адрес 0. Стъпка 3 - Прокарайте веднъж входа Run, за да го промените на "1". Регистърът A трябва да показва броя, който се променя от 1 до 5. След това се повтаря. Стъпка 4 - Ако програмата не се изпълни, натиснете control -K и тя трябва да започне.

Ако искате да разгледате възможностите на Logisim, щракнете върху връзката Помощ в лентата с менюта. Оттам можете да разгледате Logisim „Урок“, „Ръководство на потребителя“и „Справочник на библиотеката“. Отлично видео въведение се намира тук.

Стъпка 2: Йерархия и кодове на езика на машината

Компютърът BYOC-I изпълнява задачи въз основа на програми, написани на машинен език. Програмите BYOC-I от своя страна се състоят от инструкции, изпълнявани в добре определена последователност. Всяка инструкция е направена от кодове с фиксирана дължина, които представляват различни оперативни компоненти на BYOC-I. И накрая, тези кодове се състоят от низове от 1s и 0s, които съставляват машинния език, който 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 0x000D

Ширината на кода определя колко елементи могат да бъдат представени. Както бе отбелязано, 4-битовият широк код по-горе може да представлява до 16 елемента (0 до 15); тоест 2 по 2 взети четири пъти или 2 до 4 -та степен се равнява на 16. Като цяло, броят на представимите елементи е 2 повишен до n -та степен. Ето кратък списък с капацитети на n-битов код.

n - Брой артикули 1 22 43 84 165 326 647 1288 256

Ширините на компютърния код на BYOC-I са избрани така, че да отговарят на броя елементи, които трябва да бъдат представени от кода. Например, има четири вида инструкции, така че 2-битов широк код е подходящ. Ето кодовете BYOC-I с кратко обяснение на всеки от тях.

Код на типа инструкция (tt) Има четири типа инструкции: (1) MVI - Преместване на непосредствена 8 -битова константна стойност в регистър на паметта. Регистърът на паметта е устройство, което съхранява данни, които да се използват за изчисление, (2) MOV - Преместване на данни от един регистър в друг, (3) RRC - Извършване на изчисление регистър в регистър и (4) JMP - Прескачане към друга инструкция, вместо да продължите към следващата инструкция. Приетите кодове за тип инструкции BYOC-I са следните:

00 MVI01 MOV10 RRC11 JMP

Код на регистър (dd и ss) BYOC-I има четири 8-битови регистъра, способни да съхраняват стойности от 0 до 255. 2-битов код е достатъчен за обозначаване на четирите регистъра:

00 F регистър01 E регистър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 бита за съхранение в 8-битовите регистри на BYOC-I. С десетична аритметика не показваме водещи нули. С компютърна аритметика показваме водещи нули, но те не влияят на стойността. 00000101 е числово същият 101 или 5 десетичен знак.

Предложени препратки

Двоична нотация - https://learn.sparkfun.com/tutorials/binaryHexadecimal Notation -

Допълнителна информация

Идеята за използване на кодове за задвижване на процес датира от много време. Един завладяващ пример е Jacquard Loom. Автоматизираният стан се управляваше от верига от дървени карти, в които бяха пробити дупки, представляващи кодове за различни цветни прежди за тъкане. Видях първия си в Шотландия, където се използва за правене на цветни тартани. Прочетете повече за жакардовите станове тук.

Стъпка 3: Анатомия на инструкциите BYOC-I

Като се имат предвид кодовете на BYOC-I, преминаваме към следващото ниво, инструкции. За да създадем инструкция за BYOC-I, поставяме кодовете заедно в определен ред и на определени места в инструкцията. Не всички кодове се появяват във всички инструкции, но когато се появят, те заемат определено място.

Типът инструкция MVI изисква най -много битове, общо 12. Като правим думата за инструкции с дължина 12 бита, ние приемаме всички инструкции. Неизползваните (така наречените „не ми пука“) битове получават стойност 0. Ето набора от инструкции BYOC-I.

1. Преместване незабавно (MVI) - 00 dd 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 в регистър на дестинация dd. След изпълнение и двата регистра имат същата стойност като регистъра източник. Съкращение: MOV Rd, Rs, където Rd е регистърът на местоназначението A, D, E или F и Rs е регистърът на източника A, D, E или F. Пример: 01 11 01 000000 - MOV A, E - Преместване на стойността в регистър Е да регистрира А.
3. Регистрирайте се, за да регистрирате изчисление (RRC) - 10 dd ss ccc 000 Функция: Извършете определено изчисление ccc, като използвате регистъра на източника ss и регистъра на местоназначението dd, след което запишете резултата в регистъра на местоназначението. Rd); SUB Rd, Rs (ccc = 001 Rd - Rs, съхранявани в Rd); AND Rd, Rs (ccc = 100 Rd И Rs, съхранявани в Rd); ИЛИ Rd, Rs (ccc = 101 Rd OR Rs, съхранявани в Rd). Пример: 10 00 11 001 000 - SUB F, A - Извадете стойността в регистъра A от регистъра F с резултата във регистъра F.
4. Преминете към различна инструкция (JMP) - 11 j 0 aaaaaaaa Функция: Променете изпълнението на различна инструкция, разположена на адрес aaaa aaaa (a) Безусловно (j = 1) -11 1 0 aaaaaaaa Съкращение: JMP L където L е адрес aaaa aaaa Пример: 11 1 0 00001000 - JMP 8 - Промяна на изпълнението на адрес 8. (б) Условно (j = 0), когато предишното изчисление доведе до ненулев резултат - 11 0 0 aaaaaaaa Съкращение: JNZ L, където L е адрес aaaa aaaa. Пример: 11 0 0 00000100 JNZ 4 Ако последното изчисление даде ненулева стойност, променете изпълнението на адрес 4.

Битовете на думите за инструкции са номерирани вляво (най -значимият бит MSB) вдясно (най -малко значителен бит LSB) от 11 до 0. Фиксираният ред и местоположението на кодовете са както следва:

Битове-Код11-10 Тип инструкция9-8 Дестинационен регистър7-6 Регистър на източника5-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. В този случай регистър А ще има стойност 1 (00000001 двоичен) след изпълнение на инструкцията.

Съкращение: MVI A, 1 Необходими кодове: Тип MVI - 00; Дестинационен регистър А - 11; Стойност - 00000001 Инструкция Word: 00 11 00000001

2. Преместете съдържанието на регистър А в регистър D. След изпълнение и двата регистра ще имат стойността първоначално в регистър А.

Съкращение: MOV D, A (Не забравяйте, че местоназначението е първо и източник втори в списъка) Необходими кодове: Тип MOV - 01; Дестинационен регистър D - 10; Източник Регистър A - 11 Инструкция Word: 01 10 11 000000

3. Добавете съдържанието на регистър D към регистър А и съхранявайте в регистър А. След изпълнение стойността на регистър А ще бъде сумата от първоначалната стойност на регистър А и регистър D.

Съкращение: ADD A, D (Резултатът се съхранява в регистъра на местоназначението) Необходими кодове: Тип RRC - 10; Дестинационен регистър А - 11; Източник Регистър D - 10; Изчисление Добавяне - 000 Инструкция Word: 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 могат да променят коя инструкция се изпълнява по -нататък. Всяка инструкция в списъка заема един адрес в паметта на компютъра, започващ от 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 и номер последователно. Адресите за прескачане се добавят последни, след като всички инструкции са на място.

Адрес: Инструкция - Съкращение; Описание 0: 00 11 00000001 - MVI A, 1; Преместете 1, за да регистрирате A1: 01 10 11 000000 - MOV D, A; Преместете регистър A, за да регистрирате D2: 10 11 10 000 000 - ADD A, D; Добавете регистър D към регистър A и запишете резултата в регистър A3: 00 01 00 00000101 - MVI E, 5; Преместете 5 регистър E4: 10 01 11 001 000 - SUB E, A; Извадете регистър A от регистър E и запишете резултат в регистър E5: 11 0 0 00000010 - JNZ 2; Ако резултатът от изваждането не е нула, върнете се на адрес 3 и продължете да броите 6: 11 1 0 00000000 - JMP 0; Ако резултатът от изваждането е нула, върнете се и започнете отначало

Преди да прехвърлите програмата в паметта, двоичният код на инструкция трябва да бъде променен на шестнадесетичен, за да се използва с шестнадесетичния редактор на Logisim. Първо, разделете инструкцията на три групи по 4 бита всяка. След това преведете групите в шестнадесетична, като използвате таблицата в Стъпка 2. Ще се използват само последните три шестнадесетични цифри (с удебелен шрифт по -долу).

Адрес - Двоична инструкция - Двоична инструкция за разделяне - Инструкция (шестнадесетична) 0 001100000001 0011 0000 0001 - 0x03011 011011000000 0110 1100 0000 - 0x06C02 101110000000 1011 1000 0000 - 0x0B803 000100000101 0001 0000 0101 - 0x01054 100111001000 0000 11000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000, 111000000010 1110 0000 0000 - 0x0E00

Време е да прехвърлите програмата в паметта на BYOC-I за тестване.

Стъпка 6: Прехвърляне на програмата в памет и тестване

Поглеждайки към "основната" верига на Logisim, показаният блок BYOC-I е символът за действителната компютърна схема, обозначена като "BYOC-I" в панела Explorer. За да въведете програма в паметта BYOC-I:

1. Щракнете с десния бутон върху блока BYOC-I (наречен "подсхема") и изберете (задръжте курсора на мишката и щракнете с левия бутон) "Преглед на BYOC-I".
2. В работната зона ще се появи веригата BYOC-I. Щракнете с десния бутон върху символа „Памет на програмата“и изберете „Редактиране на съдържанието..“.
3. Използвайки шестнадесетичния редактор на Logisim, въведете шестнадесетичния код (само удебелен), както е показано по -горе.

Вече сте готови за изпълнение на програмата. Върнете се към основната верига, като щракнете двукратно върху „BYOC-I“в панела Explorer. Входовете Run и Reset трябва да са "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, за да можете да наблюдавате броя в регистъра А.

Максималната скорост на симулацията BYOC-I (~ 1000 инструкции в секунда) е много бавна в сравнение със съвременните компютри. Хардуерната версия на компютъра BYOC, описана в моята книга, се изпълнява с повече от 12 милиона инструкции в секунда!

Надявам се, че този Instructable е демистифицирал програмирането на машинен език и ви е дал представа как работят компютрите на най -основното им ниво. За да постигнете разбиране, опитайте да кодирате двете програми по -долу.

1. Напишете програма, която започва от 5 и брои до 0. (ANS. Count5to0.txt по -долу)
2. Започвайки от 2, пребройте с 3, докато числото надхвърли 7. Можете да направите малко умствена аритметика, да проверите за 8, знаейки, че ще кацне там, след което да рестартирате. Напишете програмата си по по -общ начин, който наистина тества дали броят „надвишава“определено число. Съвет: Разгледайте какво се случва, когато изваждането дава отрицателна стойност, например 8 - 9 = -1. След това експериментирайте с логическото И, за да проверите дали MSB в 8-битово число е "1". (ANS. ExceedsCount.txt)

Можете ли да мислите за други предизвикателни проблеми за компютъра BYOC-I? Предвид ограниченията му, какво повече може да направи? Споделете опита си с мен на [email protected]. Ако се интересувате от кодиране на микропроцесори, разгледайте моя уебсайт www.whippleway.com. Там нося машинно кодиране до съвременни процесори като серията ATMEL Mega, използвана в Arduinos.