Взаимодействие основных частей ЭВМ при выполнении программы


|                                                                           |
|                                                                           |
|Министерство образования РФ                                                |
|                                                                           |
|Хабаровский государственный технический университет                        |
|                                                                           |
|                                                                           |
|Институт (факультет) Институт информационных технологий                    |
|Кафедра Компьютерное проектирование и сертификация машин                   |
|Специальность Металлорежущие станки и инструменты                          |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|Взаимодействие основных частей ЭВМ при выполнении программы                |
|                                                                           |
|                                                                           |
|Пояснительная записка к курсовой работе                                    |
|                                                                           |
|По дисциплине «Информатика»                                                |
|                                                                           |
|КР. 991096.00.00.00 ПЗ                                                     |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|Выполнил:                                                                  |
|студент группы МРС-91                                                      |
|Егоров О.В.                                                                |
|зачетная книжка № 991096                                                   |
|Руководитель работы:                                                       |
|доцент                                                                     |
|Кетов А.В.                                                                 |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|Хабаровск 2000                                                             |
|                                                                           |
|                                                                           |
|Задание на курсовую работу                                                 |
|Разработать обучающую программу на тему "Взаимодействие основных частей ЭВМ|
|при выполнении программы".                                                 |
|Руководитель:                                                              |
|Реферат                                                                    |
|Пояснительная записка к курсовой работе содержит 22 листа формата А4, 2    |
|рисунка, 1 использованный источник, 1 приложение.                          |
|ПРОГРАММА ДЛЯ ЭВМ, ПАСКАЛЬ, АЛГОРИТМИЧЕСКИЙ ЯЗЫК, ПРОГРАММИРОВАНИЕ,        |
|ИНФОРМАТИКА.                                                               |
|Целью курсовой работы является разработка программы для ЭВМ средней        |
|сложности с удобным пользовательским интерфейсом.                          |
|Это достигается путем проектирования, разработки и отладки на языке Паскаль|
|обучающей  программы на тему: «Взаимодействие основных частей ЭВМ при      |
|выполнении программы».                                                     |
|Приведена блок-схема процедуры для вывода главного меню. В приложении      |
|приведен исходный текст программы на Turbo Pascal.                         |
|                                                                           |
|Содержание                                                                 |
|Введение 3                                                                 |
|Блок – схема процедуры «MainMenu» (вывода на экран главного меню) 3        |
|Описание программы 4                                                       |
|1. Назначение 4                                                            |
|2. Запуск программы 4                                                      |
|3. Работа с программой 4                                                   |
|3.1 Выбор пункта меню «Обучение» 4                                         |
|3.2 Выбор пункта меню «Проверка знаний» 5                                  |
|Заключение 5                                                               |
|Список использованных источников 5                                         |
|Приложение А. Исходный текст программы 6                                   |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |


|Введение                                                                   |
|Целью курсовой работы является разработка программы для ЭВМ средней        |
|сложности с удобным интерфейсом на языке программирования Паскаль.         |
|Блок – схема процедуры «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 <= 1 then                                                             |
|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 < X1 then L := X1;                                                    |
|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.                                                                       |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |
|                                                                           |

-----------------------
|  |    |        |    |    | . 991096.00.00.00                    |8AB   |
|  |    |        |    |    |                                      |  0   |


B0 | |22 | |

 | | | | | . 991096.00.00.00  |8AB | | | | | | | |