ZXNet эхоконференция «code.zx»

Hello, All! ═══════════════════ wait_1 .W ══════════════════ (c) Иван Рощин, Москва Fido : 2:5020/689.53 ZXNet : 500:95/462.53 E-mail: asder_ffc@softhome.net WWW : http://www.ivr.da.ru Программирование задержек на ассемблере Z80 ═══════════════════════════════════════════ ("Радиомир. Ваш компьютер" 3/2002) При написании программ для низкоуровневой работы с внешними устройствами часто возникает необходимость запрограммировать задержку на определенное время. Для этого можно либо использовать таймер (если он есть), либо вставить в программу фрагмент, время выполнения которого равно требуемому времени задержки. Первый способ я здесь рассматривать не буду, а вот о втором расскажу подробнее. Каждая команда процессора Z80 выполняется за определенное количество тактов. Зная величину требуемой задержки в тактах, можно написать фрагмент программы с соответствующим временем выполнения. (Сразу же замечу, что работать такой фрагмент должен при запрещенных прерываниях.) Формула для вычисления времени задержки в тактах: N=F*t где N - количество тактов, F - тактовая частота процессора, t - время задержки. Так как время выполнения команды в процессоре Z80 может выражаться лишь целым числом тактов, полученный результат следует округлить до ближайшего целого числа. Пример: пусть нужна задержка в 5 мс, тактовая частота - 3,5 МГц. Тогда требуемое количество тактов равно: 5*10^-3 с * 3,5*10^6 Гц = 17500. Начнем с программирования небольших задержек. Минимальная величина задержки соответствует наименьшему времени выполнения команды Z80 - 4 такта. Для задержки на 4 такта идеально подходит команда NOP - "нет операции". Ее выполнение не зависит от значения флагов и регистров, и она не выполняет каких-либо действий (иначе говоря, не имеет побочных эффектов). С помощью цепочки NOP'ов легко получить задержку на 8, 12, 16,... тактов (т.е. на число вида 4N). Задержку на 5 тактов можно получить с помощью команды условного выхода из подпрограммы в случае, когда условие не выполняется. Таких команд восемь: RET NC (выход при C=0) RET C (выход при C=1) RET NZ (выход при Z=0) RET Z (выход при Z=1) RET P (выход при S=0) RET M (выход при S=1) RET PO (выход при P/V=0) RET PE (выход при P/V=1) Побочных эффектов они не имеют. Добавляя NOP'ы, можно получить задержку на 9, 13, 17,... тактов (т.е. на число вида 4N+1). Очевидно, для использования одной из вышеперечисленных команд необходимо знать состояние хотя бы одного из четырех флагов (C, Z, S или P/V) к моменту ее выполнения. Если состояние флагов неизвестно, то задержку на 5 тактов получить нельзя, но на 9, 13, 17,... - можно. Для этого надо вначале установить флаг переноса с помощью команды SCF (время ее выполнения - 4 такта), после чего использовать команду RET NC, а затем при необходимости добавить NOP'ы. Установка флага переноса будет в этом случае побочным эффектом. Задержку на 6 тактов можно получить с помощью одной из следующих команд: INC BC DEC BC INC DE DEC DE INC HL DEC HL INC SP DEC SP Добавляя NOP'ы, можно получить задержку на 10, 14, 18,... тактов (т.е. на число вида 4N+2). Вышеуказанные команды не влияют на флаги, однако изменяют содержимое соответствующей регистровой пары. Если ни одну из четырех пар изменять нельзя, то и задержку на 6 тактов получить нельзя. Но на 10, 14, 18,... тактов - можно, с помощью команды безусловного перехода на следующую команду (JP $+3), на выполнение которой тратится 10 тактов, и добавленных при необходимости командах NOP. Задержку на 7 тактов можно получить различными способами. Один из них - использование команды LD r,(HL), где r - один из регистров A,B,C,D,E,H,L. Эта команда не влияет на флаги, но изменяет содержимое участвующего в операции регистра. Если ни один регистр изменять нельзя, но изменять флаги можно, то годится команда CP (HL). Если нельзя изменять ни регистры, ни флаги, - можно использовать команду условного перехода JR (при невыполняющемся условии). Таких команд четыре: JR NC (переход при C=0) JR C (переход при C=1) JR NZ (переход при Z=0) JR Z (переход при Z=1) Естественно, чтобы одну из них можно было использовать, необходимо знать состояние флага C или Z на момент ее выполнения. Добавляя NOP'ы, можно получить задержку на 11, 15, 19,... тактов (т.е. на число вида 4N+3). ════════════════════════════════════════════════ С уважением, Иван Рощин.

Hello, All! ═══════════════════ wait_2 .W ══════════════════ Итак, как же, основываясь на вышесказанном, построить участок программы, обеспечивающий нужную задержку? Пусть x - величина задержки в тактах. Разделим x на 4, получим частное a и остаток b. Тогда b+4 - это длина первой команды (4, 5, 6 или 7 тактов), а a-1 - количество добавляемых NOP'ов. Рассмотрим это на примерах. Пример 1: x=18. Делим на 4: a=4, b=2. Значит, длина первой команды будет 2+4=6 тактов, а количество NOP'ов будет 4-1=3. Соответствующий фрагмент программы будет выглядеть так: INC HL NOP NOP NOP Пример 2: x=29. Делим на 4: a=7, b=1. Значит, длина первой команды - 5 тактов, количество NOP'ов - 6. Как уже ранее упоминалось, задержка на 5 тактов реализуется условным RET'ом, а для его применения надо знать состояние хотя бы одного из четырех флагов. Предположим, что о состоянии флагов ничего не известно. Тогда придется сделать так: с помощью последовательности команд SCF: RET NC получаем задержку в 9 тактов, а NOP'ов будет на один меньше. В результате получим: SCF RET NC NOP NOP NOP NOP NOP Так как, вообще говоря, NOP'ов при таком программировании задержки может получиться довольно много, то, чтобы не "раздувать" текст программы и не ошибиться в подсчете NOP'ов при наборе текста, удобно использовать директиву ассемблера DS N (другой вариант записи - DEFS N). Она выделяет участок памяти длиной N байтов и (обычно) заполняет его нулями. Ну а 0 - это как раз и есть код команды NOP. Только убедитесь, что используемый вами ассемблер заполняет область действительно нулями. Если это не так, придется указывать нулевое значение явно: DS N,0. Таким образом, рассмотренные выше примеры могут быть записаны так: INC HL DS 3 и SCF RET NC DS 5 Если вас не устраивает, что длинная цепочка NOP'ов занимает много места в памяти, то можно использовать следующий фрагмент программы: LD B,N DJNZ $ Время его выполнения - 13N+2 тактов (где N=1..255). Таким образом, если нужна задержка на x тактов, делим x-2 на 13, получаем частное a и остаток b. Значение a показывает, сколько раз надо повторить цикл (это число, загружаемое в регистр B), а b - сколько тактов при этом остается (задержку на это время придется реализовать обычным способом). Если b=1, 2 или 3, то, так как задержку на это время получить нельзя, придется уменьшить a на 1 и увеличить b на 13 (тем самым увеличив оставшуюся задержку до 14, 15 или 16 тактов). Пример: x=140. Делим на 13: a=10, b=8. Следовательно, количество повторов цикла будет 10; задержку на оставшиеся 8 тактов обеспечиваем с помощью двух команд NOP. Получаем: LD B,10 DJNZ $ DS 2 ════════════════════════════════════════════════ С уважением, Иван Рощин.

Hello, All! ═══════════════════ wait_3 .W ══════════════════ Теперь перейдем к рассмотрению способов реализации более длительных задержек. Для задержек от 188 до 65535 тактов удобно использовать следующую 98-байтную процедуру: ORG #8000 ;или другой адрес, кратный 256 TAB_ADR DB ADR_0256 DB ADR_1256 .............. DB ADR_31256 ADR_28 NOP ADR_24 NOP ADR_20 NOP ADR_16 NOP ADR_12 NOP ADR_8 NOP ADR_4 NOP ADR_0 NOP ;4 такта RET ADR_29 NOP ADR_25 NOP ADR_21 NOP ADR_17 NOP ADR_13 NOP ADR_9 NOP ADR_5 NOP ADR_1 RET NZ ;5 тактов RET ADR_30 NOP ADR_26 NOP ADR_22 NOP ADR_18 NOP ADR_14 NOP ADR_10 NOP ADR_6 NOP ADR_2 INC HL ;6 тактов RET ADR_31 NOP ADR_27 NOP ADR_23 NOP ADR_19 NOP ADR_15 NOP ADR_11 NOP ADR_7 NOP ADR_3 LD A,(HL) ;7 тактов RET WAIT LD DE,-156 ADD HL,DE LD A,L AND 31 LD E,A ;Чтобы разделить HL на 32, достаточно сдвинуть HL на 5 разрядов ;вправо, но есть более короткий и быстрый способ: сдвинуть HL на ;3 разряда влево, помещая выдвигаемые старшие биты результата в ;аккумулятор, и затем произвести перестановку: A -> H -> L. XOR A ADD HL,HL RLA ADD HL,HL RLA ADD HL,HL RLA LD L,H LD H,A ;Цикл с временем выполнения 32 такта: WAIT_1 DEC HL LD A,H OR L NOP ;для NOP ;задержки JP NZ,WAIT_1 EX DE,HL LD H,TAB_ADR/256 LD L,(HL) JP (HL) Напомню, что оператор "" - это вычисление остатка от деления. В вышеприведенной процедуре он используется, чтобы получить младший байт двухбайтной величины. Если в используемом вами ассемблере этот оператор не поддерживается, то, возможно, предусмотрен специальный оператор вычисления младшего байта, или же ассемблер сам отбрасывает старший байт, когда результат должен быть однобайтным. В крайнем случае можно воспользоваться равенством A256=A-((A/256)*256). ════════════════════════════════════════════════ С уважением, Иван Рощин.

Hello, All! ═══════════════════ wait_4 .W ══════════════════ Требуемая продолжительность задержки в тактах (от 188 до 65535) указывается в регистровой паре HL перед вызовом процедуры. При этом не нужно специально учитывать, что выполнение команд загрузки этого числа в HL и вызова процедуры тоже займет какое-то время: это уже учитывается в самой процедуре. Если, скажем, в каком-то месте программы нужна задержка в 500 тактов, просто пишем следующее: LD HL,500 CALL WAIT Как видим, применение этой процедуры не требует от программиста специальных знаний о времени выполнения команд. Не нужно каждый раз думать, какой последовательностью команд реализовать ту или иную задержку. Ставим нужное число и все! Проще не бывает! Также этой процедурой очень удобно пользоваться, если точная величина задержки заранее не известна, и приходится "подгонять" ее в процессе отладки программы. Изменить время задержки можно, изменив лишь одно число в коде программы с помощью отладчика. При своей работе процедура изменяет значения регистровых пар HL и DE, а также аккумулятора и регистра флагов. Если это нежелательно, то, в зависимости от ситуации, можно либо сохранять их в стеке и затем восстанавливать (командами PUSH, POP), либо на время выполнения процедуры устанавливать альтернативный набор регистров, если там не содержится ничего нужного (командами EXX, EX AF,AF'). При этом из указываемого в HL времени задержки надо будет вычесть время выполнения команд сохранения и восстановления регистров (следите, чтобы при этом указываемое время задержки не стало меньше минимального - 188 тактов!). Напомню: время выполнения команд PUSH HL, PUSH DE, PUSH AF - 11 тактов; POP HL, POP DE, POP AF - 10 тактов; EXX, EX AF,AF' - 4 такта. Пример: пусть нужна задержка в 750 тактов, и значения HL и DE не должны портиться (альтернативные регистры - тоже). Значит, HL и DE надо сначала сохранить в стеке (PUSH HL, PUSH DE), а после вызова процедуры - восстановить (POP DE, POP HL). Подсчитываем время выполнения этих команд: 11+11+10+10=42 такта. В программе пишем: PUSH HL ;сохранение PUSH DE ;регистров LD HL,750-42 CALL WAIT POP DE ;восстановление POP HL ;регистров Так как процедура WAIT - универсальная, то в случае единичного ее использования она займет, очевидно, больше места в памяти, чем специально написанный для реализации конкретной задержки фрагмент программы. Но если процедура вызывается во многих местах программы, с различными временами задержки, то это будет уже выгоднее по сравнению с тем, как если бы в каждом месте был свой фрагмент программы, реализующий задержку. Процедуру WAIT можно было бы, в принципе, сделать короче и не привязывать к адресу, кратному 256. Но я при ее написании стремился к тому, чтобы минимальная задержка, достигаемая с ее помощью, была как можно меньше, т.е. к увеличению области использования процедуры. ════════════════════════════════════════════════ С уважением, Иван Рощин.

Hello, All! ═══════════════════ wait_5 .W ══════════════════ Ниже приведен текст еще одной процедуры, для реализации более продолжительных задержек (от 469 до 2^32-1 тактов). WAIT_LONG PUSH BC PUSH AF LD BC,-405 ADD HL,BC LD BC,-1 EX DE,HL ADC HL,BC EX DE,HL LD A,L AND 3 ADD A,A ADD A,A ;*4 ADD A,WAIT_CODE256 LD C,A LD A,WAIT_CODE/256 ADC A,0 LD B,A PUSH BC LD A,L RRA RRA CPL AND 15 ADD A,WAIT_NOP256 LD C,A LD A,WAIT_NOP/256 ADC A,0 LD B,A PUSH BC ;Сдвигаем DEHL: XOR A ADD HL,HL EX DE,HL ADC HL,HL EX DE,HL RLA ADD HL,HL EX DE,HL ADC HL,HL EX DE,HL RLA LD L,H LD H,E LD E,D LD D,A ;В DE - количество повторов цикла (каждое - 64 такта). LD BC,-1 WAIT_L1 ADD HL,BC INC L ;Проверяем: L=0? DEC L ;(не изменяя флаг C). JP Z,WAIT_L2 EX DE,HL ADC HL,BC EX DE,HL JR WAIT_L1 WAIT_L2 LD A,H ;L=0, а HDE=0? OR D ;Флаг C сбрасывается. OR E NOP ;Для NOP ;задержки RET C ;в 4+4+5=13 тактов. JP NZ,WAIT_L1 RET ;Переход по адресу, ранее ;помещенному в стек. WAIT_NOP DS 15,0 ;15 команд NOP. RET ;Переход по адресу, ранее ;помещенному в стек. WAIT_CODE NOP JP WAIT_EXIT RET C JP WAIT_EXIT INC HL JP WAIT_EXIT LD A,(HL) JP WAIT_EXIT WAIT_EXIT POP AF POP BC RET Длина процедуры 119 байтов. Требуемая продолжительность задержки в тактах указывается так: старшие разряды загружаются в регистровую пару DE, младшие - в HL. Как и в предыдущей процедуре, время выполнения команд загрузки и вызова специально учитывать не нужно. Пример: пусть нужна задержка в 100000 тактов. В шестнадцатеричном виде это #186A0. В программе пишем: LD HL,#0001 LD DE,#86A0 CALL WAIT_LONG ════════════════════════════════════════════════ С уважением, Иван Рощин.

Hello, All! ═══════════════════ wait_6 .W ══════════════════ Если в программе уже используется процедура WAIT для задержек, меньших 469 тактов, а величина необходимой задержки не во много раз превосходит 65535, то можно обойтись без процедуры WAIT_LONG (тем самым сэкономив в размере программы), просто поставив рядом несколько вызовов процедуры WAIT. Пример: нужна задержка в 150000 тактов. Делим 150000 на 65535, получаем частное 2 и остаток 18930. В программе пишем: LD HL,65535 CALL WAIT LD HL,65535 CALL WAIT LD HL,18930 CALL WAIT Напоследок отмечу, что процедуры WAIT и WAIT_LONG не содержат самомодифицирующихся участков; следовательно, возможна их прошивка в ПЗУ. ════════════════════════════════════════════════ С уважением, Иван Рощин.