Лампанель. Программа ЛамПанель Программа ЛамПанель

Название	Программа ЛамПанель Программа ЛамПанель
Анкор	Лампанель
Дата	04.06.2022
Размер	242 Kb.
Формат файла
Имя файла	Лампанель.doc
Тип	Программа #569028

Программа «ЛамПанель»

Программа «ЛамПанель»

Основные идеи

Программа-тренажёр «ЛамПанель» – это учебная модель компьютера, который управляет панелью лампочек. Тренажёр можно использовать:

для изучения принципов работы компьютера (процессор, ОЗУ, ПЗУ);
для начального изучения программирования на языке ассемблера;
для изучения операций с целыми числами, в том числа поразрядных логических операций и сдвигов.

Модель компьютера включает процессор, оперативную память (ОЗУ), постоянную память (ПЗУ) и устройство вывода – панель лампочек размером 8×16. Для демонстрации через проектор можно вывести увеличенную панель, нажав клавишу F10.

Система команд процессора основана на идеях известной в свое время серии 16-разрядных мини-ЭВМ PDP-11. Непосредственным предшественником тренажёра «ЛамПанель» можно считать модель компьютера E97 Е.А. Ерёмина (http://educomp.runnet.ru/e97/), с которым процессор тренажёра «ЛамПанель» частично совместим по системе команд.

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

При запуске (по клавише F9) набранная программа транслируется (переводится в машинные коды, которые появляются в окне «Отладчик») и начинается ее выполнение.

В окне «Данные в памяти» показывается содержимое оперативной памяти, в которой расположены программа и данные (принцип однородности).

Процессор имеет 4 регистра общего назначения (РОН), которые называются R0, R1, R2 и R3. Кроме того, есть еще три внутренних регистра, недоступные программисту (но видимые в окне программы):

PC (англ. programcounter) – программный счетчик, счётчик команд, указывающий на следующую выполняемую команду;
SP (англ. stackpointer) – указатель стека, адрес вершины стека; стек размещается в нижней части оперативной памяти, его содержимое можно просмотреть в нижней части окна «Данные в памяти»;
PS (англ. processorstate) – регистр состояния процессора; используются только три младших бита: 0 – бит N (англ. negative, отрицательный результат), 1 – бит Z (англ. zero, нулевой результат) и 2 – бит C (англ. carry, перенос).

В качестве устройства вывода используется панель лампочек размером 8×16. Каждый ряд лампочек управляется через отдельный порт вывода. Всего используется восемь 16-разрядных портов с именами P0, P1, P2, P3, P4, P5, P6 и P7.

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

Простейшая программа

Программа должна заканчиваться командой stop. Например, самая простая программа:

stop

Команда NOP (англ. nooperation, нет операции) – это пустая команда, она ничего не делает. Комментарий начинается символом «точка с запятой»:

nop ; пустая команда

stop

Отладка

Программу можно выполнить всю целиком (клавиша F9) или в пошаговом режиме (F8). В пошаговом режиме в окне отладчика зелёным цветом выделяется текущая строка, которая будет выполнена при следующем нажатии F8. Сочетание клавиш Ctrl+F8 позволяет отменить только что сделанную команду.

Клавиша F7 (вместо F8) позволяет войти в подпрограмму и выполнить ее пошагово (см. раздел «Подпрограммы» ниже).

Если установить курсор в какую-то строчку программы и нажать клавишу F4, программа будет выполняться до этой строчки и затем остановится.

Движок «Скорость» изменяет скорость выполнения программы.

Все команды отладки включены в меню «Программа». Кроме того, они могут выполняться с помощью кнопок панели инструментов:

	Трансляция в машинные коды без выполнения (Ctrl+F9).
	Трансляция и выполнение (F9).
	Выполнить один шаг (F8).
	Отменить один шаг (Ctrl+F8).
	Войти в подпрограмму (F7).
	Выполнить до курсора (F4).

С помощью меню «Регистры» можно изменить значения любого регистра во время выполнения программы в пошаговом режиме.

Работа с регистрами и портами

Для простейшей обработки данных можно использовать 4 регистра процессора и 8 портов ламповой панели. Основные операции:

записать данные в регистр, например,

ассемблер	псевдокод
mov 1234, R0	R0:=1234₁₆

Все числа записываются в шестнадцатеричной системе счисления.

скопировать значение из одного регистра в другой, например,

ассемблер

псевдокод

mov R0, R1

R1:=R0
вывести значение регистра в порт

ассемблер

псевдокод

out R0, P1

P1:=R0
прочитать значение из порта в регистр

ассемблер	псевдокод
in P2, R0	R0:=P2

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

ассемблер	псевдокод
mov 1234, R0 mov R0, R2 out R2, P1 stop	R0:= 1234₁₆ R2:= R0 P1:= R2 стоп

Арифметические операции

Арифметические операции могут выполняться с числами (константами) и значениями регистров. Результат записывается по адресу второго операнда-регистра (это не может быть число).

сложение

ассемблер

псевдокод

add 1, R1

add R2, R3

R1:= R1 + 1

R3:= R3 + R2
вычитание

ассемблер

псевдокод

sub 2, R1

sub R2, R3

R1:= R1 - 2

R3:= R3 - R2
умножение

ассемблер

псевдокод

mul 5, R1

mul R2, R3

R1:= R1 * 5

R3:= R3 * R2
деление

ассемблер	псевдокод
div 12, R1 div R2, R3	R1:= R1 div 12 R3:= R3 div R2

Логические операции

Логические операции могут выполняться с числами (константами) и значениями регистров. Результат записывается по адресу второго операнда-регистра (это не может быть число).

отрицание («НЕ»)

ассемблер

псевдокод

not R1

R1:= not R1
логическое умножение («И»)

ассемблер

псевдокод

and R0, R1

and 1234, R1

R1:= R1 and R0

R1:= R1 and 1234₁₆
логическое сложение («ИЛИ»)

ассемблер

псевдокод

or R0, R1

or 1234, R1

R1:= R1 or R0

R1:= R1 or 1234₁₆
сложение по модулю 2 («исключающее ИЛИ»)

ассемблер	псевдокод
xor R0, R1 xor 1234, R1	R1:= R1 xor R0 R1:= R1 xor 1234₁₆

Сдвиги

В командах сдвига первый операнд – это величина сдвига (от 1 до 10₁₆), а второй – регистр.

логический сдвиг влево и вправо

ассемблер

псевдокод

shl 2, R1

shr F, R1

R1:= R1 shl 2₁₆

R1:= R1 shr F₁₆
арифметический сдвиг вправо

ассемблер

псевдокод

sar 2, R1

R1:= R1 sar 2₁₆
циклический сдвиг влево и вправо

ассемблер

псевдокод

rol 2, R1

ror F, R1

R1:= R1 rol 2₁₆

R1:= R1 ror F₁₆
циклический сдвиг влево и вправо через бит переноса

ассемблер	псевдокод
rcl 2, R1 rcr F, R1	R1:= R1 rcl 2₁₆ R1:= R1 rcr F₁₆

Метки, сравнения и переходы

Команды перехода используются для выполнения разветвляющихся алгоритмов. Различают безусловный переход (переходить всегда) и условные переходы (переход при выполнении какого-то условия).

Чтобы обозначить место перехода, необходимо создать метку. Метка – это произвольное имя, за которым следует двоеточие. После двоеточия не должно быть никаких символов (метка – это отдельная строка программы).

Безусловный переход имеет формат

jmp метка

Пример программы (бесконечный цикл):

qq:

nop

jmp qq

Условные переходы зависят от битов состояния процессора, которые определяются результатом последней операции:

jge метка ; если больше или равно

jl метка ; если меньше

jnz метка ; если не нуль

jz метка ; если нуль

jle метка ; если меньше или равно

jg метка ; если больше

Пример программы (цикл из 5 шагов):

ассемблер	псевдокод
mov 5, R1 qq: sub 1, R1 jnz qq	R1:=5 нц пока R1<> 0 R1:= R1 - 1 кц

Существует команда сравнения, которая изменяет только биты состояния процессора:

ассемблер	значение
cmp 2, R1 cmp R0, R1	установка битов состояния по значению 2₁₆-R1 установка битов состояния по значению R0-R1

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

ассемблер	псевдокод
cmp 5, R0 jnz aaa add 1, R0 aaa:	если R0=5 то R0:= R0 + 1 все

Подпрограммы

Подпрограммы – это вспомогательные алгоритмы, которые можно вызывать по имени. В языке ассемблера имя подпрограммы – это метка. Для вызова подпрограммы используется команда

call метка

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

ret

Подпрограммы располагаются в программе ниже основной программы, после команды stop.

Пример программы, которая использует подпрограмму divMod для деления с остатком:

ассемблер	псевдокод
mov 1234, R0 mov 10, R1 call divMod stop divMod: mov R0, R2 div R1, R0 mul R0, R1 sub R1, R2 mov R2, R1 ret	R0:= 1234₁₆ R1:= 10₁₆ вызвать divMod стоп R2:= R0 R0:= R0 div R1 *R1:= R1 R0 R2:= R2 – R1 R1:= R2 возврат**

Чтобы при отладке выполнять по шагам не только основную программу, но и подпрограмму, при выполнении команды call нужно нажать не F8, а F7.

Работа со стеком

Стек – это структура типа LIFO (англ. LastIn – FirstOut, последним пришел – первым ушел). В современных компьютерах стек размещается в памяти, специальный регистр SP (англ. stackpointer) указывает на начало стека. Для работы со стеком используются всего две команды:

ассемблер	псевдокод
push R0 pop R0	сохранить R0 в стеке «снять» данные с вершины стека в R0

Конечно, сохранять в стеке можно не только R0, но и другие регистры.

Стек используется:

для временного хранения данных
для хранения адресов возврата из подпрограмм
для размещения локальных переменных подпрограмм

Пример программы (обмен значений регистров R0 и R1):

ассемблер	псевдокод
push R0 push R1 pop R0 pop R1	R0 – в стек R1 – в стек со стека – в R0 (старое значение R1) со стека – в R1 (старое значение R0)

Если подпрограмма использует какой-то регистр, которые не содержит исходные данные и не предназначен для записи результата, она должна сохранить его стеке при входе и восстановить старое значение из стека при выходе. Например:

ассемблер	псевдокод
proc: push R0 ... pop R0 ret	начало подпрограммы R0 – в стек основное тело подпрограммы со стека – в R0 (старое значение R0) возврат из подпрограммы

Заметьте, что подпрограмма, приведенная в предыдущем пункте, не совсем грамотно написана – она не сохраняет значение регистра R2, хотя «портит» его во время работы.

Вызов подпрограмм из ПЗУ

ПЗУ в данной модели компьютера – это набор подпрограмм, каждая из которых заканчивается командой ret. Всего в ПЗУ может быть до 256 подпрограмм.

ПЗУ загружается при запуске тренажёра «ЛамПанель» из файла lampanel.rom, который должен находиться в том же каталоге, что и сама программа. Это обычный текстовый файл, который можно редактировать в редакторах типа Блокнота (если, конечно, вы понимаете, что вы делаете). В настоящей версии в ПЗУ включены следующие подпрограммы:

Номер	Описание
0	Очистить все порты панели (выключить все лампочки).
1	Установить в FF₁₆ все порты панели (включить все лампочки).
2	Записать значение R0 во все порты панели.
3	Прокрутить изображение на панели вниз.
4	Прокрутить изображение на панели вверх.
5	Вывести на панель массив данных, адрес которого находится в R0.
6	Выполнить инверсию экрана (применить NOT).
7	Операция «И» со всеми портами (R1 – маска).
8	Операция «ИЛИ» со всеми портами (R1 – маска).
9	Операция «исключающее ИЛИ» со всеми портами (R1 – маска).
A₁₆	Логический сдвиг влево всех портов (R1 – величина сдвига).
B₁₆	Логический сдвиг вправо всех портов (R1 – величина сдвига).
C₁₆	Циклический сдвиг влево всех портов (R1 – величина сдвига).
D₁₆	Циклический сдвиг вправо всех портов (R1 – величина сдвига).
E₁₆	Арифметический сдвиг вправо всех портов (R1 – величина сдвига).
F₁₆	Деление с остатком (R0:=R0 div R1, R1:=R0 mod R1).
10₁₆	Вывод цифры на экран (R0 – цифра, R1 – позиция, от 0 до 2)
11₁₆	Вывод числа из R0 на экран (R1 – система счисления, от 2 до 16).
12₁₆	Вывод числа из R0 на экран в десятичной системе счисления.
13₁₆	Вывод числа из R0 на экран в шестнадцатеричной системе счисления.

Просмотреть содержимое ПЗУ можно с помощью пункта меню «Программа-Просмотр ПЗУ» или кнопки

на панели инструментов. Выделив какую-нибудь строчку в левой части окна, мы увидим справа текст выбранной подпрограммы и ее коды:

Для вызова подпрограмм из ПЗУ нужно использовать команду

system номер_подпрограммы

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

ассемблер

псевдокод

system 0

system 1

mov 123, R0

system 12

system 6

mov 1, R1

system A

system B

system 13

stop

выключить панель

включить все лампочки

R0:= 123₁₆

вывести R0 в десятичной системе

инверсия

R1:= 1 ; величина сдвига

сдвиг экрана влево

сдвиг экрана вправо

вывести R0 в шестнадцатеричной системе

стоп

Байтовые команды

Все рассмотренные выше команды работают с 16-битными данными (словами). Часто, например, при обработке текстов, нужно использовать однобайтные данные. Для этого предназначены следующие команды, которые полностью аналогичны соответствующим командам без буквы «b» (от англ. byte) на конце:

команда

значение

movb

cmpb

shlb

shrb

sarb

rolb

rorb

rclb

rcrb

копирование байта

сравнение двух байтов

логический сдвиг влево

логический сдвиг вправо

арифметический сдвиг вправо

циклический сдвиг влево

циклический сдвиг вправо

циклический сдвиг влево через бит переноса

циклический сдвиг вправо через бит переноса

Команда movb очищает старший байт регистра, в который копируются данные. Например,

ассемблер	псевдокод
mov 1234, R0 movb 12, R0	R0:= 1234₁₆ R0:= 12₁₆

Остальные команды никак не изменяют старший байт регистра-приемника.

Существует специальная команда для обмена старшего и младшего байтов слова:

swapb регистр

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

ассемблер	псевдокод
mov 1234, R0 swapb R0	R0:= 1234₁₆ R0:= 3412₁₆

Работа с данными

Согласно принципу однородности памяти фон Неймана, данные размещаются в той же области памяти, что и программа (обычно сразу после команды stop).

В тренажере «ЛамПанель» данные – это 16-битные слова (вводятся как числа в шестнадцатеричной системе счисления) или символьные строки, заключенные в двойные кавычки. Для размещения данных в памяти применяется команда data. Например:

... ; основная программа

stop

ddd: ; метка начала блока данных

data 1234 ; слово 1234₁₆

data 5678 ; слово 5678₁₆

data "Ехал Грека через реку" ; строка

Для того, чтобы работать с этими данными, нужно как-то к ним обратиться. Для этого используется косвенная адресация – в регистре находятся не сами данные, а их адрес в памяти. Рассмотрим пример:

ассемблер	псевдокод
mov @ddd, R0 swapb (R0) add 2, R0 swapb (R0) stop ddd: data 1234 data 5678	R0:= адрес метки ddd переставить байты слова под адресу ddd увеличить адрес на 2 (байта) переставить байты слова под адресу ddd+2 стоп начало блока данных здесь будет 3412₁₆ здесь будет 7856₁₆

Запись @метка означает «адрес метки». Запись (R0) означает «данные, адрес которых находится в R0» – это и есть косвенная адресация.

Косвенную адресацию можно использовать и в других командах, работающих с регистрами.

Обработка массивов

Пусть в блоке данных, который начинается на метке ddd, записан массив, который нужно обработать в цикле. В этом случае удобно использовать косвенную адресацию с автоматическим увеличением адреса. Запись «(R0)+» означает «работать с данными, адрес которых находится в R0, и после выполнения операции увеличить R0». Если команда работает со словом, R0 увеличится на 2, а если с байтом – на 1.

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

ассемблер

псевдокод

mov @ddd, R0

mov 3, R1

loop:

swapb (R0)+

sub 1, R1

jnz loop

stop

ddd:

data 1234

data 5678

data 9ABC

R0:= адрес метки ddd

записать в R1 количество шагов цикла

начало цикла

переставить байты слова под адресу из R0

уменьшить счетчик оставшихся шагов

если счетчик не ноль, перейти в начало цикла

стоп

начало блока данных

здесь будет 3412₁₆

здесь будет 7856₁₆

здесь будет BC9A₁₆

Пример программы обработки байтов:

ассемблер

псевдокод

mov @ddd, R0

loop:

movb (r0),r1

or 20,r1

movb r1,(r0)+

cmpb 0,(r0)

jnz loop

stop

ddd:

data "ABCD"

R0:= адрес метки ddd

начало цикла

R1:= байт слова под адресу из R0

из заглавной буквы сделать строчную

записать результат в память

сравнить код следующего байта с 0

если не ноль, перейти в начало цикла

стоп

начало блока данных

здесь будет "abcd"

Самомодифицирующиеся программы

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

Пример самомодифицирующейся программы:

ассемблер

псевдокод

jmp decode

main:

data ba6b

data ba98

data 27a8

data 4444

decode:

mov @main,r0

mov 4,r1

loop:

xor bbbb,(r0)+

sub 1, r1

jnz loop

jmp main

переход на блок расшифровки

начало основной части

в этом и следующем словах будет "mov 123, R0"
здесь будет "system 13"

здесь будет "stop"

начало блока расшифровки

R0:= начало зашифрованного блока

R1:= 4 ; нужно расшифровать 4 слова

начало цикла

расшифровка: xor с маской BBBB₁₆

уменьшить счетчик

если счетчик не ноль, перейти на начало цикла

перейти на основную программу

Расширение ПЗУ

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

или пункта меню «Программа – Сохранить как ПЗУ». Например, напишем подпрограмму, которая переставляет биты числа в обратном порядке, используя циклический сдвиг через бит переноса:

ассемблер

псевдокод

mov 1234, R0

call reverse

stop

reverse:

push R1

push R2

mov 10, R2

xor R1, R1

next-bit:

rcl 1, R0

rcr 1, R1

sub 1, R2

jnz next-bit

mov R1, R0

pop R2

pop R1

ret

R0:= 1234₁₆

вызов подпрограммы

стоп

начало подпрограммы

сохранить R1 в стеке

сохранить R2 в стеке

R2:= 16 = 10₁₆

R1:= 0
старший бит R0 попадает в бит переноса

бит переноса попадает в старший бит R1

R2:= R2 – 1

если R20, перейти к метке next-bit

R0:= R1

восстановить R2 из стека

восстановить R1 из стека

возврат из подпрограммы

Отладив эту программу, уберем верхние три строчки, оставив только процедуру, и применяем команду меню «Программа – Сохранить как ПЗУ». Полученный файл (он будет иметь расширение .rom) открываем в любом текстовом редакторе (например, в Блокноте) и добавляем в начало комментарий:

; Перестановка битов R0

; в обратном порядке

;-----------------------

2E10 PUSH R1

2E20 PUSH R2

01D2 MOV 10, R2

0010

0911 XOR R1, R1

9E00 RCL 1, R0

AE01 RCR 1, R1

03D2 SUB 1, R2

0001

4D0D JNZ 000A

FFF4

0110 MOV R1, R0

3E20 POP R2

3E10 POP R1

0D00 RET

Теперь остается добавить (также в текстовом редакторе) этот фрагмент в конец файла lampanel.rom. Новая процедура будет доступна при следующем запуске программы «ЛамПанель».

Приложение

Справочник по языку ассемблера «ЛамПанель»

Регистры:

R0, R1, R2, R3 – регистры общего назначения;

PC – программный счетчик;

SP – указатель стека;

PS – регистр состояния:

бит 0 – знак (бит N, negative),

бит 1 – равенство нулю (бит Z, zero)

бит 2 – бит переноса (бит C, carry).
Обозначения при описании форматов команд:

n – число в шестнадцатеричной системе счисления

Rx – некоторый регистр общего назначения

Px – некоторый порт
Метки:

Метка – это последовательность символов, заканчивающаяся двоеточием. Кроме метки, в строке не должно быть других символов.
Основные команды:

NOP – нет операции

STOP – останов

MOV Ry,Rx – пересылка Rx:=Ry

MOV n,Rx – пересылка Rx:=n

ADD Ry,Rx – сложение Rx:=Rx+Ry

ADD n,Rx – сложение Rx:=Rx+n

SUB Ry,Rx – вычитание Rx:=Rx–Ry

SUB n,Rx – вычитание Rx:=Rx–n

CMP Rx,Ry – сравнение (установка флагов по разности Rx–Ry)

CMP n,Rx – сравнение (установка флагов по разности n-Rx)

MUL Ry,Rx – умножение Rx:=Rx*Ry

MUL n,Rx – умножение Rx:=Rx*n

DIV Ry,Rx – деление Rx:=Rx div Ry

DIV n,Rx – деление Rx:=Rx div n
Логические операции:

NOT Rx – логические «НЕ» (инверсия) Rx:=not Rx

AND Ry,Rx – логическое «И» (конъюнкция) Rx:=Rx and Ry

AND n,Rx – логическое «И» (конъюнкция) Rx:=Rx and n

OR Ry,Rx – логическое «ИЛИ» (дизъюнкция) Rx:=Rx or Ry

OR n,Rx – логическое «ИЛИ» (дизъюнкция) Rx:=Rx or n

XOR Ry,Rx – «исключающее ИЛИ» Rx:=Rx xor Ry

XOR n,Rx – «исключающее ИЛИ» Rx:=Rx xor n
Сдвиги:

SHL n,Rx – логический сдвиг влево Rx:=Rx shl n

SHR n,Rx – логический сдвиг вправо Rx:=Rx shr n

SAR n,Rx – арифметический сдвиг вправо Rx:=Rx sar n

ROL n,Rx – циклический сдвиг влево Rx:=Rx rol n

ROR n,Rx – циклический сдвиг вправо Rx:=Rx ror n

RCL n,Rx – циклический сдвиг влево через перенос Rx:=Rx rcl n

RCR n,Rx – циклический сдвиг вправо через перенос Rx:=Rx rcr n
Байтовые команды:

MOVB Ry,Rx – пересылка младшего байта Rx:=Ry

MOVB n,Rx – пересылка младшего байта Rx:=n

CMPB Rx,Ry – сравнение (установка флагов по разности байтов Ry–Rx)

CMPB n,Rx – сравнение (установка флагов по разности байтов n-Rx)

SHLB n,Rx – логический сдвиг байта влево Rx:=Rx shl n

SHRB n,Rx – логический сдвиг байта вправо Rx:=Rx shr n

SARB n,Rx – арифметический сдвиг байта вправо Rx:=Rx sar n

ROLB n,Rx – циклический сдвиг байта влево Rx:=Rx rol n

RORB n,Rx – циклический сдвиг байта вправо Rx:=Rx ror n

RCLB n,Rx – циклический сдвиг байта влево через перенос Rx:=Rx rcl n

RCRB n,Rx – циклический сдвиг байта вправо через перенос Rx:=Rx rcr n

SWAPB Rx – поменять местами байты в регистре Rx
Переходы:

JMP адрес или метка – безусловный переход

JGE адрес или метка – если больше или равно

JL адрес или метка – если меньше

JNZ адрес или метка – если не нуль

JZ адрес или метка – если нуль

JLE адрес или метка – если меньше или равно

JG адрес или метка – если больше
Процедуры:

CALL адрес или метка – вызов процедуры

SYSTEM номер – вызов процедуры из ПЗУ с заданным номером

RET – возврат из процедуры
Размещение данных:

DATA число – число записывается в память как слово

DATA "строка" – символьная строка записывается в память
Работа со стеком:

PUSH Rx – сохранить в стеке регистр Rx

POP Rx – восстановить из стека регистр Rx
Работа с портами, которые управляют лампочками:

Порты: P0, P1, P2, P3, P4, P5, P6, P7. Все порты доступны на чтение и запись.

IN Py,Rx – ввод из порта Py в регистр Rx

OUT Rx,Py – вывод из регистра Rx в порт Py
Относительная адресация:

MOV @метка,Rx – записать адрес метки в регистр Rx

(Rx) – операнд находится в ячейке, адрес которой записан в регистре Rx

(Rx)+ – то же самое, но после выполнения операции значение Rx увеличивается на 2 для команды, работающей со словом, и на 1 для байтовой команды

https://kpolyakov.spb.ru