{"id":20697181,"url":"https://github.com/tsnsoft/pascal_demo_keyboard","last_synced_at":"2026-01-29T09:37:51.685Z","repository":{"id":119310616,"uuid":"131265899","full_name":"tsnsoft/PASCAL_DEMO_KEYBOARD","owner":"tsnsoft","description":"Пример программ на Pascal для работы с клавиатурой на низком уровне","archived":false,"fork":false,"pushed_at":"2018-04-27T08:16:03.000Z","size":237,"stargazers_count":5,"open_issues_count":0,"forks_count":1,"subscribers_count":0,"default_branch":"master","last_synced_at":"2025-06-12T21:54:58.647Z","etag":null,"topics":["asm","interrupts","keyboard","oldschool","pascal","port"],"latest_commit_sha":null,"homepage":null,"language":"Pascal","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"gpl-3.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/tsnsoft.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2018-04-27T08:05:17.000Z","updated_at":"2025-05-09T15:20:31.000Z","dependencies_parsed_at":null,"dependency_job_id":"f00467ae-4b42-4242-ba1a-a7b42de6ed9b","html_url":"https://github.com/tsnsoft/PASCAL_DEMO_KEYBOARD","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/tsnsoft/PASCAL_DEMO_KEYBOARD","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tsnsoft%2FPASCAL_DEMO_KEYBOARD","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tsnsoft%2FPASCAL_DEMO_KEYBOARD/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tsnsoft%2FPASCAL_DEMO_KEYBOARD/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tsnsoft%2FPASCAL_DEMO_KEYBOARD/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/tsnsoft","download_url":"https://codeload.github.com/tsnsoft/PASCAL_DEMO_KEYBOARD/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/tsnsoft%2FPASCAL_DEMO_KEYBOARD/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28873990,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-29T07:35:32.468Z","status":"ssl_error","status_checked_at":"2026-01-29T07:33:31.463Z","response_time":59,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["asm","interrupts","keyboard","oldschool","pascal","port"],"created_at":"2024-11-17T00:17:00.672Z","updated_at":"2026-01-29T09:37:51.638Z","avatar_url":"https://github.com/tsnsoft.png","language":"Pascal","funding_links":[],"categories":[],"sub_categories":[],"readme":"# PASCAL_DEMO_KEYBOARD\nПример программ на Pascal для работы с клавиатурой на низком уровне (1996г., времена MS-DOS и PASCAL...)\n\n\t\t\t       [1] ВВЕДЕНИЕ.\n\t\t\t       *************\n     Что такое современная клавиатура компьютера IBM AT\t?\n     Прежде чем\tначать изучать этот вопрос нам необходимо знать: а что же\n     такое компьютер вообще, из\tчего он\tсостоит\t?\n\n\t\t   [1.1] Основные компоненты компьютера.\n\t\t   =====================================\n     Компьютер состоит из 5 основных компонент:\n     1)\tСистемный блок;\n     2)\tНакопитель на жестком диске;\n     3)\tНакопитель на гибком диске;\n     4)\tДисплей;\n     5)\tКлавиатура;\n\n     Совокупность этих и некоторых других компонент и образует компьютер\n     как таковой. Все компоненты компьютера соединяются\tмежду собой с\n     помощью специальных кабелей, представляющих из себя набор проводников\n     в специальной изоляции с разъемами\tна концах.\n\n     1\u003e\tСистемный блок - это основная компонента компьютера,\n     представляющая из себя совокупность металлического\tчетырехугольного\n     корпуса с электронной начинкой внутри.\n     Назначение\tсистемного блока:\n\t1) Выполняет компьютерные программы;\n\t2) Является вместилищем\tосновных электронных плат компьютера и\n\tнескольких компонент компьютера: это накопитель\tна жестком диске,\n\tнакопитель на гибком диске и др. Все компоненты\tсистемного блока\n\tприкручиваются к нему шурупами и соединяются между собой при\n\tпомощи кабелей;\n\t3) Содержит блок питания, который обеспечивает электронные платы\n\tсистемного блока электрической энергией;\n\t4) Содержит вентилятор,\tкоторый\tохлаждает электронную начинку\n\tсистемного блока, которая вышла\tбы без него из строя от\tперегрева;\n\t5) Содержит несколько миниатюрных индикаторов (лампочек), которые\n\tотображают значения некоторых характеристик и состояний\n\tкомпьютера:\n\t   - индикатор,\tпоказывающий текущую скорость работы компьютера;\n\t   - лампочка \"Power\", свечение\tкоторой\tозначает, что компьютер\n\t     включен;\n\t   - лампочка \"Turbo\", свечение\tкоторой\tозначает, что компьютер\n\t     работает с\tмаксимальной скоростью;\n\t   - лампочка \"H/Disk\",\tсвечение которой означает, что в данный\n\t     момент происходит работа накопителя на жестком диске;\n\t6) Содержит несколько органов управления компьютером:\n\t   - кнопку включения/выключения компьютера: \"Power\";\n\t   - кнопку начальной установки\tкомпьютера: \"Reset\" (\"сброс\");\n\t   - кнопку переключения скорости работы компьютера: \"Turbo\";\n\t   - замок, при\tзакрытии которого работа на компьютере невозможна;\n\n     2\u003e\tНакопитель на жестком диске - это важная компонента компьютера,\n     находящаяся внутри\tсистемного блока.\n     Назначение\tнакопителя на жестком диске:\n\t1) Позволяет постоянно (даже при отключении питания) хранить\n\tбольшое\tколичество информации, данных и\tпрограмм.\n\t2) Хранит специальную информацию и программы, без которых\n\tкомпьютер при включении\tработать не будет (так называемую \"DOS\"\tи\n\tдр.);\n\n     3\u003e\tНакопитель на гибком диске - это нужная\tкомпонента компьютера,\n     находящаяся внутри\tсистемного блока. Накопитель на\tгибком диске\n     служит для\tработы с дискетами и позволяет записывать и считывать\n     информацию\tс них.\n\tДискеты\t- это специальные пластины с магнитным покрытием (это\n     покрытие подобно покрытию магнитофонных кассет), которые способны\n     сохранять записанную на них информацию в течении долгого времени.\n     Дискеты позволяют обмениваться информацией\tмежду компьютерами, а\n     также хранить резервные копии информации, данных и\tпрограмм, которые\n     могут понадобиться\tдля их восстановления на жестком диске (если они\n     там уничтожатся или разрушатся);\n\n     4\u003e\tДисплей\t- это необходимая компонента компьютера, находящаяся вне\n     системного\tблока и\tпредставляющая из себя подобие обыкновенного\n     телевизора. Назначение дисплея в том, чтобы пользователь компьютера\n     мог зрительно с ним общаться и взаимодействовать.\n\n     5\u003e\tКлавиатура - это необходимая компонента\tкомпьютера, находящаяся\n     вне системного блока и представляющая из себя корпус небольшой высоты\n     с электронной начинкой внутри. В клавиатуру вделан\tнабор клавиш и\n     индикаторов (миниатюрных лампочек,\tотражающих некоторые режимы работы\n     клавиатуры). Назначение клавиатуры\tв том, чтобы пользователь\n     компьютера\tмог с помощью пальцев рук общаться и взаимодействовать с\n     ним.\n\n\t\t\t       * * * * * * *\n\n\t\t  [1.2]\tПонятия, без которых не\tобойтись.\n\t\t  =======================================\n     1)\tКлавиши\t- этим термином\tбудем обозначать набор клавиш, которые\n     вделаны в корпус клавиатуры и представляют\tиз себя\tминиатюрные\n     переключатели, замыкающие электронные цепи\tпри их нажатии и\n     размыкающие при их\tотпускании.\n\n     2)\tКонтроллер клавиатуры -\tэто одна из важнейших микросхем\n     электронной начинки клавиатуры, с помощью которой происходит\n     \"общение\" системного блока\tс клавиатурой.\n     Назначение\tконтроллера клавиатуры:\n     - управляет всей электроникой клавиатуры;\n     - передает\tсистемному блоку информацию о фактах нажатий и отжатий\n       клавиш;\n     - передает\tсистемному блоку информацию о состоянии\tэлектроники\n       клавиатуры;\n     - принимает и исполняет команды системного\tблока;\n\n     3)\tЦентральный процессор -\tэто \"мозг\" компьютера, представляющий из\n     себя очень\tсложную\tи большую по размерам электронную микросхему.\n     Центральный процессор предназначен\tдля управления компьютером и с\n     помощью него системный блок выполняет компьютерные\tпрограммы.\n\n     4)\tОперативная память - это необходимая компонента\tкомпьютера,\n     которая предназначена для хранения\tданных и программ во время работы\n     компьютера. Без оперативной памяти\tкомпьютер работать не может. После\n     выключения\tпитания\tкомпьютера все данные из оперативной памяти\n     стираются.\n\n     5)\tБуфер клавиатуры - это небольшая оперативная память, находящаяся\n     в электронике клавиатуры. В этой памяти храниться информация о тех\n     фактах нажатий и отжатий клавиш, которые были, но еще не переданы в\n     системный блок. Буфер клавиатуры состоит из 15 ячеек, каждая из\n     которых может содержать число от 0\tдо 255.\n\n     6)\tСистемный буфер\tклавиатуры (СБК) - это часть оперативной памяти\n     системного\tблока, в которой хранятся данные, которые получены путем\n     анализа той информации (о фактах нажатий и\tотжатий\tклавиш)\tбуфера\n     клавиатуры, которую системный блок\tполучил\tот клавиатуры (а именно\tот\n     контроллера клавиатуры). Системный\tбуфер клавиатуры состоит из 16\n     ячеек, каждая из которых может содержать два числа, каждое\tиз которых\n     может принимать значения от 0 до 255.\n\n     7)\tBIOS - это набор специальных программ, постоянно хранящихся в\n     памяти компьютера (системного блока), которые после выключения\n     питания не\tстираются. Эти программы непосредственно управляют\n     электроникой компьютера и без этих\tпрограмм компьютер работать не\n     может. Использование возможностей этих программ делает\n     программирование более простым и быстрым.\n\n     8)\tПорты ввода/вывода информации -\tэто специальные\tмикросхемы,\n     которые соединяют электронику различных компонент компьютера\n     (например дисплея и системного блока) между собой.\tПорты являются как\n     бы\t\"воротами\" компьютера, через которые проходят потоки различной\n     информации. Каждый\tпорт имеет свой\tиндивидуальный номер, с\tпомощью\n     которого мы можем узнать и\tизменить все те\tпотоки информации, которые\n     через него\tпроходят. Необходимо заметить, что и клавиатура\n     взаимодействует с компьютером (системным блоком) тоже через порты\n     ввода/вывода информации.\n\n     9)\tПрерывание - это процесс, состоящий из трех основных этапов:\n\t 1) Компьютер запоминает свое текущее состояние\t(чтобы после в\n\t него вернуться) и прекращает свою текущую работу;\n\t 2) Начинает выполняться одна из специальных программ, которая\n\t определяется номером прерывания (каждое прерывание имеет свой\n\t индивидуальный\tномер);\n\t 3) После выполнения специальной программы, выполняющей\n\t (обслуживающей) данное\tпрерывание, компьютер восстанавливает свое\n\t предыдущее состояние (которое было предварительно запомнено), и\n\t начинает продолжать свою предыдущую работу с того места, где\n\t прежде\tон остановился;\n\n\t\t\t       - - - - - - -\n\n     При обозначении цифр будем\tиспользовать следующее правило:\tесли после\n     цифры стоит буква 'd' или ничего не стоит,\tто цифра написана в\n     десятичной\tсистеме\tисчисления, а если после цифры стоит буква 'h',\tто\n     цифра написана в шестнадцатеричной\tсистеме.\n\n\t\t\t       - - - - - - -\n\n\t\tТеперь перейдем\tк знакомству с клавиатурой.\n\n\t\t\t       * * * * * * *\n\n\t\t       [2] ЗНАКОМСТВО С\tКЛАВИАТУРОЙ.\n\t\t       *****************************\n     Клавиатура\t-  это устройство для ввода информации в компьютер с\n     помощью пальцев рук. Клавиатура состоит из\tнабора клавиш (с помощью\n     которых, собственно, и осуществляется ввод\tинформации) и электроники,\n     которая их\tобслуживает. Главной частью клавиатурной электроники\n     является контроллер клавиатуры, связывающий системный блок\tкомпьютера\n     с остальной электроникой клавиатуры.\n\n     Все клавиши клавиатуры можно разделить на 3 группы:\n\t1) Символьные -\tслужат для ввода компьютерных символов:\tбукв,цифр,\n\tзнаков препинания и других символов (например: \"% / # - + = *\");\n\t2) Функциональные - служат для выполнения определенных действий,\n\tнапример для удаления неверно введенного символа, для перемещения\n\tизображения по экрану и\tдр.;\n\t3) Клавиши-переключатели - изменяют режим работы клавиатуры и\n\tназначение некоторых клавиш (например включают или выключают режим\n\tввода прописных\tбукв и т.д.);\n\n     В правой части клавиатуры находятся 17 клавиш, которые имеют свои\n     аналоги в основной\tчасти клавиатуры (например в клавиатуре\tимеются\n     две клавиши \"Стрелка вправо\", две клавиши \"Enter\" и т.д.).\tЗачем,\n     спрашивается, нужно несколько одинаковых по назначению клавиш ?\n     Хотя это и\tизлишество, но оно очень удобно\tпри работе с клавиатурой\n     и поэтому клавиатуру мысленно разделяют на\tдве части: основную и\n     дополнительную. Если говорят о клавишах дополнительной клавиатуры,\n     то\tимеют в\tвиду именно 17 клавиш в\tправой части клавиатуры, а если\n     говорят просто о клавишах,\tто имеют ввиду любые клавиши клавиатуры.\n\n     Для понимания работы клавиатуры очень важно знать сущность\tследующих\n     понятий:\n\t1) Скэн-код клавиши - это условный номер, которые присвоен данной\n\tклавише\tклавиатуры, т.о. каждая\tклавиша\tклавиатуры имеет свой\n\tиндивидуальный номер, называемый скэн-кодом.Современная\tклавиатура\n\tимеет 101 клавишу, а значит и 101 скэн-код (сейчас, правда,\n\tпоявились некоторые заморские клавиатуры с 102 клавишами, но эти\n\tклавиатуры редки и касаться их мы не будем). Скэн-коды имеют\n\tномера от 1 до 101.\n\t2) Компьютер имеет определенный\tнабор компьютерных символов. Эти\n\tсимволы\tподразделяются на буквы\t(русские и латинские), знаки\n\tпрепинания (например: \",?!\") и специальные символы (например:\n\t\"*/-+()%#$\u0026\"). Всего в компьютере имеется 256 различных\tсимволов.\n\tКаждый компьютерный символ имеет свой определенный порядковый\n\tномер, который представляет из себя число в диапазоне от 0 до 255.\n\tТаким образом, первый компьютерный символ имеет\t0 порядковый\n\tномер, второй символ - 1, 256 символ - 255 порядковый номер.\n\tПорядковый номер компьютерного символа называют\tлибо ASCII\n\tкодом, либо расширенным\tASCII кодам. Таким образом, например,\n\tпорядковый номер символа \"R\", равный 82, мы можем назвать либо\n\tASCII кодом, либо расширенными ASCII кодом. Зачем, спрашивается,\n\tнужно два различных названия для одного\tи того же порядкового\n\tномера символа ? Дело в\tтом, что когда мы нажимаем на к-либо\n\tклавишу\tклавиатуры, компьютер ставит ей\tв соответствие к-либо\n\tопределенный символ. Например, если нажимается клавиша с\n\tизображенным на\tней символом \"?\", то компьютер поставит\tей в\n\tсоответствие символ \"?\". Но если мы нажмем на клавишу \"F5\", то\n\tкомпьютер и ей поставит\tв соответствие символ \"?\". Но как же нам\n\tв таком\tслучае узнать, какая именно нажималась клавиша при вводе\n\tсимвола\t\"?\": клавиша \"F5\" или клавиша с\tизображенным на\tней\n\tсимволом \"?\" ? Ответ прост: когда мы нажимаем на клавишу с\n\tизображенным на\tней символом \"?\", то компьютер ставит ей в\n\tсоответствие символ \"?\", порядковый номер которого (63)\tон назовет\n\tASCII кодом, а когда мы\tнажимаем на клавишу \"F5\", то компьютер\n\tпоставит и ей в\tсоответствие тот же символ \"?\",\tно его порядковый\n\tномер он назовет расширенным ASCII кодом. Поэтому стоит\tнам только\n\tузнать,\tкак называется порядковый номер\tвведенного с клавиатуры\n\tсимвола, и мы сразу однозначно определим ту клавишу, которую\n\tнажимали при вводе данного символа. Как\tузнать название\n\tпорядкового номера компьютерного символа мы узнаем позже.\n\n     Высказывание \"символ с ASCII кодом\" равнозначно высказыванию\n     \"порядковый номер символа называется ASCII кодом\".\tВысказывание\n     \"символ с расширенным ASCII кодом\"\tравнозначно высказыванию\n     \"порядковый номер символа называется расширенный ASCII кодом\".\n\n     Таким образом:\n     - каждая клавиша имеет свой индивидуальный\tскэн-код;\n     - при нажатии к-либо клавиши клавиатуры компьютер (системный блок)\n       ставит ей в соответствие\tопределенный символ либо с ASCII кодом,\n       либо с расширенным ASCII\tкодом;\n\n     Каждая клавиша клавиатуры имеет свое назначение по\tумолчанию, и это\n     назначение\tлегко может измениться компьютерной программой,\tт.е.\n     программным путем.\n\n     1\u003e\tНазначение по умолчанию\tсимвольных клавиш состоит в том,чтобы с\tих\n     помощью вводить различные символы.\n\n     2\u003e\tНазначение по умолчанию\tфункциональных клавиш :\n     --------------------------------------------------\n\n     Клавиша:\t       Назначение:\n     --------\t      -----------\n     Esc\t       Служит для отмены к-либо\tдействий в программе\n\t\t       (например для завершения\tработы программы).\n\n     F1,F2,...,F12     Специальные клавиши, назначение которых\n\t\t       определяется работающей программой.\n\n     PrintScreen       При нажатии на эту клавишу содержимое экрана\n\t\t       распечатывается на принтере.\n\n     Pause\t       При нажатии на эту клавишу работа компьютера\n\t\t       приостанавливается до нажатия к-либо другой\n\t\t       клавиши.\n\n     Home\t       Перемещает курсор в начало строки на экране.\n\n     End\t       Перемещает курсор в конец строки\tна экране.\n\n     PgUp (PageUp)     Перемещает текст\tна экране вверх\tна 25 строк.\n\n     PgDn (PageDown)   Перемещает текст\tна экране вниз на 25 строк.\n\n     Del (Delete)      Эта клавиша стирает тот символ на экране, на\n\t\t       котором находится курсор. Курсор\t- это специальный\n\t\t       значок на экране, показывающий то место экрана, на\n\t\t       которое будет выводится очередной символ, вводимый\n\t\t       с клавиатуры.\n\n     BackSpace\t       Эта клавиша стирает тот символ на экране, который\n\t\t       находится левее курсора.\n\n     Стрелки\t       Служат для перемещения курсора по экрану\t(вверх,\n\t\t       вниз, влево, вправо).\n\n     Enter\t       Этой клавишей завершают ввод строк с клавиатуры.\n\t\t       При ее нажатии считается, что вводимая строка\n\t\t       уже набрана.\n\n     Tab\t       Перемещает курсор немного вправо\tпо экрану.\n\n     3\u003e\tНазначение по умолчанию\tклавиш-переключателей :\n     --------------------------------------------------\n\n     Клавиша:\t      Назначение:\n     --------\t       -----------\n     CapsLock\t       Включает/выключает режим\tввода прописных\tбукв. Если\n\t\t       установлен режим\tпрописных букв,\tто вводимые буквы\n\t\t       будут иметь прописной вид, например: \"А Б В\". Если\n\t\t       режим прописных букв выключен, то вводимые буквы\n\t\t       будут иметь строчный вид, например: \"а б в\".\n\n     NumLock\t       Данной клавишей определяет, как будут\n\t\t       использоваться клавиши дополнительной клавиатуры:\n\t\t       - как цифры (для\tввода цифр);\n\t\t       - как клавиши управления\tкурсором (для перемещения\n\t\t\t текста\tи курсора по экрану);\n\n     ScrollLock\t       Включает/выключает режим, при котором нажатия на\n\t\t       стрелки будут вызывать перемещение не курсора по\n\t\t       экрану, а изображения (например текста или рисунка)\n\t\t       на нем.\n\n     Ins (Insert)      Переключает режим вставки/замены\tсимволов.\n\t\t       Разберем\tотличие\tэтих режимов на\tследующем примере:\n\t\t       пусть на\tэкране имеется строка \"Комютер\", а курсор\n\t\t       находится на букве \"ю\"; Теперь нажмем на\tклавиатуре\n\t\t       на букву\t\"п\" и после нее\tна букву \"ь\".\n\t\t       Что же получится\tна экране ?\n\t\t       - если режим вставки, то: \"Компьютер\".\n\t\t       - если режим замены, то:\t\"Компьер\".\n\n     Shift\t       Если нажать на эту клавишу и не отпуская\tее нажать\n\t\t       на к-либо букву,\tто\n\t\t       - если установлен режим прописных букв (клавишей\n\t\t\t \"CapsLock\"), то буква введется\tв строчной форме.\n\t\t       - если установлен режим строчных\tбукв (клавишей\n\t\t\t \"CapsLock\"), то буква введется\tв прописной форме.\n\t\t       Таким образом эта клавиша временно (пока\tона\n\t\t       нажата) изменяет\tтот режим ввода\t(прописных или\n\t\t       строчных\tбукв), который установлен клавишей\n\t\t       \"CapsLock\".\n\n     Ctrl,Alt\t       Если нажать на одну из этих клавиш и не отпуская\n\t\t       ее нажать на к-либо другую, то назначение второй\n\t\t       нажатой клавиши изменится. Например, если мы просто\n\t\t       нажмем на клавишу \"Pause\", то результат будет\n\t\t       такой: работа компьютера\tприостановится до нажатия\n\t\t       к-либо другой клавиши, а\tесли мы\tсперва нажмем на\n\t\t       клавишу \"Ctrl\" и\tне отпуская ее нажмем на клавишу\n\t\t       \"Pause\",\tто результат будет совсем другой:\n\t\t       программа, которая в данный момент работает,\n\t\t       завершит\tсвою работу.\n\n\t\t\t       * * * * * * *\n\n\t    [3]\tМЕХАНИЗМ ВЗАИМОДЕЙСТВИЯ\tКЛАВИАТУРЫ И КОМПЬЮТЕРА.\n\t    ****************************************************\n\n     ┌──────────┬────────┬──┐\t\t   ┌─────────────────────────────┐\n     ├─┐\t│Буфер к.│  │\t\t   │\t  ┌───────────────┐\t │\n     │К│\t└────╥───┘  │\t\t   │\t  │    B I O S\t  │\t │\n     │л│ ╔════╗\t ┌───╨───┐  │\t\t   │   ┌──┼───────────────┤\t │\n     │а│ ║Элек║\t │ Intel │  │\t\t   │   │П │ Центральный\t  │\t │\n     │в├─╢трон╟──┤8 0 4\t2│  │ К\tа б е л\tь  │   │о │ Процессор\t  │\t │\n     │и├─╢ика ╟──┤Контрол╞══╪\u003c════════════\u003e╪═══╡р ├───────────────┤\t │\n     │ш├─╫─┬┬─╫──┤лер кла│  │\t\t   │   │т │ Оперативная\t  ├────┐ │\n     │и│ ╟─┼┼─╢\t │виатуры│  │\t\t   │   │ы │ Память\t  │СБК │ │\n     ├─┘ ╚═╧╧═╝\t └───────┘  │\t\t   │   └──┴───────────────┴────┘ │\n     │\tК л а в\tи а т у\tр а │\t\t   │ С и с т е м н ы й\t б л о к │\n     └──────────────────────┘\t\t   └─────────────────────────────┘\n\n\t\t\t\t  Рис. 1.\n\n     При рассмотрения механизма\tвзаимодействия клавиатуры и компьютера\n     используйте рис.1.\tИтак:\n\n     1)\tЕсли системный блок разрешил клавиатуре\tанализировать факты\n     нажатий и отпусканий клавиш, то переход на\tшаг 2, иначе на\tшаг 1;\n     2)\tЕсли в буфере клавиатуры есть свободное\tместо, то переход на\n     шаг 3, иначе на шаг 5;\n     3)\tОжидается факт нажатия или отпускания к-либо клавиши;\n     4)\tИнформация о факте нажатия или отпускания клавиши помещается в\n     буфер клавиатуры;\n     5)\tИнформация о самом раннем факте\tнажатия\tили отпускания клавиши\n     помещается\tиз буфера клавиатуры в порт 60h;\n     6)\tЕсли системный блок разрешил клавиатуре\tзапрашивать прерывание №9,\n     то\tконтроллер клавиатуры запрашивает разрешение у системного блока\n     на\tпрерывание №9 (клавиатурное прерывание), иначе переход на шаг 1;\n     7)\tЕсли системный блок не реагирует на запрос клавиатуры, то переход\n     на\tшаг 1;\n     8)\tКлавиатура перестает анализировать факты нажатий и отпусканий\n     клавиш. Начинается\tобслуживание прерывания\t№9, т.е. начинает\n     выполняется одна из специальных программ BIOSа, которая выполняет\n     следующие действия:\n       8.1) Считывает информацию из порта 60h;\n       8.2) Сообщает контроллеру клавиатуры о считывании данного с\n       порта 60h. Этим действием системный блок\tзаставляет контроллер\n       клавиатуры удалить из буфера клавиатуры информацию, только что\n       считанную системным блоком из порта 60h,\tа также\tразрешает ему\n       анализировать факты нажатий и отпусканий\tклавиш.\n       8.3) Если считанная информация соответствует клавише-переключателю,\n       то зарегистрировать этот\tфакт в ОЗУ по адресам 417h и 418h.\n       Если считанная информация соответствует нажатию клавише \"Ins(ert)\",\n       то переход на шаг 8.6, иначе переход на шаг 1;\n       8.4) Если в системном буфере клавиатуры есть свободное место, то\n       переход на шаг 8.5, иначе издается звуковой сигнал и делается\n       переход на шаг 1;\n       8.5) Если нажатой клавише принято ставить в соответствие\tсимвол\n       с ASCII кодом, то поместить в системный буфер клавиатуры\tпорядковый\n       номер соответствующего символа и\tскэн-код нажатой клавиши. Переход\n       на шаг 1;\n       8.6) Если нажатой клавише принято ставить в соответствие\tсимвол с\n       расширенным ASCII кодом,\tто поместить в системный буфер клавиатуры\n       число ноль (это является\tпризнаком того,\tчто нажатой клавише\n       ставится\tв соответствие символ с\tрасширенный ASCII кодом) и\n       порядковый номер\tсоответствующего символа;\n\n\n\t\t\t      [3.1] Пояснения.\n\t\t\t     ================\n     1\u003e\tСистемный блок может запретить клавиатуре реагировать на любые\n     факты нажатий и отпусканий\tклавиш на клавиатуре. Для этой цели\n     системный блок посылает в контроллер клавиатуры специальную команду,\n     которая запретит электронным схемам клавиатуры реагировать\tна к-либо\n     факты нажатия или отпускания клавиш. Другой командой системный блок\n     может разрешить клавиатуре\tреагировать на факты нажатий или\n     отпусканий\tклавиш.\tНадо отметить, что системный блок посылает команды\n     клавиатуре\tи считывает из нее информацию через специальные\tпорты\n     ввода/вывода информации, номера которых 60h и 64h.\n\n\tЕсли системный блок запретил клавиатуре\tреагировать на факты\n     нажатий и отпусканий клавиш, то ввод с клавиатуры невозможен, причем\n     до\tтех пор, пока системный\tблок не\tразрешит клавиатуре реагировать\tна\n     факты нажатий и отпусканий\tклавиш.\n\n\tИтак предположим, что системный\tблок разрешил клавиатуре\n     реагировать на факты нажатий и отпусканий клавиш, тогда:\n\n     2\u003e\tКонтроллер клавиатуры проверяет: есть ли свободное место в его\n     буфере клавиатуры ?\n\t\t\t       - - - - - - -\n\n\tБуфер клавиатуры изображен на рис. 2. Буфер клавиатуры можно\n     представить как таблицу из\t15 ячеек (элементов), каждая ячейка\n     которого может содержать к-либо число от 0\tдо 255.\tВсе ячейки\n     буфера клавиатуры пронумерованы от\t1 до 15. Кроме 15 ячеек\tв\n     буфере клавиатуры имеются еще 2 специальные ячейки: это так\n     называемые\tячейка \"хвоста\"\tи ячейка \"головы\". Каждая из этих ячеек\n     содержит к-либо число от 1\tдо 15, которое соответствует к-либо\n     ячейки буфера клавиатуры. Например, если в\tячейке \"головы\"\tнаходится\n     число 02, то это число соответствует ячейке №2. Что значит\tфраза\n     \"соответствует ячейке\" ? Это станет ясно чуть позже ...\n\tПредположим, что мы только что включили\tкомпьютер. Тогда буфер\n     клавиатуры\tбудет полностью\tпустой (а это значит, что в нем\tесть\n     свободное место), в его ячейках будут содержаться нули, а в ячейке\n     \"головы\" и\tв ячейке \"хвоста\" будет\tнаходится число\t1.\n\n\t\t       Устройство буфера клавиатуры.\n\t\t       .............................\n\n\t    ┌────────────┐\t\t  ┌───────────────────┐\n\t    │ Ячейка №1\t │\t\t  │ Ячейка \"головы\"   │\n     З\t│   ├────────────┤\t\t  │ буфера клавиатуры │\n     а\t│   │ Ячейка №2\t │\u003c─────────────┐ ├───────────────────┤\n     п\t│   ├────────────┤\t\t└─┤\t   02\t      │\n     о\t│   .\t\t .\t\t  └───────────────────┘\n     л\t│   ├────────────┤\n     н\t│   │ Ячейка №7\t │\u003c─────┐\t  ┌───────────────────┐\n     е\t│   ├────────────┤\t│\t  │ Ячейка \"хвоста\"   │\n     н\t│   .\t\t .\t│\t  │ буфера клавиатуры │\n     и\t√   ├────────────┤\t│\t  ├───────────────────┤\n     е\t    │ Ячейка №15 │\t└─────────┤\t   07\t      │\n\t    └────────────┘\t\t  └───────────────────┘\n\n\t\t\t\t  Рис. 2\n\n\t\t\t       - - - - - - -\n     3\u003e\tЕсли в буфер клавиатуры\tимеется\tсвободное место, то контроллер\n     клавиатуры\tожидает\tфакта нажатия или отпускания к-либо клавиши\n     (т.е. ждет\tпока мы\tне нажмем на к-нибудь клавишу),а если нет места\t-\n     то\tделается переход на шаг\t5.\n\n\n     4\u003e\tИтак, контроллер клавиатуры дождался, наконец, пока мы нажмем и\n     отпустим к-либо клавишу.\n\n\t\t\t       - - - - - - -\n\tНадо заметить, что клавиатуре совершенно безразлично, что\n     изображенно на нажатой клавише: буква ли, цифра или что-то\tдругое.\n     Дело в том, что клавиатура\tзнает только порядковый\tномер нажатой или\n     отпущенной\tклавиши\tи этот номер называется\tскэн-кодом клавиши, а что\n     изображенно на клавише, и что это изображение означает - она\n     совершенно\tне знает. Как же тогда,\tесли например Вы нажмете на\n     клавишу с изображением \"*\", компьютер (системный блок) узнает, что\tВы\n     ввели именно \"*\", а не что-то другое? А просто: ведь системный блок\n     знает,какой символ\tкакому скэн-коду соответствует.\tПоэтому, системный\n     блок однозначно (по скэн-коду клавиши) определяет,\tкакой символ Вы\n     ввели. Таким образом: задачей определения,\tчто же за символ,\n     собственно, вводился с клавиатуры,\tзанимается не клавиатура, а\n     системный блок. Клавиатура\tлишь сообщает системному блоку порядковые\n     номера (скэн-коды)\tнажимаемых и отпускаемых клавиш.\n\t\t\t       - - - - - - -\n\n\tТак-как\tмы предположили, что буфер клавиатуры полностью\tвесь\n     пустой (так-как компьютер только что включили), то\tконтроллер\n     клавиатуры\tзапишет\tв его ячейку №1\tскэн-код только\tчто нажатой на\n     клавиатуре\tклавиши. После этого контроллер\tклавиатуры запишет в\n     ячейку \"хвоста\" число 02. Это означает, что следующая свободная\n     ячейка буфера клавиатуры имеет номер, равный 2 (т.е. ячейка №2). В\n     ячейке \"головы\" все еще остается число 01.\tЭто означает, что ячейка,\n     которая была заполнена первой, имеет номер, равный\t1(т.е. ячейка №1).\n\n\tТеперь надо учесть тот факт, что только\tчто нажатая клавиша еще\n     ведь была и отжата! Да, для контроллера клавиатуры\tэтот факт\n     знаменателен, и поэтому следующим делом, которое он сделает, будет\n     помещение в следующую свободную ячейку, номер которой хранится в\n     ячейке \"хвоста\", числа, которое на\t128 больше скэн-кода нажатой\n     клавиши. После этого он запишет в ячейку \"хвоста\" число 03. Это\n     означает, что следующая свободная ячейка буфера клавиатуры\tуже имеет\n     номер, равный 3 (т.е. ячейка №3).В\tячейке \"головы\"\tвсе еще\tостается\n     число 01. Это означает, что ячейка, которая была заполнена\tпервой,\n     имеет номер, равный 1 (т.е. ячейка\t№1). Таким образом, если в ячейке\n     буфера клавиатуры находится число большее 128, то это говорит о том,\n     что какая-то клавиша была отжата, а если в\tячейке буфера клавиатуры\n     находится число меньшее либо равное 128, то это говорит о том, что\n     какая-то клавиша была в нажатом состоянии.\tТаким образом, контроллер\n     клавиатуры\tучитывает все факты и нажатия и\tотпускания клавиш.\n\n\t\t\t       - - - - - - -\n\tА что будет, если мы нажмем к-либо клавишу и будем ее удерживать ?\n     В этом случае контроллер клавиатуры будет записывать в свой буфер\n     клавиатуры\tскэн-коды нажатой клавиши до тех пор, пока нажатая клавиша\n     не\tбудет отжата. Это явление называется \"автоповтор\". Как только\n     нажатая клавиша будет отжата контроллер клавиатуры\tзапишет\tв\n     следующую свободную ячейку\t(на которую указывает ячейка \"хвоста\")\n     скэн-код отжатой клавиши +\t128. Таким образом, если в ячейках буфера\n     клавиатуры\tв подряд записан один и\tтот же скэн-код\tклавиши, то это\n     говорит о том, что\tк-либо клавиша была нажата долгое время.\n\n\tА что будет, если мы нажмем к-либо клавишу и не\tотпуская ее нажмем\n     на\tк-либо другую клавишу, после чего отпустим вторую нажатую клавишу\n     а вслед за\tней и первую ? В этом случае будет следующее:\n     - в буфер клавиатуры будет\tзаписываться скэн-код первой нажатой\n       клавиши до тех пор, пока\tне нажмется вторая клавиша;\n     - как только нажмется вторая клавиша в буфер клавиатуры сразу начнет\n       записываться скэн-код второй нажатой клавиши, до\tтех пор, пока не\n       она не отожмется;\n     - как только отожмется вторая нажатая клавиша в буфер клавиатуры\n       сразу запишется скэн-код\tвторой клавиши + 128, после чего в буфер\n       клавиатуры ничего не будет записываться до тех пор, пока\tне\n       отожмется первая\tнажатая\tклавиша;\n     - как только отожмется первая нажатая клавиша в буфер клавиатуры\n       сразу запишется ее скэн-код + 128;\n\n\tКроме того, есть некоторые комбинации из нажатых вместе\tклавиш,\n     которые имеют свой\tиндивидуальный скэн-код, который занимает (!!)\n     несколько ячеек в буфере клавиатуры, т.е. такое совместное\tнажатие\n     нескольких\tклавиш как бы эквивалентно нажатию какой-то \"невидимой\"\n     всем нам клавиши с\tдлинющим скэн-кодом. При отжатии такой комбинации\n     клавиш в буфер клавиатуры заносится ни скэн-код + 128, а нечто\n     другое, причем оно\tтоже занимает несколько\tячеек буфера клавиатуры.\n     Мы\tне будем рассматривать подобные\tкомбинации (\"сверх\" клавиши), т.к.\n     они не представляющие для нас особого интереса ...\n\n\tТеперь рассмотрим ситуацию, когда в буфере клавиатуры заполненно\n     14\tячеек, скажем с\tячейки №1 по ячейку №14\t(ячейка\t№15 еще\tсвободна):\n\n\t    ┌────────────┐\t\t  ┌───────────────────┐\n\t    │ Ячейка №1\t │\u003c─────────────┐ │ Ячейка \"головы\"   │\n\t    ├────────────┤\t\t│ │ буфера клавиатуры │\n\t    │ Ячейка №2\t │\t\t│ ├───────────────────┤\n\t    ├────────────┤\t\t└─┤\t   01\t      │\n\t    .\t\t .\t\t  └───────────────────┘\n\t    ├────────────┤\n\t    │ Ячейка №14 │\t\t  ┌───────────────────┐\n\t    ├────────────┤\t\t  │ Ячейка \"хвоста\"   │\n\t    │ Ячейка №15 │\u003c─────────────┐ │ буфера клавиатуры │\n\t    └────────────┘\t\t│ ├───────────────────┤\n\t\t\t\t\t└─┤\t   15\t      │\n\t\t\t\t\t  └───────────────────┘\n\n     В этом случае контроллер клавиатуры определит, что\tв его буфере\n     осталась всего лишь одна свободная\tячейка (№15) и он запишет в нее\n     число 0, причем ничего другого в нее записать будет уже нельзя (!!).\n     Таким образом, данные о фактах нажатий и отжатий клавиш размещаются\n     не\tво всех\t15 ячейках буфера клавиатуры, а\tв каких-либо 14\tячейках,\n     причем в последней\tиз свободных ячеек (15-ой) всегда будет\tзаписан\t0\n     (это дело рук контроллера клавиатуры). Зачем же надо было контроллеру\n     клавиатуры\tзаписывать в последнюю из свободных ячеек число\t0 ? Прежде\n     чем ответить на этот вопрос рассмотрим следующую ситуацию:\n\n\t    ┌────────────┐\t\t  ┌───────────────────┐\n\t    │ Ячейка №1\t │\u003c─────┐\t  │ Ячейка \"головы\"   │\n\t    ├────────────┤\t│\t  │ буфера клавиатуры │\n\t    .\t\t .\t│\t  ├───────────────────┤\n\t    ├────────────┤\t│\t┌─┤\t   11\t      │\n\t    │ Ячейка №11 │\u003c─────│───────┘ └───────────────────┘\n\t    ├────────────┤\t│\n\t    │ Ячейка №12 │\t│\t  ┌───────────────────┐\n\t    ├────────────┤\t│\t  │ Ячейка \"хвоста\"   │\n\t    .\t\t .\t│\t  │ буфера клавиатуры │\n\t    ├────────────┤\t│\t  ├───────────────────┤\n\t    │ Ячейка №15 │\t└─────────┤\t   01\t      │\n\t    └────────────┘\t\t  └───────────────────┘\n\n     Смысл данной ситуации таков: в то время, когда буфер клавиатуры был\n     полностью весь пустой, по каким-то\tпричинам ячейка\t\"головы\" и ячейка\n     \"хвоста\" указывали\tне на 1\tячейку,\tа на 11\tячейку буфера клавиатуры.\n     После этого были заполнены\t5 ячеек\t(т.е. ячейки с 11 по 15). Что же\n     будет делать контроллер клавиатуры, когда ему будет нужно записать\n     к-либо информацию в буфер клавиатуры, ведь\tхоть в нем и заполнилась\n     последняя 15 ячейка, но ведь имеется еще 9\tсвободных ячеек\t(т.е.\n     ячейки с 1\tпо 10) ? Итак: после того, как заполнится 14 ячейка,\n     контроллер\tклавиатуры запишет в ячейку \"хвоста\" число 15; после того,\n     как заполнится 15 ячейка он запишет в ячейку \"хвоста\" число 1, и уже\n     после этого он сможет заполнить ячейку №1 (после ее заполнения в\n     ячейку \"хвоста\" он\tзапишет\tчисло 2), и т.д. до тех\tпор, пока он не\n     заполнит ячейку №9. После заполнения ячейки №9 значение ячейки\n     \"хвоста\" будет равно 10,а значение\tячейки \"головы\"\tостанется прежним,\n     т.е. равным 11.Теперь контроллер клавиатуры сделает вывод:\tраз ячейки\n     \"головы\" и\t\"хвоста\" отличаются на 1, то можно считать, что\tсвободного\n     места в буфере клавиатуры уже нет,\tи поэтому он запишет в последнюю\n     свободную ячейку (т.е. ячейку №10)\tчисло 0.\n\n\tТеперь пункт 3 (ожидание факта нажатия или отпускания клавиши)\n     выполняться не будет, т.к.\tуже некуда поместить информацию\tо к-либо\n     факте нажатия или отпускания клавиши.\n\n\tТеперь подошло время ответить на вопрос: зачем же надо было\n     контроллеру клавиатуры записывать в последнюю из свободных\tячеек\n     число 0 ?\tПредположим что\tпосле заполнения 9 ячейки контроллер\n     клавиатуры\tзаписал\tв ячейку \"хвоста\" число\t10, после этого\tон\n     заполнил данными ячейку №10 и записал в ячейку \"хвоста\" число 11.\n     И что бы получилось ? А то, что значения ячеек \"хвоста\" и \"головы\"\n     содержали бы число\t11, как\tи в случае полностью пустого буфера\n     клавиатуры. А как бы мы (да и компьютер) теперь узнали: буфер\n     клавиатуры\tвесь пуст и забит разными числами (\"мусором\"), или он\n     весь полон\tи содержит информацию о\tфактах нажатий и отжатий клавиш\t?\n     К сожалению мы этого никак\tбы не определили! Именно поэтому и сделали\n     буфер клавиатуры таким хитрым:\n     - если значения ячеек \"хвоста\" и \"головы\" равны, то это означает, что\n       буфер весь пуст;\n     - если значение ячейки \"головы\" больше значения ячейки \"хвоста\" на\t1,\n       причем ячейка \"хвоста\" будет указывать на ячейку\tс записанным в нее\n       нулем, то это означает, что буфер весь полон;\n\n\tТаким образом, контроллер клавиатуры записывает\tв последнюю из\n     свободных ячеек число 0 лишь для того, чтобы в ней\tчто-нибудь было,\n     т.к. в эту\tячейку все ровно нельзя\tничего записать\t(этого требует\n     хитрость устройства буфера\tклавиатуры).\n\t\t\t       - - - - - - -\n\n     5\u003e\tПосле того, как\tконтроллер клавиатуры записал в\tсвободную ячейку\n     (на которую указывала ячейка \"хвоста\") буфера клавиатуры скэн-код\n     нажатой клавиши или скэн-код + 128\t(если клавиша была отжата), то\n     он\tделает следующее: он ищет в буфере клавиатуры ту ячейку, в\n     которую он\tзаписал\tинформацию раньше всего\t(этим самым он\n     вспоминает\tо самом\tраннем факте нажатия или отпускания клавиши,\n     который он\tзапомнил). А это как раз та ячейка, на которую указывает\n     ячейка \"головы\" (т.е. в ячейке \"головы\" хранится номер ячейки с\n     информацией о самом раннем\tфакте нажатия или отпускания клавиши).\n     После того, как нужная ячейка будет найдена, ее значение (т.е. то,\n     что в ней хранится) помещается в порт №60h. Помещение содержимого\n     этой ячейки в порт\t№60h можно представить так: содержимое ячейки\n     помещается\tв чудесную \"шкатулку\" с\tнадписью \"порт 60h\", из\tкоторой,\n     после, системный блок будет \"доставать\" ее\tсодержимое, т.е. данные,\n     которые желает ему\tсообщить клавиатура.\n\n\t\t\t       - - - - - - -\n\tПосле того, как\tсистемный блок \"достанет\" данное клавиатуры из\n     порта 60h,\tон даст\tзнать об этом контроллеру клавиатуры, который\n     узнав об этом обрадуется (т.к. его\tданное успешно считано системным\n     блоком) и изменит значение\tячейки \"головы\", а именно: если\tв\n     ячейке \"головы\" было число\t1, то будет 2, если было 3, то будет 4\n     (этим самым контроллер клавиатуры удаляет из своего буфера\tклавиатуры\n     то\tданное,\tкоторое\tтолько что считал системный блок). Таким образом,\n     значение ячейки \"головы\" снова будет указывать на ту ячейку буфера\n     клавиатуры, в которой хранится наистарейшая, еще не считанная\n     системным блоком информация о факте нажатия или отпускания\tклавиши.\n     Если после\tэтого:\n     - значения\tячеек \"хвоста\" и \"головы\" равны, то это\tозначает, что\n       буфер весь пуст;\n     - значение\tячейки \"головы\"\tбольше значения\tячейки \"хвоста\"\tна 1,\n       причем ячейка \"хвоста\" будет указывать на ячейку\tс записанным в нее\n       нулем, то это означает, что буфер весь полон;\n\t\t\t       - - - - - - -\n\n\tИтак, данные из\tячейки с информацией о самом раннем факте нажатия\n     или отпускания клавиши помещены в порт №60h.\n\n     6\u003e\tЕсли системный блок разрешил клавиатуре\tзапрашивать прерывание №9,\n     то\tконтроллер клавиатуры запрашивает разрешение у системного блока\n     на\tпрерывание №9 (посылает\tпо кабелю в системный блок специальный\n     сигнал, который просит его\tвыполнить прерывание №9), иначе\tпереход\n     на\tшаг 1;\n\t\t\t       - - - - - - -\n\n     Системный блок может запретить клавиатуре запрашивать прерывание №9.\n     Для этой цели системный блок посылает в контроллер\tклавиатуры\n     специальную команду, которая запретит контроллеру клавиатуры\n     запрашивать прерывание №9.\tДругой командой\tсистемный блок может\n     разрешить контроллеру клавиатуры запрашивать прерывание №9.\n\n\t\t\t       - - - - - - -\n\tЧто же такое \"прерывание №9\" ? Прерывание №9 - это процесс,\n     состоящий из трех основных\tэтапов:\n     1)\tСистемный блок запоминает свое текущее состояние (чтобы\tпосле в\n     него вернуться) и прекращает свою текущую работу;\n     2)\tНачинает выполняться одна из специальных программ BIOSа, которая\n     называется\t\"обработчик прерывания №9\". Эта\tпрограмма считывает данное\n     клавиатуры\tчерез порт 60h и решает\t(на основании полученного от\n     клавиатуры\tскэн-кода или скэн-кода\t+ 128),\tчто же за символ был\n     введен с клавиатуры, после\tчего записывает\tв системный буфер\n     клавиатуры\tсоответствующие\tданные;\n     3)\tПосле того, как\tобработчик прерывания №9 закончит свою работу,\n     системный блок восстановит\tсвое предыдущее\tсостояние (которое было\n     предварительно запомнено),\tи начинает продолжать свою предыдущую\n     работу с того места, где прежде он\tостановился;\n\t\t\t       - - - - - - -\n\n\tИтак предположим, что системный\tблок разрешил клавиатуре\n     запрашивать прерывание №9.\n\n     7\u003e\tЕсли системный блок по каким-то\tпричинам занят и не может уделить\n     клавиатуре\tвремя на выполнение прерывания №9, то переход на шаг 1.\n\n     8\u003e\tСистемный блок получил сигнал из клавиатуры, просящий его\n     выполнить прерывание №9. Он запоминает свое текущее состояние, чтобы\n     после в  него вернуться, и\tперестает реагировать на клавиатуру (т.е.\n     на\tее просьбы выполнить прерывание\t№9).\n\n\tПосле того, как\tсистемный блок закончит\tвыполнять прерывание №9\n     и будет хотеть перейти на шаг №1, системный блок снова начнет\n     реагировать на клавиатуру и ее просьбы выполнить прерывание №9,\n     восстановит свое предыдущее состояние (он ранее его запомнил) и\n     начнет продолжать то дело,\tкоторым\tон занимался до\tвыполнения\n     прерывания.\n\n\tТеперь компьютер запустит специальную программу\tBIOSа -\tобработчик\n     прерывания\t№9 (эта\tпрограмма постоянно хранится в памяти системного\n     блока), которая будет выполнять прерывание\t№9.\n\n\tТаким образом, когда клавиатура\tузнает о каком-либо факте ввода\n     с клавиатуры, у нее сразу появляется желание сообщить об этом\n     системному\tблоку, чтобы он\tс помощью своей\tпрограммы (обрабатывающей\n     прерывание\t№9) разобрался:\tчто же такое введенно с\tклавиатуры и что\n     это значит: символ, буква и т.д.. Дело в том, что клавиатура никаких\n     символов не знает (она вообще кроме порядковых номеров клавиш мало\n     что знает). Поэтому системный блок\tвзвалил\tна себя\tтакую обязанность:\n     принимать от клавиатуры скэн-код нажатой клавиши или скэн-код+128 -\n     если клавиша отжалась и понимать: что же за символ\tбыл введен с\n     клавиатуры, прописной он должен иметь вид или строчный и т.д.\n\n\t\t\t       - - - - - - -\n\tИнтересно, а как же системный системный\tблок узнает, какой вид\n     должен иметь введенный символ, прописной или строчный ? Все просто:\n     если, к примеру, мы нажмем\tвпервые\tна клавишу \"CapsLock\" (она\n     устанавливает и выключает режим ввода букв\tв прописном виде), то\n     системный блок запомнит этот факт (сразу после того, как примет от\n     клавиатуры\tскэн-код клавиши \"CapsLock\") и после получения от\n     клавиатуры\tк-либо скэн-кода символьной клавиши будет считать, что\n     символ, соответствующий этой клавиши, имеет прописной вид.\tЕсли\n     же\tпосле системный\tблок снова получит от клавиатуры скэн-код,\n     соответствующий клавиши \"CapsLock\", то он запомнит\tэтот факт и после\n     получения от клавиатуры к-либо скэн-кода символьной клавиши будет\n     считать, что символ, соответствующий этой клавиши,\tимеет строчный\n     вид.\n\t\t\t       - - - - - - -\n\n     Итак, программа BIOSа, которая служит для выполнения прерывания №9,\n     начинает свою работу, а именно:\n\n\t8.1\u003e Считывает данное клавиатуры из порта 60h и\tзапоминает его\n\t(где она запоминает это\tданное нам не важно);\n\n\t8.2\u003e Сообщает контроллеру клавиатуры о считывании данного с\n\tпорта 60h. Этим\tдействием системный блок заставляет контроллер\n\tклавиатуры удалить из буфера клавиатуры\tинформацию, только что\n\tсчитанную системным блоком из порта 60h, а также разрешает ему\n\tанализировать факты нажатий и отпусканий клавиш. А как удаляется\n\tинформация из буфера клавиатуры\t? А очень просто: значение ячейки\n\t\"головы\" увеличивается на 1, и это означает, что свободных ячеек\n\tв буфере клавиатуры стало больше на 1. Таким образом:\n\t- ячейка \"хвоста\" буфера клавиатуры изменяется при записи данного\n\t  в его\tсвободную ячейку, и это\tозначает, что свободного места в\n\t  буфере клавиатуры стало меньше (на 1 ячейку);\n\t- ячейка \"головы\" буфера клавиатуры изменяется при считывании\n\t  системным блоком данного с его заполненной ячейки, и это\n\t  означает, что\tсвободного места в буфере клавиатуры стало больше\n\t  (на 1\tячейку);\n\n\t8.3\u003e Если считанное данное из порта №60h соответствует нажатию или\n\tотжатию\tк-либо клавиши-переключателю, то в ОЗУ по адресам 417h и\n\t418h зарегистрируется этот факт\t(в этих\tячейках\tпамяти\n\tрегистрируются факты нажатия и отжатия клавиш-переключателей),\n\tпричем если считанное данное больше 128\t(это означает, что к-либо\n\tклавиша-переключатель была отжата), то зарегистрировать\tфакт\n\tотжатия, а если\tсчитанное данное меньше\tили равно 128, то\n\tзарегистрировать факт нажатия.\n\n\t\t\t       - - - - - - -\n     Надо отметить, что\tсистемный блок придает значение\tфакту отжатия\n     к-либо клавиши только тогда, когда\tотжатой\tбыла к-либо клавиша\n     -переключатель. Если же системный блок получает от\tклавиатуры\n     данное, соответствующее отжатию к-либо другой клавиши (не клавиши\n     -переключателя), то он остается равнодушен\tк такому факту,\tи\n     делает переход на пункт 1.\tИ действительно, чего же удивительного в\n     том, что после нажатия на клавишу,\tнапример с изображенным\tна ней\n     символом \"!\", эту клавишу отжали ?\tНичего,\tтак-как\tотжатие\tэтой\n     клавиши ничего не означает: ни ввода нового символа \"!\", ни чего-то\n     другого. Тогда почему же для клавиш-переключателей\tучитываются факты\n     и нажатий и отжатий ? Дело\tв следующем: предположим что Вы, например,\n     нажали на клавишу \"Shift\" и не отпуская ее\tнажимаете на клавиши с\n     изображением букв.\tПри нажатии на клавишу \"Shift\" клавиатура сообщит\n     системному\tблоку скэн-код клавиши \"Shift\",\tпосле чего системный блок\n     поймет, что все буквы, которые будут вводиться с клавиатуры, будут\n     иметь прописной вид. Таким\tобразом, пока Вы не отожмете клавишу\n     \"Shift\" все вводимые с клавиатуры буквы будут иметь прописной вид.\n     Как только\tВы отожмете клавишу \"Shift\", клавиатура\tсообщит\tсистемному\n     блоку скэн-код клавиши \"Shift\" + 128 (что означает\tотжатие\tклавиши\n     \"Shift\"), после чего системный блок поймет, что все буквы,\tкоторые\n     будут вводиться с клавиатуры, будут иметь строчный\tвид. Таким\n     образом, если бы системный\tблок не\tреагировал на скэн-коды\tклавиш\n     -переключателей + 128 (т.е. на факты отжатий клавиш-переключателей),\n     то\tвсе вводимые буквы (даже после отжатия клавиши \"Shift\")\tимели бы\n     прописной вид! Именно поэтому системный блок учитывает факты и\n     нажатий и отжатий клавиш-переключателей.\n\t\t\t       - - - - - - -\n\n\t8.4\u003e Системный блок проверяет: есть ли свободное место в его\n\tсистемном буфере клавиатуры ? Если есть, то делается переход на\n\tшаг 8.5, иначе издается\tзвуковой сигнал\tи делается переход на\n\tшаг 1;\n\n\t\t\t       - - - - - - -\n     Системный буфер клавиатуры\t(СБК) имеет точно такое\tже устройство,\n     как и буфер клавиатуры (если не считать небольшие отличия). Прежде\n     рассматривать системный буфер клавиатуры интересно\tвыяснить: а зачем,\n     собственно, он вообще нужен компьютеру ?\n\n     Итак мы знаем, что\tв клавиатуре есть буфер\tклавиатуры, в котором\n     временно (пока не считает системный блок) хранится\tинформация о тех\n     фактах нажатия и отпускания клавиш, которые еще не\tуспели приняться\n     системным блоком. Если бы в клавиатуре не было буфера клавиатуры, то\n     вся информация о фактах нажатия и отпускания клавиш, которые бы\n     происходили в то время, когда системный блок не мог (т.к. был занят\n     более важным делом) выполнить просьбы клавиатуры о\tвыполнении\n     прерывания\t№9, были бы безвозвратно утеряны. А так-как клавиатура\n     имеет буфер клавиатуры, то\tвся эта\tинформация сохраняется и когда\n     системный блок начинает мочь выполнять прерывание №9, то вся она\n     благополучно им обработается.\n\n     В системном блоке есть подобие буфера клавиатуры -\tэто системный\n     буфер клавиатуры (СБК), в котором временно\t(пока их не считает наша\n     или к-либо\tдругая компьютерная программа) хранятся\tте данные, которые\n     были введены с клавиатуры:\tбуквы, цифры, различные\tзнаки (\"*/-+!\")\tи\n     т.д. Если бы в системном блоке не было СБК, то системный блок мог бы\n     запомнить лишь ту поступившую в него информацию от\tклавиатуры,\n     которая бы\tпоступила последней (это потому, что последние поступившая\n     информация\tзаписалась бы на тоже самое место, где бы хранилась еще\tне\n     считанная нашей программой\tранее туда записанная информация). А это\n     значило бы, что вся информация, которая поступила в системный блок\n     перед последнее поступившей информацией, безвозвратно утеряна.\n     Поэтому в системном блоке и устроили СБК, чтобы он\tсохранял\n     поступившую с клавиатуры информацию до тех\tпор, пока она не\n     понадобится работающей (например нашей) компьютерной программе.\n\n     Системный буфер клавиатуры\tизображен на рис. 3. Системный буфер\n     клавиатуры\tможно представить как таблицу из 16 ячеек (элементов),\n     каждая из которых состоит из 2 байтов (частей). Каждый байт ячейки\n     СБК может содержать к-либо\tчисло от 0 до 255. Все байты ячеек СБК\n     пронумерованы от 30 до 61.\tКроме 32 байтов\tв буфере клавиатуры\n     имеются 2 специальные ячейки: это так называемые ячейка \"хвоста\" и\n     ячейка \"головы\". Каждая из\tэтих ячеек содержит к-либо число от 30\n     до\t60, которое соответствует началу к-либо\tячейки буфера клавиатуры.\n     Например, если в ячейке \"головы\" находится\tчисло 32, то это число\n     соответствует байту №32 (началу ячейки №2).\n\n\t\t Устройство системного буфера клавиатуры.\n\t\t ........................................\n\n\t    ┌───────┬───────┐\t\t     ┌───────────────────┐\n\t    │30\tбайт│31\tбайт│\t Ячейка\t№1   │ Байт \"головы\" СБК │\n     З\t│   ├───────┼───────┤\t\t     │\t\t\t │\n     а\t│   │32\tбайт│33\tбайт│\t Ячейка\t№2   ├───────────────────┤\n     п\t│   ├──┬────┴───────┤\t\t   ┌─┤\t      32\t │\n     о\t│   .  └───────────────────────────┘ └───────────────────┘\n     л\t│   ├───────┬───────┤\n     н\t│   │42\tбайт│43\tбайт│\t Ячейка\t№7   ┌───────────────────┐\n     е\t│   ├──┬────┴───────┤\t\t     │ Байт \"хвоста\" СБК │\n     н\t│   .  └───────────────┐\t     │\t\t\t │\n     и\t√   ├───────┬───────┤  │\t     ├───────────────────┤\n     е\t    │60\tбайт│61\tбайт│  │ Ячейка\t№16 ┌┤\t      42\t │\n\t    └───────┴───────┘  └────────────┘└───────────────────┘\n\n\t\t\t\t  Рис. 3\n\n\tС помощью системного буфера клавиатуры наши программы узнают о\n\tтом, какие буквы, знаки\tи т.д. были введены с клавиатуры.\n\tС помощью наших\tпрограмм мы можем узнать содержимое системного\n\tбуфера клавиатуры, а также значения ячеек \"головы\" и \"хвоста\".\n\tНапример, если значения\tячеек \"хвоста\" и \"головы\" будут\tравны, то\n\tэто будет означать, что\tСБК весь пуст (никакие данные с\tклавиатуры\n\tне поступали), а если значение ячейки \"хвоста\" не будет\tравно\n\tзначению ячейки\t\"головы\", то это будет означать, что в СБК есть\n\tдля нас\tкакая-то информация. Кроме этого, у нас\tесть возможность\n\tпроизвольно изменять содержимое\tсистемного буфера клавиатуры и\n\tзначения его ячеек \"головы\" и \"хвоста\".\tТакое изменение\tячеек\n\t\"головы\" и \"хвоста\"будет создавать иллюзию либо\tнажатия\tк-либо\n\tклавиши\tна клавиатуре (хотя ее никто и не нажимал), либо наоборот\n\t- как будто ничего не нажималось (хотя фактически данные с\n\tклавиатуры вводились). Как это сделать будет рассмотренно в [6].\n\t\t\t       - - - - - - -\n\n       8.5\u003e Если нажатой клавише принято ставить в соответствие\tсимвол,\n       порядковый номер\tкоторого должен\tназываться ASCII кодом,\tто\n       системный блок поместит в свободную ячейку СБК (ее номер\tсистемный\n       блок усмотрит в ячейке \"хвоста\")\tследующее:\n       - в первый байт ячейки: порядковый номер\t(который теперь\tназывается\n\t ASCII кодом) символа, соответствующего\tклавише;\n       - во второй байт: скэн-код (порядковый номер) той клавиши, которую\n\t нажимали и которой был\tпоставлен в соответствие символ;\n       После этого делается переход на шаг 1;\n\n       8.6\u003e Если нажатой клавише принято ставить в соответствие\tсимвол,\n       порядковый номер\tкоторого должен\tназываться расширенным ASCII\n       кодом, то системный блок\tпоместит в свободную ячейку СБК\t(ее номер\n       системный блок усмотрит в ячейке\t\"хвоста\") следующее:\n       - в первый байт ячейки: число 0 (число 0\tкак-раз\tи указывает на\n\t то, что в данной ячейке СБК находится порядковый номер\tсимвола,\n\t который теперь\tназывается не ASCII кодом, а расширенным ASCII\n\t кодом);\n       - во второй байт: порядковый номер (который теперь называется\n\t расширенным ASCII кодом) символа, соответствующего клавише;\n\n\t\t\t       - - - - - - -\n     Нужно отметить, что системный блок\tумеет различать\tне только факты\n     нажатия и отжатия отдельной клавиши, но и факты нажатия и отжатия\n     некоторых определенных комбинаций клавиш. Эти комбинации получаются\n     при совместном нажатии одной или нескольких клавиш-переключателей и\n     к-либо другой клавиши. Подобную комбинацию\tможно получить,\tнапример,\n     если нажать на клавишу \"Alt\" и не отпуская\tее нажать на клавишу \"F1\".\n     Такое совместное нажатие клавиш системный блок воспринимает как\n     нажатие на\tк-либо одну \"новую\" клавишу. В таблице [5.1] приведены все\n     возможные комбинации клавиш, которые системный блок принимает за одну\n     \"виртуальную\" клавишу.\n\n     Как же системный блок распознает комбинации из нажатых клавиш ?\n     Рассмотрим, например, как системный блок распознает следующую\n     комбинацию\tиз трех\tнажатых\tклавиш:\t\"Ctrl\",\t\"Alt\", \"F1\", т.е. сперва\n     нажимают на клавишу \"Ctrl\"\tи не отпуская ее нажимают на клавишу\n     \"Alt\" и клавишу \"F1\". Итак:\n       1) При нажатии на клавишу \"Ctrl\"\tклавиатура передает системному\n       блоку скэн-код клавиши \"Ctrl\". Системный\tблок поняв, что\tна\n       клавиатуре нажали на клавишу-переключатель \"Ctrl\", сразу\n       зафиксирует этот\tфакт в ОЗУ по адресам 417h и 418h;\n       2) Теперь (не отжимая клавишу \"Ctrl\") на\tклавиатуре нажимают на\n       клавишу \"Alt\". Теперь клавиатура\tпередает системному блоку скэн-код\n       клавиши \"Alt\". Системный\tблок поняв, что\tна клавиатуре нажали на\n       клавишу-переключатель \"Alt\", сразу зафиксирует этот факт\tв ОЗУ по\n       адресам 417h и 418h;\n       3) Теперь (не отжимая клавишу \"Ctrl\" и клавишу \"Alt\") на\tклавиатуре\n       нажимают\tна клавишу \"F1\". Теперь\tклавиатура передает системному\n       блоку скэн-код клавиши \"F1\". Системный блок поняв, что на\n       клавиатуре нажали на клавишу \"F1\", сразу\tсмотрит: в ОЗУ по адресам\n       417h и 418h зафиксирован\tли какой-нибудь\tфакт того, что к-либо\n       клавиша-переключатель находится в нажатом состоянии (если клавиша\n       находится в нажатом состоянии, то системный блок\tполучал\tот\n       клавиатуры только ее скэн-код (при ее нажатии), а скэн-код + 128\n       (при ее отжатии)\tон не получал).\tЕсли никаких фактов нажатий на\n       клавиши-переключатели не\tзафиксированно,\tто системный блок (как\n       обычно) записывает в системный буфер клавиатуры соответствующие\n       клавише \"F1\" данные. А если к-либо факты\tнажатия\tна клавиши\n       -переключатели зафиксированы (в ОЗУ адресам 417h\tи 418h), то\n       системный блок записывает в системный буфер клавиатуры данные,\n       соответствующие не клавише \"F1\",\tа комбинации из\tнажатых\tклавиш-\n       переключателей (в нашем примере это клавиша \"Ctrl\" и клавиша \"Alt\")\n       и к-либо\tклавиши\t(в нашем примере это клавиша \"F1\");\n       4) При отжатии клавиши \"F1\" клавиатура передаст системному блоку\n       скэн-код\tклавиши\t\"F1\" + 128. Системный блок поймет, что на\n       клавиатуре отжали клавишу \"F1\", и он проигнорирует этот факт, т.к.\n       этот факт ему ни\tо чем интересном не говорит;\n       5) При отжатии клавиши \"Alt\" клавиатура передаст\tсистемному блоку\n       скэн-код\tклавиши\t\"Alt\" +\t128. Системный блок поймет, что\tна\n       клавиатуре отжали клавишу \"Alt\",\tи он сразу же зафиксирует этот\n       факт (т.е. факт отжатия клавиши \"Alt\") в\tОЗУ по адресам 417h и 418h\n       (этот факт для него достаточно важен);\n       6) При отжатии клавиши \"Ctrl\" клавиатура\tпередаст системному блоку\n       скэн-код\tклавиши\t\"Ctrl\"\" + 128. Системный блок поймет, что на\n       клавиатуре отжали клавишу \"Ctrl\"\", и он сразу же зафиксирует этот\n       факт (т.е. факт отжатия клавиши \"Ctrl\"\") в ОЗУ по адресам 417h и\n       418h (этот факт для него\tдостаточно важен);\n\n       Если теперь мы снова нажмем на клавишу \"F1\", то системный блок,\n       получив от клавиатуры скэн-код клавиши \"F1\" и увидев, что в ОЗУ по\n       адресам 417h и 418h нет информации о нажатии к-либо клавиши\n       -переключателя, запишет в системный буфер клавиатуры (как и обычно)\n       данные, соответствующие клавише \"F1\";\n\t\t\t       - - - - - - -\n\n     9\u003e\tПереход\tна шаг 1.\n\n\t\t\t       * * * * * * *\n\n\t\t      [4] ДОПОЛНИТЕЛЬНАЯ ИНФОРМАЦИЯ.\n\t\t      ******************************\n\n\t\t\t     [4.1] Автоповтор.\n\t\t\t     =================\n     При вводе информации с клавиатуры часто бывает необходимо нажимать\n     несколько раз в подряд одну и ту же клавишу. Например: нам\tнеобходимо\n     ввести с клавиатуры такую строку \"************\". Для этого\tмы должны\n     нажать и отпустить\tклавишу\tс изображением \"*\" 12 раз. Для того, чтобы\n     это было не так утомительно и более быстро\tпридумали следующее: если\n     мы\tнажимаем на к-либо клавишу и удерживаем\tее в нажатом состоянии\n     больше чем\tобычно,\tто контроллер клавиатуры понимает, что мы хотим\n     ввести несколько одинаковых данных, например символов \"*\",\tи поэтому\n     он\tначинает за нас\t\"отпускать и нажимать\" нажатую клавишу,\tдо тех\n     пор, пока мы ее не\tотпустим.\n\n\tРассмотрим механизм автоповтора.\n     Нажмем, например, на клавишу с изображением \"*\" и будем удерживать\tее\n     в нажатом состоянии больше\tчем обычно. При\tэтом произойдет\tследующее:\n     при обнаружении факта нажатия на клавишу '*' контроллер клавиатуры\n     запишет в свободную ячейку\tбуфера клавиатуры скэн-код нажатой\n     клавиши, равный 9.\tПосле этого контроллер клавиатуры обнаружит, что\n     клавиша нажата больше чем обычно, и поэтому в следующую ячейку буфера\n     клавиатуры\tон снова запишет код нажатой клавиши, т.е. число 9. До тех\n     пор, пока мы не отпустим нажатую клавишу контроллер клавиатуры будет\n     записывать\tв следующие ячейки скэн-код, равный 9. Как только мы\n     отпустим нажатую клавишу контроллер клавиатуры запишет в следующую\n     ячейку число 9+128, означающий что\tнажатая\tклавиша\tбыла отпущена.\n\n     Таким образом, анализируя информацию, посылаемую  клавиатурой,\n     системный блок узнает, какие клавиши действительно\tнажимались и\n     отпускались много раз, а какие были нажаты, удержаны больше чем\n     обычно, а после отпущены.\tНадо отметить, что системному блоку нет\n     разницы, как вводятся данные, путем нажатия и отпускания, либо путем\n     нажатия, удерживания и отпускания.\tВ обоих\tслучаях\tв СБК появятся\n     одинаковые\tданные.\n\n\t\t\t       * * * * * * *\n\n\t\t\t[4.2] Прямой ввод символов\n\t\t       в системный буфер клавиатуры.\n\t\t       =============================\n     Иногда бывает необходимо ввести с клавиатуры к-либо символ, который\n     не\tизображен ни на\tодной клавиши, например\tтакой '┼'. Как же ввести\n     с клавиатуры такой\tсимвол ? Для этого случая программа BIOSа,\n     выполняющая прерывание №9,\tпредоставляет нам метод\tпрямого\tввода\n     символов. Что это за метод\t? Суть этого метода состоит в том, что\n     если нам нужно ввести к-либо символ, то можно нажать на клавишу 'Alt'\n     и удерживая ее нажатой набрать на дополнительной клавиатуре\n     десятичный\tASCII код (порядковый номер) нужного символа, после чего\n     отжать клавишу 'Alt'. После отжатия клавиши 'Alt' набранный символ\n     поместится\tв системный буфер клавиатуры.\n\n\t\t\t       * * * * * * *\n\n\t\t       [4.3] Индикаторы\tклавиатуры.\n\t\t       ============================\n     В клавиатуре имеются 3 миниатюрных\tиндикатора, которые отображают\n     некоторые режимы работы клавиатуры. Это:\n\n     Индикатор:\t       Назначение:\n     ---------\t       -----------\n     CapsLock\t       Если светится, то включен режим ввода букв в\n\t\t       прописном виде, а если не светится, то включен\n\t\t       режим ввода букв\tв строчном виде.\n\n     NumLock\t       Если светится, то включен режим использования\n\t\t       клавиш дополнительной клавиатуры\tдля ввода цифр,\n\t\t       а если не светится, то включен режим использования\n\t\t       клавиш дополнительной клавиатуры\tдля перемещения\n\t\t       текста и\tкурсора\tпо экрану.\n\n     ScrollLock\t       Если светится, то включен такой режим работы\n\t\t       клавиатуры, при котором нажатия на стрелки будут\n\t\t       вызывать\tперемещение не курсора по экрану, а\n\t\t       изображения (текста,рисунка) на нем.\n\n     Контроллер\tклавиатуры включает и выключает\tсвои индикаторы\tлишь по\n     командам системного блока.\tМы имеем произвольно включать и\tвыключать\n     индикаторы\tклавиатуры. Для\tэтого нам необходимо написать программу,\n     которая бы\tотдала соответствующее приказание �","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftsnsoft%2Fpascal_demo_keyboard","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Ftsnsoft%2Fpascal_demo_keyboard","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Ftsnsoft%2Fpascal_demo_keyboard/lists"}