- •Міністерство освіти і науки України
- •Дніпропетровськ
- •Міністерство освіти і науки України
- •Дніпропетровськ
- •1. Система команд микроконтроллеров семейства мк51
- •2. Компилятор для микроконтроллеров семейства мк51
- •2.1 Системные соглашения
- •2.2 Синтаксис языка ассемблера
- •2.3 Директивы ассемблера
- •2.4 Вычисления во время транслирования
- •2.5 Сравнения во время транслирования
- •2.6 Сообщения об ошибках ассемблирования
- •2.7 Методика работы с компилятором x8051
- •2.7.1 Диалоговый режим.
- •2.7.2 Режим командной строки
- •2.7.3 Режим редактирования и компилирования из среды текстового редактора multi edit
- •3. Редактор связей для компилятора микроконтроллера семейства мк51
- •4. Полноэкранный отладчик ассемблерных программ для микроконтроллеров семейства мк51
- •4.1 Запуск отладчика
- •4.2 Ввод команд
- •4.3 Описание команд
- •4.3.1 Функциональные клавиши
- •4.3.2 Команды отладчика
- •Робочий зошит студента
- •49027, М. Дніпропетровськ-27, просп. К. Маркса, 19.
1. Система команд микроконтроллеров семейства мк51
В машинном коде команда занимает один, два или три байта. Все команды выполняются за один или два машинных цикла, команды умножения и деления - за четыре. Один машинный цикл при частоте тактового генератора 12 МГц составляет 1 мкс.
Все команды условных переходов осуществляются относительно содержимого счетчика команд. Адрес перехода вычисляется микроконтроллером во время выполнения команды.
Систему команд МК51 условно можно разбить на пять групп:
арифметические команды;
логические команды;
команды передачи данных;
команды битового процессора;
команды ветвления программ и передачи управления.
Способы адресации операндов:
регистровая адресация;
прямая адресация;
косвенно-регистровая адресация;
непосредственная;
косвенная адресация по сумме базового и индексного регистра.
Описание каждой команды микроконтроллеров семейства МК51 состоит из предложения на языке ассемблера, кода, длины команды в байтах, времени ее выполнения, алгоритма и примера. При описании операций используются обозначения, приведенные в таблице.
Обозначение, символ |
Назначение |
1 |
2 |
A |
Аккумулятор |
Rr |
Регистры текущего банка регистров общего назначения |
r |
Номер загружаемого регистра, указанного в команде |
direct |
Прямо адресуемый 8-битовый адрес, который может быть ячейкой внутреннего ОЗУ (00H-7FH) или регистром специальных функций (80H-FFH) |
@Rr |
Косвенно адресуемая 8-битовая ячейка внутреннего ОЗУ |
data 8 |
8-битовое непосредственное данное |
data 16 |
16-битовое непосредственное данное |
data H |
Старшие биты (15-8) непосредственных 16-битовых данных |
data L |
Младшие биты (7-0) непосредственных 16-битовых данных |
addr 11 |
11-битовый адрес назначения |
addr 16 |
16-битовый адрес назначения |
addr L |
Младшие биты адреса назначения |
Продолжение таблицы
1 |
2 |
bit |
Бит с прямой адресацией, находящийся во внутреннем ОЗУ или в регистрах специальных функций |
a15,a14...a0 |
Биты адреса назначения |
(X) |
Содержимое элемента X |
((X)) |
Содержимое по адресу хранящемуся в элементе X |
(X)[M] |
Разряд M элемента X |
(X)[M1-M2] |
Группа разрядов M1-M2 элемента X |
+ |
Операция сложения |
- |
Операция вычитания |
* |
Операция умножения |
/ |
Операция деления |
AND |
Операция логического умножения (операция «И») |
OR |
Операция логического сложения (операция «ИЛИ») |
XOR |
Операция сложения по модулю 2 (операция «Исключающее ИЛИ») |
/X |
Инверсия элемента X |
Команда ACALL <addr 11>. Команда "абсолютный вызов подпрограммы" вызывает, безусловно, подпрограмму, размещенную по указанному адресу. При этом счетчик команд увеличивается на 2 для получения адреса следующей команды, после чего полученное 16-битовое значение PC помещается в стек (сначала следует младший байт), и содержимое указателя стека также увеличивается на два. Адрес перехода получается с помощью конкатенации старших бит увеличенного содержимого счетчика команд, битов старшего байта команды и младшего байта команды.
Ассемблер: ACALL <метка>
Код |
|
A10 A9 A8 1 |
0 0 0 1 |
|
A7 A6 A5 A4 |
A3 A2 A1 A0 |
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, (SP):=(SP)+1, ((SP)):=(PC[7-0]), (SP):=(SP)+1, ((SP)):=(PC[l5-8]),
(PC[10-0]):=A10 A9 A8 || A7 A6 A5 A4 A3 A2 A1 A0, где || - знак конкатенации (сцепление)
Пример: ;(SP)=07H, метка МТ1 соответствует адресу: 0345Н, (PC)=02F8H
ACALL МТ1 ;(PC)=028DH,(SP)=09H, (РС)=0345Н, ОЗУ [08]=8FH, ОЗУ [09]=02Н.
Команда ADD А, <байт-источник>. Эта команда ("сложение") складывает содержимое аккумулятора А с содержимым байта-источника, оставляя результат в аккумуляторе. При появлении переносов из разрядов 7 и 3, устанавливаются флаги переноса (С) и дополнительного переноса (АС) соответственно, в противном случае эти флаги сбрасываются. При сложении целых чисел без знака флаг переноса "С" указывает на появление переполнения. Флаг переполнения (OV) устанавливается, если есть перенос из бита 6 и нет переноса из бита 7, или есть перенос из бита 7 и нет - из бита 6, в противном случае флаг OV сбрасывается. При сложении целых чисел со знаком флаг OV указывает на отрицательную величину, полученную при суммировании двух положительных операндов или на положительную сумму для двух отрицательных операндов.
Для команды сложения разрешены следующие режимы адресации байта-источника:
1) регистровый;
2) косвенно-регистровый;
3) прямой;
4) непосредственный.
Ассемблер: 1) ADD A.Rn ;где n=0-7
Код |
|
0 0 1 0 |
1 r r r |
|
|
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (A):=(A)+(Rn) ;где n=0-7
С:=Х, OV:=X, АС:=Х ;где Х=(0 или 1)
Ассемблер: 2) ADD A,@Ri ;где i=0,1
Код |
|
0 0 1 0 |
0 1 1 i |
|
|
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+((Ri)) ;где i=0,1
С:=Х, OV:=X, AC:=X ;где Х=(0 или 1)
Ассемблер: 3) ADD A,<direct>
Код |
|
0 0 1 0 |
0 1 0 1 |
|
direct address |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+(direct)
С:=Х, OV:=X, AC:=X ;где Х=(0 или 1)
Ассемблер: 4) ADD A,<#data>
Код |
|
0 0 1 0 |
0 1 0 0 |
|
#data |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+#data
С:=Х, OV:=X, AC:=X ;где Х=(0 или 1)
Примеры:
1) ;(А)=СЗН, (R6)=AAH
ADD A,R6 ;(A)=6DH, (R6)=AAH ,(AC)=0, (C)=l, (OV)=1
2) ;(А)=95Н, (R1)=31H, (ОЗУ [31])=4СН
ADD A,@R1 ;(А)=Е1Н, (ОЗУ [31])=4СН, (C)=0, (AC)=1, (OV)=0
3) ;(А)=77Н, (ОЗУ [90])=FFH
ADD A,90H ;(A)=76H, (ОЗУ (90])=FFH, ;(C)=1, (OV)=0, ; (AC)=1
4) ;(А)=09Н
ADD A,#0D3H ;(A)=DCH, (C)=0, (OV)=0, (AC)=0
Команда ADDC A. <байт-источник>. Эта команда ("сложение с переносом") одновременно складывает содержимое байта-источника, флаг переноса и содержимое аккумулятора А, оставляя результат в аккумуляторе. При этом флаги переноса и дополнительного переноса устанавливаются, если есть перенос из бита 7 или бита 3, и сбрасываются в противном случае. При сложении целых чисел без знака флаг переноса указывает на переполнение. Флаг переполнения (OV) устанавливается, если имеется перенос бита 6 и нет переноса из бита 7 или есть перенос из бита 7 и нет - из бита 6, в противном случае OV сбрасывается. При сложении целых чисел со знаком OV указывает на отрицательную величину, полученную при суммировании двух положительных операндов, или на положительную сумму от двух отрицательных операндов. Для этой команды разрешены следующие режимы адресации байта-источника:
1) регистровый;
2) косвенно-регистровый;
3) прямой;
4) непосредственный.
Ассемблер: 1) ADDC A,Rn ;где n=0-7
Код |
|
0 0 1 1 |
1 r r r |
|
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (A):=(A)+(C)+(Rn)
(С):=Х, (AC):=X, (OV):=X ;где X=(0 или 1)
Ассемблер: 2) ADDC A,@Ri ;где i=0,l
Код |
|
0 0 1 1 |
0 1 1 i |
|
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+(C)+((Ri))
(С):=Х, (AC):=X, (OV):=X, где X=(0 или 1)
Ассемблер: 3) ADDC A,<direct>
Код |
|
0 0 1 1 |
0 1 0 1 |
|
direct address |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+(C)+(direct)
(С):=Х, (AC):=X, (OV):=X ;где X=(0 или 1)
Ассемблер: 4) ADDC A,#data
Код |
|
0 0 1 0 |
0 1 0 1 |
|
#data |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)+(C)+(direct)
(С):=Х, (AC):=X, (OV):=X ;где X=(0 или 1)
Примеры:
1) ;(А)=В2Н, (R3)=99, (C)=1
ADDC A,R3 ;(A)=4CH, (R3)=99, (C)-1, (AC)=0, (OV)=1
2) ;(A)=D5H, (R0)=3AH, (ОЗУ[ЗА])=1АН, (C)=l
ADDC A,@R0 ;(A)=F0H, (ОЗУ[ЗА]=1АН), ;(C)=0, (AC)=1, ; (OV)=0
3) ;(A)=11H, (O3У[80])=DFH, (C)=l
ADDC A,80H ;(A)=F1H, (C)=0, (AC)=1, (OV)=0
4) ;(А)=55Н, (C)=0
ADDC А,#55Н ;(А)=ААН, (С)=0, (AC)=0, (OV)=1
Команда AJMP <addr11>. Команда "абсолютный переход", передает управление по указанному адресу, который получается при конкатенации пяти старших бит счетчика команд PC (после увеличения его на два), 7-5 битов кода операции и второго байта команды. Адрес перехода должен находится внутри одной страницы объемом 2 Кбайт памяти программы, определяемой пятью старшими битами счетчика команд.
Ассемблер: AJMP <метка>
Код |
|
A10 A9 A8 0 |
0 0 0 1 |
|
A7 A6 A5 A4 |
A3 A2 A1 A0 |
|
|
|
Время: 2 цикла
Алгоритм: (РС[15-0]):=(РС[15-0])+2, (РС[10-0]):=<addr11>
Пример: ;(PC)=028FH, Метке МТ2 соответствует адрес ;034АН
AJMP МТ2 ;(РС)=034АН
Команда ANL <байт-назначения>, <байт-источник>. Команда "логическое "И" для переменных-байтов" выполняет операцию логического "И" над битами указанных переменных и помещает результат в байт-назначения. Эта операция не влияет на состояние флагов. Два операнда обеспечивают следующие комбинации шести режимов адресации:
байтом назначения является аккумулятор (А):
1) регистровый;
2) прямой;
3) косвенно-регистровый;
4) непосредственный;
байтом назначения является прямой адрес (direct):
5) прямой аккумуляторный;
6) непосредственный (байт-источник равен константе).
Ассемблер: 1) ANL A, Rn ;где n=0-7
Код |
|
0 1 0 1 |
1 r r r |
|
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (А):=(А) AND (Rn)
Ассемблер: 2) ANL A, <direct>
Код |
|
0 1 0 1 |
0 1 0 1 |
|
direct address |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A) AND (direct)
Ассемблер: 3) ANL A, @Ri; где i=0,l
Код |
|
0 1 0 1 |
0 1 1 i |
|
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A) AND ((Ri))
Ассемблер: 4) ANL A, #data
Код |
|
0 1 0 1 |
0 1 0 0 |
|
#data |
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A) AND #data
Ассемблер: 5) ANL <direct>, A
Код |
|
0 1 0 1 |
0 0 1 0 |
|
direct address |
|
|
|
Время: 1 цикл
Алгоритм: (direct):=(direct) AND (A)
Ассемблер: 6) ANL <direct>,#data
Код |
|
0 1 0 1 |
0 0 1 0 |
|
direct address |
|
#data8 |
Время: 2 цикла
Алгоритм: (direct):=(direct) AND #data
Примеры:
1) ;(A)=FEH, (R2)=C5H
ANL A,R2 ;(A)=C4H, (R2)=C5H
2) ;(A)=A3H, (PSW)=86H
ANL A,PSW ;(A)-82H, (PSW)=86H
3) ;(А)=ВСН, (ОЗУ[35])=47Н, (R0)=35H
ANL A,@R0 ;(A)=04H, (ОЗУ[351)=47Н
4) ;(A)=36H
ANL A,#0DDH ;(A)=14H
5) ;(A)=55H, (P2)=AAH
ANL P2,A ;(P2)=00H, (A)=55H
6) ;(P1)=FFH
ANL P1,#73H ;(P1)=73H
Примечание. Если команда "ANL" применяется для изменения содержимого порта, то значение, используемое в качестве данных порта, будет считываться из "защелки" порта, а не с выводов БИС.
Команда ANL С,<бит источника>. Команда "логическое "И" для переменных-битов", выполняет операцию логического "И" над указанными битами. Если бит-источник равен "0", то происходит сброс флага переноса, в противном случае флаг переноса не изменяет текущего значения. "/" перед операндом в языке ассемблера указывает на то, что в качестве значения используется логическое отрицание адресуемого бита, однако сам бит источника при этом не изменяется. На другие флаги эта команда не влияет. Для операнда-источника разрешена только прямая адресация к битам.
Ассемблер: 1) ANL C,<bit>
Код |
|
1 0 0 0 |
0 0 1 0 |
|
bit address |
|
|
|
Время: 2 цикла
Алгоритм: (С):=(С) AND (bit)
Ассемблер: 2) ANL C,</bit>
Код |
|
1 0 1 1 |
0 0 0 0 |
|
bit address |
|
|
|
Время: 2 цикла
Алгоритм: (С):=(С) AND (/bit)
Примеры:
1) ;(С)=1, Р1[0]=0
ANL С,Р1.0 ;(С)=0, Р1[0]=0
2) ;(С)=1, (AC)=0
ANL С,/AC ;(C)=1, (AC)=0
Команда CJNE <байт назначения>, <байт источник>, <смешение>. Команда "сравнение и переход, если не равно" сравнивает значения первых двух операндов и выполняет ветвление, если операнды не равны. Адрес перехода (ветвления) вычисляется при помощи сложения значения (со знаком), указанного в последнем байте команды, с содержимым счетчика команд после увеличения его на три.
Флаг переноса "С" устанавливается в "1", если значение целого без знака <байта назначения> меньше, чем значение целого без знака <байта источника>, в противном случае перенос сбрасывается (если значения операндов равны, флаг переноса сбрасывается). Эта команда не оказывает влияния на-1 операнды.
Операнды, стоящие в команде, обеспечивают комбинации четырех режимов 1 адресации:
если байтом-назначения является аккумулятор:
прямой;
непосредственный,
если байтом-назначения является любая ячейка ОЗУ с косвенно-регистровой или регистровой адресацией:
непосредственный к регистровому;
непосредственный к косвенно-регистровому
Ассемблер: 1) CJNE A, <direct>, <метка>
Код |
|
1 0 1 1 |
0 1 0 1 |
|
direct address |
|
rel8 |
Время: 2 цикла
Алгоритм: (PC):=(PC)+3,
если (direct) < (А) то (PC):=(PC)+<rel8>, C:=0;
если (direct) > (A), то (PC):=(PC)+<rel8>, C:=1;
Ассемблер: 2) CJNE A,#data,<метка>
Код |
|
1 0 1 1 |
0 1 0 0 |
|
#data8 |
|
rel8 |
Время: 2 цикла
Алгоритм: (PC):=(PC)+3,
если #data8<(A), то (РС)+<ге18>,С:=0;
если #data8>(A),то (PC):=(PC)+<rel8>, С:=1
Ассемблер: 3) CJNE Rn,#data,<метка> ;где n=0-7
Код |
|
1 0 1 1 |
1 r r r |
|
#data8 |
|
rel8 |
Время: 2 цикла
Алгоритм: (PC):=(PC)+3,
если #data8<(Rn), то (PC):=(PC)+<rel8>, С:=0;
если #data8>(Rn), то (PC)+<rel8>, С:=1
Ассемблер: 4) CJNE @Ri,#data, <метка> ;где i=0,l
Код |
|
1 0 1 1 |
0 1 1 i |
|
#data8 |
|
rel8 |
Время: 2 цикла.
Алгоритм: (РС):=(РС)+3,
если #data<((Ri)), то (PC)+<rel8>,C:=0
если #data8>((Ri)), то (PC)+<rel8>, C:=1
Примеры:
1) ;(A)=97H, (P2)=F0H, (C)=0
CJNE A,P2,MT3
MT3: CLR A ;(A)=97H, (P2)=F0H, (C)=l. Адрес, ;соответствующий метке МТЗ
;вычисляется, как (РС):=(РС)+3+(ге18)
2) ;(A)=FCH, (С)=1
CJNE A,#0BFH,MT4
МТ4: INC A ;(A)=FDH, C-0, (PC):=(PC)+3+(rel8)
3) ;(R7)=80H, (C)=0
CJNE R7,#81H,MT5
MT5: NOP ;(R7)=80H, (C)=l, (PC):=(PC)+3+(rel8)
4) ;(R0)=41H, (C)=l, (ОЗУ[41])=57Н
CJNE @R0,#29H,MT6
MT6: DEC R0 ;(ОЗУ[41])=57Н, (C)=0, (PC):=(PC)+3+(rel8)
Команда CLR A. Команда "сброс аккумулятора" сбрасывает (обнуляет) содержимое аккумулятора А. На флаги команда не влияет.
Ассемблер: CLR А
Код |
|
1 1 1 0 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл.
Алгоритм: (А):=0
Пример: ;(A)=6DH, (C)=0, (АС)=1
CLR А ;(А)=00Н, (C)=0, (АС)=1
Команда CLR <bit>. Команда "сброс бита" сбрасывает указанный бит в нуль. Эта команда работает с флагом переноса "С" или любым битом с прямой адресацией.
Ассемблер: 1) CLR С
Код |
|
1 1 0 0 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (С):=0
Ассемблер: 2) CLR <bit>
Код |
|
1 1 0 0 |
0 0 1 0 |
|
bit address |
|
|
Время: 1 цикл
Алгоритм: (bit) :=0
Примеры:
1) ;(C)=l
CLR С ;(C)=0
2) ;(Р1)=5ЕН (01011110В)
CLR Р1.3 ;(Р1)=56Н (01010110В)
Команда CPL А. Команда "инверсия аккумулятора" каждый бит аккумулятора инвертирует (изменяет на противоположный). Биты, содержащие "единицы", после этой команды будут содержать "нули", и наоборот. На флаги эта операция не влияет.
Ассемблер: CPL А
Код |
|
1 1 1 1 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=/(А)
Пример: ;(А)=65Н (01100101В)
CPL А ;(А)=9АН (10011010В)
Команда CPL <bit>. Команда "инверсия бита" инвертирует (изменяет на противоположное значение) указанный бит. Бит, который был "единицей", изменяется в "нуль" и наоборот. Команда CPL может работать с флагом переноса или с любым прямо адресуемым битом. На другие флаги команда не влияет.
Ассемблер: 1) CPL <bit>
Код |
|
1 0 1 1 |
0 0 1 0 |
|
bit address |
|
|
Время: 1 цикл
Алгоритм: (bit):=/(bit)
Ассемблер: 2) CPL С
Код |
|
1 0 1 1 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (С):=/(С)
Пример:
1) ;(Р1)=39Н (00111001В)
CPL Р1.1
СPL Р1.3 ;(Р1)=ЗЗН (00110011В)
2) ;(С)=0, (АС)=1, (OV)=0
CPL С ;(С)=1, (АС)=1, (OV)=0
Примечание: Если эта команда используется для изменения информации на выходе порта, значение, используемое как исходные данные, считывается из "защелки" порта, а не с выводов БИС.
Команда DA А. Команда "десятичная коррекция аккумулятора для сложения" упорядочивает 8-битовую величину в аккумуляторе после выполненной ранее команды сложения двух переменных (каждая в упакованном двоично-десятичном формате). Для выполнения сложения может использоваться любая из типов команд ADD или ADDC. Если значение битов 3 - 0 аккумулятора (А) превышает 9 (ХХХХ 1010 - ХХХХ 1111) или если флаг АС равен "1", то к содержимому (А) прибавляется 06, получая соответствующую двоично-десятичную цифру в младшем полубайте. Это внутреннее побитовое сложение устанавливает флаг переноса, если перенос из поля младших четырех бит распространяется через все старшие биты, а в противном случае - не изменяет флаг переноса. Если после этого флаг переноса равен "1", или если значение четырех старших бит (7-4) превышает 9 (1010 ХХХХ - 1111 ХХХХ), значения этих старших бит увеличивается на 6, создавая соответствующую двоично-десятичную цифру в старшем полубайте. И снова при этом флаг переноса устанавливается, если перенос получается из старших битов, но не изменяется в противном случае. Таким образом, флаг переноса указывает на то, что сумма двух исходных двоично-десятичных переменных больше чем 100. Эта команда выполняет десятичное преобразование с помощью сложения 06, 60, 66 с содержимым аккумулятора в зависимости от начального состояния аккумулятора и слова состояния программы (PSW).
Ассемблер: DA А
Код |
|
1 1 0 1 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: если ((A[3-0])>9 или (АС)=1), то А[3-0]:=А[3-0]+6
если ((А[7-4])>9 или (С)=1), то А[7-4]:=А[7-4]+6
Примеры:
1) ;(А)=56Н, (R3)=67H, (С)=1
ADDC A,R3
DA A ;(A)=24H, (R3)=67H, (С)=1
2) ;(A)=30H, (C)=0
ADD A,#99H
DA A ;(A)=29, (C)-=l
Примечание: Команда DA А не может просто преобразовать шестнадцатеричное значение в аккумуляторе в двоично-десятичное представление и не применяется, например, для десятичного вычитания.
Команда DEC <байт>. Команда "декремент" производит вычитание "1" из указанного операнда. Начальное значение 00Н перейдет в 0FFH. Команда DEC не влияет на флаги. Этой командой допускается четыре режима адресации операнда:
1) к аккумулятору;
2) регистровый;
3) прямой;
4) косвенно-регистровый;
Ассемблер: 1) DEC А
Код |
|
0 0 0 1 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=(А)-1
Ассемблер: 2) DEC Rn ;где n=0-7
Код |
|
0 0 0 1 |
1 r r r |
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (Rn):=(Rn)-l
Ассемблер: 3) DEC <direct>
Код |
|
0 0 0 1 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (direct):=(direct)-l
Ассемблер: 4) DEC @Ri ;где i=0,l
Код |
|
0 0 0 1 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: ((Ri)):=((Ri)-l)
Примеры:
1) ;(А)=11Н, (С)=1, (АС)=1
DEC А ;(А)=10Н, (С)=1, (АС)=1
2),4) ;(R1)=7FH, (ОЗУ[7F])=40Н, (ОЗУ[7F])=00Н
DEC @R1
DEC R1
DEC @R1 ;(R1)=7EH, (ОЗУ[7F])=ЗEH, (03У[7F])=FFH
3) ;(SCON)=A0H, (C)=l, (AC)=1
DEC SCON ;(SCON)=9FH, (C)=l, (AC)=1
Примечание: Если эта команда используется для изменения информации на выходе порта, значение, используемое как исходные данные, считывается из "защелки'" порта, а не с выводов БИС.
Команда DIV АВ. Команда "деление" делит 8-битовое целое без знака из аккумулятора А на 8-битовое целое без знака в регистре В. Аккумулятору присваивается целая часть частного (старшие разряды), а регистру В - остаток. Флаги переноса (С) и переполнения (0V) сбрасываются. Если (А) < (В), то флаг дополнительного переноса (АС) не сбрасывается. Флаг переноса сбрасывается в любом случае.
Ассемблер: DIV АВ
Код |
|
1 0 0 0 |
0 1 0 0 |
|
|
|
|
Время: 4 цикла
Алгоритм: (A):=((A)/(B)) [15-8], (В):=((А)/(В)) [7-0]
Пример: Пусть аккумулятор содержит число 251 (0FBH или 11111011В), а регистр В - число 18 (12Н или 00010010В). После выполнения команды DIV АВ в аккумуляторе будет число 13 (0DH или 00001101В), а в регистре В - число 17 (11Н или 00010001В), т.к. 251=(13*18)+17. Флаги С и OV будут сброшены.
Примечание: Если В содержит 00H, то после команды DIV содержимое аккумулятора А и регистра В будут не определены. Флаг переноса сбрасывается, а флаг переполнения устанавливается в 1.
Команда DJNZ <байт>, <смещение>. Команда "декремент и переход, если не равно нулю" выполняет вычитание "1" из указанной ячейки и осуществляет ветвление по вычисляемому адресу, если результат не равен нулю. Начальное значение 00Н перейдет в 0FFH. Адрес перехода (ветвления) вычисляется сложением значения смещения (со знаком), указанного в последнем байте команды, с содержимым счетчика команд, увеличенным на длину команды DJNZ. На флаги эта команда не влияет и допускает следующие режимы адресации:
1) регистровый
2) прямой
Ассемблер: 1) DJNZ Rn,<метка> ;где n=0-7
Код |
|
1 1 0 1 |
1 r r r |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, (Rn):=(Rn)-l, если ((Rn)>0 или (Rn)<0), то (РС):=(РС)+<ге18>
Ассемблер: 2) DJNZ <direct>,<метка>
Код |
|
1 1 0 1 |
0 1 0 1 |
|
direct address |
|
rel8 |
Время: 2 цикла
Алгоритм: (РС):=(РС)+3, (direct) :=(direct)-l, если ((direct)>0 или (direct)<0), то (PC):=(PC)+<rel8>
Примеры:
1) ;(R2)=08H, (P1)=FFH (11111111В)
LAB4: CPL Р1.7
DJNZ R2,LAB4 ;(R2)={07-00}. Эта последовательность ;команд переключает Р1.7
;восемь раз и приводит к появлению ;четырех импульсов ;на выводе
;БИС, соответствующем биту Р1.7.
2) ;(ОЗУ40)=01Н, (ОЗУ[50])=80Н, (ОЗУ 60)= ;=25Н
DJNZ 40Н,LAB1 ;(ОЗУ[40]):=00Н
DJNZ 50Н,LAB2 ;(ОЗУ[50]):=7FH
DJNZ 60Н,LАВЗ ;(ОЗУ[60]):=25Н
. . . . . .
LAB1: CLR A
. . . . . .
LAB2: DEC R1 ;осуществился переход на метку LAB2
Примечание: Если команда DJNZ используется для изменения выхода порта, значение, используемое как операнд, считывается из "защелки" порта, а не с выводов БИС.
Команда INC <байт>. Команда "инкремент" выполняет прибавление "1" к указанной переменной и не влияет на флаги. Начальное значение 0FFH перейдет в 00Н. Эта команда допускает четыре режима адресации:
1) к аккумулятору;
2) регистровый;
3) прямой;
4) косвенно-регистровый.
Ассемблер: 1) INC А
Код |
|
0 0 0 0 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=(А)+1
Ассемблер: 2) INC Rn ;где n=0-7
Код |
|
0 0 0 0 |
1 r r r |
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (Rn):=(Rn)+1
Ассемблер: 3) INC <direct>
Код |
|
0 0 0 0 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (direct):=(direct)+1
Ассемблер: 4) INC @Ri ;где i=0,l
Код |
|
0 0 0 0 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: ((Ri)):=((Ri))+1
Примеры:
1) ;(A)=1FH, (АС)=0
INC А ;(А)=20Н, (АС)=0
2) ;(R4)=FFH, (С)=0, (АС)=0
INC R4 ;(R4)=00H, (С)=0, (АС)=0
3) ;(ОЗУ[43])=22Н
INC 43Н ;(ОЗУ[43])=23Н
4) ;(R1)=41H, (ОЗУ[41])=4FН, (АС)=0
INC @RI ;(R1)=41H, (ОЗУ[41])=50Н, (АС)=0
Примечание: При использовании команды INC для изменения содержимого порта величина, используемая как операнд, считывается из "защелки" порта, а не с выводов БИС.
Команда INC DPTR. Команда "инкремент указателя данных" выполняет инкремент (прибавление "1") содержимого 16-битового указателя данных (DPTR). Прибавление "1" осуществляется к 16 битам, причем переполнение младшего байта указателя данных (DPL) из FFH в 00Н приводит к инкременту старшего байта указателя данных (DPH). На флаги эта команда не влияет.
Ассемблер: INC DPTR
Код |
|
1 0 1 0 |
0 0 1 1 |
|
|
|
|
Время: 2 цикла
Алгоритм: (DPTR):=(DPTR)+1
Пример: ;(DPH)=12H, (DPL)=FEH
INC DPTR
INC DPTR
INC DPTR ;(DPH)=13H, (DPL)=01H
Команда JB <bit>,<rel8>. Команда "переход, если бит установлен" выполняет переход по адресу ветвления, если указанный бит равен" 1", в противном случае выполняется следующая команда. Адрес ветвления вычисляется с помощью прибавления относительного смещения со знаком в третьем байте команды (ге18) к содержимому счетчика команд после прибавления к нему 3. Проверяемый бит не изменяется. Эта команда на флаги не влияет.
Ассемблер: JB (bit),<метка>
Код |
|
0 0 1 0 |
0 0 0 0 |
|
bit address |
|
rel8 |
Время: 2 цикла
Алгоритм: (РС):=(РС)+3, если (bit)=l, то (PC):=(PC)+<rel8>
Пример: ;(А)=96Н (10010110В)
JB ACC.2,LAB5 ;эта команда обеспечивает переход на метку ;LAB5
. . . . . .
LAB5: INC А
Команда JBC <bit>,<rel8>. Команда "переход, если бит установлен и сброс этого бита", выполняет ветвление по вычисляемому адресу, если бит равен "1". В противном случае выполняется следующая за JBC команда. В любом случае указанный бит сбрасывается. Адрес перехода вычисляется сложением относительного смещения со знаком в третьем байте команды (rel8) и содержимого счетчика команд после прибавления к нему 3. Эта команда не влияет на флаги.
Ассемблер: JBC (bit),<метка>
Код |
|
0 0 0 1 |
0 0 0 0 |
|
bit address |
|
rel8 |
Время: 2 цикла
Алгоритм: (РС):=(РС)+3, если (bit)=1, то (bit):=0, (PC):=(PC)+<rel8>
Пример: ;(А)=76Н (0111 0110В)
JBC ACC.3,LAB6 ;Перехода на LAB6 нет, т.к. (A[3])=0
JBC ACC.2,LAB7 ;(А)=72Н (0111 0010В) и переход на адрес, ;соответствующий
;метке LAB7.
Примечание: Если эта команда используется для проверки бит порта, то значение, используемое как операнд, считывается из "защелки" порта, а не с вывода БИС.
Команда JC <rel8>. Команда "переход, если перенос установлен" выполняет ветвление по адресу, если флаг переноса равен "1", в противном случае выполняется следующая команда. Адрес ветвления вычисляется с помощью сложения относительного смещения со знаком во втором байте команды (ге18) и содержимого счетчика команд после прибавления к нему 2. Эта команда на флаги не влияет.
Ассемблер: JC <метка>
Код |
|
0 1 0 0 |
0 0 0 0 |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, если (С)=1, то (РС):=(РС)+<ге18>
Пример: ;(С)=0
JC LAB8 ;нет перехода на метку LAB8
CPL С ;(С):=1
LAB8: JC LAB9 ; переход на метку LAB9, т.к. (С)=1
. . . . . .
LAB9: NOP
Команда JMP @A+DPTR. Команда "косвенный переход" складывает 8-битовое содержимое аккумулятора без знака с 16-битовым указателем данных (DPTR) и загружает полученный результат в счетчик команд, содержимое которого является адресом для выборки следующей команды. 16-битовое сложение выполняется по модулю 216, перенос из младших восьми бит распространяется на старшие биты программного счетчика. Содержимое аккумулятора и указателя данных не изменяется. Эта команда на флаги не влияет.
Ассемблер: JMP @A+DPTR
Код |
|
0 1 1 1 |
0 0 1 1 |
|
|
|
|
Время: 2 цикла
Алгоритм: (PC):=(A)[7-0]+(DPTR) [15-0]
Пример: ;(РС)=034ЕН, (А)=86Н, (DPTR)=0329H
JMP @A+DPTR ;(PC)=03AFH, (А)=86Н, (DPTR)=0329H
Команда JNB <bit>,<rel8>. Команда "переход, если бит не установлен" выполняет ветвление по адресу, если указанный бит равен "нулю", в противном случае выполняется следующая команда. Адрес ветвления вычисляется с помощью сложения относительного смещения со знаком в третьем байте команды (rel8) и содержимого счетчика команд после прибавления к нему 3. Проверяемый бит не изменяется. Эта команда на флаги не влияет.
Ассемблер: JNB (bit),<метка>
Код |
|
0 0 1 1 |
0 0 0 0 |
|
bit address |
|
rel8 |
Время: 2 цикла
Алгоритм: (РС):=(РС)+3, если (bit)=0, то (РС):=(РС)+<ге18>
Пример: ;(Р2)=САН (11001010В), (A)=56H (0101 ;0110В)
JNB P1.3,LAB10 ;нет перехода на LAB10
JNB ACC.3,LAB11 ;переход на метку LAB11
. . . . . .
LAB11: INC А
Команда JNC <rel8>. Команда "переход, если перенос не установлен" выполняет ветвление по адресу, если флаг переноса равен нулю, в противном случае выполняется следующая команда. Адрес ветвления вычисляется с помощью сложения относительного смещения со знаком во втором байте команды (re18) и содержимого счетчика команд после прибавления к нему 2. Флаг переноса не изменяется. Эта команда на другие флаги не влияет.
Ассемблер: JNC <метка>
Код |
|
0 1 0 1 |
0 0 0 0 |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, если (С)=0, то (РС):=(РС)+<ге18>
Пример: ;(С)=1
JNC LAB12 ;нет перехода на LAB12
CPL С
LAB12: JNC LAB13 ;переход на метку LAB13
Команда JNZ <ге18>. Команда "переход, если содержимое аккумулятора не равно нулю" выполняет ветвление по адресу, если хотя бы один бит аккумулятора равен "1", в противном случае выполняется следующая команда. Адрес ветвления вычисляется сложением относительного смещения со знаком во втором байте команды (rel8) и содержимого счетчика команд (PC) после прибавления к нему 2. Содержимое аккумулятора не изменяется. Эта команда на флаги не влияет.
Ассемблер: JNZ <метка>
Код |
|
0 1 1 1 |
0 0 0 0 |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, если ((А)>0 или (A)<0), то (РС):=(РС)+<ге18>
Пример: ;(А)=00Н
JNC LAB14 ;нет перехода на LAB14
INC А
LAB14: JNZ LAB15 ;переход на метку LAB15
. . . . . .
LAB15: NОР
Команда JZ <ге18>. Команда "переход, если содержимое аккумулятора равно "0" выполняет ветвление по адресу, если все биты аккумулятора равны "0", в противном случае выполняется следующая команда. Адрес ветвления вычисляется сложением относительного смещения со знаком во втором байте команды (rel8) с содержимым счетчика команд после прибавления к нему 2. Содержимое аккумулятора не изменяется. Эта команда на флаги не влияет.
Ассемблер: JZ <метка>
Код |
|
0 1 1 0 |
0 0 0 0 |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, если (А)=0, то (РС):=(РС)+<ге18>
Пример: ;(А)=01Н
JZ LAB16 ;нет перехода на LAB16
DEC А
LAB16: JZ LAB17 ;переход на метку LAB17
. . . . . .
LAB17: CLR А
Команда LCALL <addrl6>. Команда "длинный вызов" вызывает подпрограмму, находящуюся по указанному адресу. По команде LCALL к счетчику команд (PC) прибавляется 3 для получения адреса следующей команды и после этого полученный 16-битовый результат помещается в стек (сначала следует младший байт, за ним - старший), а содержимое указателя стека (SP) увеличивается на 2. Затем старший и младший байты счетчика команд загружаются, соответственно, вторым и третьим байтами команды LCALL. Выполнение программы продолжается командой, находящейся по полученному адресу. Подпрограмма, следовательно, может начинаться в любом месте адресного пространства памяти программ объемом до 64 Кбайт. Эта команда на флаги не влияет.
Ассемблер: LCALL <метка>
Код |
|
0 0 0 1 |
0 0 1 0 |
|
addr[15-8] |
|
addr[7-0] |
Время: 2 цикла
Алгоритм: (РС):=(РС)+3, (SP):=(SP)+1, ((SP)):=(PC[7-0]),
(SP):=(SP)+1, ((SP)):=(РС[ 15-8]), (PC):=<addr[15-0]>
Пример: ;(SP)=07H, метке PRN соответствует адрес 1234H,
;по адресу 0126Н находится команда LCALL
LCALL PRN ;(SP)=09H, (РС)=1234Н, (ОЗУ[08])=26Н, ; (ОЗУ[09])=01Н
Команда LJMP <addr16>. Команда "длинный переход" выполняет безусловный переход по указанному адресу, загружая старший и младший байты счетчика команд (PC) соответственно вторым и третьим байтами, находящимися в коде команды. Адрес перехода, таким образом, может находиться по любому адресу пространства памяти программ в 64 Кбайт. Эта команда на флаги не влияет.
Ассемблер: LJMP <метка>
Код |
|
0 0 0 0 |
0 0 1 0 |
|
addr[15-8] |
|
addr[7-0] |
Время: 2 цикла
Алгоритм: (PC):=<addr[15-0]>
Команда MOV <байт-назначения>, <байт-источника>. Команда "переслать переменную-байт" пересылает переменную-байт, указанную во втором операнде, в ячейку, указанную в первом операнде. Содержимое байта источника не изменяется. Эта команда на флаги и другие регистры не влияет. Команда "MOV" допускает 15 комбинаций адресации байта-источника и байта-назначения:
Ассемблер: 1) MOV A,Rn ;где n=0-7
Код |
|
1 1 1 0 |
1 r r r |
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (A):=(Rn)
Ассемблер: 2) MOV A,<direct>
Код |
|
1 1 1 0 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (A):=(direct)
Ассемблер: 3) MOV A,@Ri ;где i=0,1
Код |
|
1 1 1 0 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=((Ri))
Ассемблер: 4) MOV A,#data
Код |
|
0 1 1 1 |
0 1 0 0 |
|
#data8 |
|
|
Время: 1 цикл
Алгоритм: (A):=<#data8>
Ассемблер: 5) MOV Rn,A ;где n=0-7
Код |
|
1 1 1 1 |
1 r r r |
|
|
|
|
где rrr=000-111
Время: 1 цикл
Алгоритм: (Rn):=(A)
Ассемблер: 6) MOV Rn,<direct> ;где n=0-7
Код |
|
1 0 1 0 |
1 r r r |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: (Rn):=(direct)
Ассемблер: 7) MOV Rn,#data ;где n=0-7
Код |
|
0 1 1 1 |
1 r r r |
|
#data8 |
|
|
Время: 1 цикл
Алгоритм: (Rn):=<#data8>
Ассемблер: 8) MOV <direct>,A
Код |
|
1 1 1 1 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (direct):=(A)
Ассемблер: 9) MOV <direct>,Rn ;где n=0-7
Код |
|
1 0 0 0 |
1 r r r |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: (direct):=(Rn)
Ассемблер: 10) MOV <direct>,<direct>
Код |
|
1 0 0 0 |
0 1 0 1 |
|
direct address |
|
direct address |
Время: 2 цикла
Алгоритм: (direct):=(direct)
Ассемблер: 11) MOV <direct>,@Ri ;где i=0,l
Код |
|
1 0 0 0 |
0 1 1 i |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: (direct):=((Ri))
Ассемблер: 12) MOV <direct>,#data
Код |
|
0 1 1 1 |
0 1 0 1 |
|
direct address |
|
#data8 |
Время: 2 цикла
Алгоритм: (direct):=<#data8>
Ассемблер: 13) MOV @Ri,A ;где i=0,l
Код |
|
1 1 1 1 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: ((Ri)):=(A)
Ассемблер: 14) MOV @Ri,<direct> ;где i=0,l
Код |
|
1 0 1 0 |
0 1 1 i |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: ((Ri)):=(direct)
Ассемблер: 15) MOV @Ri,#data ;где i=0,l
Код |
|
0 1 1 1 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: ((Ri)):=<#data8>
Примеры:
1) ;(A)=FAH, (R4)=93H
MOV A,R4 ;(A)=93H, (R4)=93H
2) ;(A)=93H, (ОЗУ[40])=10Н, (R0)=40H
MOV A,40H ;(A)=10H, (ОЗУ[40])=10Н, (R0)=40H
3) ;(А)=10Н, (R0)=41H, (ОЗУ[41])=0САН
MOV A,@R0 ;(A)=CAH, (R0)=41H, (ОЗУ[41])=0САН
4) ;(A)=C9H (11001001В)
MOV A,#37H ;(A)=37H (00110111В)
5) ;(А)=38Н, (R0)=42H
MOV R0,A ;(А)=38Н, (R0)=38H
6) ;(R0)=39H, (P2)=0F2H
MOV R0,P2 ;(R0)=F2H
7) ;(R0)=0F5H
MOV R0,#49H ;(R0)=49H
8) ;(P0)=FFH, (A)=4BH
MOV P0,A ;(P0)=4BH, (A)=4BH
9) ;(PSW)=C2H, (R7)=57H
MOV PSW,R7 ;(PSW)=57H, (R7)=57H
10) ;(ОЗУ[45])=ЗЗН, (03У[48])=0DEH
MOV 48H,45H ;(ОЗУ[45])=ЗЗН, (ОЗУ[48])=ЗЗН
11) ;(R1)=49H, (ОЗУ[49])=0ЕЗН
MOV 51H,@R1 ;(ОЗУ[51])=0ЕЗН, (ОЗУ[49])=0ЕЗН
12) ;(ОЗУ[5F])=9ВН
MOV 5FH,#07H ;(ОЗУ[5F])=07Н
13) ;(R1)=48H, (ОЗУ[48])=75Н, (A)=0BDH
MOV @R1,A ;(ОЗУ[48])=0ВDН
14) ;(R0)=51H, (ОЗУ[51])=0ЕЗН, (Р0)=0АСН
MOV @R0,P0 ;(ОЗУ[51])=0АСН
15) ;(ОЗУ[7Е])=67Н, (R1)=7EH
MOV @R1,#0А9Н;(ОЗУ[7Е])=0А9Н, (Р1)=7ЕН
Команда MOV <бит назначения>, <бит источника>. Команда "переслать бит данных" битовую переменную, указанную во втором байте, копирует в разряд, который указан в первом операнде. Одним из операндов должен быть флаг переноса С, а другим может быть любой бит, к которому возможна прямая адресация.
Ассемблер: 1) MOV C,<bit>
Код |
|
1 0 1 0 |
0 0 1 0 |
|
bit address |
|
|
Время: 2 цикла
Алгоритм: (C):=(bit)
Ассемблер: MOV <bit>,C
Код |
|
1 0 0 1 |
0 0 1 0 |
|
bit address |
|
|
Время: 2 цикла
Алгоритм: (bit):=(C)
Примеры:
1) ;(С)=0, (P3)=D5H (11010101В)
MOV C,P3.0 ;C:=1
MOV C,P3.3 ;C:=0
MOV C,P3.7 ;C:=1
2) ;(С)=1, (Р0)=20Н (00100000В)
MOV Р0.1,С
MOV Р0.2,С
MOV Р0.3,С ;(С)=1, (Р0)=2ЕН (00101110В)
Команда MOV DPTR,#datal6. Команда "загрузить указатель данных 16-битовой константой" загружает указатель данных DPTR 16-битовой константой, указанной во втором и третьем байтах команды. Второй байт команды загружается в старший байт указателя данных (DPH), а третий байт - в младший байт указателя данных (DPL). Эта команда на флаги не влияет и является единственной командой, которая одновременно загружает 16 бит данных.
Ассемблер: MOV DPTR,#<data16>
Код |
|
1 0 0 1 |
0 0 0 0 |
|
#data[15-8] |
|
#data[7-0] |
Время: 2 цикла
Алгоритм: (DPTR):=#data[15-0], причем DPH:=#data[15-8], DPL:=#data[7-0]
Пример: ;(DPTR)=01FDH
MOV DPTR,#1234H ;(DPTR)=1234H, (DPH)=12H, (DPL)=34H
Команда MOVC A,@A+(<R16>). <R16> - 16-разрядный регистр. Команда "переслать байт из памяти программ" загружает аккумулятор байтом кода или константой из памяти программы. Адрес считываемого байта вычисляется как сумма 8-битового исходного содержимого аккумулятора без знака и содержимого 16-битового регистра. В качестве 16-битового регистра может быть:
1) указатель данных DPTR;
2) счетчик команд PC.
В случае, когда используется PC, он увеличивается до адреса следующей команды перед тем, как его содержимое складывается с содержимым аккумулятора. 16-битовое сложение выполняется так, что перенос из младших восьми бит может распространяться через старшие биты. Эта команда на флаги не влияет.
Ассемблер: 1) MOVC A,@A+DPTR
Код |
|
1 0 0 1 |
0 0 1 1 |
|
|
|
|
Время: 2 цикла
Алгоритм: (A):=((A)+(DPTR))
Ассемблер: 2) MOVC А,@А+РС
Код |
|
1 0 0 0 |
0 0 1 1 |
|
|
|
|
Время: 2 цикла
Алгоритм: (А):=((А)+(РC))
Примеры:
1) ;(А)=1ВН, (DPTR)=1020H, ; (ПЗУ[103В])=48Н,
MOVC A,@A+DPTR ;(А)=48Н, (DPTR)=1020H
2) ;(A)=FAH, (РС)=0289, ; (ПЗУ[0384])=9ВН
MOVC А,@А+РС ;(А)=9ВН, (РС)=028АН
Команда MOVX <байт приемника>,<байт источника>. Команда "переслать во внешнюю память (из внешней памяти) данных" пересылает данные между аккумулятором и байтом внешней памяти данных. Имеется два типа команд, которые отличаются тем, что обеспечивают 8-битовый или 16-битовый косвенный адрес к внешнему ОЗУ данных.
В первом случае содержимое R0 или R1 в текущем банке регистров обеспечивает 8-битовый адрес, который мультиплексируется с данными порта Р0. Для расширения дешифрации ввода-вывода или адресации небольшого массива ОЗУ достаточно восьми бит адресации. Если применяются ОЗУ, немного больше чем 256 байт, то для фиксации старших битов адреса можно использовать любые другие выходы портов, которые переключаются командой, стоящей перед командой MOVX.
Во втором случае при выполнении команды MOVX указатель данных DPTR генерирует 16-битовый адрес. Порт Р2 выводит старшие восемь бит адреса (DPH), а порт Р0 мультиплексирует младшие 8 бит адреса (DPL) с данными. Эта форма является эффективной при доступе к большим массивам данных (до 64К байт), так как для установки портов вывода не требуется дополнительных команд.
Ассемблер: 1) MOVX A,@Ri ;где i=0,l
Код |
|
1 1 1 0 |
0 0 1 i |
|
|
|
|
Время: 2 цикла
Алгоритм: (A):=((Ri))
Ассемблер: 2) MOVX A,@DPTR
Код |
|
1 1 1 0 |
0 0 0 0 |
|
|
|
|
Время: 2 цикла
Алгоритм: (А):=((DPTR))
Ассемблер: 3) MOVX @Ri,A ;где i=0,l
Код |
|
1 1 1 1 |
0 0 1 i |
|
|
|
|
Время: 2 цикла
Алгоритм: ((Ri)):=(A)
Ассемблер: 4) MOVX @DPTR,А
Код |
|
1 1 1 1 |
0 0 0 0 |
|
|
|
|
Время: 2 цикла
Алгоритм: ((DPTR)):=(A)
Примеры:
1) ;(А)=32Н, (R0)=83H, ячейка внешнего ОЗУ ;по адресу 83Н
;содержит В6Н
MOVX A,@R0 ;(А)=В6Н, (R0)=83H
2) ;(А)=5СН, (DPTR)=1ABEH, ячейка ;внешнего ОЗУ по адресу
;1АВЕН содержит 72Н
MOVX А,@DPTR ;(А)=72Н, (DPTR)=2ABEH
3) ;(А)=95Н, (R1)=FDH, ячейка внешнего ОЗУ ;с адресом FDH
;содержит 00
MOVX @R1,A ;(А)=95Н, (R1)=FDH, ячейка внешнего ОЗУ ;с адресом FDH
;содержит 95Н
4) ;(А)=97Н, (DPTR)=1FFFH, ячейка внешнего ;ОЗУ с адресом 1FFFH
;содержит 00
MOVX @DPTR,A ;(А)=97Н, ячейка внешнего ОЗУ с адресом ;1FFFH содержит 97Н
Команда MUL АВ. Команда "умножение" умножает 8-битовые целые числа без знака из аккумулятора и регистра В. Старший байт 16-битового произведения помещается в регистр В, а младший - в аккумулятор А. Если результат произведения больше, чем 0FFH (255), то устанавливается флаг переполнения (OV), в противном случае он сбрасывается. Флаг переноса всегда сбрасывается.
Ассемблер: MUL АВ
Код |
|
1 0 1 0 |
0 1 0 0 |
|
|
|
|
Время: 4 цикла
Алгоритм: (А)[7-0]=(А)*(В), (В)[15-8]=(А)*(В)
Примеры:
1) ;(А)=50Н (50Н=80 DEC), (С=1), (В)=0А0Н ; (А0Н=160 DEC), (OV)=0
MUL АВ ;(А)=00Н, (В)=32Н, (С)=0, (OV)=1
2) ;(A)=2HH, (OV)=1, (B)=06H, (C)=l
MUL АВ ;(A)=0D8H, (B)=00H, (OV)=0, (C)=0
Команда NOP. Команда "нет операции" выполняет холостой ход и не влияет на регистры и флаги, кроме как на счетчик команд (PC).
Ассемблер: NOP
Код |
|
0 0 0 0 |
0 0 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (РС):=(РС)+1
Пример: Пусть требуется создать отрицательный выходной импульс на порте Р1[6] длительностью 3 цикла. Это выполнит следующая последовательность команд:
CLR Р1.6 ;Р1[6]:=0
NOP
NOP
NOP
SETB Р1.6 ;Р1[6]:=1
Команда ORL <байт назначения>,<байт источника>. Команда "логическое "ИЛИ" для переменных-байтов" выполняет операцию логического "ИЛИ" над битами указанных переменных, записывая результат в байт назначения. Эта команда на флаги не влияет. Допускается шесть комбинаций режимов адресации:
если байтом назначения является аккумулятор:
1) регистровый;
2) прямой;
3) косвенно-регистровый;
4) непосредственный;
если байтом назначения является прямой адрес:
5) к аккумулятору
6) к константе
Ассемблер: 1) ORL A,Rn ;где n=0-7
Код |
|
0 1 0 0 |
1 r r r |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=(А) OR (Rn), где OR - операция логического "ИЛИ"
Ассемблер: 2) ORL A,<direct>
Код |
|
0 1 0 0 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (А):=(А) OR (direct)
Ассемблер: 3) ORL A,@Ri ;где i=0,1
Код |
|
0 1 0 0 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=(А) OR ((Ri))
Ассемблер: 4) ORL A,#<data>
Код |
|
0 1 0 0 |
0 1 0 0 |
|
#data8 |
|
|
Время: 1 цикл
Алгоритм: (А):=(А) OR #<data>
Ассемблер: 5) ORL (direct),A
Код |
|
0 1 0 0 |
0 0 1 0 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (direct):=(direct) OR (A)
Ассемблер: 6) ORL (direct),#<data>
Код |
|
0 1 0 0 |
0 0 1 1 |
|
direct address |
|
#data8 |
Время: 2 цикла
Алгоритм: (direct):=(direct) OR#<data>
Примеры:
1) ;(А)=15Н, (R5)=6CH
ORL A,R5 ;(A)=7DH, (R5)=6CH
2) ;(A)=84H, (PSW)=C2H
ORL A,PSW ;(A)=C6H, (PSW)=C2H
3) ;(A)=52H, (R0)=6DH, (ОЗУ[6D])=49Н
ORL A,@R0 ;(A)=5BH, (ОЗУ[6D])=49Н
4) ;(A)=F0H
ORL A,#0AH ;(A)=FAH
5) ;(A)=34H, (IP)=23H
ORL IP,A ;(IP)=37H, (A)=34H
6) ;(P1)=00H
ORL P1,#0C4H ;(Р1)=11000100В (С4Н)
Примечание: Если команда используется для работы с портом, величина, используемая в качестве исходных данных порта, считывается из "защелки" порта, а не с выводов БИС.
Команда ORL С, <бит источника>. Команда "логическое "ИЛИ" для переменных-битов" устанавливает флаг переноса С, если булева величина равна логической "1", в противном случае устанавливает флаг С в "0". Косая дробь ("/") перед операндом на языке ассемблера указывает на то, что в качестве операнда используется логическое отрицание значения адресуемого бита, но сам бит источника не изменяется. Эта команда на другие флаги не влияет.
Ассемблер: 1) ORL C,<bit>
Код |
|
0 1 1 1 |
0 0 1 0 |
|
bit address |
|
|
Время: 2 цикла
Алгоритм: (С):=(С) OR (bit)
Ассемблер: 2) ORL C,/<bit>
Код |
|
1 0 1 0 |
0 0 0 0 |
|
bit address |
|
|
Время: 2 цикла
Алгоритм: (С):=(С) OR /(bit)
Примеры:
1) ;(С)=0, (Р1)=53Н (01010011В)
ORL С,Р1.4 ;(С)==1, (Р1)=53Н (01010011В)
2) ;(С)=0, (ОЗУ[25])=39Н (00111001В)
ORL С,/2А ;(С)=1, (ОЗУ[25])=39Н (00111001В)
Команда POP <direct>. Команда "чтение из стека" считывает содержимое ячейки, которая адресуется с помощью указателя стека, в прямо адресуемую ячейку ОЗУ, при этом указатель стека уменьшается на единицу. Эта команда не воздействует на флаги и часто используется для чтения из стека промежуточных данных.
Ассемблер: POP <direct>
Код |
|
1 1 0 1 |
0 0 0 0 |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: (direct):=((SP)), (SP):=(SP)-1
Пример: ;(SP)=32H, (DPH)=01, (DPL)=ABH, ; (ОЗУ[32])=12Н,(ОЗУ[31])=56Н,
;(ОЗУ[30])=20Н
POP DPH
POP DPL ;(SP)=30H, (DPH)=12H, (DPL)=56H, ; (ОЗУ[32])=12Н, (ОЗУ[31])=56Н
POP SP ;(SP)=20H, (ОЗУ[30])=20Н
Команда PUSH <direct>. Команда "запись в стек" увеличивает указатель стека на единицу и после этого содержимое указанной прямо адресуемой переменной копируется в ячейку внутреннего ОЗУ, адресуемого с помощью указателя стека. На флаги эта команда не влияет и используется для записи промежуточных данных в стек.
Ассемблер: PUSH <direct>
Код |
|
1 1 0 0 |
0 0 0 0 |
|
direct address |
|
|
Время: 2 цикла
Алгоритм: (SP):=(SP)+1, ((SP)):=(direct)
Пример: ;(SP)=09H, (DPTR)=1279H
PUSH DPL
PUSH DPH ;(SP)=0BH, (DPTR)=1279H, (ОЗУ[0А])=79Н, ; (ОЗУ[0В])=12Н
Команда RET. Команда "возврат из подпрограммы" последовательно выгружает старший и младший байты счетчика команд из стека, уменьшая указатель стека на 2. Выполнение основной программы обычно продолжается по адресу команды, следующей за ACALL или LCALL. На флаги эта команда не влияет.
Ассемблер: RET
Код |
|
0 0 1 0 |
0 0 1 0 |
|
|
|
|
Время: 2 цикла
Алгоритм: (PC)[15-8]:=((SP)), (SP):=(SP)-1, (PC)[7-0]:=((SP)), (SP):=(SP)-1
Пример: ;(SP)=0DH, (ОЗУ[0С])=93Н, (OЗУ[0D])=02H
RET ;(SP)=0BH, (PC)=0293H
Команда RETI. Команда "возврат из прерывания" выгружает старший и младший байты счетчика команд из стека и устанавливает "логику прерываний", разрешая прием других прерываний с уровнем приоритета, равным уровню приоритета только что обработанного прерывания. Указатель стека уменьшается на 2. Слово состояния программы (PSW) не восстанавливается автоматически. Выполнение основной программы продолжается с команды, следующей за командой, на которой произошел переход к обнаружению запроса на прерывание. Если при выполнении команды RETI обнаружено прерывание с таким же или меньшим уровнем приоритета, то одна команда основной программы успевает выполниться до обработки такого прерывания.
Ассемблер: RETI
Код |
|
0 0 1 1 |
0 0 1 0 |
|
|
|
|
Время: 2 цикла
Алгоритм: (PC)[15-8]:=((SP)), (SP):=(SP)-1, (PC)[7-0]:=((SP)), (SP):=(SP)-1
Пример: ;(SP)=0BH, (ОЗУ[0А]).=2АН, (OЗУ[0B])=03H,
;(РС)=YYYYН, где Y=0-FH
RETI ;(SP)=09H, (PC)=032AH
Команда RL A. Команда "сдвиг содержимого аккумулятора влево", сдвигает восемь бит аккумулятора на один бит влево, бит 7 засылается на место бита 0. На флаги эта команда не влияет.
Ассемблер: RL А
Код |
|
0 0 1 0 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[N+1]):=(A[N]), где N=0-6
(A[0]):=(A[7])
Пример: ;(A)=0D5H (11010101В), (С)=0
RL А ;(А)=0АВН (10101011В), (С)=0
Команда RLC А. Команда "сдвиг содержимого аккумулятора влево через флаг переноса" сдвигает восемь бит аккумулятора и флаг переноса влево на один бит. Содержимое флага переноса помещается на место бита 0 аккумулятора, а содержимое бита 7 аккумулятора переписывается в флаг переноса. На другие флаги эта команда не влияет.
Ассемблер: RLC А
Код |
|
0 0 1 1 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[N+1]):=(A[N]), где N=0-6
(A[0]):=(C), (C):=(A[7])
Пример: ;(А)=56Н (01010110В), (С)=1
RLC A ;(A)=0ADH (10101101В), (С)=0
Команда RR А. Команда "сдвиг содержимого аккумулятора вправо" сдвигает вправо на один бит все восемь бит аккумулятора. Содержимое бита 0 помещается на место бита 7. На флаги эта команда не влияет.
Ассемблер: RR А
Код |
|
0 0 0 0 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[N]):=(A[N+1]), где N=0-6
(А[7]):=(А[0])
Пример: ;(A)=0D6H (11010110В), (С)=1
RR A ;(A)=6BH (01101011B), (C)=l
Команда RRC A. Команда "сдвиг содержимого аккумулятора вправо через флаг переноса" сдвигает восемь бит аккумулятора и флаг переноса на один бит вправо. Бит 0 перемещается в флаг переноса, а исходное содержимое флага переноса помещается в бит 7. На другие флаги эта команда не влияет.
Ассемблер: RRC А
Код |
|
0 0 0 1 |
0 0 1 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[N]):=(A[N+1]), где N=0-6
(А[7]):=(С), (С):=(А[0])
Пример: ;(А)=95Н (10010101В), (С)=0
RRC А ;(А)=4АН (01001010В), (С)=1
Команда SETB <бит>. Команда "установить бит" устанавливает указанный бит в "1". Адресуется:
1) к флагу переноса (С);
2) к биту с прямой адресацией.
Ассемблер: 1) SETB С
Код |
|
1 1 0 1 |
0 0 1 1 |
|
|
|
|
Время: 1 цикл
Алгоритм: (С):=1
Ассемблер: 2) SETB <bit>
Код |
|
0 0 0 1 |
0 1 0 0 |
|
bit address |
|
|
Время: 1 цикл
Алгоритм: (bit):=1
Примеры:
1) ;(С)=0
SETB С ;(С)=1
2) ;(Р2)=38Н (00111000В)
SETB Р2.0
SETB Р2.7 ;(Р2)=В9Н (10111001В)
Команда SJMP <метка>. Команда "короткий переход" выполняет безусловное ветвление в программе по указанному адресу. Адрес ветвления вычисляется сложением смещения со знаком во втором байте команды с содержимым счетчика команд после прибавления к нему 2. Таким образом, адрес перехода должен находиться в диапазоне от 128 байт, предшествующих команде, до 127 байт, следующих за ней.
Ассемблер: SJMP <метка>
Код |
|
1 0 0 0 |
0 0 0 0 |
|
rel8 |
|
|
Время: 2 цикла
Алгоритм: (РС):=(РС)+2, (РС):=(РС)+(ге18)
Пример: ;(РС)=0418Н, метка МЕТ1 соответствует адресу ;039АН
SJMP МЕТ1 ;(РС)-039АН, где (rel8)=80H= -128 DEC
SJMP МЕТ2 ;(РС)=041АН, где метка МЕТ2 соответствует ;адресу 041АН,
;(rel8)=7DH= +125 DEC
Команда SUBB А,<байт источника>. Команда "вычитание с заемом" вычитает указанную переменную вместе с флагом переноса из содержимого аккумулятора, засылая результат в аккумулятор. Эта команда устанавливает флаг переноса (заема), если при вычитании для бита 7 необходим заем, в противном случае флаг переноса сбрасывается. Если флаг переноса установлен перед выполнением этой команды, то это указывает на то, что заем необходим при вычитании с увеличенной точностью на предыдущем шаге, поэтому флаг переноса вычитается из содержимого аккумулятора вместе с операндом источника. (АС) устанавливается, если заем необходим для бита 3 и сбрасывается в противном случае. Флаг переполнения (0V) устанавливается, если заем необходим для бита 6, но его нет для бита 7, или есть для бита 7, но нет для бита 6.
При вычитании целых чисел со знаком (0V) указывает на отрицательное число, которое получается при вычитании отрицательной величины из положительной, или положительной число, которое получается при вычитании положительного числа из отрицательного. Операнд источника допускает четыре режима адресации:
1) регистровый;
2) прямой;
3) косвенно-регистровый;
4) непосредственный (к константе).
Ассемблер: 1) SUBB A.Rn ;где n=0-7
Код |
|
1 0 0 1 |
1 r r r |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)-(C)-(Rn); (С):=Х, (AC):=X, (OV):=X, где X=(0 или 1)
Ассемблер: 2) SUBB A,<direct>
Код |
|
1 0 0 1 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (A):=(A)-(C)-(direct); (C):=X, (AC):=X, (OV):=X, где Х=(0 или 1)
Ассемблер: 3) SUBB A,@Ri ;где i=0,l
Код |
|
1 0 0 1 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A)-(C)-((Ri)); (C):=X, (AC):=X, (OV):=X, где X=(0 или 1)
Ассемблер: 4) SUBB A,#data
Код |
|
1 0 0 1 |
0 1 0 0 |
|
#data8 |
|
|
Время: 1 цикл
Алгоритм: (A):=(A)-(C)-(#data8); (C):=X, (AC):=X, (OV):=X, где Х=(0 или 1)
Примеры:
1) ;(А)=С9Н, (R2)=54H, (C)=l
SUBB A,R2 ;(A)=74H, (R2)=54H, (C)==0, (AC)=0, (OV)=1
2) ;(A)=97H, (B)=25H, (C)=0
SUBB А,В ;(A)=72H, (B)=25H, (C)=0, (AC)=0, (OV)=1
3) ;(A)=49H, (C)=l, (R0)=33H, (ОЗУ[33])=68Н
SUBB A,@R0 ;(A)=E0H, (C)=l, (AC)=0, (OV)=0
4) ;(А)=0ВЕН, (C)=0
SUBB A,#3FH ;(A)=7FH, (C)=0, (AC)=1, (OV)=1
Команда SWAP A. Команда "обмен тетрадами внутри аккумулятора" осуществляет обмен между младшими четырьмя и старшими четырьмя битами аккумулятора (между старшей и младшей тетрадами).Эта команда может рассматриваться так же, как команда четырехбитового циклического сдвига. На флаги эта команда не влияет.
Ассемблер: SWAP А
Код |
|
1 1 0 0 |
0 1 0 0 |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[3-0]):=(A[7-4]), (A[7-4]):=(A[3-0])
Пример: ;(A)=0D7H (11010111В)
SWAP A ;(A)=7DH (01111101B)
Команда XCH А,<байт>. Команда "обмен содержимого аккумулятора с переменной-байтом" осуществляет обмен содержимого аккумулятора с содержимым источника, указанным в команде. Операнд источника может использовать следующие режимы адресации:
1) регистровый;
2) прямой;
3) косвенно-регистровый.
Ассемблер: 1) XCH A,Rn ;где n=0-7
Код |
|
1 1 0 0 |
1 r r r |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(Rn), (Rn):=(A)
Ассемблер: 2) XCH A,<direct>
Код |
|
1 1 0 0 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (A):=(direct), (direct):=(A)
Ассемблер: 3) XCH A,@Ri, где i=0,1
Код |
|
1 1 0 0 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=((Ri)), ((Ri)):=(A)
1) ;(А)=3CН, (R4)=15H
XCH A,R4 ;(A)=15H, (R4)=3CH
2) ;(A)=0FEH, (P3)=0DAH
XCH A,P3 ;(A)=0DAH, (P3)=0FEH
3) ;(R1)=39H, (ОЗУ[39])=44Н, (А)=0ВСН
XCH A,@R1 ;(ОЗУ[39])=0ВСН, (А)=44Н
Команда ХCНD А,@Ri. Команда "обмен тетрадой" выполняет обмен младшей тетрады (биты 3 - 0) аккумулятора с содержимым младшей тетрады (биты 3 - 0) ячейки внутреннего ОЗУ, косвенная адресация к которой производится с помощью указанного регистра. На старшие биты (биты 7 - 4) и на флаги эта команда не влияет.
Ассемблер: XCHD A,@Ri ;где i=0,l
Код |
|
1 1 0 1 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (A[3-0]):=((Ri[3-0])), ((Ri[3-0]))=(A[3-0])
Пример: ;(R0)=55H, (А)=89Н, (0ЗУ[55])=0A2H
XCHD A,@R0 ;(A)=82H, (ОЗУ[55])=0А9Н
Команда XRL <байт назначения>, <байт источника>. Команда "логическое "ИСКЛЮЧАЮЩЕЕ ИЛИ" для переменных-байтов" выполняет операцию "ИСКЛЮЧАЮЩЕЕ ИЛИ" над битами указанных переменных, записывая результат в байт назначения. На флаги эта команда не влияет. Допускается шесть режимов адресации:
байтом назначения является аккумулятор:
1) регистровый;
2) прямой;
3) косвенно-регистровый;
4) непосредственный;
байтом назначения является прямой адрес:
5) к аккумулятору;
6) к константе.
Ассемблер: 1) XRL A,Rn ;где n=0-7
Код |
|
0 1 1 0 |
1 r r r |
|
|
|
|
Время: 1 цикл
Алгоритм: (А):=(А) XOR (Rn)
Ассемблер: 2) XRL A,<direct>
Код |
|
0 1 1 0 |
0 1 0 1 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (A):=(A) XOR (direct)
Ассемблер: 3) XRL A,@Ri ;где i=0,1
Код |
|
0 1 1 0 |
0 1 1 i |
|
|
|
|
Время: 1 цикл
Алгоритм: (A):=(A) XOR ((Ri))
Ассемблер: 4) XRL A,#data
Код |
|
0 1 1 0 |
0 1 0 0 |
|
#data8 |
|
|
Время: 1 цикл
Алгоритм: (A):=(A) XOR <data>
Ассемблер: 5) XRL <direct>,A
Код |
|
0 1 1 0 |
0 0 1 0 |
|
direct address |
|
|
Время: 1 цикл
Алгоритм: (direct):=(direct) XOR (A)
Ассемблер: 6) XRL <direct>,#data
Код |
|
0 1 1 0 |
0 0 1 1 |
|
direct address |
|
#data8 |
Время: 2 цикла
Алгоритм: (direct):=(direct) XOR #data
Примеры:
1) ;(A)=C3H, (R6)=AAH
XRL A,R6 ;(A)=69H, (R6)=AAH
2) ;(A)=0FH, (P1)=A6H
XRL A,P1 ;(A)=A9H, (P1)=A6H
3) ;(A)=55H, R1=77H, (03У[77])=5AH
XRL A,@R1 ;(A)=0FH, (ОЗУ[77])=5АН
4) ;(A)=0C3H
XRL A,#0F5H ;(A)=36H
5) :(A)=31H, (P1)=82H
XRL P1,A ;(A)=31H, (P1)=B3H
6) ;(IP)=65H
XRL IP,#65H ;(IР)=00Н
Примечание: Если эта команда используется для работы с портами, то значение, используемое в качестве операнда, считывается из "защелки" порта, а не с выводов БИС.