Инструкция к микрокалькулятору электроника мк 61

Введение

В прошлой статье (Калькулятор Электроника МК61) я кратко рассказал об особенностях микрокалькулятора Электроника МК61, о его устройстве и принципах работы, с которыми мне удалось самому разобраться за пару вечеров.

Далее я стал разбираться как же всё таки писать и затем вводит программы в этот калькулятор и хочу здесь поделится этой информацией со всеми кому интересна данная тема.

Для начала необходимо осознать, что МК61 не обладает ПЗУ (постоянное запоминающие устройство), т.е. введённая в калькулятор программа будет потеряна/очищена сразу после отключения калькулятора и в следующий раз придётся вводить её вновь.

В прошлом в различных конструкторских бюро утро начиналось не с чашечки кофе (как в современных НИИ и IT-компаниях), а с того, что инженеры вводили программы в свои калькуляторы, а уже после можно и кофе.

Программа для МК61 и ему подобных калькуляторов в основном представляет из себя запись последовательности действий, которые пользователь осуществлял бы и без программы, но записав их в программу этот набор действий будет сохранён и избавит пользователя от многократного повторения.

Когда это может быть актуально? Тогда, когда необходимо много раз производить расчёт, но с разными вводными. Либо когда необходимо повторять расчёт многократно и вводными данными служат результаты предыдущего расчёта (построение графиков) и т.п. Если это одиночная операция, то проще не заморачиваться с программированием.

В первую очередь необходимо перевести микрокалькулятор в режим программирования, для этого нажимаем F ПРГ, после чего справа на дисплее будут отображено 00, это значит, что калькулятор успешно переведён в режим ввода программы.

00 означает порядковый номер команды в программе, в МК61 их максимально может быть 105. После ввода каждой последующей команды этот счётчик будет инкрементироваться. Если допустили ошибку ввода или есть необходимость скорректировать какой-то шаг программы, то есть две клавиши(ШГ-> и ШГ<-), которые позволяют перемещаться по введённой программе и вносить, чтоб затем ввести изменения.

Ну и давайте напишем нашу первую программу, а точнее функцию, которая будет воспроизводит пример из прошлой статьи, помните (2 + 5) * 3, но сделаем так, чтоб значения можно было менять и повторять расчёт. В итоге получается примерно вот так (x + y) * z = ?. Теперь подставляя значения в x,y,z можно получать результат не производя лишних действий. А помните про регистры из прошлой статьи, так вот мы их и будем использовать в качестве переменных X — REG2; Y — REG3; Z — REG4 и конечно же не забываем про обратную польскую запись 🙂

Погнали

Для начала переведём калькулятор в режим программирования [F] [ПРГ] и начнём вводить нашу первую программу для МК61. Теперь на экране отображаются в правой части дисплея 00, это текущий номер команды.

Вводим:

[П->X] [4] — читаем из памяти значение регистра REG4 в регистр X.

[П->X] [3] — читаем из памяти значение регистра REG3 в регистр X, а предыдущее значение переносится в регистр Y.

[П->X] [2] — читаем из памяти значение регистра REG2 в регистр X, а предыдущее значение переносится в регистр Y.

[+] — операция сложения регистров X и Y, а результат записан в X, знвчение регистра стека Z спускается в Y.

[*] — операция умножения на текущими значениями X и Y, результат записывается в X и как следствие отображается на эране.

[С\П] — остановка исполнения программы.

Выходим из режима программирования [F] [АВТ].

Вот и введена наша первая программа в МК61, осталось только заполнить вводные параметы в регистры X — REG2; Y — REG3; Z — REG4 и запустить нашу программу.

Для ввод значений в каждый регистров необходимо нажать:

[3][X->П][4] — вводим 3-ку в REG4

[5][X->П][3] — вводим 5-ку в REG3

[2][X->П][2] — вводим 2-ку в REG2

Вот и всё подготовили, программа введена, значения регистров(по аналогии аргументы функции) введены. Теперь осталось выполнить запуск [СХ][В/О][С/П] и в результате должны на дисплее увидеть 21, если получилось, то значит всё сделали правильно.

Ну а дальше можно вводить новые значения в регистры REG2, REG3, REG4 и повторять запуск программы.

Как прикладной простой пример может выступать программа, которая конвертирует температуру из Фаренгейта в Цельсии.

Пример (50°F => C):

Расчёт будет вот такой (50°F — 32) : 1,8 = 10°C, ну и давайте превратим это в программу, чтобы только вводить значения F и получать C.

Для начала выключим и включим калькулятор после прошлых расчётов, затем переведём калькулятор в режим программирования [F] [ПРГ]. Далее вводим программу

[П->X] [2] — берём значение 50 в стек из REG2

[П->X] [3] — берём значение 32 (константное) в стек из REG3

[-] — вычитаем 50 — 32

[П->X] [4] — берём значение 1,8 (константное) в стек из REG4

[/] — деление 18 / 1.8

[С\П] — остановка исполнения программы.

В итоге должен получится следующий код программы: 62 63 11 64 13 50

Далее переводим калькулятор в режим расчётов [F][АВТ] и заполняем регистры REG2, REG3, REG4.

[СХ] — на всякий случай отчистим всё

[50][X->П][2] — заносим в REG2 значение (50)
[32][X->П][3] — заносим в REG3 значение (32)
[1,8][X->П][4] — заносим в REG4 значение (1,8)

Ну попробуем запустить, то что у нас получилось: [СХ][В/О][C/П], должно получится 10.

Теперь переписывая значения в REG2 на любые нужные F-ы, и выполняя [СХ][В/О][C/П], будут автоматически высчитываться C.

Ссылка на симулятор Электроника МК61

Расцвет эпохи программируемых калькуляторов в нашей стране пришёлся на середину 80-х годов. Потом на смену относительно сытым и благополучным временам пришла эпоха бандитского капитализма, когда стране стало не до выпуска своей высокотехнологичной продукции бытового назначения, вот уже сменились поколения, но ностальгия по тем временам, когда мы бессонными ночами пытались сократить код программы хотя бы на пару байтов, чтобы уместить задуманную функцию, выискивали всё новые и новые недокументированные возможности, придумывая способы, как их можно использовать на практике, сочиняли целые циклы рассказов в качестве фона для наших игровых программ, не даёт забыть свой МК-61 со 105 байтами программной памяти. Поэтому хочу написать заметку о том, что собой представляли и как работали эти самые программируемые калькуляторы. Даже если эта тема сегодня периодически и поднимается, то не настолько часто, чтобы приесться уважаемому читателю, так что надеюсь поведать что-то новое.

Немного истории

Для начала небольшой экскурс в историю. Программируемый калькулятор отличается от инженерного возможностью задать пользовательскую программу вычислений, имеет увеличенную память и набор операций для управления ходом исполнения программы, т. е. по сути является примитивным портативным компьютером. Отечественные программируемые калькуляторы (ПМК) принято делить на поколения. Первый массовый советский карманный ПМК, получивший обозначение Б3-21, увидел свет в 1977 году, он имел 60 шагов программной памяти, два операционных регистра X и Y, семь регистров памяти, а также двунаправленный кольцевой стек на шесть чисел (объединённый с X, который выводился на индикатор). Вычисления на нём производились в формате обратной (постфиксной) бесскобочной записи, т. е. сперва в операционный стек помещались операнды, затем над ними производилась операция, — это позволяло значительно упростить как сам калькулятор, так иногда и работу с ним. На базе этого ПМК строилось их первое поколение, к нему относятся, например, настольные варианты МК-46 и МК-64. Несмотря на очевидные недостатки, прежде всего заоблачную цену (350 рублей на момент появления в продаже), появление первых ПМК значительно упростило жизнь людям, имеющим дело со сложными вычислениями.

На смену им пришли «ПМК расширяющегося ряда», про них и пойдёт речь в этой статье. Это поколение в 1980 году начал калькулятор Б3-34, он получил новый процессор из серии К145ИК13 (на его базе также создавались и некоторые инженерные калькуляторы). Он по-прежнему работал в обратной бесскобочной нотации, но зато у него появилось место под 98 шагов программы, 14 регистров памяти и стек из 4 ячеек (плюс дополнительный регистр предыдущего результата), была добавлена косвенная адресация и циклы со счётчиком. Этот ПМК содержит два упомянутых процессора с разной прошивкой: один — как управляющее устройство, другой — как математический сопроцессор. Вместе с двумя микросхемами памяти К145ИР2 они соединены однобитной шиной (магистралью) в кольцо, получая сигналы синхронизации от тактового генератора К145ГФ3.

Наконец, в 1984 году был выпущен МК-61. Позаимствовав корпус у калькулятора из семейства Б3-34 — МК-54, он получил дополнительный, третий процессор — К745ИК1306. Таким образом у нового устройства появились дополнительные функции (модуль, целая и дробная часть, знак числа и другое), семь дополнительных шагов программной памяти — теперь их стало 105, и ещё один регистр. Стоил он 85 рублей — цена внушительная, но при необходимости подъёмная. Именно эта машинка стала самым массовым и популярным ПМК в нашей стране. В следующем году был выпущен МК-52, аналог МК-61, но уже с энергонезависимой памятью (ППЗУ) объёмом 512 байтов и возможностью подключения блоков расширения памяти с прошитыми в них библиотеками программ (выпускались централизованно).

Следующее поколение представлено микрокомпьютером МК-85 и его «сородичами». С одной стороны, это был качественный скачок вперёд, с другой — это были калькуляторы со встроенным интерпретатором морально устаревшего и даже не русифицированного языка BASIC и 16-битным процессором с системой команд компьютеров американской фирмы DEC. С развалом страны и их производство сошло на нет, на этом история отечественных программируемых калькуляторов заканчивается…

Значимость и продолжение истории

Но семейство Б3-34 прочно закрепилось в быту советского человека. До массового распространения персональных компьютеров оставалось ждать пару десятилетий, да и счастливчикам, ставшим обладателями такового ещё тогда, в карман всё равно его было не положить. А ПМК были относительно доступны и практичны, поэтому и обрели заслуженное уважение наших людей. Я бы даже назвал народную любовь к ПМК социально-культурным явлением. Пользовались этими приборами, казалось бы, сугубо инженерного назначения, все категории граждан: от школьников младших классов до пенсионеров преклонных лет, мужчины и женщины самых разнообразных профессий, со всех концов нашей страны — от Западной Украины до Чукотки и от Кольского полуострова до Средней Азии. Весьма полезными ПМК были и для студентов (прежде всего инженерных специальностей) с интеллектом выше среднего, но поскольку дефицит таковых начал наблюдаться уже тогда, основным контингентом пользователей было всё же взрослое население.

Трудно найти сферу человеческой деятельности, где не был применён наш микрокалькулятор. Нужно подсчитать параметры статистического ряда или определить рентабельность производства? Рассчитать параметры электрической цепи, вычислить молярную массу вещества, найти радиус чёрной дыры? Легко. Смоделировать манёвры боевого самолёта, рассчитать курс морского судна или сориентировать орбитальный корабль? Пожалуйста. Известно, например, что МК-52 реально использовался штурманами военно-морского флота, а также, в качестве запасного вычислительного устройства, космонавтами. Выбрать класс трактора или оценить параметры почвы, определить генетическое расстояние между популяциями, рассчитать пропорции в кулинарии, дозу или концентрацию лекарства, сгенерировать узор для вязания? Всё есть. Увлекаетесь нумерологией, биоритмами и прочей лженаукой? Найдутся и для вас программки.

А игры, которые создавались сотнями и целыми сериями с сюжетом, — это вообще отдельная тема. Было всё: от крестиков-ноликов и мини-шашек до симуляций исторических сражений и экономики государства. Были изданы десятки книг, сборников программ, рецептов программирования. В популярнейших журналах, издававшихся многомиллионными тиражами, таких как «Наука и жизнь», «Техника — молодёжи» и др., регулярно печатались рубрики, посвящённые ПМК. Отдельно очень активно шло изучение недокументированных возможностей калькуляторов этой серии, особенностей реализованных функций и т. п., получившее название «еггогология» — от слова, которым обозначалась ошибка при вычислениях, — «ЕГГОГ». Рассматривались также способы аппаратной модификации устройств.

Сегодня об этой занятной науке можно прочитать лишь в отсканированных журналах, например в библиотеке сайта Сергея Тарасова, посвящённого ПМК. Очень рекомендую тем, кто желает погрузиться в атмосферу тех лет. А на сайте Евгения Века собрано более 250 авторских игровых программ — подборка даёт хорошее представление об игровом движении калькуляторщиков и о самом явлении.

Хотя с развалом страны и прекращением выпуска новых моделей калькуляторов интерес к теме в народе стал резко падать, народные умельцы всё же не сидели без дела. В 2003 году программист Евгений Троицкий разработал симулятор отечественных калькуляторов «Калькуляторы 3000» — арифметических, инженерных и программируемых — наверное, единственный в своём роде с таким охватом и точностью симуляции. А «в железе» на это всё можно посмотреть на сайте музея вычислительной техники Сергея Фролова.

Писались статьи, сканировались печатные материалы, принимались и другие попытки воссоздать калькуляторы программно, переводилась на иностранные языки документация. Причём не только русские люди не дают нашим калькуляторам бесследно раствориться в прошлом. Вот, например, очень примечательные случаи: француз Гийом сравнивает быстродействие МК-61 и МК-52 и пишет транслятор BASIC-подобного языка в код ПМК, голландец Альфред исследует недокументированные особенности МК-61 и возможности «синтетического программирования» калькулятора, а канадец Виктор тестирует и сравнивает МК-61 с другими калькуляторами из своей коллекции.

Кто-то даже пытается заработать на приятных воспоминаниях. Так, новосибирская фирма «Семико» собрала из китайских запчастей пару калькуляторов, назвав их в честь отечественных МК-61 и МК-52 и снабдив похожим языком. Понятно, что дальше продвижения на Интернет-помойках вроде Википедии дело не пошло, и рынок ожидаемо проигнорировал это начинание.

И вот в 2012 году инженер из США Феликс Лазарев, вооружившись профессиональным микроскопом, смог при участии Евгения Троицкого и других энтузиастов проанализировать и восстановить содержимое ПЗУ микросхем процессоров МК-61. Так были созданы первые эмуляторы калькуляторов серии Б3-34 (за исключением МК-52, у которого не была отсканирована микросхема, управляющая энергонезависимой памятью).

Вскоре с использованием восстановленного кода был написан эмулятор МК-61 на JavaScript. Сегодня это, по всей видимости, наиболее функциональный и удобный эмулятор из всех. Не требуя скачивания и установки, он позволяет работать как с самим МК-61, так и с калькуляторами-аналогами Б3-34 (без третьего процессора), а также с такими устройствами, как арифмометр «Феликс-М», логарифмическая линейка «НЛ-10М» и русские счёты. Во время работы калькулятора на экране показывается содержимое всех регистров памяти, операционного стека, адресов возврата из подпрограмм и счётчика команд в режиме реального времени. Имеется возможность скопировать и ввести сохранённое состояние или поставить исполнение на паузу. Важной функцией является возможность ввести и прочитать код программы, используя общепринятые мнемоники команд в различных вариантах, т. е. теперь можно просто скопировать код программы, вставить в эмулятор и запустить, не вводя его вручную.

Работа на калькуляторе

Думаю, многим, кого заинтересовала эта тема, захочется опробовать на практике, «на ощупь» этот самый калькулятор. Так что давайте теперь посмотрим, как собственно работать на этих машинках.

Впервые добравшись до МК-61, человек, знакомый с традиционными арифметическими и инженерными калькуляторами, обычно задаётся вопросом: где здесь кнопка «=» или скобки? Попробуем разобраться. Итак, для начала калькулятор нужно включить. В верхней его части находится индикатор, на котором отображается число, с которым в данный момент работает калькулятор. Он также работает и с другими числами, расположенными в ячейках памяти, называемых регистрами, но обычно результат вводится и выводится на индикатор, значение которого также находится в регистре, обозначаемом X. Слева под индикатором находится переключатель, подписанный справа «Вкл», — включаем, на индикаторе загорится «0». Число набирается традиционно, при помощи цифровых кнопок. Можно также ввести дробное число посредством кнопки десятичной запятой (справа от кнопки «0»), поменять его знак («/−/») и ввести порядок («ВП»). Например, нужно ввести число −0,00000123 — для этого последовательно нажимаем: «[1] [2] [3] /−/ ВП [8] /−/».

Как же тут выполнять арифметические операции? Чтобы понять это, необходимо ознакомиться с таким понятием, как операционный стек. Стек нашего калькулятора — это просто четыре регистра, связанные между собой порядком помещения и извлечения из них чисел. Он подобен стопке, колоде карт: верхняя карта (в нашем случае число) лежит в регистре X и отображается на индикаторе. Когда мы кладём число в эту стопку, остальные числа оказываются глубже (под ним), а оно перед нами, на индикаторе. В нашем распоряжении находятся четыре регистра стека (и один дополнительный, в него помещается результат предыдущей операции), обозначаемые буквами X, Y, Z, T (и X1), мы можем производить с ним определённые операции. Вводимое с клавиатуры число оказывается в регистре X. Его можно поднять (скопировать) в следующий за ним регистр Y, при этом содержимое Y переместится в Z, содержимое Z — в T (предыдущее значение T сотрётся). Стек можно вращать, при этом X перемещается в T, T — в Z и т. д. Подъём или спуск значений происходит и при выполнении некоторых действий.

Тут дело в том, что калькулятор, как уже было сказано ранее, принимает выражения в бесскобочной постфиксной нотации, т. е. не в традиционной форме «a + b =», а в форме «a b +», т. е. сначала вводятся числа, после производится операция. А вводятся числа как раз в этот самый стек. Введя число в регистр X, его нужно поднять в Y, для этого используется кнопка [В↑]. После этого можно начинать вводить следующее число, текущее значение X при этом сотрётся.

Операции над числами делятся на двухместные (с двумя аргументами: сложение, вычитание, возведение в степень и т. д.) и одноместные (над одним числом: корень, тригонометрия, логарифмы и т. д.). Двухместные операции производятся над регистрами X и Y. Для примера сложим два числа: «[1] [В↑] [2] [+]». Здесь в X вводится число 1, поднимается в Y, в X вводится число 2, после чего Y и X складываются, результат — на индикаторе (в X). При этом значения стека спускаются: T обнуляется, предыдущее значение T перемещается в Z, Z — в Y, в X1 — предыдущее значение X (т. е. 2). В случае с вычитанием выполняется операция (аналогично с делением). Для доступа к функциям, обозначения которых нанесены над кнопками, используются кнопки [F] и [K] соответственно цвету, которым написано обозначение функции. Например, для вычисления натурального логарифма числа нужно нажать «[F] [3]» (над кнопкой «3» находится обозначение «ln»).

В качестве основной памяти в МК-61 используются 15 регистров общего назначения. Они обозначаются цифрами от 0 до 9 и буквами от A до E (10—15). Для помещения числа в один из регистров используется кнопка «X→П», после нажатия которой нужно нажать соответствующую номеру регистра кнопку на цифровой клавиатуре или кнопку, подписанную нужной буквой снизу/справа от неё. Аналогичным образом число извлекается из регистра посредством кнопки «П→X». При работе на калькуляторе для хранения промежуточных данных зачастую используется стек. При этом необходимо следить, чтобы сохранённое значение не было стёрто в процессе вычислений. В МК-61 существует также косвенная адресация регистров. Так, например, если поместить в регистр №7 число 8, то при помощи последовательного нажатия «[K] [П→X] [7]» на индикаторе появится содержимое регистра №8. Здесь необходимо отметить, что при косвенном обращении через регистры 0—3 ихнее значение предварительно уменьшается на единицу, а через 4—6 — увеличивается. Т. е. если в Р4 было 5, то «[K] [П→X] [4]» выдаст число из Р6.

Теперь посмотрим, как вводятся и исполняются программы. Для запуска режима ввода программы необходимо нажать последовательность кнопок «[F] [ВП]» («ПРГ»). Далее вводится программа, аналогично тому, как производятся вычисления в ручном режиме. В правой части индикатора отображается счётчик команд, текущее его значение показывает адрес, по которому будет размещена вводимая инструкция (шаг программы). Максимальная длина программы — 105 шагов. При вводе программы на индикаторе отображаются три последних (предшествующих указываемому адресу) кода инструкции.

Напишем для примера программу, которая умножит вводимое число на 3, прибавит к нему 4 и возведёт полученное значение в квадрат. Для этого последовательно нажимаем: «[В↑] [3] [×] [4] [+] [F] [×] [С/П]». В результате в программной памяти окажется программа: «↑ 3 × 4 + x² С/П». При оформлении кода программы в текстовом виде указывается не непосредственно клавиша, которую необходимо нажать, а инструкция, которая будет выполнена: в нашем случае — не «F ×», а «x²». Команда «С/П» (стоп/пуск) останавливает выполнение программы.

Теперь выходим из режима программирования нажатием «[F] /−/» («АВТ»). Для запуска программы обнуляем счётчик шагов кнопкой «В/О» (возврат/очистка), вводим начальные данные, например 5. Запускаем программу — «С/П». После выполнения на индикаторе 361.

Примеры программ

Рассмотрим пример программы, выполняющей реальные вычисления. Этот код вычисляет дату Пасхи по введённому номеру года:

П2      1       9       ПП      86      П3      ИП2     4       ПП      86
П4      ИП2     7       ПП      86      П5      1       9       ИП3     *
1       5       +       3       0       ПП      86      П6      2       ИП4
*       4       ИП5     *       +       6       ИП6     *       +       6
+       7       ПП      86      ИП6     +       П1      3       П4      ИП2
1       -       2       10^x    /       [x]     ^       ^       4       /
[x]     -       2       0       +       ИП1     +       П3      3       1
-       x>=0    76      П3      КИП4    ИП3     3       0       -       x>=0
83      П3      КИП4    ИП3     ИП4     С/П     П0      <->     П1      <->
/       [x]     ИП0     *       ИП1     -       /-/     В/О

Чтобы не вводить его вручную, как на реальном устройстве, достаточно просто вставить его в эмуляторе в окошко «Код программы» и нажать кнопку «Ввести в память». Вводим на клавиатуре номер года, нажимаем «С/П» для запуска (если счётчик команд не обнулён, то обнуляем его, нажав перед запуском «В/О»). Примерно через 14 секунд получим результат: на индикаторе (в регистре X) будет номер месяца, в регистре Y — число месяца; нажимаем «⟷», чтобы обменять значения X и Y и увидеть номер дня.

Или вот такая программа, которая переводит числа в троичную симметричную систему счисления:

ЗН      П2      Вx      |x|     П0      0       П3      П4      1       П5
ИП0     /-/     x<0     80      ИП0     ^       ^       3       /       [x]
П0      3       *       -       П1      ИП3     x#0     54      ИП1     x=0
38      ИП2     ПП      88      0       П3      БП      10      ИП1     1
-       x=0     49      ИП2     /-/     ПП      88      БП      10      0
ПП      88      БП      10      ИП1     x=0     62      0       ПП      88
БП      10      ИП1     1       -       x=0     72      ИП2     ПП      88
БП      10      ИП2     /-/     ПП      88      1       П3      БП      10
ИП3     x#0     86      ИП2     ПП      88      ИП4     С/П     8       +
ИП5     *       ИП4     +       П4      ИП5     1       0       *       П5
В/О

Вводим число, выполняем — на экране результат. При этом −1, 0 и 1 обозначаются соответственно цифрами 7, 8 и 9. Например, введя 123, получим 977778, т. е. «+−−−−0». Особенно забавно, что такой код, показанный нынешним «кодерам-прогерам» с дипломами ЕГЭ-бакалавров, ввергает их в ступор и экзистенциальный ужас (проверено не раз), не говоря уже о предложении написать что-то самим. Но это далеко не самое сложное, что есть в этих калькуляторах. Попробуем же понять их внутреннее устройство, используя для этого JS-код эмулятора.

Внутреннее устройство

В 1990 году Ярослав Карпович Трохименко выпустил книгу «Программируемые микрокалькуляторы: устройство и пользование», в которой досконально описал работу ПМК «расширяющегося ряда» на всех уровнях организации, аппаратных и программных. Хотя там и не был напечатан весь код ПЗУ калькуляторных процессоров, это сократило путь к программному воспроизведению устройств в разы и дало первые объяснения глубинным причинам эффектов «еггогологии».

Итак, как уже было сказано выше, МК-61 работает под управлением трёх процессоров К745ИК13, отличающихся только прошивкой (серия К745 — бескорпусные варианты К145). Они соединены однобитной шиной, реализующей последовательное соединение процессоров вместе с микросхемами оперативной памяти К745ИР2 в кольцо. Графически схему калькулятора можно изобразить так:

Процессор ИК13 оперирует 4-битными словами. Его динамическая память представлена тремя регистрами M, R и ST объёмом 42 слова каждый, а также регистрами S и S1 размером в одно слово и однобитными ячейками L, T и П. Кроме того, в коде эмулятора имеются переменные для реализации взаимодействия между процессорами, памятью, индикатором, клавиатурой и для сохранения предыдущего состояния.

Память ПЗУ процессора состоит из 256 команд по 23 бита, 128 синхропрограмм, являющихся массивами из девяти шестибитных ячеек, и 68 микрокоманд по 28 битов. Каждая команда содержит три адреса синхропрограмм; ячейки синхропрограммы являются адресами микрокоманд; а биты микрокоманды определяют, какие элементарные операции необходимо выполнить на текущем такте процессора. За один такт выполняется одна микрокоманда и по системной магистрали прогоняется одна тетрада битов, а за 42 такта выполняется одна команда.

constructor(ПЗУ) {
    [this.ПЗУ_микрокоманд, this.ПЗУ_синхропрограмм, this.ПЗУ_команд] =
        [ПЗУ.микрокоманды, ПЗУ.синхропрограммы, ПЗУ.команды];
    this.Сброс();
}

Сброс() {
    [this.M, this.R, this.ST] =
        [new Array(42).fill(0), new Array(42).fill(0), new Array(42).fill(0)];
    this.S = this.S1 = this.L = this.T = this.П =
    this.такт = this.команда = this.АСП =
    this.вход = this.выход = this.клав_x = this.клав_y = 0;
    this.запятые = new Array(14).fill(false);
    this.обновить_индикатор = false;
}

Выбор микрокоманды для текущего такта

На первом из 42-х такте определяем адрес новой команды, которую мы начинаем исполнять, взяв 4-битное слово из регистра R по адресу 36 в качестве младших разрядов и по адресу 39 в качестве старших, и берём эту команду из кода ПЗУ. Сама команда состоит из трёх адресов синхропрограмм, под которые отведено дважды по 7 битов и третий раз — 8, а также флага, влияющего на выполнение определённой части микрокоманды. Если биты третьего адреса с третьего по последний равны нулю, то обнуляем ячейку T.

if (this.такт == 0) {
    this.команда = this.ПЗУ_команд[this.R[36] + 16 * this.R[39]];
    if ((this.команда >>> 16 & 0b111111) == 0) this.T = 0;
}

Находим, к какой девятке (по порядку) относится номер такта и какое место в ней занимает. Девятка тактов определяет, какой адрес синхропрограммы, записанный в команде, использовать.

const
    девятка_тактов = this.такт / 9 | 0,
    такт_в_девятке = this.такт - девятка_тактов * 9;

Если это первый такт в девятках с номерами 0, 3 или 4, то следует установить синхропрограмму. Если номер такта относится к первым трём девяткам, то адрес синхропрограммы составляют первые 7 битов команды; если к четвёртой, то вторые 7 битов. А если же к пятой, то берём третьи 8 битов, но в случае, если адрес синхропрограммы больше 31, на первом такте пятой девятки помещаем в регистр R по адресу 37 младшие 4 бита адреса, по адресу 40 — старшие, сам же адрес заменяем на 95 (на любом такте). Таким образом имеется возможность передать два слова в память непосредственно из команды (поэтому поле этого адреса сделано длиннее).

if (такт_в_девятке == 0 && !(девятка_тактов > 0 && девятка_тактов < 3)) {
    if (девятка_тактов < 3)
        this.АСП = this.команда & 0b1111111;
    else if (девятка_тактов == 3)
        this.АСП = this.команда >>> 7 & 0b1111111;
    else if (девятка_тактов == 4) {
        this.АСП = this.команда >>> 14 & 0b11111111;
        if (this.АСП > 31) {
            if (this.такт == 36) {
                this.R[37] = this.АСП & 0b1111;
                this.R[40] = this.АСП >>> 4;
            }
            this.АСП = 95;
        }
    }
}

Определяем адрес микрокоманды, записанный в синхропрограмме. Последняя представляет собой последовательность из 9 адресов микрокоманд, но в массиве они записаны раздельно. Поэтому умножаем вычисленный адрес синхропрограммы на 9, получив индекс её первого элемента, и добавляем к нему значение по следующему правилу: если номер такта — от 0 до 5, то используем его, если от 6 до 20, то берём остаток от деления его на 3, прибавив к нему 3, а если от 21 до 41, то номер такта в девятке.

let АМК = this.ПЗУ_синхропрограмм[
    this.АСП * 9 +
    (this.такт < 6 ? this.такт : this.такт < 21 ? this.такт % 3 + 3 : такт_в_девятке)
];

На всякий случай отсекаем биты старше 6-го (в коде эмулятора все остальные данные из ПЗУ используются только по частям, что позволяет не беспокоиться о некорректных данных), и если адрес микрокоманды — от 60 до 63, то реализуем условный выбор в зависимости от состояния ячейки L: для значения 0 — чётные номера больше 60, для 1 — нечётные. Таким образом, хоть адрес микрокоманды и 6-битный, но самих микрокоманд 68.

АМК &= 0b111111;
if (АМК > 59) {
    АМК = (АМК - 60) * 2;
    if (this.L == 0) АМК++;
    АМК += 60;
}

Вытаскиваем микрокоманду из кода ПЗУ и разбираем её на массив однобитных микроприказов (флагов), которые далее составляют поля микрокоманды — либо поодиночке, либо совместно, определяя номер выполняемого действия.

let микрокоманда = this.ПЗУ_микрокоманд[АМК], микроприказы = [];
for (let сч = 0; сч < 28; сч++) {
    микроприказы.push(микрокоманда & 1);
    микрокоманда >>>= 1;
}

Сумматор и клавиатура

На этот раз определяем, к какой уже тройке по порядку относится номер такта, и создаём объект сумматора с параметрами α, β, γ и полем суммы Σ. Далее, если микроприказ с номером 25 установлен в 1, используем данные с клавиатуры — параметры x и y, особенные для каждой кнопки (x также используется для передачи меры угла): если следующая за текущей тройка тактов не равна x, то выполняем побитовую дизъюнкцию ячейки S1 с y. После этого проходим по первым 12 микроприказам, выполняя их, если они установлены.

const тройка_тактов = this.такт / 3 | 0;
const сумматор = { альфа: 0, бета: 0, гамма: 0, сигма: 0 };

if (микроприказы[25] == 1 && тройка_тактов != this.клав_x - 1)
    this.S1 |= this.клав_y;

for (let сч = 0; сч < 12; сч++)
    if (микроприказы[сч] == 1)
        this.Выполнить_микроприказ(сч, сумматор);

После этого снова работаем с клавиатурой. Если хотя бы один из битов команды с номерами 17—22 установлен в 1 и y кнопки равен нулю, то обнуляем T. Если же все упомянутые биты нулевые, то устанавливаем значение в массиве запятых на индикаторе равным L, флаг необходимости обновления индикатора, и если при этом следующая тройка тактов равна x, а y больше 0, то записываем y в S1, а в Т — 1. Затем выполняем при необходимости микроприказы 12, 13 и 14.

if ((this.команда >>> 16 & 0b111111) > 0) {
    if (this.клав_y == 0) this.T = 0;
}
else {
    if (тройка_тактов == this.клав_x - 1 && this.клав_y > 0) {
        this.S1 = this.клав_y;
        this.T = 1;
    }
    this.запятые[тройка_тактов] = this.L > 0;
    this.обновить_индикатор = true;
}

for (let сч = 12; сч < 15; сч++)
    if (микроприказы[сч] == 1)
        this.Выполнить_микроприказ(сч, сумматор);

Теперь складываем входы сумматора, от суммы берём младших 4 бита и кладём в Σ, а 5-й бит (флаг переноса) — в П.

const сумма = сумматор.альфа + сумматор.бета + сумматор.гамма;
сумматор.сигма = сумма & 0b1111;
this.П = сумма >>> 4 & 1;

Поля микрокоманды

Если последний бит команды равен 0 или это последняя девятка тактов (точнее говоря, их в ней всего 6), то определяем значение следующего поля микрокоманды из битов 15, 16 и 17 (в порядке возрастания старшинства). Если полученное значение не равно нулю, то выполняем микроприказ с номером, равным этому полю, увеличенным на 14 (количество уже обработанных микроприказов). Последнее приходится учитывать, поскольку действий предусмотрено 35, а битов в микрокоманде — всего 28, т. е. некоторые биты группируются в поля. При том же условии относительно номера такта или битов 24—31 проходим по микроприказам 18 и 19 (действие определяется номером, увеличенным на четыре — 7 предусмотренных тремя битами действий минус 3 битовых места в микрокоманде).

if ((this.команда >>> 22 & 1) == 0 || девятка_тактов == 4) {
    const поле_микрокоманды =
        микроприказы[17] << 2 |
        микроприказы[16] << 1 |
        микроприказы[15];
    if (поле_микрокоманды > 0)
        this.Выполнить_микроприказ(поле_микрокоманды + 14, сумматор);
    for (let сч = 18; сч < 20; сч++)
        if (микроприказы[сч] == 1)
            this.Выполнить_микроприказ(сч + 4, сумматор);
}

Проходим по микроприказам 20 и 21. Потом следуют три двухбитовых поля, определяющих, соответственно, по три действия (при нулевом значении поля ничего не делается).

for (let сч = 20; сч < 22; сч++)
    if (микроприказы[сч] == 1)
        this.Выполнить_микроприказ(сч + 4, сумматор);

for (let сч = 0; сч < 3; сч++) {
    const поле_микрокоманды =
        микроприказы[23 + сч * 2] << 1 |
        микроприказы[22 + сч * 2];
    if (поле_микрокоманды > 0)
        this.Выполнить_микроприказ(поле_микрокоманды + 25 + сч * 3, сумматор);
}

На выход микросхемы подаётся слово из регистра M, соответствующее номеру такта, после чего вместо него записывается слово, поступившее на вход. Такт увеличивается; если становится равным 42, то обнуляется, — приступаем к обработке следующей команды.

this.выход = this.M[this.такт];
this.M[this.такт] = this.вход;
this.такт++;
if (this.такт == 42) this.такт = 0;

Последний фрагмент собственно составляет также содержание такта памяти ИР2, с той разницей что тактов там 252, как и число слов в единственном регистре M. После выполнения такта одного процессора значение ячейки выхода присваивается ячейке входа следующего процессора или памяти. Чтобы замкнуть кольцо на такте, который был обработан, после прохождения по всем элементам от ИК1302 до второго ИР2 значение выхода последнего передаётся в ячейку первого с номером обработанного только что такта. Память ИР2 вместе с регистрами процессоров ИК13 (не включая сверхоперативные ячейки) можно визуально изобразить так (положение на 84-м такте ИР2):

Микроприказы

А вот и содержание самих микроприказов. Здесь биты микрокоманды с номерами 0—6 влияют на вход сумматора α, 7—11 — на β, 12—14 — на γ. Влияние заключается в побитовой дизъюнкции имеющегося значения входа сумматора с некоторым значением (результат является новым значением входа). Выбор действия с номером от 15 до 21 задаётся трёхбитным полем микрокоманды с битами 15—17, а за действия 22 и 23 отвечают соответственно биты 18 и 19; это всё влияет на регистр R, на слово, задаваемое текущим номером такта, либо на одно из двух предшествующих ему. Предшествующие и следующие адреса берутся по модулю 42, т. е. предыдущим адресом для 0 является 41 (0 — следующим для 41). Биты 20 и 21 задают действия под номерами 24 и 25 соответственно — над регистром M и ячейкой L. Далее идут три двухбитовых поля, отвечающих каждое за три действия — над регистрами S, S1 и ST. В регистре ST операции производятся над тройкой слов, начинающейся с текущего номера такта.

Выполнить_микроприказ(номер, сумматор) {
    switch (номер) {
        case 0: сумматор.альфа |= this.R[this.такт]; break;
        case 1: сумматор.альфа |= this.M[this.такт]; break;
        case 2: сумматор.альфа |= this.ST[this.такт]; break;
        case 3: сумматор.альфа |= ~this.R[this.такт] & 0b1111; break;
        case 4: if (this.L == 0) сумматор.альфа |= 0xA; break;
        case 5: сумматор.альфа |= this.S; break;
        case 6: сумматор.альфа |= 4; break;
        case 7: сумматор.бета |= this.S; break;
        case 8: сумматор.бета |= ~this.S & 0b1111; break;
        case 9: сумматор.бета |= this.S1; break;
        case 10: сумматор.бета |= 6; break;
        case 11: сумматор.бета |= 1; break;
        case 12: сумматор.гамма |= this.L & 1; break;
        case 13: сумматор.гамма |= ~this.L & 1; break;
        case 14: сумматор.гамма |= ~this.T & 1; break;
        case 15: this.R[this.такт] = this.R[(this.такт + 3) % 42]; break;
        case 16: this.R[this.такт] = сумматор.сигма; break;
        case 17: this.R[this.такт] = this.S; break;
        case 18: this.R[this.такт] = this.R[this.такт] | this.S | сумматор.сигма; break;
        case 19: this.R[this.такт] = this.S | сумматор.сигма; break;
        case 20: this.R[this.такт] = this.R[this.такт] | this.S; break;
        case 21: this.R[this.такт] = this.R[this.такт] | сумматор.сигма; break;
        case 22: this.R[(this.такт + 41) % 42] = сумматор.сигма; break;
        case 23: this.R[(this.такт + 40) % 42] = сумматор.сигма; break;
        case 24: this.M[this.такт] = this.S; break;
        case 25: this.L = this.П; break;
        case 26: this.S = this.S1; break;
        case 27: this.S = сумматор.сигма; break;
        case 28: this.S = this.S1 | сумматор.сигма; break;
        case 29: this.S1 = сумматор.сигма; break;
        case 30: this.S1 = this.S1; break;
        case 31: this.S1 = this.S1 | сумматор.сигма; break;
        case 32:
            this.ST[(this.такт + 2) % 42] = this.ST[(this.такт + 1) % 42];
            this.ST[(this.такт + 1) % 42] = this.ST[this.такт];
            this.ST[this.такт] = сумматор.сигма;
        break;
        case 33: {
            const x = this.ST[this.такт];
            this.ST[this.такт] = this.ST[(this.такт + 1) % 42];
            this.ST[(this.такт + 1) % 42] = this.ST[(this.такт + 2) % 42];
            this.ST[(this.такт + 2) % 42] = x;
        } break;
        case 34: {
            const
                x = this.ST[this.такт],
                y = this.ST[(this.такт + 1) % 42],
                z = this.ST[(this.такт + 2) % 42];
            this.ST[this.такт] = сумматор.сигма | y;
            this.ST[(this.такт + 1) % 42] = x | z;
            this.ST[(this.такт + 2) % 42] = y | x;
        } break;
    }
}

Так работает один процессор, выполняя одну микрокоманду. В режиме исполнения программы реальный калькулятор выполняет около 3–4 шагов пользовательской программы в секунду, примерно на такую же скорость работы настроен и эмулятор. Для прохождения одного шага такт повторяется 23520 раз, выполняя 560 команд, прописанных в коде ПЗУ.

Это обстоятельство и сам довольно нетривиальный алгоритм исполнения кода делают реконструкцию механизмов и алгоритмов работы, запрограммированных в коде микросхем этих калькуляторов, очень и очень затруднительной. Достоверно и детально описать, как это работает, могли лишь причастные к разработке этих устройств; сегодня же любителям советских программируемых калькуляторов, интересующимся этой темой, остаётся лишь тоскливо рассматривать под лупой каждый бит восстановленного кода и пытаться понять, зачем он нужен.

Впрочем, некоторые моменты благодаря эмулятору и книге «Устройство и пользование» всё же удалось прояснить. Например, стало понятно, как возникают числа с порядком больше 99, работа с которыми была одним из основных направлений «еггогологии», – т. н. «электронный океан чисел». Разряды числа в памяти хранятся в двоично-десятичной форме, т. е. одна тетрада битов кодирует одну десятичную цифру (хотя может кодировать и шестнадцатеричную). Сами числа представлены в экспоненциальной форме и занимают 12 ячеек (вообще 14 – треть от длины регистра, но два разряда – служебные), при этом первая ячейка обозначает знак порядка, следующие две – сам порядок, потом ещё одна ячейка – знак мантиссы и восемь – собственно мантисса. Хотя на знак отведено аж четыре бита, используются только два значения – 0 для положительных чисел и нуля и 9 для отрицательных. Так вот, при переполнении следующий разряд порядка записывается в ячейку его знака, т. е. даёт «», но в памяти записан порядок , где единица стоит в ячейке знака. Над этим значением можно производить некоторые операции, как над обычным числом, правда, до тех пор, пока порядок находится в пределах второй сотни – дальше начинаются сложности (причём над «ЕГГОГом», полученным именно таким способом; полученный при делении на 0, например, ничего не даст). Однако глубинные механизмы «числового океана» всё же так и остались невыясненными.

Используя эмулятор, можно, например, изучить содержание памяти калькулятора во время каких-либо манипуляций или же прогонять код по одному такту или команде, можно посмотреть на порядок выполнения команд каждого процессора или попробовать добавлять или убирать устройства с системной магистрали. Но насколько это позволит продвинуться в изучении работы МК-61?..

Завершить эту заметку хочу цитатой, которая, на мой взгляд, хорошо резюмирует написанное выше.

Программирование МК-61 имеет глубокий философский подтекст.

Ограниченность ресурсов и доступного инструментария, добровольно принимаемая программистом, отражает собой многовековой опыт аскетических духовных практик. Сложнейшая многоуровневая иерархия программ управления калькулятором – от кода, вводимого человеком, до микрокоманд и микроприказов — есть отражение необычайной сложности божественного мироздания, всех глубин и уровней материи – от крупномасштабных структур вселенной до элементарных частиц, от сознания до неживой материи, от социума до первозданного хаоса и небытия.

Сам микрокод, прошитый в ПЗУ калькулятора, предстаёт объектом благоговейного созерцания, ибо никто не может в полной мере постичь принципы его работы, структуру или как-либо повлиять на его исполнение, склоняя нас к агностицизму и мыслям об иллюзорности свободы воли. Тройственность структуры микрокода – команды, синхропрограммы и микрокоманды – и три процессора калькулятора отсылают нас к вытекающей из христианского представления о Боге как о Троице троичности бытия, к естественной (троичной) аристотелевой логике, к трём уровням человеческой психики и к концепции триединой русской нации.

Программа, подаваемая человеком калькулятору, представляя собой с одной стороны низкоуровневый автокод, составленный из элементарных команд, с другой же – высокоуровневые инструкции, исполняемые прошивкой ПЗУ, демонстрирует нам диалектический закон единства и борьбы противоположностей. Исполнение же программы, когда, пройдя 105 шагов программной памяти, калькулятор возвращается в начало и продолжает исполнение кода, есть образ колеса сансары, а получение решения задачи становится подобием нирваны, достигнутой в результате правильно написанной и выполненной программы.

Микрокалькулятор Б3-34/МК-52/МК-54/МК-61. Руководство по эксплуатации.

• Общие сведения
  • Регистры калькулятора
• Работа калькулятора в автоматическом режиме
  • Выполнение операций
  • Использование стековой памяти
• Работа калькулятора в режиме «Программирование»
  • Общие сведения
  • Этапы вычислений по программам
  • Команды переходов
  • Организация циклов
  • Косвенное обращение к регистрам
• Программа решения квадратных уравнений
  • Выполнение вычислений

Общие сведения

Ввод чисел, операций и команд в микрокалькулятор осуществляется нажатием соответствующих клавиш.
Многие клавиши имеют двойную и тройную символику. Цвет символов, изображённых над клавишами,
соответствует цвету клавиш f и k. Ввод функции,
символ которой изображён на клавишной панели, осуществляется следующим образом: сначала нажимают
клавишу f или k, затем клавишу, над которой изображён
символ вводимой функции. Назначение клавиш приведено в табл.
Назначение функциональных клавиш и
Назначение клавиш, используемых при программировании.

k-функции имеются только в МК-52/МК-61.

Назначение функциональных клавиш

Назначение клавиш, используемых при программировании

Примечание: для команд, работающих с регистрами, вторая цифра кода (r) совпадает
с номером регистра из таблицы Номера и коды регистров.

Регистры калькулятора

Для хранения исходных данных и промежуточных результатов в микрокалькуляторе предусмотрена регистровая память,
состоящая из 15 (14 в Б3-34 и МК-54) адресуемых регистров RG0, RG1-RG9, RGa, RGb, RGc, RGd,
RGe (отсутствует в Б3-34 и МК-54).

Запись числа в адресуемые регистры осуществляется из регистра X после нажатия клавиши
x→п
и одной из клавиш 0—9,
a, b, c, d,
e, совпадающих с индексом адресуемого регистра.
При этом число, переданное в адресуемый регистр, сохраняется в регистре X

Вызов числа адресуемого регистра в регистр X осуществляется после нажатия клавиши
п→х и клавиш с индексом адресуемого регистра.

Кроме адресуемых регистров в микрокалькуляторе имеется стековая память, состоящая из четырёх регистров:
X, У, Z и Т. Регистры X и У — операционные.

В микрокалькуляторе имеется регистр предыдущего результата XI, который предназначен для записи числа,
находящегося в регистре X до выполнения операции.

Работа калькулятора в автоматическом режиме

Вычисления на микрокалькуляторе производятся в режиме «Автоматическая работа». Этот режим автоматически
устанавливается после включения питания микрокалькулятора или после нажатия клавиш
f 
АВТ, если до этого микрокалькулятор находился в режиме «Программирование».

Выполнение операций

Одноместные операции выполняются с числом, находящимся в регистре X. Результат одноместной операции
записывается в регистр X, при этом содержимое остальных регистров не изменяется.

Пример:

3 
f x²  ⇒  
9

Ввод аргумента при вычислении прямых тригонометрических функций и вычисление аргумента для обратных
тригонометрических функций могут осуществляться в радианах, градах или градусах в зависимости от
положения переключателя «Р/ГРД/Г» (радиан/град/градус).
Примечание: градусы, грады и радианы находятся в следующей зависимости: 360° = 400 град = 2π радиан.

Для выполнения двухместных операций используется обратная польская запись при которой сначала вводятся оба
операнда, а затем — операция. Ввод чисел в микрокалькулятор осуществляется обычным способом.
Чтобы отделить первое число от второго, нажмите клавишу
^BA.

Пример:

3 ^BA 
2 ×  ⇒  
6

Если на индикаторе высвечивается результат предыдущих вычислений, то набор на клавиатуре нового числа
автоматически передвигает информацию из регистра X в регистр У. Таким образом, результат вычисления
предыдущей операции может участвовать в качестве второго числа при выполнении последующих зачислений.

При выполнении некорректной операции на индикаторе высвечивается сигнал ошибки EDD0D

Использование стековой памяти

В стековую память входят четыре регистра X, У, Z и T, которые организованы по принципу магазинной памяти,
когда последовательно записанная информация может быть считана только в последовательности, обратной
последовательности записи (последнее записанное число является первым).

После включения микрокалькулятора регистры стека находятся в нулевом состоянии:

Ввод чисел всегда производится в регистр X. Информация в регистрах стека смещается вверх: T — теряется,
Z→T, Y→Z, X→Y, X — введённое значение.

Нажатие клавиши ^BA передаёт копию числа
из регистра X в регистр У, а также содержимое регистра У в регистр Z и содержимое регистра Z в регистр Т.
При этом содержимое регистра X сохраняется, а регистра Т исчезает.

Нажатие клавиши ⁼ меняет местами содержимое
регистров X и Y, не затрагивая Z и T.

Нажатие клавиши f ⁰
вызывает циклическое перемещение информации в стеке T→Z, Z→Y, Y→X, X→T.

При выполнении одноместных операций микрокалькулятор оперирует с числом, находящимся в регистре X,
при этом содержимое регистров У, Z и Т сохраняется, а число, находившееся до выполнения операции в
регистре X, передаётся в регистр предыдущего результата (регистр XI). Результат одноместной операции
передаётся в регистр X.

При выполнении двухместных операций микрокалькулятор оперирует с числами, находящимися в регистрах X и У.
При этом информация в регистрах стека передвигается (опускается) следующим образом:
T→Z, Z→Y, X→XI, результат операции→X.

Работа калькулятора в режиме «Программирование»

В режиме «Программирование» микрокалькулятор устанавливается после нажатия клавиш
f ПРГ.

Общие сведения

Для записи программ в микрокалькуляторе имеется специальная программная память, состоящая из
105 (98 в Б3-34/МК-54) ячеек, и стек возврата, состоящий из пяти разрядов.

При нажатии клавиш в режиме «Программирование» двузначный код операций, команд и цифр,
присвоенный данной клавише или ее комбинации с клавишами f, k,
X→П, П→x, записывается в специальную память программы.
Коды операций см. в табл.
Назначение функциональных клавиш и
Назначение клавиш, используемых при программировании.

Последовательность вводимых операций и команд, необходимых для решения задачи, представляет собой программу.

Первой ячейке программной памяти присвоен номер 00, последней — 104 (97 в Б3-34/МК-54).
При записи программы в микрокалькулятор двузначный код (шаг программы) в программной памяти занимает одну ячейку.
Местонахождение кода в программной памяти определяется адресом. Для обозначения адресов от 00 до 99
используются соответствующие числа, а для адресов от 100 до 104 старшие две цифры обозначаются знаком
минус (например, адрес 100 обозначается как «-0»).

Для управления последовательностью записи и для выполнения команд в микрокалькуляторе имеется счётчик адреса.
Этот счётчик может быть установлен на любой начальный адрес (от 00 до 104). При записи программы введение
в программную па­мять команд (операций) увеличивает содержимое счётчика на 1. Для того, чтобы
последовательность выполнения команд отличалась от последовательности записи команд в программе,
чтобы отдельные части программы повторились, чтобы изменение последовательности исполнения происходило в
зависимости от промежуточных результатов вычисления, в микрокалькуляторе имеются команды, с помощью
которых изменяется содержимое счётчика адреса. Эти команды называются командами переходов. Изменение
содержимого счётчика адреса происходит по адресу перехода, записанному либо в программной памяти,
либо в адресуемых регистрах, либо в пятиразрядном стеке возврата — специальной области памяти.
Если адрес перехода записан в адресуемом регистре, то такая адресация называется «косвенной».
Косвенная адресация используется также при обращении к адресуемым регистрам. В этом случае в программе
вместо прямого указания номера адресуемого регистра записывается косвенный номер, т.е. номер того
адресуемого регистра, в котором хранится номер вызываемого.

В режиме «Программирование» индикатор используется для отображения кодов трёх последовательных команд из
программной памяти и текущего состояния счётчика команд, т.е. адреса, по которому будет записана следующая
команда. Например, на индикаторе отображено

02 01 0E 06

В этом случае двузначные команды операций на индикаторе означают:

1. код 06 — текущее состояние счётчика адреса;
2. коды 0E, 01, 02 —
   три последовательные команды, расположенные соответственно по адресам 03, 04, 05.

Этапы вычислений по программам

Вычисления по программам производятся в следующем по рядке:

1. программирование задачи;
2. ввод программы в память и редактирование программы;
3. отладка программы;
4. занесение исходных данных и выполнение программы.

Для составления разветвляющихся программ и многократного прохождения отдельных частей программ
(подпрограмм) используются команды переходов (прямые и косвенные), команды косвенной индикации вызова
и записи, команды организации циклов. После команд переходов (прямых) и команд организации циклов в
составляемой программе должен стоять адрес перехода. Адрес перехода для косвенной команды содержится
в самой команде. Для прямых и косвенных команд адреса переходов 00-99 записываются с помощью
соответствующих цифровых клавиш 0 — 9. Адреса переходов 100 — 104
используются только для прямых команд и записываются с помощью клавиши •,
которая соответствует цифре 10 и одной из клавиш 0—4.

Наличие в микрокалькуляторе стека возврата предусматривает создание подпрограмм внутри программ.
Глубина подпрограмм определяется разрядностью стека и равна пяти. Регистр стека работает по системе:
первым зашёл, последним вышел.

Для автоматического останова и индикации результата вычислений программа обязательно должна содержать
команду останова С/П.

Программа решения задачи может начинаться с ад­реса 00 или с любого произвольного адреса.
Для занесения программы с нулевого адреса необходимо в режиме «Автоматическая работа» нажать клавишу
очистки программного счётчика В/О и перейти в режим «Программирование»,
нажав клавиши f ПРГ. На индикаторе в этом случае
индицируется адрес счётчика 00, с которого будет вводиться программа. Вводят программу, нажимая клавиши,
записанные в программе. Для занесения программы с произвольного адреса необходимо в режиме
«Автоматическая работа» нажать клавишу БП, а затем клавиши, которые обеспечат
переход на требуемый адрес. После перехода в режим «Программирование» на счётчике адресов команд
установится адрес, с которого должна вводиться программа.

Если при вводе программы допущена ошибка, то для ее исправления необходимо перейти на адрес,
по которому записана ошибочная команда. Для этого можно воспользоваться клавишей
^> или
^<, если адрес ошибочной команды
находится недалеко от текущего. При каждом нажатии этих клавиш содержимое счётчика адресов команд
соответствен­но увеличивается или уменьшается на единицу. Причём, если ошибка допущена в адресе перехода,
то для её исправления необходимо сдвинуть информацию на два шага и повторить ввод команды и следующий
за ней адрес перехода. При большой разнице адресов ошибочной и текущей команд нужно воспользоваться
командой безусловного перехода. Для этого необходимо перейти в режим «Автоматическая работа»,
нажать клавишу БП, а затем клавиши, которые обеспечат переход на нужный адрес.
После установки режима «Программирование» на индикаторе появится адрес ошибочной команды.
Исправьте ошибку, нажав клавишу требуемой операции либо команды.

Если необходимо исключить какую-либо команду из программы, перейдите на адрес исключаемой команды,
а затем нажмите клавиши k НОП. В программную память запишется
команда «Нет операции», по которой при вычислении ничего не выполняется.

Отладка программы производится в режиме «Автоматическая работа» путём анализа выполнения отдельного
шага программы. Выполнение программы по отдельной команде осуществляется нажатием клавиши
ПП в режиме «Автоматическая работа». Для отладки программы перейдите в режим
«Автоматическая работа», нажав клавиши f АВТ,
занесите исходные данные для работы программы, установите начальный адрес записанной программы,
нажмите клавишу ПП и проанализируйте выполнение каждого шага программы.
При пошаговом просмотре выполнения программы следует учитывать, что выполнение команды перехода и
установка адреса перехода осуществляются за один шаг программы.

Для выполнения программы в режиме «Автоматическая работа» наберите на клавиатуре исходные данные и
занесите их в необходимый адресуемый регистр памяти (RG0 — RGe) либо в регистр стека (X, У, Z, T).
Установите адрес начала программы и пустите программу на счёт, нажав клавишу ПП
для пошагового прохождения команд программы либо клавишу С/П для автоматического
выполнения последовательности шагов программы.

Нажатие клавиши С/П сопровождается подсветкой индикатора, что свидетельствует о
выполнении программы. Время выполнения программы зависит от её длины и характера вычислений.
В случае зацикливания, т.е. бесконечного повторения некоторого участка программы, необходимо остановить её,
нажав клавишу С/П, а затем проверить программу и устранить причину зацикливания.

После выполнения программы прочитайте результат на индикаторе.

Команды переходов

Команда безусловного перехода реализуется клавишей БП. Эта команда прерывает
естественный порядок выполнения команд программы и осуществляет переход к выполнению команды,
указанной в адресе перехода.

Команды перехода по условию (Х≥0, Х<0, X=0, X≠0) реализуются клавишей f и клавишей условия
(Х≥0, Х<0, X=0, X≠0).
С помощью этих команд проверяют содержимое регистра X на выполнение заданного условия. Если условие не
выполняется, то следующей
по программе будет исполнена команда, адрес которой указан непосредственно за командой условного перехода.
Если условие выполняется, то следующей по программе будет исполнена команда, записанная в программе после
адреса перехода. При этом адрес перехода не воспринимается.

Команда перехода на подпрограмму реализуется клавишей ПП. С помощью этой команды
реализуется переход на подпрограмму по адресу, указанному непосредственно после команды перехода,
и запоминается адрес следующей команды в стеке возврата.

Команда возврата из подпрограммы реализуется клавишей В/О. С помощью этой команды из стека
возврата производится вызов адреса, записанного по команде перехода на подпрограмму ПП,
и осуществляется переход по этому адресу к выполнению шагов основной программы.

Команда косвенного безусловного перехода по модифицированному адресу реализуется клавишами
k , БП и клавишей адресуемого регистра
(0—9, a, b,
c, d, e). При исполнении этой команды
производится модификация адреса, хранящегося в адресуемом регистре, индекс которого входит в команду,
и переход к исполнению команды, записанной по новому (модифицированному) адресу.

Модификация адреса
происходит в зависимости от номера регистра, входящего в команду. Если команда содержит номер одного из
регистров RG0, RG1, RG2, RG3, то при исполнении команды из содержимого регистра (адреса перехода)
вычитается 1, если номер одного из регистров RG4, RG5, RG6, то к содержимому этих регистров прибавляется 1,
если номер одного из регистров RG7, RG8, RG9 , RGa, RGb , RGc, RGd, RGе, то содержимое этих регистров
не изменяется.

Команды косвенных переходов по условию реализуются клавишей k, клавишей условия
(Х≥0, Х<0, X=0, X≠0)
и клавишей адресуемого регистра (0—9, a,
b, c, d, e).
С помощью этой команды проверяют содержимое регистра X на выполнение заданного условия.
Если условие не выполняется, то происходит модификация адреса,
хранящегося в адресуемом регистре, индекс которого входит в команду, и осуществляется переход к выполнению
команды, записанной по модифицированному адресу. Если условие выполняется, то осуществляется переход к
выполнению следующей команды. При этом адрес, записанный в адресуемом регистре, не модифицируется.

Команда косвенного перехода на подпрограмму реализуется клавишами k,
ПП и клавишей адресуемого регистра
(0—9, a,
b, c, d, e).
С помощью этой команды производится модификация адреса,
хранящегося в адресуемом регистре, индекс которого входит в команду, запись следующей команды в стек
возврата и переход к исполнению команды, записанной по модифицированному адресу.

Организация циклов

Команды организации циклов реализуются клавишами f,
L0 (либо L1, L2, L3).
При нажатии клавиши L0 (либо L1, L2,
L3), происходит обращение к регистру RG0 (RG1, RG2, RG3). При каждом обращении к регистру
из содержимого этого регистра вычитается 1 и производится анализ его содержимого на нуль. Если содержимое
регистра не равно нулю, то осуществляется переход к выполнению команды, записанной по адресу перехода,
следующему за командой цикла, если равно нулю, то выполняется команда, записанная в программе за адресом перехода.

Косвенное обращение к регистрам

Команда косвенной записи в регистр реализуется клавишами k, x→П
и клавишей адресуемого регистра
(0—9, a, b, c,
d, e).
С помощью этой команды производится модификация содержимого адресуемого регистра,
индекс которого входят в команду, и запись содержимого регистра X в регистр, соответствующий полученному
модифицированному коду.

Команда косвенной индикации вызова реализуется клавишами k, П→x
и клавишей адресуемого регистра. С помощью этой команды производится
модификация содержимого адресуемого регистра и вызов в регистр X содержимого
того регистра, который соответствует модифицированному коду

Программа решения квадратных уравнений

Рассмотрим программу для решения квадратных уравнений вида
ax² + bx + c = 0

Выполнение вычислений

Перед выполнением вычислений необходимо коэффициенты a, b, c занести в регистры
a, b, c соответственно. После останова в
регистре X находится один корень, в регистре Y — второй. Если уравнение не имеет действительных корней,
на экране высветится

EDD0D

Рассмотрим решение уравнения x²+2x-3=0

1. 1 X→П a

2. 2 X→П b

3. 3 /-/ X→П c

4. В/О C/П

5. -3.

6. ⁼

7. 1.