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

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

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

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

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

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

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

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

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

КР. 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» (вывода на экран главного меню)

КР. 991096.00.00.00 ПЗ Лист ——– Изм. Лист № докум. Подп. Дата 3

Описание программы

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] = 'Вопрос #';

{Вопросы]

('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 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 в < 0 then

begin

DX := -1;

DY := -1;

end;

case XY of

1: DY := 0;

2: DX := 0;

end;

в := Abs(D);

for I := 1 to в 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 <> в 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.