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

БОЛЬШАЯ ЛЕНИНГРАДСКАЯ БИБЛИОТЕКА - РЕФЕРАТЫ - Взаимодействие основных частей ЭВМ при выполнении программы

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

| |

| |

|Министерство образования РФ |

| |

|Хабаровский государственный технический университет |

| |

| |

|Институт (факультет) Институт информационных технологий |

|Кафедра Компьютерное проектирование и сертификация машин |

|Специальность Металлорежущие станки и инструменты |

| |

| |

| |

| |

| |

| |

| |

| |

| |

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

| |

| |

|Пояснительная записка к курсовой работе |

| |

|По дисциплине «Информатика» |

| |

|КР. 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 | | | | | | | |