Взаємодія основних частин ЕОМ при виконанні програми

Завдання на курсову роботу
Розробити навчальну програму на тему "Взаємодія основних частин ЕОМ при виконанні програми".
Керівник:
Реферат
Пояснювальна записка до курсової роботи містить 22 аркуша формату А4, 2 малюнки, 1 спожитий джерело, 1 додаток.
ПРОГРАМА ДЛЯ ЕОМ, ПАСКАЛЬ, алгоритмічні мови, ПРОГРАМУВАННЯ, ІНФОРМАТИКА.
Метою курсової роботи є розробка програми для ЕОМ середньої складності із зручним для користувача інтерфейсом.
Це досягається шляхом проектування, розробки та налагодження на мові Паскаль навчальної програми на тему: «Взаємодія основних частин ЕОМ при виконанні програми».
Наведено блок-схема процедури для виводу головного меню. У додатку наведено початковий текст програми на Turbo Pascal.

Введення
Метою курсової роботи є розробка програми для ЕОМ середньої складності зі зручним інтерфейсом на мові програмування Паскаль.
Блок - схема процедури «MainMenu» (виведення на екран головного меню)

Опис програми
1. Призначення
Дана програма показує і навчає, як взаємодіють основні частини ЕОМ при виконанні програми.
Програма написана на мові Turbo Pascal [1] для персональних ЕОМ, сумісних з IBM PC, і операційною системою MS DOS.
2. Запуск програми
Перебуваючи в каталозі з програмою, у відповідь на підказку DOS набрати computer.exe і натиснути клавішу Enter. Вихід з програми при натисненні клавіші Esc.
3. Робота з програмою
Після запуску програми на екрані з'являється головне меню вибору:

Вибір пунктів меню здійснюється за допомогою курсорні клавіш Вгору, Вниз і натиснення клавіші Enter для запуску потрібної частини програми. Для виходу з програми досить натиснути клавішу Esc або вибрати в меню опцію з написом «Esc - Вихід».
3.1 Вибір пункту меню «Навчання»
Навчальна частина програми має вигляд:

Внизу екрана знаходяться функціональні клавіші
Допомога (F1), Назад (?), Вперед (?), Вихід (Esc):
Допомога (F1) - отримати довідку,
Назад (?) - Повернутися назад,
Вперед (?) - Вивести таку інформацію,
Вихід (Esc) - вийти з навчання.

3.2 Вибір пункту меню "Перевірка знань»
Тест має вигляд:

Вибір відповіді здійснюється клавішами 1, 2 і 3. При необхідності вийти можна натиснути клавішу Esc і вийти з тіста.

По закінченні тесту виводиться вікно підсумку, яке має вигляд:

Висновок
У курсовій роботі була спроектована, розроблена і налагоджена на мові програмування Паскаль навчальна програма на тему: «Взаємодія основних частин ЕОМ при виконанні програми».
Програма має зручний для користувача інтерфейс і можливістю перегляду графічного зображення процесів що проходять в ЕОМ при виконанні програми.
Список використаних джерел
1. Марченко А.І. Програмування в середовищі Turbo Pascal 7.0. Навчальний посібник. - К.: ВЕК +, М.: ДЕССА, 1999. - 496 с.

Додаток А. Оригінальний текст програми
program LEAN_Ecm;

uses Crt, Graph, Sm_Graph, Sm_Const;
{-------------------} (Uses)

var
I: Integer;
FuncKeyWindow: array [1 .. 3] of TImage; (Масив картинок функціональних клавіш)
Temp: array [1 .. 2] of TImage; (Масив допоміжний)
{-------------------} (Var)

procedure BildWin;
const
TxtCol: Word = Red; (Колір тексту)
RTACol: Word = Yellow; (Колір прямокутників)
BACCol: Word = Black; (Колір фону)
(Малюємо головну картинку)
begin
SetBkColor (BACCol);
SetColor (BRDCol);
Rectangle (X0, Y0, X0 + 385, Y0 + 300);
Rectangle (X0, Y0 + 305, GetMaxX - X0, YS - 5);
SetColor (MemCol);
(Осередки пам'яті)
SetLineStyle (1, 0, 0);
for I: = 1 to 4 do (Осередки пам'яті)
begin
Line (X0 + 130 + 16 * I, Y0 + 120, X0 + 130 + 16 * I, Y0 + 200);
Line (X0 + 130, Y0 + 120 + 16 * I, X0 + 210, Y0 + 120 + 16 * I)
end;
(CPU)
SetColor (CPUCol);
MoveTo (X0 + 83, Y0 + 203); (0)
LineTo (X0 + 7, Y0 + 203); (1)
LineTo (X0 + 7, Y0 + 117); (2)
LineTo (X0 + 40, Y0 + 117); (3)
LineTo (X0 + 40, Y0 + 45); (4)
LineTo (X0 + 127, Y0 + 45); (5)
LineTo (X0 + 127, Y0 + 27); (6)
LineTo (X0 + 213, Y0 + 27); (7)
LineTo (X0 + 213, Y0 + 73); (8)
LineTo (X0 + 127, Y0 + 73); (9)
LineTo (X0 + 127, Y0 + 55); (10)
LineTo (X0 + 50, Y0 + 55); (11)
LineTo (X0 + 50, Y0 + 117); (12)
LineTo (X0 + 83, Y0 + 117); (12)
LineTo (X0 + 83, Y0 + 203); (13)
SetLineStyle (0, 0, 0);
(Прямокутники)
SetColor (RTACol);
Rectangle (X0 + 10, Y0 + 120, X0 + 80, Y0 + 200); (УУ (ЦУУ))
Rectangle (X0 + 55, Y0 + 120, X0 + 80, Y0 + 130); (КОП)
Rectangle (X0 + 130, Y0 + 120, X0 + 210, Y0 + 200); (ОЗП)
Rectangle (X0 + 130, Y0 + 30, X0 + 210, Y0 + 70); (АЛУ)
Rectangle (X0 + 130, Y0 + 250, X0 + 210, Y0 + 290); (ВЗП)
Rectangle (X0 + 260, Y0 + 120, X0 + 360, Y0 + 150); (У. Введення)
Rectangle (X0 + 260, Y0 + 170, X0 + 360, Y0 + 200); (У. Висновку)

(Підписи до прямокутника)
SetColor (TxtCol);

SetTextJustify (2, 0);
OutTextXY (X0 + 80, Y0 + 200, 'УУ (ЦУУ )'); OutTextXY (X0 + 80, Y0 + 130, 'PC');
OutTextXY (X0 + 210, Y0 + 200, 'ОЗУ');
OutTextXY (X0 + 210, Y0 + 70, 'АЛУ');
OutTextXY (X0 + 210, Y0 + 290, 'ВЗП');
OutTextXY (X0 + 360, Y0 + 150, 'У. Введення');
OutTextXY (X0 + 360, Y0 + 200, 'У. Висновку');
SetTextJustify (0, 0);
(Стрілки Big)
SetColor (ARBCol);
SetFillStyle (1, FILCol);
(Вид стрілки)
CArrow: = BArrow;
Arrow (X0 + 85, Y0 + 140, 40, 1); (ОЗП - УУ (ЦУУ))
FloodFill (X0 + 90, Y0 + 140, ARBCol);
Arrow (X0 + 150, Y0 + 75, 40, 3); (ОЗП - АЛУ)
FloodFill (X0 + 150, Y0 + 80, ARBCol);
Arrow (X0 + 190, Y0 + 115, 40, 4); (АЛП - ОЗУ)
FloodFill (X0 + 190, Y0 + 110, ARBCol);
Arrow (X0 + 150, Y0 + 205, 40, 3); (ВЗП - ОЗУ)
FloodFill (X0 + 150, Y0 + 210, ARBCol);
Arrow (X0 + 190, Y0 + 245, 40, 4); (ОЗП - ВЗП)
FloodFill (X0 + 190, Y0 + 240, ARBCol);
Arrow (X0 + 215, Y0 + 135, 40, 1); (У. Введення - ОЗУ)
FloodFill (X0 + 220, Y0 + 135, ARBCol);
Arrow (X0 + 255, Y0 + 185, 40, 2); (У. Висновку - ОЗУ)
FloodFill (X0 + 250, Y0 + 185, ARBCol);
(Стрілки Small)
SetColor (ARSCol);
(Вид стрілки)
CArrow: = SArrow;
Arrow (X0 + 125, Y0 + 180, 40, 2); (УУ (ЦУУ) - ОЗУ)
Arrow (X0 + 125, Y0 + 270, 80, 2); (УУ (ЦУУ) - ВЗП)
Arrow (X0 + 125, Y0 + 50, 80, 2); (УУ (ЦУУ) - АЛУ = КОП)
Line (X0 + 45, Y0 + 115, X0 + 45, Y0 + 50); (1)
OutTextXY (X0 + 70, Y0 + 60, 'КОП'); (2)
(УУ (ЦУУ) - У. Вводи, У. Висновку)
Line (X0 + 45, Y0 + 205, X0 + 45, Y0 + 295); (1)
Line (X0 + 45, Y0 + 295, X0 + 380, Y0 + 295); (2)
Line (X0 + 380, Y0 + 295, X0 + 380, Y0 + 135); (3)
Arrow (X0 + 365, Y0 + 135, 15, 1); (in) (4)
Arrow (X0 + 365, Y0 + 185, 15, 1); (out) (5)
(Носик стрілок Small)
SetColor (LightGreen);
Arrow (X0 + 125, Y0 + 180, 0, 2); (1)
Arrow (X0 + 125, Y0 + 270, 0, 2); (2)
Arrow (X0 + 125, Y0 + 50, 0, 2); (3)
Arrow (X0 + 365, Y0 + 135, 0, 1); (4)
Arrow (X0 + 365, Y0 + 185, 0, 1); (5)
SetColor (BRDCol);
Rectangle (0, 0, GetMaxX, GetMaxY);
end; (BildWin)
{-------------------} 
procedure BildContext;
const
TxtCol: Word = LightBlue;
begin
SetColor (BRDCol); (Встановлюємо колір кордону і малюємо її)
Rectangle (XC, YC, GetMaxX - X0, YC + 300);
SetTextJustify (1, 1);
SetColor (TxtCol + 1); (Заголовок)
OutTextXY (GetMaxX - (GetMaxX - X0 - XC) div 2 - X0, YC + 20, 'Розташування' +
'на схемі :'); 

CArrow: = BArrow; (Стрілки)
SetColor (ARBCol);
SetFillStyle (1, Blue);
Arrow (XC + 50, YC + 50, 40, 2);
FloodFill (XC + 40, YC + 50, ARBCol);
CArrow: = SArrow;
SetColor (ARSCol);
Arrow (XC + 50, YC + 80, 40, 2);
SetColor (LightGreen);
Arrow (XC + 50, YC + 80, 0, 2);
SetColor (MemCol);
SetLineStyle (1, 0, 0);
Line (XC + 10, YC + 110, XC + 34, YC + 110);
Line (XC + 10, YC + 126, XC + 34, YC + 126);
Line (XC + 14, YC + 106, XC + 14, YC + 128);
Line (XC + 30, YC + 106, XC + 30, YC + 128);
SetColor (CPUCol);
Line (XC + 12, YC + 150, XC + 30, YC + 150);
SetLineStyle (0, 0, 0);
SetColor (TxtCol);
SetTextJustify (0, 1); (Значення)
OutTextXY (XC + 60, YC + 50, '- Передача даних');
OutTextXY (XC + 60, YC + 80, '- Сигнал управління');
OutTextXY (XC + 60, YC + 120, '- Осередок пам'яті');
OutTextXY (XC + 60, YC + 150, '- Цією лінією');
OutTextXY (XC + 60, YC + 160, 'обведені частини');
OutTextXY (XC + 60, YC + 170, 'що входять до складу');
OutTextXY (XC + 60, YC + 180, 'процесора (ЦП )'); OutTextXY (XC + 20, YC + 200, '? - Вміст файлу');
OutTextXY (XC + 20, YC + 210, '1 - адреса першого операнда ');
OutTextXY (XC + 20, YC + 220, '2 - адреса друга операнда ');
OutTextXY (XC + 20, YC + 230, '3 - адреса результату ');
SetTextJustify (0, 0)
end; (Context)
{-------------------} 
procedure BildFuncKey;
const
StrFK: array [1 .. 4] of string [11] =
( 'Допомога F1', 'Назад', 'Вихід Esc');
FkbCol: Word = Green;
TxtCol: Word = LightCyan;
begin
SetColor (BRDCol);
Rectangle (XS, YS, GetMaxX - XS, GetMaxY - XS);
SetTextJustify (1, 1);
SetFillStyle (1, DarkGray);
for I: = 1 to 4 do
begin
SetColor (FkbCol); (Установка кольору кордону клавіш)
Bar ((GetMaxX - XS * 2) div 5 * I - Length (StrFK [I]) * 4, YS + 7,
(GetMaxX - XS * 2) div 5 * I + Length (StrFK [I]) * 4, YS + 23);
Rectangle ((GetMaxX - XS * 2) div 5 * I - Length (StrFK [I]) * 4, YS + 7,
(GetMaxX - XS * 2) div 5 * I + Length (StrFK [I]) * 4, YS + 23);
SetColor (Black); (Встановлення кольору тексту клавіш)
OutTextXY ((GetMaxX - XS * 2) div 5 * I + 2, YS + 15 - 2, StrFK [I]);
SetColor (TxtCol);
OutTextXY ((GetMaxX - XS * 2) div 5 * I, YS + 15, StrFK [I])
end;
SetTextJustify (0, 0);
(Сахраняем картинки)
FuncKeyWindow [1]. Get (XS, YS, GetMaxX - XS, GetMaxY - XS);
SetFillStyle (1, GetBkColor);
Bar ((GetMaxX - XS * 2) div 5 * 3 - Length (StrFK [I]) * 4, YS + 7,
(GetMaxX - XS * 2) div 5 * 3 + Length (StrFK [I]) * 4, YS + 23);

FuncKeyWindow [3]. Get (XS, YS, GetMaxX - XS, GetMaxY - XS);
FuncKeyWindow [1]. Put (XS, YS);
Bar ((GetMaxX - XS * 2) div 5 * 2 - Length (StrFK [I]) * 4, YS + 7,
(GetMaxX - XS * 2) div 5 * 2 + Length (StrFK [I]) * 4, YS + 23);
FuncKeyWindow [2]. Get (XS, YS, GetMaxX - XS, GetMaxY - XS)
end; (FuncKey)
{-------------------} 
{+----------------------------------------------+}
()
(Процедури виведення текстової інформації на екран)
()
{+----------------------------------------------+}

procedure Page_1;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
ClearViewPort;
SetColor (Blue);
OutTextXY (GetMaxX - X - 25, 100, '1 ');
SetColor (TxtCol);
MyText (0, 8, 'До початку роботи програми, вона знаходиться на ВЗП,' +
'у вигляді файлу програми');
MyText (0, 16, '(*. exe або *. com ).'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_1)
{-------------------} 
procedure Page_2;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
ClearViewPort;
SetColor (Blue);
OutTextXY (GetMaxX - X - 25, 100, '2 ');
SetColor (TxtCol);
MyText (0, 8, 'Після того як ЕОМ отримала команду на запуск' +
'програми, вміст');
MyText (0, 16, 'цього файлу поміщається в комірку ОЗУ, починаючи з' +
'осередку з деяким');
MyText (0, 24, 'стартовим адресою .'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_2)
{-------------------} 
procedure Page_3;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
ClearViewPort;
SetColor (Blue);
OutTextXY (GetMaxX - X - 25, 100, '3 ');
SetColor (TxtCol);
MyText (0, 8, 'Вміст комірки зі стартовим адресою програми' +
'(Перший машинна команда )'); MyText (0, 16, 'пересилається в УУ. УУ розшифровує перший машинну' +
'команду і виробативает');
MyText (0, 24, 'їй відповідні сигнали управління для всіх систем управління .'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_3)
{-------------------} 
procedure Page_4_1;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
ClearViewPort;

SetColor (Blue);
OutTextXY (GetMaxX - X - 25, 100, '4 ');
SetColor (TxtCol);
MyText (0, 8, 'Наприклад: якщо перший машинної командою виявилася' +
'трьох адресної командою');
MyText (0, 16, 'складання двох чисел, відбудуться наступні дії :'); MyText (0, 24, '- УУ посилає перша і друга адреса в ОЗП');
SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_1)
{-------------------} 
procedure Page_4_2;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);

SetColor (TxtCol);
MyText (0, 32, '- ОЗУ пересилає комірки з цими адресами в АЛП ,'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_2)
{-------------------} 
procedure Page_4_3;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
SetColor (TxtCol);
MyText (0, 40, '- УУ відправляє сигнал управління (КОП) в АЛП ,'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_3)
{-------------------} 
procedure Page_4_4;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
SetColor (TxtCol);
MyText (0, 48, '- АЛП виконує цю операцію (додавання) над двома' +
'операндами і повертає');
MyText (0, 56, 'результат в ОЗУ .'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_4)
{-------------------} 
procedure Page_4_5;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
SetColor (TxtCol);
MyText (0, 64, '- УУ собщаєт ОЗУ третій адреса (адреса результату ),'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_5)
{-------------------} 
procedure Page_4_6;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
SetColor (TxtCol);
MyText (0, 72, '- ОЗУ поміщає отриманий результат в комірку пам'яті .'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_6)
{-------------------} 
procedure Page_4_7;
begin
SetViewPort (X, Y, GetMaxX - X, YS - 10, ClipOn);
SetColor (TxtCol);
MyText (0, 80, 'На цьому виконання першого машинної команди' +
'закінчується, відбувається');

MyText (0, 88, 'перехід до наступної по порядку машинної команді.' +
'Вміст комірки ОЗУ з');
MyText (0, 96, 'адресою, наступним за стартових, пересилається в УУ' +
'і все повторюється .'); SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end; (Page_4_6)
{-------------------} 
{+------------------+} ()
(Процедури анімації)
()
{+------------------+} 
procedure Move_1;
begin
BLink (150, 285, 'kurs.exe');
end; (Move_1)
{-------------------} 
procedure Move_2;
begin
SetColor (Green);
Animation (150, 285, -125, 2, '??', True)
end; (Move_2)
{-------------------} 
procedure Move_3;
begin
SetColor (GetBkColor);
SetColor (Green);
Animation (100, 168, -70, 1, '1 2 +', True)
end; (Move_3)
{-------------------} 
procedure Move_4_1;
begin
SetColor (GetBkColor);
OutTextXY (30, 176, '1 2');
SetColor (Green);
Animation (47, 198, 63, 1, '1 2', False);
SetColor (GetBkColor);
OutTextXY (150, 168, '? ?'); SetColor (Green);
OutTextXY (150, 168, 'a b')
end; (Move_4_1)
{-------------------} 
procedure Move_4_2;
begin
SetColor (Green);
Animation (150, 160, -95, 2, 'a b', True)
end; (Move_4_2)
{-------------------} 
procedure Move_4_3;
begin
setcolor (getbkcolor);
OutTextXY (30, 176, '+'); SetColor (Green);
Animation (52, 160, -94, 2, '+', False)
end; (Move_4_3)
{-------------------} 
procedure Move_4_4;

begin
SetColor (Green);
Animation (52, 66, 115, 1, '+', True);
OutTextXY (183, 73, '= c')
end; (Move_4_4)
{-------------------} 
procedure Move_4_5;
begin
SetColor (GetBkColor);
SetColor (Green);
Animation (47, 198, 63, 1, '3 ', False);
end; (Move_4_1)
{-------------------} 
procedure Move_4_6;
begin
SetColor (Green);
Animation (191, 66, 94, 2, 'c', True)
end; (Move_4_5)
{-------------------} 

procedure Help; (Допомога)
const
XH: Integer = 70;
YH: Integer = 70;
begin
ClearDevice;
SetColor (BRDCol);
Rectangle (0, 0, GetMaxX, GetMaxY);
SetColor (LightCyan);
SetTextJustify (1, 0);
OutTextXY (GetMaxX div 2, YH + 10, 'Допомога :'); SetTextJustify (0, 0);
OutTextXY (XH + 10, YH + 20, 'Адреса :'); OutTextXY (XH + 10, YH + 30, 'УУ :'); OutTextXY (XH + 10, YH + 40, 'АЛУ :'); OutTextXY (XH + 10, YH + 50, 'АЛУ + УУ :'); OutTextXY (XH + 10, YH + 60, 'ВЗП :'); OutTextXY (XH + 10, YH + 70, 'ОЗУ :'); OutTextXY (XH + 10, YH + 80, 'УВвода :'); OutTextXY (XH + 10, YH + 90, 'УВивода :'); SetColor (Cyan);
OutTextXY (XH + 90, YH + 20, 'номер елементу пам'яті');
OutTextXY (XH + 90, YH + 30, 'пристрій керування');
OutTextXY (XH + 90, YH + 40, 'арифметико-логічний пристрій');
OutTextXY (XH + 90, YH + 50, 'процесор');
OutTextXY (XH + 90, YH + 60, 'зовнішній запам'ятовуючий пристрій (hdd, fdd та ін )'); OutTextXY (XH + 90, YH + 70, 'оперативний запам'ятовуючий пристрій');
OutTextXY (XH + 90, YH + 80, 'пристрій введення');
OutTextXY (XH + 90, YH + 90, 'пристрій виводу');
_Pause
end; (Help)
{-------------------} 
procedure MainWin;
begin
ClearDevice;
BildWin;
BildContext;
BildFuncKey
end; (MainWin)
{-------------------} 

procedure Play;
{-------------} procedure SelectPage (N: Byte);
begin
case N of
1: begin
FuncKeyWindow [2]. Put (XS, YS);
Page_1;
Move_1
end;
2: begin
FuncKeyWindow [1]. Put (XS, YS);
Page_2;
Move_2
end;
3: begin
FuncKeyWindow [1]. Put (XS, YS);
Page_3;
Move_3
end;
4: begin
FuncKeyWindow [3]. Put (XS, YS);
Page_4_1;
Move_4_1;
Delay (Time_3 * 20);
Page_4_2;
Delay (Time_3 * 20);
Move_4_2;
Delay (Time_3 * 20);
Page_4_3;
Delay (Time_3 * 20);
Move_4_3;
Move_4_4;
Page_4_4;
Delay (Time_3 * 20);
Page_4_5;
Delay (Time_3 * 20);
Move_4_5;
Delay (Time_3 * 20);
Page_4_6;
Delay (Time_3 * 20);
Move_4_6;
Delay (Time_3 * 20);
Page_4_7
end
end
end; (SelectPage)
{-------------} 
const
Back = # 75;
Next = # 77;
F1 = # 59;
Esc = # 27;
var
ArrowsAndEsc: set of Char;
ExtentedKey: Boolean;
Flag: Boolean;
CH: Char;
N: Byte;
begin
ClearDevice;
MainWin;
N: = 0;

ArrowsAndEsc: = [Back, Next, F1, Esc];
repeat
ExtentedKey: = False;
Flag: = False;
CH: = ReadKey;
if CH = Esc then
Flag: = True;
if CH = # 0 then
begin
CH: = ReadKey;
ExtentedKey: = True
end;
if ExtentedKey then
case CH of
Back: begin
Dec (N);
SelectPage (N);
if N <1 then N: = 1>
end;
Next: begin
Inc (N);
SelectPage (N);
if N> 4 then N: = 4
end;
F1: begin
Temp [1]. Get (X0, Y0, X0 + 380, Y0 + 300);
Temp [2]. Get (X0, Y0 + 305, GetMaxX - X0, YS - 5);
Help;
MainWin;
Temp [1]. Put (X0, Y0);
Temp [2]. Put (X0, Y0 + 305);
if N
FuncKeyWindow [2]. Put (XS, YS);
if N = 4 then
FuncKeyWindow [3]. Put (XS, YS)
end
end (Case)
until Flag;
ClearDevice
end; (Play)
{-------------------} 
procedure TextT (Col: TColor; S: TText);
begin
SetTextJustify (1, 1);
for I: = 1 to 4 do
begin
SetColor (Col [I]);
OutTextXY (GetMaxX div 2, GetMaxY div 2 + I * 10 - 40, S [I])
end;
SetTextJustify (0, 0)
end; (TextT)
{-------------------} 
procedure TestMode;
{-----------------} function Quastion (N: Byte; var CH: Char): Byte;
var
I: Byte;
C: Char;
CHEAt: string [1];
Code: Integer;
StrN: string [3];
Res: Byte;
Begin

CH: = # 0;
SetColor (BRDCol);
Rectangle (0, 0, GetMaxX, GetMaxY);
SetColor (White);
MyText (XT, YT, 'Питання #' + QuastionS [N]);
SetColor (Yellow);
for I: = 1 to 3 do
begin
if I = Ok [N] then
Cheat: = V
else
Cheat: ='';
MyText (XT, YT + 10 * I, Answer [N, I] + Cheat)
end;
repeat
C: = ReadKey;
if C = # 27 then
begin
SetTextJustify (1, 0);
SetViewPort (1, GetMaxY - 100, GetMaxX - 1, GetMaxY - 1, ClipOn);
SetColor (Red);
OutTextXY (GetMaxX div 2, 10, 'Ви дійсно хочете вийти ?'); SetColor (Green);
OutTextXY (GetMaxX div 2, 30, 'Так (Y), Ні (N )'); SetTextJustify (0, 0);
C: = ReadKey;
if C = 'y' then
C: = # 27
else
begin
C: = # 0;
ClearViewPort
end;
SetViewPort (0, 0, GetMaxX, GetMaxY, ClipOn)
end
until C in ['1 ', '2', '3 ', # 27];
if C # 27 then
begin

Val (C, Res, Code);
if Res = Ok [N] then
begin
Quastion: = 1;
SetColor (Green);
MyText (GetMaxX div 2 - 20, GetMaxY - 200, 'ВЕРНО')
end
else
begin
Quastion: = 0;
SetColor (Red);
MyText (GetMaxX div 2 - 28, GetMaxY - 200, 'Неправильний')
end;
Delay (Time_2)
end
else
CH: = C;
ClearDevice
end; (Quastion)
{-----------------} 
function Mark (Res: Byte): Char;
begin
case Res of
1: Mark: = '1 ';
2: Mark: = '2 ';

3: Mark: = '3 ';
4: Mark: = '4 ';
5: Mark: = '5 ';
else
Mark: = '0 '
end
end; (Mark)
{-----------------} 
var
I: Byte;
Result: Byte;
StrRes: string [2];
TempS: TText;
C: Char;
begin
C: = # 0;
ClearDevice;
Result: = 0;
TempS: = EndofTest;
for I: = 1 to 5 do
begin
if Quastion (I, C) = 1 then
Inc (Result);
if C = # 27 then Exit
end;
ClearDevice;
SetColor (BRDCol);
Rectangle (0, 0, GetMaxX, GetMaxY);
Str (Result, StrRes);
TempS [3]: = EndofTest [3] + StrRes;
TempS [4]: = EndofTest [4] + Mark (Result);
SetColor (BRDCol);
Rectangle (GetMaxX div 2 - 150, GetMaxY div 2 - 60,
GetMaxX div 2 + 150, GetMaxY div 2 + 40);
TextT (TestCol, TempS);
_Pause;
ClearDevice
end; (TestMode)
{-------------------} 
procedure MainMenu;
var
C: Char;
ExtentedKey: Boolean;
TempCol: TColor;
K: ShortInt;
begin
ClearDevice;
TempCol [1]: = MenuCol [1];
TempCol [2]: = MenuCol [3];
TempCol [3]: = MenuCol [4];
TempCol [4]: = MenuCol [4];
K: = 1;
repeat
SetColor (BRDCol);
Rectangle (GetMaxX div 2 - 150, GetMaxY div 2 - 60,
GetMaxX div 2 + 150, GetMaxY div 2 + 40);
Rectangle (0, 0, GetMaxX, GetMaxY);
ExtentedKey: = False; (прапор надходження розширеного коду)
TextT (TempCol, Menu);
while KeyPressed do ReadKey; (очищення буфера клавіатури)
C: = ReadKey; (зчитування коду нової натиснутою клавіші)
if C = # 0 then (якщо "так" - код розширений)
begin

C: = ReadKey; (зчитується другий символ розширеного коду)
ExtentedKey: = True
end;
if ExtentedKey then (якщо код був розширений)
case C of
# 72: K: = K - 1;
# 80: K: = K + 1
end;
if C = # 13 then
case K of
1: Play; (Навчання)
2: TestMode; (Перевірка знань)
3: Exit (Вихід)
end;
if K <1 then K: = 3;>
if K> 3 then K: = 1;
for I: = 2 to 4 do
TempCol [I]: = MenuCol [4];
TempCol [K + 1]: = MenuCol [3]; (Зміна кольору виделленого пункту)
until C = # 27 (тобто натиснута клавіша "Esc")
end; (MainMenu)
{-------------------} 
begin
MyInitGraph; (Ініціалізація графічного режиму)
Title; (Титульний аркуш)
MainMenu; (Головне меню)
CloseGraph; (Закриття графічного режиму)
end. (LEAN_Ecm;)
{-------------------} Текст модуля Sm_Const
unit Sm_Const;
interface
uses Graph, Sm_Graph;
type
TText = array [1 .. 4] of string;
TColor = array [1 .. 4] of Word;
------------------- Type
const
X0: Integer = 10; (Початкова координата X)
Y0: Integer = 20; (Початкова координата Y)
XS: Integer = 10; (FuncKey)
YS: Integer = 440; (FuncKey)
XC: Integer = 400; (Context)
YC: Integer = 20; (Context)
XT: Integer = 80; (Test)
YT: Integer = 150; (Test)
X: Integer = 15; (Координата висновок тексту X)
Y: Integer = 330; (Координата висновок тексту Y)
ARBCol: Word = LightCyan; (Колір зовнішнього кордону стрілки Big)
ARSCol: Word = Red; (Колір зовнішнього кордону стрілки Small)
FILCol: Word = Blue; (Колір стрілки Big)
MemCol: Word = LightGreen; (Колір комірок пам'яті)
CPUCol: Word = DarkGray; (Колір CPU)
BRDCol: Word = Brown; (Колір рамки)
TxtCol: Word = White; (Колір тексту)
BArrow: TArrow = (X1: 15; Y1: 2; Y2: 5); (Форма стрілки Big)
SArrow: TArrow = (X1: 5; Y1: 0; Y2: 1); (Форма стрілки Small)
TestCol: TColor = (Green, White, Blue, Red); (Колір вікна тесту)
MenuCol: TColor = (Cyan, 0, LightGreen, Blue);
V: string [1] ='';
Q: string [9] = 'Питання #';
(Питання]
Quastions: array [1 .. 5] of string =

('1. Що таке ВЗП? ',
'2. Що в ходить в процесор? ',
'3. Через який пристрій в ЕОМ відбувається обмін даними? ',
'4. Де в початковий момент знаходиться програма? ',
'5. Яка з пристроїв розшифровує перший машинну команду ?'); (Варіанти відповідей)
Answer: array [1 .. 5, 1 .. 3] of string =
(('1. Зовнішнє записуючий пристрій ', '2. Зовнішнє запам'ятовуючий пристрій', '3. Внутрішнє запам'ятовуючий пристрій '), ('1. ЦУУ + АЛУ + ВЗП', '2. УВвода + ОЗУ ', '3. ЦУУ + АЛУ + КОП '),
('1. АЛУ ', '2. ОЗУ', '3. ВЗП '),
('1. У ВЗП ', '2. У АЛУ', '3. У УУ '),
('1. ВЗП ', '2. ЦУУ', '3. АЛУ')); (Номери правильних відповідей)
OK: array [1 .. 5] of Byte = (2, 3, 2, 1, 2);
(Текст Меню)
Menu: TText = ( 'Ваш вибір:',
'Навчання',
'Перевірка знань',
'Esc - Вихід');
(Текст підсумку тестової частини програми)
EndofTest: TText = ( 'Ваш результат:',
'Всього питань: 5',
'Кількість правильних відповідей:',
'Оцінка:');
------------------- Const
implementation
end.
Текст модуля Sm_graph
unit Sm_Graph;
interface
uses
Graph, Crt;
{-------------------} (Uses)

type

TArrow = record X1, Y1, Y2: Integer; end;

TImage =
object
private
Image: Pointer;
Size: Word;
public
procedure Destroy;
procedure Get (X1, Y1, X2, Y2: Integer);
procedure Put (X, Y: Integer);
end;
{-------------------} (Type)

const
CArrow: TArrow = (X1: 15; Y1: 2; Y2: 5);
Time_1: Word = 5000; (Час мерехтіння)
Time_2: Word = 15000; (Час затримки екрану після відповіді на питання)
Time_3: Word = 300; (Час анімації)
Time_4: Word = 400; (Час затримки виведення тексту по буквах)
procedure _Pause;
procedure Animation (X, Y: Integer; D: Integer; XY: Byte; S: string; Vis: Boolean);
procedure Arrow (X, Y, L: Integer; DIRectIOn: Byte);
procedure BLink (X, Y: Integer; S: string);
procedure MyInitGraph;
procedure MyText (X, Y: Integer; S: string);

procedure Title;

var
TempImage: TImage;
implementation

{--------- Object TImage ----------)
procedure TImage.Destroy;
begin
if Image nil then
begin
FreeMem (Image, Size);
Image: = nil;
Size: = 0;
end
end; (Timage.Destroy)
{-------------------} 
procedure TImage.Get (X1, Y1, X2, Y2: Integer);
begin
Destroy;
Size: = ImageSize (X1, Y1, X2, Y2);
GetMem (Image, Size);
GetImage (X1, Y1, X2, Y2, Image ^);
end; (TImage.Get)
{-------------------} 
procedure TImage.Put (X, Y: Integer);
begin
if Image nil then
PutImage (X, Y, Image ^, 0);
end; (TImage.Put)
{--------- Object TImage ----------)

procedure MyInitGraph;
var
GD, GM: Integer;

begin
GD: = Detect;
InitGraph (GD, GM ,''); if GraphResult grOK then
Halt (1);
end; (MyInitGraph)
{-------------------} 
procedure MyText (X, Y: Integer; S: string);
var
I: Word;
C: Char;
begin
MoveTo (X, Y);
I: = 0;
repeat
Inc (I);
OutText (S [I]);
Delay (Time_4);
until (I = Length (S));
end; (NyText)
{-------------------} 
procedure _Pause;
begin
ReadKey;
end; (_Pause)

{-------------------} 
procedure Animation (X, Y: Integer; D: Integer;
XY: Byte; S: string; Vis: Boolean);
(Animation)
var
DX, DY: Integer;
I: Integer;
begin
DX: = 1;
DY: = 1;
SetColor (Green);
if D <0 then>
begin
DX: = -1;
DY: = -1;
end;
case XY of
1: DY: = 0;
2: DX: = 0;
end;
D: = Abs (D);
for I: = 1 to D do
begin
TempImage.Get (I * DX + X,
I * DY + Y,
TextWidth (S) + I * DX + X,
TextHeight (S) + I * DY + Y);
OutTextXY (X + I * DX, Y + TextHeight (S) + I * DY, S);
Delay (Time_3);
if I D then
TempImage.Put (X + I * DX, Y + I * DY);
if (I = D) and not VIs then
TEMPImage.Put (X + I * DX, Y + I * DY);
end;
end; (Animation)
{-------------------} 
procedure Arrow (X, Y, L: Integer; Direction: Byte);
type
COOrAR = array [1 .. 6] of Integer;
var
X1: Integer;
Y1: Byte;
Y2: Byte;
XX: COOrAR;
YY: COOrAR;

procedure Change1;
begin
X1: =-X1;
L: =-L
end;

procedure Change2;
var
I: Byte;
Temp: Integer;
begin
for I: = 1 to 6 do
begin
TEMP: = XX [I];
XX [I]: = YY [I];
YY [I]: = TEMP;
end;

end;

procedure ArrowCCOOr;
begin
XX [1]: = X1; YY [1]: = Y2;
XX [2]: = X1; YY [2]: = Y1;
XX [3]: = L; YY [3]: = Y1;
XX [4]: = L; YY [4]: =-Y1;
XX [5]: = X1; YY [5]: =-Y1;
XX [6]: = X1; YY [6]: =-Y2;
end;

var
I: Byte;
begin
X1: = CArrow.X1;
Y1: = CArrow.Y1;
Y2: = CArrow.Y2;
if L
case Direction of
2, 4: Change1;
end;
ArrowCCOOr;
case Direction of
3, 4: Change2;
end;
MoveTo (X, Y);
for I: = 1 to 6 do
LineTo (X + XX [I], Y + YY [I]);
LineTo (X, Y);
end; (Arrow)
{-------------------} 
procedure Title;
const
Word_1: string = 'Курсова робота з інформатики.';
Word_2: string = 'Тема: взаємодія основних частин ЕОМ при виконанні програми';
Word_3: string = 'Виконали студенти групи МРС-91:';
Word_4: string = 'Єгоров О.В.';
Word_5: string = 'Шетманюк М.В.';
begin
ClearDevice;
SetColor (LightGreen);
Rectangle (0, 0, GetMaxX, GetMaxY);
SetFillStyle (1, Blue);
FloodFill (1,1, LightGreen);
SetColor (LightGray);
Rectangle (25, 25, GetMaxX-25, GetMaxY-25);
SetFillStyle (1, DarkGray);
FloodFill (101,101, LightGray);
SetTextJustify (1, 0);
SetTextStyle (0,0,2);
SetColor (Black);
OutTextXY (GetMaxX div 2 +1, GetMaxY div 2-1, Word_1);
SetColor (Brown)
OutTextXY (GetMaxX div 2, GetMaxY div 2, Word_1);
SetTextStyle (0,0,0);
SetColor (Red);
OutTextXY (GetMaxX div 2, GetMaxY-35, 'Хабаровськ 2000');
SetColor (Black);
OutTextXY (GetMaxX div 2 +1, GetMaxY div 2-1 +18, Word_2);
SetColor (Brown)
OutTextXY (GetMaxX div 2, GetMaxY div 2 +18, Word_2);
SetTextJustify (0, 0);

SetColor (Black);
OutTextXY (GetMaxX-Length (Word_3) * 8 +1-180, GetMaxY-100-1, Word_3);
SetColor (White);
OutTextXY (GetMaxX-Length (Word_3) * 8-180, GetMaxY-100, Word_3);
SetColor (Black);
OutTextXY (GetMaxX +1-180, GetMaxY-90-1, Word_4);
SetColor (LightGreen);
OutTextXY (GetMaxX-180, GetMaxY-90, Word_4);
SetColor (Black);
OutTextXY (GetMaxX +1-180, GetMaxY-80-1, Word_5);
SetColor (LightGreen);
OutTextXY (GetMaxX-180, GetMaxY-80, Word_5);
_Pause;
ClearDevice;
end; (Title)
{-------------------} 
procedure BLink (X, Y: Integer; S: string);
var I: Byte;
begin
for I: = 1 to 3 do
begin
SetColor (Black);
Delay (Time_1);
OutTextXY (X, Y + TextHeight (S), S);
SetColor (Green);
Delay (Time_1);
OutTextXY (X, Y + TextHeight (S), S)
end
end; (Blink)
{-------------------} 
end.