Вариант 8. В рпд, начиная с адреса 30h находится массив из 20 элементов. Подсчитать количество элементов массива, попавших в интервал от 50 до 100. Результат запомнить в регистре r5.

ORG 0 ; Установка начального адреса

MOV R5, #0 ; Инициализация счетчика в регистре R5

MOV R0, #30h ; Загрузка начального адреса массива в регистр R0

MOV R1, #20 ; Загрузка количества элементов массива в регистр R1

MOV R2, #50 ; Загрузка нижней границы интервала в аккумулятор A

LOOP:

MOV B, R2 ; Загрузка текущего элемента массива в регистр B

CJNE A, B, NOT_FOUND ; Сравнение элемента с нижней границей интервала

INC R5 ; Увеличение счетчика, если элемент попадает в интервал

NOT_FOUND:

INC R0 ; Увеличение указателя на следующий элемент массива

DJNZ R1, LOOP ; Повторение цикла, пока не обработаны все элементы

EXIT:

SJMP EXIT ; Бесконечный цикл для завершения программы

END ; Конец программы

Вариант 9. В рпд, начиная с адреса 30н, находится массив из 16 чисел. Найти максимальный элемент массива и поместить в r2 его значение, а в r3 его адрес.

ORG 0 ; Установка начального адреса

MOV R2, #0 ; Инициализация регистра R2 для хранения максимального элемента

MOV R0, #30h ; Загрузка начального адреса массива в регистр R0

MOV R1, #16 ; Загрузка количества элементов массива в регистр R1

LOOP:

MOV A, @R0 ; Загрузка текущего элемента массива в аккумулятор A

SUBB A, R2 ; Сравнение текущего элемента с максимальным элементом

JC NEXT ; Переход к следующему элементу, если текущий элемент меньше R2

MOV R2, A ; Загрузка нового максимального элемента в R2

NEXT:

INC R0 ; Увеличение указателя на следующий элемент массива

DJNZ R1, LOOP ; Повторение цикла, пока не обработаны все элементы

EXIT:

SJMP EXIT ; Бесконечный цикл для завершения программы

END ; Конец программы

Вариант 10. В регистре r5 находится двоично-десятичный операнд. Перевести операнд в шестнадцатеричное значение и поместить в r5

ORG 0 ; Установка начального адреса

MOV A, R5 ; Загрузка двоично-десятичного операнда в аккумулятор A

MOV R4, A ; Сохранение значения операнда в регистре R4

MOV A, #0Ah ; Загрузка числа 10 в аккумулятор A

DIV AB ; Деление значения в A на значение в B

MOV R5, A ; Сохранение частного (шестнадцатеричной цифры) в регистре R5

MOV A, B ; Загрузка остатка от деления в аккумулятор A

SWAP A ; Перестановка полубайтов аккумулятора A

MOV R6, A ; Сохранение старшего полубайта в регистре R6

MOV A, R4 ; Восстановление значения операнда в аккумулятор A

ANL A, #0Fh ; Маскирование старшего полубайта операнда

MOV R5, A ; Сохранение младшего полубайта (первой шестнадцатеричной цифры) в регистре R5

ANL A, #0Fh ; Очистка старшего полубайта операнда

ORL A, R6 ; Склеивание старшего полубайта операнда с аккумулятором A

MOV R4, A ; Сохранение результата в регистре R4 (шестнадцатеричное значение)

EXIT:

SJMP EXIT ; Бесконечный цикл для завершения программы

END ; Конец программы

$MOD51

ORG 0H ; начальный адрес программы

MOV R5, #25H ; пример BCD числа (для ввода своего числа замените 25H на нужное BCD значение)

MOV A, R5 ; скопируем значение из R5 в аккумулятор для удобства работы

ANL A, #0F0H ; маскируем младшие биты чтобы получить старшие BCD цифры

SWAP A ; меняем местами старшие и младшие 4 бита

MOV B, A ; сохраняем старшую BCD цифру в регистр B

MOV A, R5 ; снова помещаем значение R5 в аккумулятор

ANL A, #00FH ; маскируем старшие биты, чтобы получить младшие BCD цифры

ADD A, B ; складываем старшую и младшую BCD цифры - получаем шестнадцатеричное значение

MOV R5, A ; сохраняем результат обратно в R5

SJMP $ ; бесконечный цикл

END ; конец программы

Вариант 11. В РПД, начиная с адреса 20h, находится массив из 16 элементов. Подсчитать и сохранить в регистрах: R2 – количество элементов массива, меньших значения 128; R3 – количество элементов массива, равных 128; R4 – количество элементов массива, больших 128.

ORG 0 ; Установка начального адреса

MOV R2, #0 ; Инициализация регистра R2 для хранения количества элементов меньше 128

MOV R3, #0 ; Инициализация регистра R3 для хранения количества элементов равных 128

MOV R4, #0 ; Инициализация регистра R4 для хранения количества элементов больше 128

MOV R0, #20h ; Загрузка начального адреса массива в регистр R0

MOV R1, #16 ; Загрузка количества элементов массива в регистр R1

LOOP:

MOV A, @R0 ; Загрузка текущего элемента массива в аккумулятор A

CJNE A, #128, CHECK_LESS ; Сравнение текущего элемента с 128

INC R3 ; Увеличение счетчика элементов равных 128

SJMP NEXT ; Переход к следующему элементу

CHECK_LESS:

JB ACC.7, INCREMENT_R4 ; Проверка старшего бита текущего элемента

INC R2 ; Увеличение счетчика элементов меньше 128

SJMP NEXT ; Переход к следующему элементу

INCREMENT_R4:

INC R4 ; Увеличение счетчика элементов больше 128

NEXT:

INC R0 ; Увеличение указателя на следующий элемент массива

DJNZ R1, LOOP ; Повторение цикла, пока не обработаны все элементы

EXIT:

SJMP EXIT ; Бесконечный цикл для завершения программы

END ; Конец программы

$MOD51

ORG 0H ; начальный адрес программы

; Инициализация регистров

MOV R0, #20H ; адрес начала массива во внутреннем ОЗУ

MOV R2, #0 ; счётчик элементов меньше 128

MOV R3, #0 ; счётчик элементов равных 128

MOV R4, #0 ; счётчик элементов больше 128

MOV R7, #0 ; индекс текущего элемента массива

; Цикл перебора массива

LOOP:

MOV A, @R0 ; перемещаем текущий элемент массива в аккумулятор

INC R0 ; переходим к следующему адресу

CJNE A, #128, NOT_EQUAL ; сравниваем элемент с 128

INC R3 ; инкремент, если элемент равен 128

SJMP CONTINUE_LOOP

NOT_EQUAL:

JB ACC.7, ABOVE_128 ; проверяем, больше ли элемент 128

INC R2 ; инкремент, если элемент меньше 128

SJMP CONTINUE_LOOP

ABOVE_128:

INC R4 ; инкремент, если элемент больше 128

CONTINUE_LOOP:

INC R7 ; увеличиваем индекс

CJNE R7, #10H, LOOP ; проверяем, не дошли ли до конца массива 10h = 16

; Завершение программы

SJMP $ ; бесконечный цикл, чтобы программа не выполняла неопределённый код

END ; конец программы

Вариант 12. В РПД с адреса 20h находится массив, состоящий из 16 элементов. Суммировать элементы массива до тех пор, пока значение суммы не превысит 512. Выдать в R3 номер элемента, на котором произошло переполнение. Если сумма элементов не достигла значения 512, то выдать в регистре R3 значение 0.

ORG 0 ; Установка начального адреса

MOV R3, #0 ; Инициализация регистра R3 для хранения номера элемента

MOV A, #0 ; Инициализация аккумулятора A для хранения суммы

MOV R0, #20h ; Загрузка начального адреса массива в регистр R0

MOV R1, #16 ; Загрузка количества элементов массива в регистр R1

SUM_LOOP:

ADD A, @R0 ; Сложение текущего элемента массива с аккумулятором A

JC OVERFLOW ; Проверка флага переноса (если сумма превысила 255)

INC R0 ; Увеличение указателя на следующий элемент массива

DJNZ R1, SUM_LOOP ; Повторение цикла, пока не обработаны все элементы

EXIT:

MOV R3, #0 ; Установка значения 0 в регистр R3

SJMP END ; Переход к концу программы

OVERFLOW:

MOV A, R1 ; Сохранение значения R1 (номер элемента)

INC A ; Увеличение значения R3 на 1 (так как R1 начинается с 0)

MOV R3, A

SJMP END ; Переход к концу программы

END:

SJMP END ; Бесконечный цикл для завершения программы

END ; Конец программы

$MOD51 ORG 0

; Инициализируем регистры

MOV R0, #20h ; Устанавливаем адрес начала массива в РПД

MOV R1, #0 ; Счетчик элементов массива

MOV R2, #0 ; Нижний байт суммы

MOV R3, #0 ; Регистр R3 и будет хранить результат

MOV R4, #0 ; Верхний байт суммы, используется для проверки переполнения

SUM_LOOP: MOV A, @R0 ; Загружаем элемент массива в аккумулятор

ADD A, R2 ; Добавляем элемент к нижнему байту суммы

MOV R2, A ; Обновляем нижний байт суммы, A переполнен если было сложение с переносом

JC UPDATE_HIGH ; Если перенос, обновляем верхний байт суммы

INC R0 ; Переходим к следующему адресу элемента массива

INC R1 ; Инкрементируем счетчик элементов

CJNE R1, #10h, CHECK_SUM ; Проверяем, обработали ли мы все 16 элементов

SJMP END_SUM ; Если да, выходим из цикла

UPDATE_HIGH: INC R4 ; Инкрементируем верхний байт суммы

CHECK_SUM: JNB ACC.7, NO_OVERFLOW ; Проверяем, не произошло ли переполнение нижнего байта

MOV A, R4

SUBB A, #02h ; Вычитаем из верхнего байта значение 2 (512 в байтах)

JC SUM_OVERFLOW ; Если после вычитания произошел перенос, достигнуто условие

NO_OVERFLOW: SJMP SUM_LOOP

SUM_OVERFLOW: MOV R3, R1 ; Записываем в R3 номер элемента, на котором произошло переполнение

SJMP FINAL

END_SUM: MOV R3, #0 ; Устанавливаем значение 0 в R3, так как сумма не превысила 512 после цикла

FINAL:

END

Вариант 13. Для функции Y=20Х+45 выдать в R2 первое значение аргумента, при котором значение функции превысит 1024. Начальное значение аргумента Х=10.

ORG 0 ; Установка начального адреса

MOV R2, #10 ; Инициализация регистра R2 значением 10 (начальное значение аргумента X)

MOV A, R2 ; Загрузка значения аргумента X в аккумулятор A

MOV B, #20

MUL AB ; Умножение значения аргумента X на 20

ADD A, #45 ; Сложение 45 к результату умножения

CJNE A, #1024, NEXT_VALUE ; Проверка, превышает ли значение функции 1024

SJMP EXIT ; Если значение функции не превысило 1024, завершение программы

NEXT_VALUE:

MOV A, R2

INC A ; Увеличение значения аргумента X на 1

CJNE A, #256, LOOP ; Проверка, достигнуто ли максимальное значение аргумента (255)

SJMP EXIT ; Если достигнуто максимальное значение аргумента, завершение программы

LOOP:

MOV A, R2 ; Загрузка значения аргумента X в аккумулятор A

MOV B, #20

MUL AB ; Умножение значения аргумента X на 20

ADD A, #45 ; Сложение 45 к результату умножения

CJNE A, #1024, NEXT_VALUE ; Проверка, превышает ли значение функции 1024

SJMP EXIT ; Если значение функции превысило 1024, завершение программы

EXIT:

SJMP EXIT ; Бесконечный цикл для завершения программы

END ; Конец программы

$MOD51 ORG 0

; Инициализация начальных значений

MOV R1, #10 ; Начальное значение X

MOV R0, #0 ; Старший байт Y

MOV R2, #45 ; Младший байт Y с суммой начального значения 45

NEXT_VAL: ; Метка цикла для следующего значения X

CLR C ; Очищаем бит переноса, чтобы избежать ошибок при сложении

MOV A, R1

ADD A, #0 ; Проверяем перенос для увеличения старшего байта Y

JNC NO_CARRY ; Если не произошло переноса, пропускаем увеличение

INC R0 ; Увеличиваем старший байт Y

NO_CARRY:

MOV A, R2

ADD A, #20 ; Добавляем 20 к младшему байту Y

MOV R2, A ; Сохраняем новое значение Y

; Проверяем старший байт Y на переполнение

; (т.е., верхняя граница для проверки значения, превышающего 1024)

JNB ACC.7, CHECK_LOWER

OVERLIMIT: ; Условие превышения 1024 выполнено

SJMP RESULT ; Переход к выводу результата

CHECK_LOWER: ; Проверяем нижний байт Y (если старший байт Y == 4, нужно убедиться, что младший байт >0 для превышения 1024)

MOV A, R0

CJNE A, #4, LOOP ; Если R0 не равен 4, значит Y < 1024, продолжаем цикл

MOV A, R2

JZ LOOP ; Если R2 равен 0, значит Y точно не больше 1024, продолжаем цикл

RESULT: ; Место для вывода результата

MOV R2, R1 ; Перемещаем значение X, при котором Y превысила 1024 в R2

END_LOOP: ; Конец программы

SJMP END_LOOP

LOOP: ; Цикл, где X увеличивается на 1 и проверяется новое значение Y

INC R1 ; Увеличиваем X

SJMP NEXT_VAL ; Возвращаемся к началу цикла для новых вычислений

END