Розробка програми-емулятора мовою Турбо Паскаль

Размещено на http://www.allbest.ru/

Размещено на http://www.allbest.ru/

Зміст

Вступ

1. Навчальна обчислювальна машина F1

1.1 Архітектура ЕОМ

1.2 Формати представлення інформації та команд

1.3 Система команд

1.4 Принцип роботи ЕОМ

2. Програмування в кодах навчальної ЕОМ

2.1 Програмування формул

2.2 Циклічна програма з розгалуженням

2.3 Виконання логічних команд із використання підпрограм

3. Програмна модель навчальної ЕОМ

3.1 Призначення та галузь застосування

3.2 Технічні характеристики програми

3.3 Опис програми

Висновок

Додаток А. Текст програми

Додаток Б. Результати роботи програми

програма емулятор команда



Вступ

В теперішній час широке розповсюдження отримало використання мікропроцесорів в якості вбудованих елементів систем автоматичного управління, в тому числі як керуючих блоків периферійних вузлів обчислювальних комплексів. Функції, покладені в такій системі на мікропроцесор, повністю визначаються програмою, яку він виконує. Оскільки програма роботи вбудованого мікропроцесора змінюється досить рідко, к параметрам цієї програми та до її функціональності пред'являються особливо жорсткі вимоги. У зв'язку з цим є обов'язковою старана відладка та всебічне тестування програми мікропроцесору.

Мікропроцесори мають, як правило, обмежені можливості вводу-виводу, що затрудняє виконання робот по відладці програми. Такі роботи також забруднені або зовсім неможливі при розробці нових мікропроцесорних систем. Все це стимулює використання універсальних ЕОМ для відладки мікро ЕОМ та мікропроцесорів, тобто використання методики емуляції програми.

Темою курсової роботи є розробка програми-емулятору для заданої навчальної ЕОМ, яка в спрощеному виді відображає структуру реальної машини. Емуляція виконується в середовищі Pasacal 7.0 на мові Pascal.



1. Навчальна обчислювальна машина F1

1.1 Архітектура ЕОМ F1

Навчальна ЕОМ F1 являє собою одно адресну ЕОМ із двома регістрами-акумуляторами. До складу ЕОМ F1 входять наступні основні вузли:

- оперативний запам'ятовуючий пристрій ОЗП ємністю 256 16-розрядних слів;

- 8-розрядний регістр адреси RA, що визначає номер комірки пам'яті, з яким відбувається взаємодія в даний момент часу;

- 8-розрядний лічильник адреси команд SAK, призначений для збереження адреси наступної команди;

- 16-розрядний регістр слова RS для тимчасового збереження інформації що читається чи записується;

- 16-розрядний регістр команд RK, що зберігає виконувану команду;

- 16-розрядні регістри-акумулятори R1 і R2;

- арифметико-логічний пристрій АЛП, що виконує операцію, задану кодом операції команди;

- дешифратор коду операції DC;

- схема формування адреси СФА;

- 8-розрядний регістр РС для збереження проміжної адреси;

- 3-розрядный регістр ознак завершення операції RP.

1.2 Формати представлення інформації і команд

Регістр команди розділяється на наступні поля:

- поле КОР (біти 1 - 4) містить код виконуваної операції;

- поле R (біт 5) задає використовуваний регістр-акумулятор: регістр R1 при R = 0 чи регістр R2 при R = 1;

- поле B (біти 6 - 8) містить номер комірки пам'яті, у якій записаний базова адреса;

- поле Х (біти 9 - 11) містить номер комірки пам'яті, у якій записаний індекс;

- поле D (біти 12 - 16) містить безпосереднє значення зсуву адреси.

Адреси комірок пам'яті змінюються від 0 до 255 (від 00000000 до 11111111 у двійковій системі числення). У нульовій комірці завжди знаходиться нуль, який можна читати, але не можна записувати в цю комірку. Комірки пам'яті з адресами від 1 до 7 призначені для збереження базових адрес і індексів, розряди 1 - 8 цих комірок не використовуються. Формування виконавчих адрес відбувається в такий спосіб: .

В ЕОМ F1 використовуються 16-розрядні числа з фіксованої комою (цілі числа зі знаком). Негативні значення чисел записуються в додатковому коді.

1.3 Система команд

Система команд ЕОМ F1 наведена у таблиці 1.

Таблиця 1. Система команд ЕОМ F1.

КОР	Назва	Ознаки	Виконання команди
		S	Z	C
0000	Зупинка	-	-	-
0001	Завантаження акумулятора	-	-	-
0010	Запис акумулятора	-	-	-
0011	Додавання	+	+	+
0100	Вирахування	+	+	+
0101	Множення	+	+	+
0110	Поділ	+	+	+
0111	Діз'юнкція	+	+	-
1000	Зсув праворуч арифметичний	+	+	-
1001	Зсув ліворуч арифметичний	+	+	-
1010	Виклик підпрограми	-	-	-
1011	Повернення з підпрограми	-	-	-
1100	Безумовний перехід	-	-	-
1101	Умовний перехід по S	-	-	-
1110	Умовний перехід по Z	-	-	-
1111	Умовний перехід по С	-	-	-

Круглі дужки в графі «Виконання команди» означають уміст чи регістра комірки пам'яті. Наприклад, запис Аисп - це адреса осередку, а (Аисп) - вміст осередку з адресою Аисп.

1.4 Принцип роботи ЕОМ

Виконання команди починається з завантаження вмісту комірки пам'яті, адреса якого задана у SAK, у регістр команд RK. При цьому значення адреси виконуваної команди з SAK переписується в регістр адреси RA, по цій адресі читається зміст відповідної комірки пам'яті ОЗП і через буферний регістр слова RS пересилається в регістр RK. У наступному з RK виділяються полючи KOP, R, B, X і D. Для підготовки вибірки наступної команди значення лічильника SAK збільшується на одиницю. Дешифратор DC аналізує значення KOP і визначає команду, що повинна виконуватися в даний момент (дешифратор має 16 виходів по кількості дешифруємих команд).

Далі у всіх командах, крім команд «Зупинка» і «Повернення з підпрограми», виконується формування виконавчої адреси . Формування здійснюється в два етапи. Спочатку значення комірки В передається в регістр RA і по ньому вибирається з ОЗП базова адреса (розряди 9 - 16 відповідної комірки), що через регістр RS надходить на другий вхід СФА; на перший вхід СФА подається значення поля D, результат підсумовування записується в регістр РС. Потім за значенням поля Х регістра RK з ОЗП аналогічно базовій адресі на другий вхід СФА подається індекс, що додається до значення адреси, що знаходиться в регістрі РС. У результаті другого підсумовування регістр РС буде містити виконавча адреса. Якщо в полі Х знаходяться нулі, то індекс не використовується, і другий етап формування адреси не виконується.

У командах умовного переходу аналізується стан регістра ознак RP. Якщо відповідний ознака дорівнює 1, значення виконавчої адреси з регістра РС передається в лічильник SAK.

У команді «Завантаження акумулятора» значення адреси передається в регістр RA, після чого вибирається відповідна комірка пам'яті і її вміст записується в регістр RS, потім, у залежності від поля R команди, зміст RS завантажується в регістр R1 (R = 0) чи в регістр R2 (R=1). Команда «Запис акумулятора» виконує зворотний запис з регістрів R1 чи R2 у регістр RS, а потім в осередок ОЗП, обумовлену адресою.

Команди зсуву орієнтовані тільки на акумулятор. Особливістю арифметичного зсуву, на відміну від логічного, є те, що при зсуві вліво знаковий розряд не зачіпається, при цьому розряди, що звільняються в правій частині акумулятора, заповнюються нулями; при зсуві вправо розряд знака (0 чи 1) поширюється на зсуваємі розряди. Кількість зсувів визначається значенням виконавчої адреси.

Якщо Аисп>14, то зсув розрядів акумулятора не виконується; у цьому випадку по команді зсуву вліво розряди 1..15 заповнюються нулями, по команді зсуву вправо - значенням розряду знака (0 чи 1).

В арифметико-логічних командах на перший вхід АЛУ подається вміст регістра R1 (при R = 0) чи регістра R2 (при R = 1), на другий вхід надходить вміст осередку ОЗП, що відповідає адресі. Результат операції залишається в регістрі R1 (при R = 0) чи в регістрі R2 (при R = 1).

Результат арифметичної операції використовується для формування в регістрі RP ознаки S (S = 1, якщо результат менше нуля), Z (Z = 1, якщо результат дорівнює нулю) чи C (C = 1, якщо відзначена некоректність виконання операції - переповнення чи акумулятора спроба розподілу на нуль). Необхідні зміни регістра RP відбиті в таблиці 1.

Для логічних операцій і для команд зсуву, як було раніше зазначене, виробляється лише аналіз результату на рівність нулю: S = 1, якщо результат операції не дорівнює нулю, чи Z = 1, якщо цей результат дорівнює нулю.

Символ “-” у графі ознак таблиці 1 визначає ситуацію, що не може виникнути в даній операції (наприклад, некоректність при виконанні операції зсуву), чи те, що дана операція не змінює регістр RP (наприклад, команда безумовного переходу).

При звертанні до підпрограми повинні бути виконані дві дії: передача керування на початкову ділянку підпрограми і повернення в зухвалу програму після відпрацьовування підпрограми. Ця робота в ЕОМ F1 виконується двома командами: «Виклик підпрограми» і «Повернення з підпрограми».

У команді «Виклик підпрограми» після формування виконавчої адреси в регістр адреси RA записується значення 8, що визначає комірку ОЗП, у бітах 9 - 16 якої зберігається поточне значення лічильника SAK (адреса повернення). Потім у лічильник SAK з регістра РС пересилається адреса .

У команді «Повернення з підпрограми» у регістрі RA встановлюється адреса, рівний 8, значення бітів 9 - 16 комірки 8 ОЗП через регістр RS передається в лічильник SAK.

По команді безумовного переходу (БП) значення Аисп заноситься в лічильник SAK.

У команді умовного переходу (УП) по S спочатку аналізується значення бітів регістра RP. Якщо ознака S = 1 (результат операції менше нуля), то значення Аисп передається в лічильник SAK. Аналогічно в команді УП по Z і УП по С адреса Аисп пересилається в SAK, якщо відповідно ознака Z = 1 (результат операції дорівнює нулю) чи С =1 (некоректність виконання операції).

Якщо в регістрі RP встановлена ознака С = 1, то команда умовного переходу по С робить передачу керування за адресою, у противному випадку - наступної один по одному команді. При відсутності команди умовного переходу по С ніякої реакції на ознаку С = 1 не відбувається.



2. Програмування в кодах навчальної ЕОМ

2.1 Програмування формул

;

.

Таблиця ОЗП для цього приклада.

Адреса	КОР	R	B	X	D	16 с. ч.	Коментар
0	0000	0	000	000	00000	0	Комірка 0
3	0000	0	000	001	10010	32	Базова адреса 50
12	0001	0	011	000	00001	1301	load r1,a
13	0100	0	011	000	00011	5303	sub r1,b
14	0101	0	011	000	01000	2308	mul r1,c321
15	0001	0	011	000	00000	1300	load r2,b
16	0101	0	011	000	00100	5304	mul r2,c32
17	0010	0	011	000	01000	4308	save r2,tmp
18	0011	0	011	000	01000	2308	add r1,tmp
19	0001	0	011	000	00000	1300	load r2,a
20	0011	0	011	000	00101	5305	add r2,b
21	0010	0	011	000	00010	4302	save r2,tmp
22	0101	0	011	000	01001	2309	mul r2,tmp
23	0101	0	011	000	00001	1301	mul r2,c2
24	0010	0	011	000	00110	5306	save r2,tmp
25	0110	0	011	000	01001	3309	div r1,tmp
26	0010	0	011	000	01000	6308	save r1,y
27	0000	0	000	000	00000	0	Halt
50	0000	0	000	000	10100	14	A=20
51	1111	1	111	111	10110	FFF6	B=-10
52	0000	0	000	000	00001	1	константа 321
53	0000	0	000	000	01100	C	константа 32
54	0000	0	000	000	01010	A	константа 2
55	0000	0	000	001	00000	0	константа k1
56	0000	0	000	000	00000	0	константа k2
57	1111	1	111	110	01000	FFC8	результат - у= -56

2.2 Циклічна програма з розгалуженнями

Таблиця ОЗП для цього приклада.

Адреса	КОР	R	B	X	D	16 с.ч.	Коментар
0	0000	0	000	000	00000	0	Комірка 0
2	0000	0	000	001	10010	32	Базова адреса 50
3	0000	0	000	000	10100	14	Базова адреса 20
20	0001	0	000	000	00001	1001	load r1,x[i]
21	0100	0	010	000	00100	3204	sub r1,a
22	1101	0	000	000	00001	2001	js [100010]
23	1110	0	010	001	00000	1220	jz [101001]
24	0001	0	010	000	00000	4200	load r1,x[i]
25	0101	0	011	000	00101	D305	mul r1,a
26	0011	0	011	000	01100	E30C	add r1,c1
27	0010	0	010	001	00000	1220	save r1,y[i]
28	0001	0	010	000	00100	3204	load r1,i
29	0011	0	010	000	00111	2207	add r1,c1
30	0010	0	010	000	00000	1200	save r1,i
31	0100	0	010	000	00110	5206	sub r1,c3
32	1110	0	010	000	00100	4204	jz [101100]
33	1100	0	010	000	00111	6207	jmp [10100]
34	0001	0	011	000	01111	C30F	load r1,x[i]
35	0011	0	010	001	00000	1220	add r1,c1
36	0001	0	010	000	00100	3204	load r2,a
37	0100	0	010	000	00111	2207	sub r2,c1
38	0010	0	010	000	00000	1200	save r2,tmp
39	0110	0	010	000	00100	4204	div r1,tmp
40	1100	0	010	000	00111	5207	jmp [11011]
41	0001	0	011	000	01111	C30F	load r1,a
42	0011	0	010	000	00000	1200	add r1,c1
43	1100	0	010	000	00110	5206	jmp [11011]
44	0000	0	000	000	00000	0	Halt
50	0000	0	000	001	11000	28	A=40
51	0000	0	000	011	00100	64	x1= 100
52	0000	0	000	001	11000	28	х2=40
53	1111	1	111	100	11100	FF9C	х3=-100
54	0000	0	000	000	00001	1	Константа 1
55	0000	0	000	000	00011	3	Константа 3
56	0000	0	000	000	00000	0	k1
57	0000	1	111	101	00001	FA1	y1- 4001
58	0000	0	000	001	01001	29	y2- 41
59	1111	0	000	111	01011	F0EB	y3- -3861

2.3 Використання логічних команд із використанням підпрограм

Таблиця ОЗП для цього приклада.

Адреса	КОР	R	B	X	D	16 с. ч.	Коментар
0	0000	0	000	000	00000	0	Комірка
2	0000	0	000	000	10100	14	Базова адреса 20
3	0000	0	000	000	10010	12	Базова адреса 18
11	0001	1	010	000	10011	1A13	load r2,z1
12	0010	1	000	000	00001	3801	save r2,1
13	1010	1	011	000	00000	AB00	call [010010]
14	0001	1	010	000	10111	1A17	load r2,z2
15	0010	1	000	000	00001	3801	save r2,1
16	1010	1	011	000	00000	AB00	call [010010]
17	0000	0	000	000	00000	0000	halt
18	0001	0	010	001	00000	1220	load r1,a -початок підпрогами
19	1000	0	000	000	00100	8004	sar r1,4
20	0001	1	010	001	00000	1A20	load r2,a
21	1000	1	000	000	00010	8802	sar r2,2
22	0010	1	010	000	11110	2A1E	save k1
23	0001	1	010	001	00001	1A21	load r2,b
24	1001	1	000	000	00011	9803	sal r2,3
25	0111	1	010	000	11110	7A1E	Or r2,k1
26	0010	0	010	000	11110	221E	save r1,k1
27	0111	1	010	000	11110	7A1E	or r2,k1
28	0010	1	010	001	00010	2A22	save r2,y
29	1011	0	000	000	00000	B000	ret -кінець підпрограми
39	0000	0	000	000	10100	14	z1=20
40	0011	0	110	110	11100	36DC	a1=14044
41	1101	1	000	011	01111	D86F	b1=-10129
42	1100	1	111	111	11111	CFFF	y1=-12289
43	0000	0	000	000	11000	0018	z2= 24
44	1001	1	110	010	01001	9E49	a2=-25015
45	1010	0	001	110	00110	A1C6	b2=-24122
46	1111	1	111	111	10110	FFF6	y2=-10
50	0000	0	000	000	00000	0	k1



3. Програмна модель навчальної ЕОМ

3.1 Призначення та галузь застосування

У цей час емулятори набули великого поширення. Вони застосовуються з метою контролю правильності роботи мікропроцесору або обчислювальної машини загалом на етапах конструювання.

Програма-емулятор повинна мати наступні характеристики:

- повністю відповідати архітектурі пристрою, що моделюється;

- програма-емулятор повинна моделювати гранично жорсткі умови роботи фізичного пристрою;

- програма повинна обробляти як можна більшу кількість станів фізичного пристрою;

- програма повинна забезпечувати перевірку правильності роботи всіх блоків пристрою, що досліджується.

3.2 Технічні характеристики програми

Програма містить 4 юніти та файл проекту. Загальний розмір 1190 строк.

3.3 Опис програми

Емулятор реалізований у вигляді модульної структури та складається з 4 модулів. Головною програмою є файл проекту emulat.pas, в якому записані дії, які програма виконує на самому початку роботи (завантаження ресурсів, створення інтерфейсу, тощо). Програма містить 4 модулі: 1) DesUnit - містить константи і т.п.; 2) BasUnit - базові процедури та функції; 3) InsUnit - процедури та функції, що використовуються в АЛП; 4)RegUnit - процедури та функції, що відповідають за режим роботи програми.

Модулі, які використовуються в програмі містять усі процедури і функції, які відповідають за інтерфейсну частину (видача повідомлень і т. п.) та які реалізують наступні 5 режимів:

- введення вихідних даних;

- повне виконання програми;

- покроковий режим роботи;

- перегляд змісту пам'яті;

- копіювання блоку пам'яті.



Висновок.

Я виконав курсову роботу і придбав навики програмування в середовищі Pascal 7.0 У процесі розробки програми я почав краще розуміти як працює мікропроцесор, які операції він може виконувати. Я розібрався з особливостями ЕОМ F1 і розробив кілька простих тестів для перевірки правильності роботи програми. Курсова робота принесла мені користь тим, що я поліпшив навички програмування і став краще розуміти пристрій ЕОМ.



Додаток А

Текст програми

UNIT DesUnit;

{ Глобальные описания констант, типов, переменных }

Interface

Uses Crt;

Const

MaxAdress=255 ; { максимальный адрес оперативной памяти }

MaxNumber=32767.0; { макс.значение 16-разрядного 2-ого числа }

{ для индикации переполнения }

Enter=13; { код клавиши Enter }

PressKey='Нажмите клавишу "Enter"';

Type

set1=set of 1..1;

set3=set of 1..3;

set4=set of 1..4;

set5=set of 1..5;

set8=set of 1..8;

set16=set of 1..16;

string80=string[80];

string4=string[4];

RKType=record { тип регистра команд }

Kop:set4;

R:set1;

B,X:set3;

D:set5;

end;

MemoryType=array[0..MaxAdress] of set16; { тип памяти }

Var

Aisp,

Sak,

Ra,

Pc,

NumReg : byte;

op : integer;

Rp : set3;

Rs,Slovo,R1,R2,Op1,Op2 : set16;

Cond,CondExec : boolean;

Memory : MemoryType;

Rk : RkType;

cho : char;

FileModul : text;

Implementation

End.

UNIT BasUnit;

{ Базовые процедуры и функции }

Interface

Uses Crt, DesUnit, Printer;

Procedure WaitEnter;

Procedure PrintString(X,Y:byte; S:string);

Procedure PrintKeyAndWaitEnter;

Function Space(S:String80; k:byte):byte;

Function NotSpace(S:String80; k:byte):byte;

Function GetKey : byte;

Function GetNumber(MinNumber,MaxNumber:real; m1,n1,m2,n2:byte):real;

Procedure StartPosMemory;

Procedure StartPosRegisters;

Procedure FromSetToNumber(Operand:set16; Var Number:integer);

Procedure FromNumberToSet(Number:integer; Var Operand:set16);

Procedure LittleFromSetToNumberForD(Operand:set3; var Number:integer);

Procedure LittleFromSetToNumber(Operand:set3;Var Number:integer);

Procedure Wait(intro:integer);

Implementation

{ -------------------------------------------------------------- }

Procedure WaitEnter;

{ Задержка выполнения программы до тех пор, }

{ пока не будет нажата клавиша Enter }

Var ch : char;

Begin

Repeat

ch:=ReadKey;

Until ord(ch) = Enter;

End { WaitEnter };

{ -------------------------------------------------------------- }

Procedure PrintString(X,Y:byte; S:string);

{ Печать строки S с позиции X строки экрана с номером Y }

Begin

GotoXY(X,Y); Write(S);

End { PrintString };

{ -------------------------------------------------------------- }

Procedure PrintKeyAndWaitEnter;

{ Печать строки-константы PressKey с позиции 1 строки экрана 25 }

{ и задержка выполнения программы до нажатия клавиши Enter }

Begin

PrintString(1,25,PressKey);

WaitEnter;

ClrScr;

End { PrintKeyAndWaitEnter };

{ -------------------------------------------------------------- }

Function Space(S:String80; k:byte):byte;

{ Поиск ближайшего пробела, начиная с позиции k }

{ строки S; Space = 0, если пробел не обнаружен }

Var i : byte;

Begin

Space:=0;

For i:=k to length(S) do

If S[i]=' ' then

Begin

Space:=i; Exit

End;

End { Space };

{ -------------------------------------------------------------- }

Function NotSpace(S:String80; k:byte):byte;

{ Поиск ближайшего непробела, начиная с позиции k }

{ строки S; NotSpace=0, если непробел не обнаружен }

Var i : byte;

Begin

NotSpace:=0;

For i:=k to length(S) do

If S[i]<>' ' then

Begin

NotSpace:=i; Exit

End;

End { NotSpace };

{ -------------------------------------------------------------- }

Function GetKey : byte;

{ Чтение символа клавиатуры }

Var ch : char;

Begin

ch := ReadKey;

If ord(ch) = 0 then { Расширенный код символа }

GetKey := ord(ReadKey)

Else

GetKey := ord(ch); { Нормальный код символа }

End { GetKey };

{ -------------------------------------------------------------- }

Function GetNumber(MinNumber,MaxNumber:real; m1,n1,m2,n2:byte):real;

{ Ввод числа с клавиатуры; MinNumber,MaxNumber - допустимый }

{ диапазон; m1,n1,m2,n2 - формат сообщения о доп.диапазоне }

Var k : integer;

Number : real;

Cond : boolean;

Begin

Repeat

Cond:=true;

{$I-} Read(Number); {$I+}

k:=IOResult;

If k<>0 then

Begin

Writeln(#7'Неправильный формат числа');

Writeln('Повторите ввод');

Cond:=false

End

Else

If (Number<MinNumber) or (Number>MaxNumber) then

Begin

Write(#7'Число должно быть в диапазоне ');

Writeln('от ',MinNumber:m1:n1,' до ',MaxNumber:m2:n2,' .');

Writeln('Повторите ввод');

Cond:=false

End;

Until Cond;

GetNumber:=Number;

End { GetNumber };

{ -------------------------------------------------------------- }

Procedure StartPosMemory;

{ Установка памяти в начальное состояние }

Var i:byte;

Begin

For i:=0 to MaxAdress do

Memory[i]:=[];

End { StartPosMemory };

{ -------------------------------------------------------------- }

Procedure StartPosRegisters;

{ Установка регистров в начальное состояние }

Begin

Sak:=0;

Rk.Kop:=[];

Rk.R:=[];

Rk.B:=[];

Rk.X:=[];

Rk.D:=[];

R1:=[];

R2:=[];

Rp:=[];

Rs:=[];

End { StartPosRegisters };

{ -------------------------------------------------------------- }

Procedure FromSetToNumber(Operand:set16; Var Number:integer);

{ Преобразование множества в число }

Var i : byte;

Cond : boolean;

Begin

Cond:=false;

If 1 in Operand then

Begin

Cond:=true;

For i:=1 to 16 do { инверсирование цифр }

If i in Operand then { отрицательного двоичного }

Operand:=Operand-[i] { числа }

Else

Operand:=Operand+[i];

End;

Number:=0;

For i:=2 to 16 do { получение численного }

Begin { значения по схеме }

Number:=2*Number; { Горнера }

If i in Operand then

Number:=Number+1;

End;

If Cond then { добавление единицы, если }

Begin { был преобразован дополни-}

Inc(Number); { тельный код, и изменение }

Number:=-Number { знака числа }

End;

End { FromSetToNumber };

{ ------------------------------------------------------- }

Procedure FromNumberToSet(Number:integer; Var Operand:set16);

{ Преобразование числа в множество }

Var i : byte;

k,Divisor : integer;

Cond : boolean;

Begin

Cond:=false;

If Number<0 then

Begin

Cond:=true; { получение положительного }

Number:=-Number; { числа и вычитание из него }

Dec(Number); { единицы }

End;

Divisor:=16384; Operand:=[]; { делитель равен 2**14 }

For i:=2 to 16 do

Begin { последовательное формиро- }

k:=Number div Divisor; { вание двоичных цифр числа }

If k>0 then

Operand:=Operand + [i];

Number:=Number mod Divisor;

Divisor:=Divisor shr 1;

End;

If Cond then

For i:=1 to 16 do { инверсирование цифр отри- }

If i in Operand then { цательного числа (получе- }

Operand:=Operand - [i] { ние дополнительного кода) }

Else

Operand:=Operand + [i];

End { FromNumberToSet };

{ ------------------------------------------------------- }

Procedure LittleFromSetToNumberForD(Operand:set3; var Number:integer);

Begin

Number:=0;

if 5 in Operand then

Number:=1;

if 4 in Operand then

Number:=Number+2;

if 3 in Operand then

Number:=Number+4;

if 2 in Operand then

Number:=Number+8;

if 1 in Operand then

Number:=Number+16;

End;

{ ------------------------------------------------------- }

Procedure LittleFromSetToNumber(Operand:set3;Var Number:integer);

Begin

Number:=0;

if 3 in Operand then

Number:=1;

if 2 in operand then

Number:=Number+2;

if 1 in Operand then

Number:=number+4;

End;

{ ------------------------------------------------------- }

Procedure Wait(intro:integer);

Var

rt:char;

i:byte;

Vspom:integer;

S1,RpS,MemSRa,MemSSak,R1S,R2S:string[80];

Begin

clrscr;

Rps:='Регистр признаков:';

for i:=1 to 3 do

if i in Rp then

RpS:=Rps+'1'

else

Rps:=Rps+'0';

PrintString(25,3,RpS);

MemSRa:='В памяти по адресу RA: ';

MemSSak:='В памяти по адресу Sak: ';

R1S:='Регистр 1:';

R2S:='Регистр 2:';

for i:=1 to 16 do

begin

if i in Memory[Ra] then

MemSRa:=MemsRa+'1'

else

MemSRa:=MemSRa+'0';

if i in Memory[Sak] then

MemSSak:=MemSSak+'1'

else

MemSSak:=MemSSak+'0';

if i in R1 then

R1S:=R1S+'1'

else

R1S:=R1S+'0';

if i in R2 then

R2S:=R2S+'1'

else

R2S:=R2S+'0';

end;

S1:='';

str(Ra,S1);

PrintString(50,6,'Значение Ra: '+S1);

PrintString(5,6,MemSRa);

writeln;

str(Sak,S1);

PrintString(50,7,'Значение Sak: '+S1);

PrintString(5,7,MemSSak);

FromSetToNumber(R1,Vspom);

S1:='';

str(Vspom,S1);

R1S:=R1S+' = '+S1;

S1:='';

FromSetToNumber(R2,Vspom);

str(Vspom,S1);

R2S:=R2S+' = '+S1;

PrintString(5,10,R1S);

PrintString(30,12,R2S);

S1:='';

str(intro,S1);

PrintString(25,14,'Исполнительный адрес: '+S1);

S1:='';

for i:=1 to 16 do

if i in Memory[intro] then

S1:=S1+'1'

else

S1:=S1+'0';

PrintString(11,16,'В памяти по исполнительному адресу: '+S1);

FromSetToNumber(Memory[intro],Vspom);

s1:='';

str(Vspom,s1);

PrintString(65,16,' = '+S1);

rt:=ReadKey;

End;

{ ------------------------------------------------------- }

End.

UNIT InsUnit;

{ Процедуры выполнения машинных команд }

Interface

Uses Crt, DesUnit, BasUnit, Printer;

procedure Load(intro:integer);

procedure Save(intro:integer);

procedure Add(intro:integer);

procedure Subtract(intro:integer);

procedure Multiple(intro:integer);

procedure Divide(intro:integer);

procedure OrO(intro:integer);

procedure SAR(intro:integer);

procedure SAL(intro:integer);

procedure Call(intro:integer);

procedure Ret;

procedure Jump(intro:integer);

procedure JumpS(intro:integer);

procedure JumpZ(intro:integer);

procedure JumpC(intro:integer);

Implementation

procedure Load(intro:integer);

begin

if 1 in Rk.R then

R2:=Memory[intro]

else

R1:=Memory[intro];

end;

{ ------------------------------ }

procedure Save(intro:integer);

begin

if 1 in Rk.R then

Memory[intro]:=R2

else

Memory[intro]:=R1;

end;

{ ------------------------------ }

procedure Add(intro:integer);

var

vspom:set16;

N1Vspom,N2Vspom:integer;

Nvspom:longint;

begin

if 1 in Rk.R then

vspom:=R2

else

Vspom:=R1;

FromSetToNumber(Vspom,N1Vspom);

FromSetToNumber(Memory[intro],N2vspom);

Nvspom:=N1Vspom+N2Vspom;

Rp:=[];

if Nvspom=0 then

Rp:=Rp+[2]

else

if abs(Nvspom)>32768 then

Rp:=Rp+[3]

else

if Nvspom<0 then

Rp:=Rp+[1];

if not(3 in Rp) then

begin

FromNumberToSet(Nvspom,Vspom);

if 1 in Rk.R then

R2:=vspom

else

R1:=vspom

end

else

begin

PrintString(2,5,'Обнаружена ошибка в строке: ');

Write(ra);

Cond:=false;

Exit;

end;

end;

{ ------------------------------ }

procedure Subtract(intro:integer);

var

Vspom:set16;

N1Vspom,N2Vspom:integer;

Nvspom:longint;

begin

if 1 in Rk.r then

Vspom:=R2

else

Vspom:=R1;

FromSetToNumber(Vspom,N1Vspom);

FromSetToNumber(Memory[intro],N2Vspom);

Rp:=[];

Nvspom:=N1vspom-N2Vspom;

if abs(NVspom)>32768 then

Rp:=Rp+[3]

else

if Nvspom=0 then

Rp:=Rp+[2]

else

if Nvspom<0 then

Rp:=Rp+[1];

if not(3 in Rp) then

begin

FromNumberToSet(Nvspom,Vspom);

if 1 in Rk.R then

R2:=vspom

else

R1:=vspom

end

else

begin

PrintString(2,5,'Обнаружена ошибка в строке: ');

Write(ra);

Cond:=False;

exit;

end;

end;

{ ------------------------------ }

procedure Multiple(intro:integer);

var

Vspom:set16;

N1Vspom,N2vspom:integer;

Nvspom:longint;

begin

if 1 in Rk.R then

Vspom:=R2

else

Vspom:=R1;

FromSetToNumber(Vspom,N1Vspom);

FromSetToNumber(Memory[intro],N2Vspom);

Nvspom:=N1vspom*N2Vspom;

Rp:=[];

if Nvspom=0 then

Rp:=Rp+[2]

else

if abs(Nvspom)>32768 then

Rp:=Rp+[3]

else

if Nvspom<0 then

Rp:=Rp+[1];

if not(3 in Rp) then

begin

FromNumberToSet(Nvspom,vspom);

if 1 in Rk.R then

R2:=Vspom

else

R1:=Vspom;

end

else

begin

PrintString(2,5,'Обнаружена ошибка в строке: ');

Write(ra);

Cond:=false;

exit;

end;

end;

{ ------------------------------ }

procedure Divide(intro:integer);

var

Vspom:set16;

N1Vspom,N2Vspom:integer;

Nvspom:longint;

begin

if 1 in Rk.R then

Vspom:=R2

else

vspom:=R1;

FromSetToNumber(Vspom,N1vspom);

FromsetToNumber(Memory[intro],N2vspom);

Nvspom:=N1Vspom div N2vspom;

Rp:=[];

if abs(Nvspom)>32768 then

Rp:=Rp+[3]

else

if Nvspom=0 then

Rp:=Rp+[2]

else

if Nvspom<0 then

Rp:=Rp+[1];

if not(3 in Rp) then

begin

FromNumbertoSet(Nvspom,vspom);

if 1 in Rk.r then

R2:=Vspom

else

R1:=Vspom

end

else

begin

PrintString(2,5,'Обнаружена ошибка в строке: ');

Write(ra);

cond:=false;

exit;

end;

end;

{ ------------------------------ }

procedure Jump(intro:integer);

begin

Ra:=intro-1;

Sak:=intro;

end;

{ ------------------------------ }

procedure JumpS(intro:integer);

begin

if 1 in Rp then

begin

Ra:=intro-1;

Sak:=intro;

end;

end;

{ ------------------------------ }

procedure JumpZ(intro:integer);

begin

if 2 in Rp then

begin

Ra:=intro-1;

Sak:=intro;

end;

end;

{ ------------------------------ }

procedure JumpC(intro:integer);

begin

if 3 in Rp then

begin

Ra:=intro-1;

Sak:=intro;

end;

end;

{ ------------------------------ }

procedure Call(intro:integer);

var

Vspom:set16;

begin

FromNumberToSet(Sak,Vspom);

Ra:=8;

Memory[Ra]:=Vspom;

Sak:=intro;

end;

{ ------------------------------ }

procedure Ret;

var

vspom:integer;

begin

Ra:=8;

FromSetToNumber(Memory[Ra],Vspom);

Sak:=Vspom;

end;

{ ------------------------------ }

procedure OrO(intro:integer);

Var

Vspom,Vs:set16;

Num:integer;

i:byte;

begin

Vs:=[];

if 1 in Rk.R then

Vspom:=R2

else

Vspom:=R1;

for i:=1 to 16 do

if (i in Memory[intro]) or (i in Vspom) then

Vs:=Vs+[i];

FromSetToNumber(Vs,Num);

Rp:=[];

if Num<0 then

Rp:=Rp+[1]

else

if Num=0 then

Rp:=Rp+[2];

if 1 in Rk.R then

R2:=Vs

else

R1:=Vs;

end;

{ ------------------------------ }

procedure Sar(intro:integer);

var

Vspom:set16;

i,j:byte;

Try:string80;

Num:integer;

begin

if 1 in Rk.R then

Vspom:=R2

else

Vspom:=R1;

Try:='';

for i:=1 to 16 do

if i in Vspom then

Try:=Try+'1'

else

Try:=Try+'0';

if intro>14 then

if 1 in Vspom then

begin

Vspom:=[];

for i:=1 to 15 do

Vspom:=Vspom+[i]

end

else

Vspom:=[]

else

begin

for i:=1 to intro do

for j:=16 downto 2 do

Try[j]:=Try[j-1];

Vspom:=[];

for i:=1 to 16 do

if Try[i]='1' then

Vspom:=Vspom+[i]

end;

FromSetToNumber(Vspom,Num);

Rp:=[];

if Num<0 then

Rp:=Rp+[1]

else

if Num=0 then

Rp:=Rp+[2];

if 1 in Rk.R then

R2:=Vspom

else

R1:=Vspom;

end;

{ ------------------------------ }

procedure Sal(intro:integer);

var

i,j:byte;

Vspom:set16;

Try:string80;

Num:integer;

begin

if 1 in Rk.R then

Vspom:=R2

else

Vspom:=R1;

Try:='';

for i:=1 to 16 do

if i in Vspom then

Try:=Try+'1'

else

Try:=Try+'0';

if intro>14 then

begin

if 1 in Vspom then

j:=1

else

j:=0;

Vspom:=[];

if j=1 then

Vspom:=Vspom+[1];

end

else

begin

for i:=1 to intro do

for j:=1 to 15 do

Try[j]:=Try[j+1];

for i:=16 downto 16-intro+1 do

Try[i]:='0';

Vspom:=[];

for i:=1 to 16 do

if Try[i]='1' then

Vspom:=vspom+[i];

end;

FromSetToNumber(Vspom,Num);

Rp:=[];

if Num<0 then

Rp:=Rp+[1]

else

if Num=0 then

Rp:=Rp+[0];

if 1 in Rk.R then

R2:=Vspom

else

R1:=Vspom;

end;

{ ------------------------------ }

End.

UNIT RegUnit;

{ Процедуры реализации режимов работы эмулятора }

Interface

Uses Crt, DesUnit, BasUnit, InsUnit, Printer;

Procedure Abaut;

Procedure InputModul;

Procedure Run;

Procedure Step;

Procedure WriteStore;

Procedure DopModul;

Implementation

{ -------------------------------------------------------- }

Procedure Abaut;

Begin

ClrScr;

PrintString(22,8,'ДонГТУ');

Writeln;

Writeln(' Кафедра электронных вычислительных машин');

Writeln(' ____________________________________________');

Writeln;

Writeln(' Эмулятор учебной ЭВМ F1 ');

Writeln;

Writeln(' Выполнил:');

Writeln(' ст.гр. СП-04б');

Writeln(' Брацун Д.Ю.');

Writeln;

Writeln(' Донецк 2005');

Writeln;

PrintKeyAndWaitEnter;

End;

{ -------------------------------------------------------- }

Procedure InputModul;

Const

Evk='0123456789ABCDEF';

sl:string80=('Выберите номер теста: 1,2,3');

a:array[1..16] of string4=

('0000','0001','0010','0011','0100','0101','0110','0111',

'1000','1001','1010','1011','1100','1101','1110','1111');

Type

String30=string[30];

String10=string[10];

Var

ch:char;

d,k,i:byte;

FModul:text;

ind,HA,vspom,err:integer;

vs,s1:String30;

Cond:boolean;

Slo:string10;

Newset:set16;

Begin

StartPosMemory;

StartPosRegisters;

clrscr;

PrintString(25,10,Sl);

repeat

cho:=ReadKey;

until ord(cho) in [49..51];

vs:='Test-'+cho+'.dat';

assign(FModul,vs);

reset(FModul);

Cond:=true;

k:=0;

NewSet:=[];

s1:='';

while Not Eof(FModul) do

begin

readln(Fmodul,vs);

k:=pos('BA',vs);

if k<>0 then

begin

vs:=vs+' ';

Slo:=copy(vs,k+3,1);

vspom:=Space(vs,k+5);

val(Slo,ind,err);

Slo:=Copy(vs,k+5,vspom-(k+5));

val(Slo,vspom,err);

FromNumberToSet(Vspom,NewSet);

Memory[ind]:=NewSet;

end

else

begin

k:=pos('PA',vs);

if k<>0 then

begin

vs:=vs+' ';

vspom:=Space(vs,k+3);

Slo:=copy(vs,k+3,vspom-(k+3));

val(slo,Sak,err);

end

else

begin

k:=pos('HA',vs);

if k<>0 then

begin

vs:=vs+' ';

vspom:=Space(vs,k+3);

Slo:=copy(vs,k+3,vspom-(k+3));

Val(Slo,HA,err);

d:=HA-1;

end

else

begin

s1:='';

NewSet:=[];

d:=d+1;

for i:=1 to 4 do

begin

ch:=vs[i];

vspom:=pos(ch,Evk);

s1:=s1+a[vspom];

end;

Newset:=[];

for i:=1 to 16 do

if s1[i]='1' then

NewSet:=NewSet+[i];

Memory[d]:=newSet;

end;

end;

end;

end;

End;

{ -------------------------------------------------------- }

Procedure Run;

Var

i,Code,adr1:byte;

Bvspom,Xvspom,Dvspom,Adr:integer;

Chvspom:char;

Begin

Cond:=true;

while Cond do

begin

RA:=SaK;

Rs:=Memory[sak];

Sak:=Sak+1;

Rk.Kop:=[];

Rk.r:=[];

Rk.B:=[];

Rk.x:=[];

Rk.D:=[];

for i:=1 to 4 do

if i in Rs then

Rk.Kop:=Rk.kop+[i];

if 5 in Rs then

Rk.R:=[1];

for i:=6 to 8 do

if i in Rs then

Rk.B:=Rk.B+[i-5];

for i:=9 to 11 do

if i in Rs then

Rk.X:=Rk.X+[i-8];

for i:=12 to 16 do

if i in Rs then

Rk.D:=Rk.d+[i-11];

if Rk.Kop<>[] then

begin

Adr:=0;

Bvspom:=0;

Xvspom:=0;

Dvspom:=0;

LittleFromsetToNumber(Rk.B,Bvspom);

FromSetToNumber(Memory[Bvspom],Bvspom);

LittleFromSetToNumber(Rk.X,Xvspom);

FromSetToNumber(Memory[Xvspom],Xvspom);

LittleFromsetToNumberForD(Rk.D,Dvspom);

Adr:=Dvspom+Xvspom+Bvspom;

Code:=0;

for i:=1 to 4 do

begin

Code:=2*code;

if i in Rk.Kop then

Code:=Code+1;

end;

case Code of

1:Load(Adr);

2:Save(Adr);

3:Add(Adr);

4:Subtract(Adr);

5:Multiple(Adr);

6:Divide(Adr);

7:OrO(Adr);

8:SAR(Adr);

9:SAL(Adr);

10:Call(Adr);

11:Ret;

12:Jump(Adr);

13:JumpS(Adr);

14:JumpZ(Adr);

15:JumpC(Adr);

end;

end

else

Cond:=false;

end;

End;

{ -------------------------------------------------------- }

Procedure Step;

Var

i,Code,adr1:byte;

Bvspom,Xvspom,Dvspom,Adr:integer;

Chvspom:char;

Begin

Cond:=true;

while Cond do

begin

RA:=SaK;

Rs:=Memory[sak];

Sak:=Sak+1;

Rk.Kop:=[];

Rk.r:=[];

Rk.B:=[];

Rk.x:=[];

Rk.D:=[];

for i:=1 to 4 do

if i in Rs then

Rk.Kop:=Rk.kop+[i];

if 5 in Rs then

Rk.R:=[1];

for i:=6 to 8 do

if i in Rs then

Rk.B:=Rk.B+[i-5];

for i:=9 to 11 do

if i in Rs then

Rk.X:=Rk.X+[i-8];

for i:=12 to 16 do

if i in Rs then

Rk.D:=Rk.d+[i-11];

if Rk.Kop<>[] then

begin

Adr:=0;

Bvspom:=0;

Xvspom:=0;

Dvspom:=0;

LittleFromsetToNumber(Rk.B,Bvspom);

FromSetToNumber(Memory[Bvspom],Bvspom);

LittleFromSetToNumber(Rk.X,Xvspom);

FromSetToNumber(Memory[Xvspom],Xvspom);

LittleFromsetToNumberForD(Rk.D,Dvspom);

Adr:=Dvspom+Xvspom+Bvspom;

Code:=0;

for i:=1 to 4 do

begin

Code:=2*code;

if i in Rk.Kop then

Code:=Code+1;

end;

case Code of

1:Load(Adr);

2:Save(Adr);

3:Add(Adr);

4:Subtract(Adr);

5:Multiple(Adr);

6:Divide(Adr);

7:OrO(Adr);

8:SAR(Adr);

9:SAL(Adr);

10:Call(Adr);

11:Ret;

12:Jump(Adr);

13:JumpS(Adr);

14:JumpZ(Adr);

15:JumpC(Adr);

end;

Wait(Adr);

end

else

Cond:=false;

end;

End;

{ -------------------------------------------------------- }

Procedure WriteStore;

Var

d1,i,j,left,right:byte;

button:char;

d2,d3:integer;

Chis:string;

Li:longInt;

Begin

left:=0;

right:=21;

i:=0;

repeat

ClrScr;

WriteLn('Содержимое памяти ОЗУ (нажмите d чтобы выбрать диапозон)');

WriteLn(' № 2c/c');

for i:=left to right do

begin

Li:=0;

Chis:='0000000000000000';

Write(i:3,' ');

for j:=1 to 16 do

begin

if j in Memory[i] then

begin

Write('1');

Chis[j]:='1';

end

else

begin

Write('0');

Chis[j]:='0';

end;

end;

WriteLn;

end;

button:=ReadKey;

if (ord(button)=80) and (right<255) then

begin

Inc(Right);

Inc(Left);

end

else

if (ord(button)=72) and (left>0) then

begin

Dec(Right);

Dec(Left);

end

else

if (ord(button)=100) then

begin

repeat

ClrScr;

WriteLn('Введите адрес в памяти, на который хотите переместиться (>=0 and <256)');

Read(d1);

until (d1>=0) and (d1<256);

if (d1-21)<0 then

begin

left:=0;

right:=21;

end

else

if (d1+21)>255 then

begin

left:=234;

right:=255;

end

else

begin

left:=d1;

right:=d1+21;

end;

end;

until ord(button)=13;

End;

{ -------------------------------------------------------- }

Procedure DopModul;

Var

adr1,adr2,adr3,pish,k,v,n,i:byte;

Begin

ClrScr;

repeat

WriteLn('Введите начальный адрес копируемого блока памяти (>=0 and <256)');

Read(adr1);

WriteLn('Введите конечный адрес копируемого блока памяти (>=0 and <256)');

Read(adr2);

WriteLn('Введите адрес памяти, начиная с которого копировать (>=0 and <256)');

Read(adr3);

until ((adr1>=0)and(adr2>=0)and(adr3>=0)and(adr1<256)and

(adr2<256)and(adr3<256)and(adr1<adr2)and(adr2<adr3));

k:=adr2-adr1+1;

v:=255-k;

n:=255;

while v>adr3 do

begin

Memory[n]:=Memory[v];

Dec(v);

Dec(n);

end;

pish:=adr3;

for i:=adr1 to adr2 do

begin

Memory[pish]:=Memory[i];

if (pish=255) then break;

Inc(pish);

end;

End;

{ -------------------------------------------------------- }

End.

Program Emulat;

Uses Crt, DesUnit, BasUnit, RegUnit, InsUnit;

Procedure MakeMenu;

Var

KeyRegime : byte;

Begin

Repeat

ClrScr;

PrintString(15,7,'Укажите режим работы программы:');

PrintString(17,8,'0 - О программе');

PrintString(17,9,'1 - Ввод исходных данных');

PrintString(17,10,'2 - Полное выполнение программы');

PrintString(17,11,'3 - Шаговое выполнение программы');

PrintString(17,12,'4 - Вывод области памяти');

PrintString(17,13,'5 - Дополнительный режим');

PrintString(17,14,'6 - Выход из меню');

Writeln;

KeyRegime:=Round(GetNumber(0,6,1,0,1,0));

Case KeyRegime of

0 : Abaut ;

1 : InputModul;

2 : Run ;

3 : Step ;

4 : WriteStore;

5 : DopModul ;

6 :

Else KeyRegime:=6;

End;

Until KeyRegime=6;

End;

Begin

{ Очистка памяти и регистров }

StartPosMemory;

StartPosRegisters;

{ Формирование меню }

MakeMenu;

End.



Додаток Б. Результати роботи програми

1. Размещено на www.allbest.ru