А
Б В
Г Д
Е Ж
З И
К Л
М Н
О П
Р С
Т У
Ф Х
Ц Ч
Ш Э
Ю Я
Реферат: Взаимодействия с ЭВМ на естественном языке.
Взаимодействия с ЭВМ на естественном языке.
Министерство образования РФ
Хабаровский государственный технический университет
Институт (факультет) Институт информационных технологий
Кафедра Компьютерное проектирование и сертификация машин
Специальность Металлорежущие станки и инструменты
ВЗАИМОДЕЙСТВИЕ ОСНОВНЫХ ЧАСТЕЙ ЭВМ ПРИ ВЫПОЛНЕНИИ ПРОГРАММЫ
Пояснительная записка к курсовой работе
По дисциплине «Информатика»
КР. 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 end;
Next: begin
Inc(N);
SelectPage(N);
if N > 4 then N := 4
end;
F1: begin
Temp[1].Get(X0, Y0, X0 + 380, Y0 + 300);
Temp[2].Get(X0, Y0 + 305, GetMaxX - X0, YS - 5);
Help;
MainWin;
Temp[1].Put(X0, Y0);
Temp[2].Put(X0, Y0 + 305);
if N FuncKeyWindow[2].Put(XS, YS);
if N = 4 then
FuncKeyWindow[3].Put(XS, YS)
end
end {Case}
until Flag;
ClearDevice
end; {Play}
{-------------------}
procedure TextT(Col: TColor; S: TText);
begin
SetTextJustify(1, 1);
for I := 1 to 4 do
begin
SetColor(Col[I]);
OutTextXY(GetMaxX div 2, GetMaxY div 2 + I * 10 - 40, S[I])
end;
SetTextJustify(0, 0)
end; {TextT}
{-------------------}
procedure TestMode;
{-----------------}
function Quastion(N: Byte; var CH: Char): Byte;
var
I: Byte;
C: Char;
CHEAt: string[1];
Code: Integer;
StrN: string[3];
Res: Byte;
Begin
CH := #0;
SetColor(BRDCol);
Rectangle(0, 0, GetMaxX, GetMaxY);
SetColor(White);
MyText(XT, YT, 'Вопрос #' + QuastionS[N]);
SetColor(Yellow);
for I := 1 to 3 do
begin
if I = Ok[N] then
Cheat := V
else
Cheat := '';
MyText(XT, YT + 10 * I, Answer[N, I] + Cheat)
end;
repeat
C := ReadKey;
if C = #27 then
begin
SetTextJustify(1, 0);
SetViewPort(1, GetMaxY - 100, GetMaxX - 1, GetMaxY - 1, ClipOn);
SetColor(Red);
OutTextXY(GetMaxX div 2, 10, 'Вы действительно хотите выйти?');
SetColor(Green);
OutTextXY(GetMaxX div 2, 30, 'Да(Y), Нет(N)');
SetTextJustify(0, 0);
C := ReadKey;
if C = 'y' then
C := #27
else
begin
C := #0;
ClearViewPort
end;
SetViewPort(0, 0, GetMaxX, GetMaxY, ClipOn)
end
until C in ['1', '2', '3', #27];
if C 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 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 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 PutImage(X, Y, Image^, 0);
end; {TImage.Put}
{---------Object TImage----------}
procedure MyInitGraph;
var
GD, GM : Integer;
begin
GD := Detect;
InitGraph(GD, GM,'');
if GraphResult 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 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 TempImage.Put(X + I * DX, Y + I * DY);
if (I = D) and not VIs then
TEMPImage.Put(X + I * DX, Y + I * DY);
end;
end; {Animation}
{-------------------}
procedure Arrow(X, Y, L: Integer; Direction: Byte);
type
COOrAR = array [1..6] of Integer;
var
X1: Integer;
Y1: Byte;
Y2: Byte;
XX: COOrAR;
YY: COOrAR;
procedure Change1;
begin
X1 := -X1;
L := -L
end;
procedure Change2;
var
I: Byte;
Temp: Integer;
begin
for I := 1 to 6 do
begin
TEMP := XX[I];
XX[I] := YY[I];
YY[I] := TEMP;
end;
end;
procedure ArrowCCOOr;
begin
XX[1] := X1; YY[1] := Y2;
XX[2] := X1; YY[2] := Y1;
XX[3] := L; YY[3] := Y1;
XX[4] := L; YY[4] := -Y1;
XX[5] := X1; YY[5] := -Y1;
XX[6] := X1; YY[6] := -Y2;
end;
var
I: Byte;
begin
X1 := CArrow.X1;
Y1 := CArrow.Y1;
Y2 := CArrow.Y2;
if L case Direction of
2, 4: Change1;
end;
ArrowCCOOr;
case Direction of
3, 4: Change2;
end;
MoveTo(X, Y);
for I := 1 to 6 do
LineTo(X+XX[I], Y+YY[I]);
LineTo(X, Y);
end; {Arrow}
{-------------------}
procedure Title;
const
Word_1: string = 'Курсовая работа по информатике.';
Word_2: string = 'Тема: взаимодействие основных частей ЭВМ при выполнении программы';
Word_3: string = 'Выполнили студенты группы МРС-91:';
Word_4: string = 'Егоров О.В.';
Word_5: string = 'Шетманюк М.В.';
begin
ClearDevice;
SetColor(LightGreen);
Rectangle(0, 0, GetMaxX, GetMaxY);
SetFillStyle(1, Blue);
FloodFill(1,1, LightGreen);
SetColor(LightGray);
Rectangle(25, 25,GetMaxX-25, GetMaxY-25);
SetFillStyle(1, DarkGray);
FloodFill(101,101, LightGray);
SetTextJustify(1, 0);
SetTextStyle(0,0,2);
SetColor(Black);
OutTextXY(GetMaxX div 2+1, GetMaxY div 2-1, Word_1);
SetColor(Brown);
OutTextXY(GetMaxX div 2, GetMaxY div 2, Word_1);
SetTextStyle(0,0,0);
SetColor(Red);
OutTextXY(GetMaxX div 2, GetMaxY-35, 'Хабаровск 2000');
SetColor(Black);
OutTextXY(GetMaxX div 2+1, GetMaxY div 2-1+18, Word_2);
SetColor(Brown);
OutTextXY(GetMaxX div 2, GetMaxY div 2+18, Word_2);
SetTextJustify(0, 0);
SetColor(Black);
OutTextXY(GetMaxX-Length(Word_3)*8+1-180, GetMaxY-100-1, Word_3);
SetColor(White);
OutTextXY(GetMaxX-Length(Word_3)*8-180, GetMaxY-100, Word_3);
SetColor(Black);
OutTextXY(GetMaxX+1-180, GetMaxY-90-1, Word_4);
SetColor(LightGreen);
OutTextXY(GetMaxX-180, GetMaxY-90, Word_4);
SetColor(Black);
OutTextXY(GetMaxX+1-180, GetMaxY-80-1, Word_5);
SetColor(LightGreen);
OutTextXY(GetMaxX-180, GetMaxY-80, Word_5);
_Pause;
ClearDevice;
end; {Title}
{-------------------}
procedure BLink(X, Y: Integer; S: string);
var I: Byte;
begin
for I := 1 to 3 do
begin
SetColor(Black);
Delay(Time_1);
OutTextXY(X, Y + TextHeight(S), S);
SetColor(Green);
Delay(Time_1);
OutTextXY(X, Y + TextHeight(S), S)
end
end; {Blink}
{-------------------}
end.
|
