Взаємодія основних частин ЕОМ при виконанні програми

| Вступ |
| Метою курсової роботи є розробка програми для ЕОМ середньої |
| складності зі зручним інтерфейсом на мові програмування Паскаль. |
| Блок - схема процедури «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, '- ОЗУ пересилає комірки з цими адресами в АЛП ,');|< br>| |
| 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, 'Help:'); |
| SetTextJustify (0, 0); |
| OutTextXY (XH + 10, YH + 20, 'Адреса:'); |
| OutTextXY (XH + 10, YH + 30, 'УУ:'); |
| OutTextXY (XH + 10, YH + 40, 'АЛУ:'); |
| OutTextXY (XH + 10, YH + 50, 'АЛУ + УУ:'); |
| OutTextXY (XH + 10, YH + 60, 'ВЗП:'); |
| OutTextXY (XH + 10, YH + 70, 'ОЗУ:'); |
| OutTextXY (XH + 10, YH + 80, 'УВвода:'); |
| OutTextXY (XH + 10, YH + 90, 'УВивода:'); |
| SetColor (Cyan); |
| OutTextXY (XH + 90, YH + 20, 'номер елементу пам'яті'); |
| OutTextXY (XH + 90, YH + 30, 'пристрій керування'); |
| OutTextXY (XH + 90, YH + 40, 'арифметико-логічний пристрій'); |
| OutTextXY (XH + 90, YH + 50, 'процесор'); |
| OutTextXY (XH + 90, YH + 60, 'зовнішній запам'ятовуючий пристрій (hdd, fdd і |
| ін) '); |
| OutTextXY (XH + 90, YH + 70, 'оперативний запам'ятовуючий пристрій'); |
| OutTextXY (XH + 90, YH + 80, 'пристрій введення'); |
| OutTextXY (XH + 90, YH + 90, 'пристрій виводу'); |
| _Pause |
| end; (Help) |
|{-------------------} |
| |
| procedure MainWin; |
| begin |
| ClearDevice; |
| BildWin; |
| BildContext; |
| BildFuncKey |
| end; (MainWin) |
|{-------------------} |
| |
| |
| |
| procedure Play; |
|{-------------} |
| procedure SelectPage (N: Byte); |
| begin |
| case N of |
| 1: begin |
| FuncKeyWindow [2]. Put (XS, YS); |
| Page_1; |
| Move_1 |
| end; |
| 2: begin |
| FuncKeyWindow [1]. Put (XS, YS); |
| Page_2; |
| Move_2 |
| end; |
| 3: begin |
| FuncKeyWindow [1]. Put (XS, YS); |
| Page_3; |
| Move_3 |
| end; |
| 4: begin |
| FuncKeyWindow [3]. Put (XS, YS); |
| Page_4_1; |
| Move_4_1; |
| Delay (Time_3 * 20); |
| Page_4_2; |
| Delay (Time_3 * 20); |
| Move_4_2; |
| Delay (Time_3 * 20); |
| Page_4_3; |
| Delay (Time_3 * 20); |
| Move_4_3; |
| Move_4_4; |
| Page_4_4; |
| Delay (Time_3 * 20); |
| Page_4_5; |
| Delay (Time_3 * 20); |
| Move_4_5; |
| Delay (Time_3 * 20); |
| Page_4_6; |
| Delay (Time_3 * 20); |
| Move_4_6; |
| Delay (Time_3 * 20); |
| Page_4_7 |
| end |
| end |
| end; (SelectPage) |
|{-------------} |
| |
| const |
| Back = # 75; |
| Next = # 77; |
| F1 = # 59; |
| Esc = # 27; |
| var |
| ArrowsAndEsc: set of Char; |
| ExtentedKey: Boolean; |
| Flag: Boolean; |
| CH: Char; |
| N: Byte; |
| begin |
| ClearDevice; |
| MainWin; |
| N: = 0; |
| |
| |
| ArrowsAndEsc: = [Back, Next, F1, Esc]; |
| repeat |
| ExtentedKey: = False; |
| Flag: = False; |
| CH: = ReadKey; |
| if CH = Esc then |
| Flag: = True; |
| if CH = # 0 then |
| begin |
| CH: = ReadKey; |
| ExtentedKey: = True |
| end; |
| if ExtentedKey then |
| case CH of |
| Back: begin |
| Dec (N); |
| SelectPage (N); |
| if N <1 then N: = 1 |
| end; |
| Next: begin |
| Inc (N); |
| SelectPage (N); |
| if N> 4 then N: = 4 |
| end; |
| F1: begin |
| Temp [1]. Get (X0, Y0, X0 + 380, Y0 + 300); |
| Temp [2]. Get (X0, Y0 + 305, GetMaxX - X0, YS - 5); |
| Help; |
| MainWin; |
| Temp [1]. Put (X0, Y0); |
| Temp [2]. Put (X0, Y0 + 305); |
| if N 3 then K: = 1; |
| for I: = 2 to 4 do |
| TempCol [I]: = MenuCol [4]; |
| TempCol [K + 1]: = MenuCol [3]; (Зміна кольору виделленого пункту) |
| until C = # 27 (тобто натиснута клавіша "Esc") |
| end; (MainMenu) |
|{-------------------} |
| |
| begin |
| MyInitGraph; (Ініціалізація графічного режиму) |
| Title; (Титульний аркуш) |
| MainMenu; (Головне меню) |
| CloseGraph; (Закриття графічного режиму) |
| end. (LEAN_Ecm;) |
|{-------------------} |
| Текст модуля Sm_Const |
| unit Sm_Const; |
| interface |
| uses Graph, Sm_Graph; |
| type |
| TText = array [1 .. 4] of string; |
| TColor = array [1 .. 4] of Word; |
|------------------- Type |
| const |
| X0: Integer = 10; (Початкова координата X) |
| Y0: Integer = 20; (Початкова координата Y) |
| XS: Integer = 10; (FuncKey) |
| YS: Integer = 440; (FuncKey) |
| XC: Integer = 400; (Context) |
| YC: Integer = 20; (Context) |
| XT: Integer = 80; (Test) |
| YT: Integer = 150; (Test) |
| X: Integer = 15; (Координата висновок тексту X) |
| Y: Integer = 330; (Координата висновок тексту Y) |
| ARBCol: Word = LightCyan; (Колір зовнішнього кордону стрілки Big) |
| ARSCol: Word = Red; (Колір зовнішнього кордону стрілки Small) |
| FILCol: Word = Blue; (Колір стрілки Big) |
| MemCol: Word = LightGreen; (Колір комірок пам'яті) |
| CPUCol: Word = DarkGray; (Колір CPU) |
| BRDCol: Word = Brown; (Колір рамки) |
| TxtCol: Word = White; (Колір тексту) |
| BArrow: TArrow = (X1: 15; Y1: 2; Y2: 5); (Форма стрілки Big) |
| SArrow: TArrow = (X1: 5; Y1: 0; Y2: 1); (Форма стрілки Small) |
| TestCol: TColor = (Green, White, Blue, Red); (Колір вікна тесту) |
| MenuCol: TColor = (Cyan, 0, LightGreen, Blue); |
| V: string [1] =''; |
| Q: string [9] = 'Питання #'; |
| (Питання] |
| Quastions: array [1 .. 5] of string = |
| |
| |
| |
| ('1. Що таке ВЗП? ', |
| '2. Що в ходить в процесор? ', |
| '3. Через який пристрій в ЕОМ відбувається обмін даними? ', |
| '4. Де в початковий момент знаходиться програма? ', |
| '5. Яка з пристроїв розшифровує перший машинну команду? '); |
| (Варіанти відповідей) |
| Answer: array [1 .. 5, 1 .. 3] of string = |
| (('1. Зовнішнє записуючий пристрій ', '2. Зовнішнє запам'ятовуючий |
| пристрій ', '3. Внутрішній запам'ятовуючий пристрій '), ('1. ЦУУ + АЛУ + |
| ВЗП ', '2. УВвода + ОЗУ ', '3. ЦУУ + АЛУ + КОП '), |
| ('1. АЛУ ', '2. ОЗУ', '3. ВЗП '), |
| ('1. У ВЗП ', '2. У АЛУ', '3. У УУ '), |
| ('1. ВЗП ', '2. ЦУУ', '3. АЛУ ')); |
| (Номери правильних відповідей) |
| OK: array [1 .. 5] of Byte = (2, 3, 2, 1, 2); |
| (Текст Меню) |
| Menu: TText = ( 'Ваш вибір:', |
| 'Навчання', |
| 'Перевірка знань', |
| 'Esc - Вихід'); |
| (Текст підсумку тестової частини програми) |
| EndofTest: TText = ( 'Ваш результат:', |
| 'Всього питань: 5', |
| 'Кількість правильних відповідей:', |
| 'Оцінка:'); |
|------------------- Const |
| implementation |
| end. |
| Текст модуля Sm_graph |
| unit Sm_Graph; |
| interface |
| uses |
| Graph, Crt; |
|{-------------------} (Uses) |
| |
| type |
| |
| TArrow = record X1, Y1, Y2: Integer; end; |
| |
| TImage = |
| object |
| private |
| Image: Pointer; |
| Size: Word; |
| public |
| procedure Destroy; |
| procedure Get (X1, Y1, X2, Y2: Integer); |
| procedure Put (X, Y: Integer); |
| end; |
|{-------------------} (Type) |
| |
| const |
| CArrow: TArrow = (X1: 15; Y1: 2; Y2: 5); |
| Time_1: Word = 5000; (Час мерехтіння) |
| Time_2: Word = 15000; (Час затримки екрану після відповіді на питання) |
| Time_3: Word = 300; (Час анімації) |
| Time_4: Word = 400; (Час затримки виведення тексту по буквах) |
| procedure _Pause; |
| procedure Animation (X, Y: Integer; D: Integer; XY: Byte; S: string; Vis: |
| Boolean); |
| procedure Arrow (X, Y, L: Integer; DIRectIOn: Byte); |
| procedure BLink (X, Y: Integer; S: string); |
| procedure MyInitGraph; |
| procedure MyText (X, Y: Integer; S: string); |
| |
| |
| |
| procedure Title; |
| |
| var |
| TempImage: TImage; |
| implementation |
| |
|{--------- Object TImage ----------) |
| procedure TImage.Destroy; |
| begin |
| if Image nil then |
| begin |
| FreeMem (Image, Size); |
| Image: = nil; |
| Size: = 0; |
| end |
| end; (Timage.Destroy) |
|{-------------------} |
| |
| procedure TImage.Get (X1, Y1, X2, Y2: Integer); |
| begin |
| Destroy; |
| Size: = ImageSize (X1, Y1, X2, Y2); |
| GetMem (Image, Size); |
| GetImage (X1, Y1, X2, Y2, Image ^); |
| end; (TImage.Get) |
|{-------------------} |
| |
| procedure TImage.Put (X, Y: Integer); |
| begin |
| if Image nil then |
| PutImage (X, Y, Image ^, 0); |
| end; (TImage.Put) |
|{--------- Object TImage ----------) |
| |
| procedure MyInitGraph; |
| var |
| GD, GM: Integer; |
| |
| begin |
| GD: = Detect; |
| InitGraph (GD, GM ,''); |
| if GraphResult grOK then |
| Halt (1); |
| end; (MyInitGraph) |
|{-------------------} |
| |
| procedure MyText (X, Y: Integer; S: string); |
| var |
| I: Word; |
| C: Char; |
| begin |
| MoveTo (X, Y); |
| I: = 0; |
| repeat |
| Inc (I); |
| OutText (S [I]); |
| Delay (Time_4); |
| until (I = Length (S)); |
| end; (NyText) |
|{-------------------} |
| |
| procedure _Pause; |
| begin |
| ReadKey; |
| end; (_Pause) |
| |
| |
| |
|{-------------------} |
| |
| procedure Animation (X, Y: Integer; D: Integer; |
| XY: Byte; S: string; Vis: Boolean); |
| (Animation) |
| var |
| DX, DY: Integer; |
| I: Integer; |
| begin |
| DX: = 1; |
| DY: = 1; |
| SetColor (Green); |
| if D <0 then |
| begin |
| DX: = -1; |
| DY: = -1; |
| end; |
| case XY of |
| 1: DY: = 0; |
| 2: DX: = 0; |
| end; |
| D: = Abs (D); |
| for I: = 1 to D do |
| begin |
| TempImage.Get (I * DX + X, |
| I * DY + Y, |
| TextWidth (S) + I * DX + X, |
| TextHeight (S) + I * DY + Y); |
| OutTextXY (X + I * DX, Y + TextHeight (S) + I * DY, S); |
| Delay (Time_3); |
| if I D then |
| TempImage.Put (X + I * DX, Y + I * DY); |
| if (I = D) and not VIs then |
| TEMPImage.Put (X + I * DX, Y + I * DY); |
| end; |
| end; (Animation) |
|{-------------------} |
| |
| procedure Arrow (X, Y, L: Integer; Direction: Byte); |
| type |
| COOrAR = array [1 .. 6] of Integer; |
| var |
| X1: Integer; |
| Y1: Byte; |
| Y2: Byte; |
| XX: COOrAR; |
| YY: COOrAR; |
| |
| procedure Change1; |
| begin |
| X1: =-X1; |
| L: =-L |
| end; |
| |
| procedure Change2; |
| var |
| I: Byte; |
| Temp: Integer; |
| begin |
| for I: = 1 to 6 do |
| begin |
| TEMP: = XX [I]; |
| XX [I]: = YY [I]; |
| YY [I]: = TEMP; |
| end; |
| |
| |
| |
| end; |
| |
| procedure ArrowCCOOr; |
| begin |
| XX [1]: = X1; YY [1]: = Y2; |
| XX [2]: = X1; YY [2]: = Y1; |
| XX [3]: = L; YY [3]: = Y1; |
| XX [4]: = L; YY [4]: =-Y1; |
| XX [5]: = X1; YY [5]: =-Y1; |
| XX [6]: = X1; YY [6]: =-Y2; |
| end; |
| |
| var |
| I: Byte; |
| begin |
| X1: = CArrow.X1; |
| Y1: = CArrow.Y1; |
| Y2: = CArrow.Y2; |
| if L | 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. |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |

-----------------------< br>| | | | | |. 991096.00.00.00 | 8AB |
| | | | | | | 0 |

B0 | | 22 | |

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