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

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

Вернуться