Передача параметров хитрой железке
 

Граждане программеры, возник вопрос: щас прорабатывается концепция хитрой железки, и вот возникла необходимость железяке передавать команды и параметры, железяка достаточно умная теоретически умеет прослушивать шину спекка и соответствующим образом реагировать. В общем нужна помощь искушонных в Z80 людей.

Так как планируется свести к минимуму колво портов в адресном пространстве машинки мы добавляем всего 2 порта 1-индекс внутреннего регистра, 2 непосредственно адресуемый регистр в связи с этим становиться неудобно передавать параметры,
так как получается следующего вида манипуляции
1. устанавливаем в первом порту номер регистра для параметра 1
2. записываем параметр в порт 2

и так для каждого регистра. плюс ситуация усугубляется еще и тем что параметры очень часто первышають 8 бит (то есть могут встречаться 2 байтные параметры)


Была одна из мыслей реализовать следующим образом передачу параметров.
ld h,код команды
ld l, первый 1 байтый параметр
push hl // записываем в стек

ld hl,параметр2
push hl
ld hl,параметр3
push hl
ld hl,параметр4
push hl

ld a,a // признак железяке что необходимо исполнить команду

// возвращаем стек в нормальное состояние
pop hl
pop hl
pop hl
pop hl

Железяка ведет себя следующим образом, у нее есть FIFO буфер длинной в 8 байт, железяка прослушивает шину и видет что процу попалась команда PUSH HL после чего следует 2 цикла записи в память - железка пихает их в FIFO буфер

Далее если процу попадается команда ld a,a она это дело воспринимает как признак для исполнения команды (код команды получается лежит в FIFO как самый старый байт). То есть метод как бы позволяет без проблем передавать 16 бит параметры и команды, но у него есть существенные недостатки
1. Юзается стек
2. если между инструкциями PUSH HL происходит прерыание и в обработчике прерываний тоже встречаются команды PUSH HL то естественно железяка засунет эти байты в FIFO очередь (то есть уже совсем левые параметры)
3. Нужно стек возвращать в исходное состояние - а это лишние траты тактов проца

В общем это я привел один из примеров что бы было видно что можно достаточно нетривиально поступать.

Основные требования к методу это
1. Скорость работы
2. возможность удобно передавать 2 байтные параметры (хоят тут выменя можете разубедить что вы 2 байтные параметры можете пердавать и байтику и вам это не мешает)
3. предусмотреть возможность что количество параметров может быть непостоянно

И еще так как тема относиться вроде бы к железяке добавлю что железяку тут не обсужаю, важно мнение программистов которые теоретически будут работать с данным делом и важна оптимальность взаимоотношения железяки и программаного обеспечения

Можно сделать так: 2 порта регистр команд/состояния и регистр данных. Шлем команду "записать данные в регистр N", протом шлем необходимое количество байт в рег данных. Чтение аналогично. 256 команд надеюсь хватит ;)

классические порты незачем бояться :) или расшаренная память как самый быстрый вариант кидания массивов.

так и работает v9990 между прочим - указываешь стартовый адрес, и пошел пхать байты подряд :)))) OUTI не слишком тормознее стекового копирования, вполне сносно. и достаточно просто чтобы юзать.

Тут вот в чем вопрос допустим тебе штук 10 одинаковых команд послать надо они только отличаются скажем одним параметром, а параметр в цикле вычисляется получаются такие телодвижения

Для начала выделяем где нить буфер для комадного пакета

заполняем его
при помощи outi запихиваем в железяку
вычисляем параметр
правим буфер
и все сначала

Тоесть есть лишние телодвижения, вопрос - как вы считаете это нормально (можно ли с этим смириться)?

Альтернативный вариант - открывающиеся/закрывающиеся порты.
Когда работает старый софт, который может нагадить в порты, порты закрыты и не реагируют.
Новый крутой софт работает при открытых портах и использует их возможности.
Можно прослушивать только команду LD и брать её непосредственные операнды.
Код будет выглядеть так:
Другой вариант - DMA.
Умная железка могла бы прослушивать их и вести себя соответственно.

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

а как этот самый параметр у тебя планируется править когда он уже залитый в FIFO буфере лежит :)
ну и кучка pop hl - тоже время как бы кушает-то :)

а можно не ипать мозги а повесить 256 байт обычного озу на старший байт (a8-15) порта и править эти команды хоть вдоль хоть поперек.

Нечетко выразился

Просто ты можеш в регистре нужные манипуляции провести и послать заново push hl. В общем варант с outi все самый оптимальный выходит.

а мне память на портах больше нравица ;)

Ересь. Возьмите ОДИН 8-битный порт. Останется ещё 8 бит (старшая половина адреса) для адресации 256 регистров вашей железяки.

Для тугодумов: В СПЕКТРУМЕ ИМЕЮТ ЗНАЧЕНИЕ МЛАДШИЕ 8 РАЗРЯДОВ.

ld a,a // признак железяке что необходимо исполнить команду

Дурацкий метод. В том смысле, что может самопроизвольно что угодно
навыполняться. Через порты надёжнее.

[quote]
Основные требования к методу это
1. Скорость работы
[quote]

LD HL, paramters_address
LD BC, #xxyy ; xx -- ваш регистр, yy -- порт.
OTIR

Медленно?