Программист макетных компьютеров

Об этом проекте

Что это за проект?

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

После сборки компьютера быстро стало ясно, что если мне придется вручную переключать программу с помощью DIP-переключателей каждый раз, когда я ее включаю, то она вообще не будет иметь особого смысла. Даже переключение всего лишь на 16 байт снова и снова быстро устаревает. Также я планировал увеличить объем памяти до 256 байт, и это было полезно только в том случае, если каким-то образом программы могли быть загружены и сохранены.

Что я могу с этим сделать?

• Сохранение программы из ОЗУ макетного компьютера.

• Загрузить программу в оперативную память макетного компьютера.

• Автоматический запуск сохраненной программы при запуске макетного компьютера.

• Проверяйте и изменяйте содержимое памяти через последовательное соединение.

• Запрограммируйте макетный компьютер на языке ассемблера.

• Разобрать содержимое памяти

• Пошаговая инструкция по инструкции

• Установите точки останова и дойдите до точки останова

Вот видео, демонстрирующее эти функции. Прошу прощения за качество видео - я ни в коем случае не профессиональный создатель видеоконтента:

Как это работает?

Создавая этот проект, я преследовал несколько целей:

• Для его создания требуется как можно меньше оборудования.

• Как можно меньше изменений в самом макетном компьютере.

Вначале я думал об использовании EEPROM для хранения программ, а затем о какой-то логике для передачи программ из EEPROM в RAM макетного компьютера. Однако придумать логику переноса оказалось сложнее, чем я мог справиться (я больше занимаюсь программным обеспечением, хотя мне очень нравится работать с аппаратным обеспечением). Я был большим поклонником Arduino, поэтому в какой-то момент я начал думать о замене логики передачи на Arduino. Потребовалось время, чтобы убедить себя, что использование Arduino не является обманом (в конце концов, даже Arduino UNO намного мощнее, чем сам макет), но я доволен результатом, поэтому я примирился.

Так что же нужно делать Arduino? Ну, он должен уметь читать данные из памяти и записывать данные в память. Самый простой и наименее навязчивый (для макетного компьютера) способ сделать это - использовать тот же интерфейс, который уже есть у модуля памяти:шину и сигналы управления. Контакты цифрового ввода-вывода Arduino являются двунаправленными, поэтому подключение 8 из них напрямую к шине позволяет Arduino читать и записывать на шину. Чтобы заставить модуль RAM читать или писать на шину, все, что необходимо, - это установить соответствующие сигналы MI / RI / RO. Теперь эти сигналы обычно управляются EEPROM логики управления, поэтому управление ими со стороны Arduino может привести к конфликтам и возможным ситуациям короткого замыкания. Однако EEPROMS AT28C16, используемый Беном, имеет вход Chip Enable (CE), который переводит все выходные данные в состояние с высоким z, что затем позволяет Arduino манипулировать сигналами. Чтобы считать данные из ОЗУ, Arduino необходимо сделать следующее:

• установить высокий уровень сигнала CE EEPROM (т.е. отключить логику управления)

• вывести первый адрес для чтения на шину

• установите высокий уровень сигнала MI и дождитесь перехода тактового сигнала от низкого к высокому.

• установите низкий уровень MI и высокий уровень RO и дождитесь перехода тактового сигнала от низкого к высокому.

• прочитать байт данных с шины

• повторить шаг 2 для всех 16 адресов.

• установить низкий уровень сигнала CE EEPROM (т.е. повторно включить управляющую логику)

И это все. Запись содержимого ОЗУ очень похожа, Arduino просто нужно записать в шину и установить высокий RI вместо RO. Конечно, есть некоторые технические проблемы, которые необходимо решить, но вышеуказанный базовый механизм является сердцем этого проекта.

Какие изменения мне нужно внести в макетный компьютер?

Необходимо внести два изменения:

• Установите понижающие резисторы на выходы данных EEPROM логики управления.

• Отключить (или постоянно сбрасывать) счетчик звонков, когда EEPROM отключена.

Понижающие резисторы

Понижающие резисторы необходимы, потому что после отключения EEPROM подтягивающие резисторы логических вентилей, к которым подключены управляющие сигналы (такие как AO / AI / EO ...), будут повышать эти сигналы. Это будет означать, что несколько регистров будут писать в шину, вызывая конфликты.

Подтягивающие резисторы на входах затворов 74LS составляют около 10 кОм. Таким образом, понижающие резисторы должны быть достаточно маленькими, чтобы снизить напряжение до минимума. Для большинства сигнальных линий я использовал резисторы 3,3 кОм. Однако есть два исключения:во-первых, сигнал «SU» подключается к 8 логическим элементам «исключающее ИЛИ», что означает, что эффективный подтягивающий резистор составляет 10 кОм / 8 =1,25 кОм. Понижающий резистор должен быть значительно меньше 1 кОм, чтобы понизить этот низкий уровень. К счастью, сигнал SU (вычитание) не контролирует какое-либо взаимодействие с шиной, поэтому мы можем просто игнорировать его и не использовать понижающий резистор. Во-вторых, CE (включение счетчика) нуждался в понижающем резисторе 1 кОм - более высокие значения в некоторых случаях вызывали случайное поведение программного счетчика.

Я обнаружил, что проще всего добавить понижающие резисторы на макетную плату, на которой находятся все синие светодиоды, то есть между анодами светодиодов (которые подключены к выходам EEPROM) и GND.

[Мне не удалось установить здесь резисторы для сигналов HLT / MI / RI, поэтому я добавил их в других местах на макете]

Сброс счетчика звонков

Другая модификация - обнуление счетчика звонков. Технически в этом нет необходимости для сохранения / загрузки программ, но это позволяет плавно передавать управление от Arduino обратно логике управления. Дело в том, чтобы счетчик звонков оставался равным 0, пока CE высокий (т.е. логика управления отключена). Когда Arduino переключает CE обратно на низкий уровень (активируя логику управления), счетчик звонков будет равен нулю, и макетный компьютер начнет выполнение следующей инструкции.

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

Если вы используете реализацию Бена фиксированного 5-ступенчатого кольцевого счетчика, я думаю, что следующее расширение его схемы сброса должно сбрасывать счетчик, когда CE высокий (щелкайте стрелки влево / вправо ниже, чтобы переключаться между исходной схемой Бена и расширенная версия):

Как видите, для этого требуется еще 3 логических элемента NAND, то есть еще один чип 74LS00. Обратите внимание, что я не тестировал этот подход, но, насколько я могу судить, он должен работать.

Это изменение не является абсолютно необходимым - вы можете оставить его вначале. Загрузка и сохранение, а также монитор / ассемблер / дизассемблер по-прежнему будут работать нормально. Однако любое действие, требующее передачи управления от Arduino к управляющей логике, работать не будет. В частности, это автоматический запуск сохраненных программ при запуске, а также пошаговый запуск и запуск в отладчике.

Как мне настроить Arduino?

Загрузите скетч из архива GIT в Arduino и подключите Arduino к макетному компьютеру следующим образом:

• Контакт Arduino 5V ( не Вин!) На шину 5В на макетной плате.

• Вывод GND Arduino на вывод GND на макетной плате.

• Цифровые контакты 2–9 Arduino к шине 0–7

• Цифровой вывод 10 Arduino для управления логическим выходом EEPROM, который управляет RO

• Цифровой вывод 11 Arduino для управления логическим выходом EEPROM, который управляет RI.

• Цифровой вывод 12 Arduino для управления логическим выходом EEPROM, который управляет MI.

• Аналоговый вывод 0 Arduino для сигнала ЧАСОВ

• Аналоговый вывод 3 Arduino на CE (вывод 18) всех логика управления EEPROM и через резистор 10 кОм на +5 В

Кроме того, вам потребуется подключить входные контакты аналогового 1 и аналогового 2 Arduino к DIP-переключателям и кнопкам, как показано на схемах (более подробную информацию см. В прилагаемом файле Fritzing).

Для абсолютно минимальной (но все же функциональной) версии вы можете сделать следующее:

• Добавьте понижающие резисторы 3,3 кОм к выходным контактам EEPROM, которые управляют AO, CO, EO, IO, RO.

• Пропустите приведенные выше инструкции "Сброс счетчика звонков".

• Выполните подключение Arduino к макетному компьютеру, как показано выше (вы можете не использовать резистор 10 кОм на последнем этапе, если хотите).

• Подключите аналоговый вывод 1 и аналоговый вывод 2 к GND.

Чтобы использовать кнопки загрузки / сохранения, все, что вам нужно сделать, это подключить кнопки, DIP-переключатели и соответствующие резисторы к аналоговым контактам 1 и 2 в соответствии со схемой.

Чтобы использовать функцию автозапуска, Arduino должен поддерживать счетчик программ и счетчик звонков на 0 во время сброса и во время передачи программы. Подтягивающий резистор между аналоговым выводом 3 и + 5V удерживает управляющую логику отключенной (и, следовательно, программный счетчик на 0), пока Arduino сбрасывается. Для счетчика звонков следуйте приведенным выше инструкциям «Сброс счетчика звонков».

Как мне загружать и сохранять программы?

Приведенная выше минимальная настройка позволит вам управлять Arduino через последовательный интерфейс. Для связи с Arduino вам понадобится терминальная программа, такая как Putty или TeraTerm. Последовательный монитор в программном обеспечении Arduino также будет работать, но разделение между областью ввода и вывода в последовательном мониторе делает его немного неуклюжим в этом сценарии.

• Включите макетный компьютер.

• Подключите ПК к Arduino с помощью кабеля USB.

• Запустите программу терминала и настройте скорость 9600 бод, 8 бит, без контроля четности, 1 стоповый бит.

• Нажмите ESC в окне терминала, чтобы войти в режим монитора.

• Вы должны увидеть значок "." в виде командной строки

• Введите "h" и нажмите клавишу ВВОД, чтобы получить список поддерживаемых команд.

После минимальной настройки вы сможете использовать команды «m», «M», «C», «l» и «s». Это позволяет вам видеть содержимое памяти, изменять содержимое памяти, а также загружать и сохранять программы.

Чтобы сохранить или загрузить программу с помощью кнопки:

• Выключите часы на макетном компьютере.

• Установите DIP-переключатели, чтобы выбрать номер файла, под которым должны быть сохранены данные.

• Нажмите кнопку «сохранить» или «загрузить». Светодиод, подключенный к CE, загорится, указывая на то, что Arduino взял на себя управление.

• Включите часы на макетном компьютере. Вы должны увидеть, как Arduino циклически перебирает адреса (следите за светодиодами регистра адреса памяти)

• Подождите, пока светодиоды шины перестанут мигать, а светодиоды регистра адреса памяти не покажут 1111

• Выключите часы на макетном компьютере. Светодиод, подключенный к CE, погаснет, указывая на то, что управление было возвращено управляющей логике.

Чтобы автоматически запускать программу при запуске (убедитесь, что у вас есть все необходимые схемы), просто установите DIP-переключатели на номер файла, под которым сохранена программа, и включите макетный компьютер (или нажмите кнопку сброса). Есть два особых случая:если все DIP-переключатели выключены, компьютер запускается регулярно, без автозапуска. Если все DIP-переключатели включены, то Arduino переходит в режим монитора непосредственно при запуске.

Как использовать ассемблер и дизассемблер?

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

  struct opcodes_struct opcodes_4bit [] ={{"NOP", B00000000, 0, false}, {"LDA", B00010000, 2, true}, ... {".OR", B11111110, 0, true}, // устанавливаем начальный адрес {".BY", B11111111, 0, true}, // определяем один байт данных {NULL, 0, 0, false}};  

В каждой строке указан один код операции:

• Первое поле - мнемоника («LDA»). Для немедленной адресации добавьте в мнемонический знак "#". То, что Бен называет «LDI», здесь будет называться «LDA #». Можете ли вы сказать, что я вырос на ассемблере 6510 на C64?

• Второе поле - это сам код операции. Младшие четыре бита всегда должны быть равны 0. (за исключением специальных кодов операций .OR и .BY, см. Ниже).

• Третье поле - это количество циклов, которые требуется для выполнения кода операции (в дополнение к циклам выборки). Например, в моей реализации LDA имеет код операции 0001 и требует в общей сложности четырех циклов для выполнения, два из которых являются циклом выборки. Если вы следовали инструкциям Бена (где все коды операций используют 5 циклов), то всегда должно быть 3.

• Последнее поле указывает, требуется ли для этого кода операции аргумент. Например, LDA требует аргумент, а OUT - нет.

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

После ввода всех кодов операций загрузите программное обеспечение в Arduino. Подключите терминал и войдите в режим монитора (либо нажав ESC в окне терминала, либо включив все DIP-переключатели). Теперь вы можете дизассемблировать свою программу. Если ввести на мониторе только букву "d", дизассемблирование начнется с адреса 0.

Ассемблер минимален, но работает довольно хорошо. Введите «a», чтобы начать сборку с адреса 0. Условные обозначения:

• Если строка начинается не с пробела, она должна начинаться с определения метки. Ярлыки должны начинаться с алфавитного символа, за которым следуют буквенно-цифровые символы, могут иметь длину не более 3 символов и чувствительны к регистру.

• После первого пробела в строке ассемблер ожидает мнемонику (LDA, STA, OUT ...).

• Специальная мнемоника ".BY" напрямую указывает байт данных, который будет сохранен в текущем месте.

• Специальная мнемоника ".OR" сообщает ассемблеру продолжить сборку по новому адресу.

• Если аргумент начинается с буквенного символа, предполагается, что это метка.

• Ожидается, что любой числовой аргумент будет десятичным числом. Чтобы указать шестнадцатеричный формат, перед аргументом поставьте «$». Например, чтобы загрузить шестнадцатеричный номер FF в регистр A, используйте «LDA # $ FF».

• Что-нибудь после ";" считается комментарием и игнорируется.

Например, код Фибоначчи можно ввести следующим образом:

  первый LDA # 0; x =0 STA x LDA # 1; y =1 STA y lp ADD x; z =y + x STA z JC rst; перезапустить при переполнении OUT; print z LDA y; x =y STA x LDA z; y =z STA y JMP lp; цикл x .BY 0 y .BY 0 z .BY 0  

Какие есть ограничения?

Чтобы сэкономить место в ОЗУ на Arduino, ассемблер работает как однопроходный ассемблер (в противном случае Arduino пришлось бы буферизовать весь исходный код). Ассемблер записывает коды операций в память макетного компьютера по мере их ввода. Это означает, что сборка замедляется из-за тактовой частоты макетного компьютера. Если вы копируете и вставляете текст в окно терминала, это может привести к потере символов, поскольку Arduino не успевает за символами, поступающими на скорости 9600 бод (потому что он тратит слишком много времени на ожидание часов макетного компьютера). Чтобы обойти это, либо уменьшите скорость передачи, либо используйте TeraTerm, который предоставляет настройку для указания задержки между отправляемыми символами. Другой способ - увеличить тактовую частоту макетного компьютера. Мои часы увеличиваются до 160 кГц, и на этой скорости я могу без проблем копировать и вставлять код со скоростью 9600 бод.

В своей конфигурации по умолчанию скетч Arduino может обрабатывать тактовые частоты на макетном компьютере примерно до 1-2 кГц (может быть, немного больше). Обратите внимание, что часы Бена в его конфигурации по умолчанию не превышают 500 Гц. Если ваши часы быстрее, ищите #ifdef FAST_IO переключитесь в коде. Включение FAST_IO должно заставить Arduino работать с тактовой частотой до 250 кГц. Я тестировал его до 160 кГц. Вероятно, можно было бы поддерживать более высокие скорости, реализуя критические по времени циклы непосредственно в ассемблере, но, честно говоря, тактовая частота 160 кГц уже кажется слишком высокой на макетном компьютере с его ограниченными в остальном возможностями. Обязательно прочтите соответствующие комментарии в коде перед включением FAST_IO.

Arduino имеет 1 КБ EEPROM и, следовательно, может содержать 1024/16 =64 различных программы. Фактически это 63, поскольку 16 байтов зарезервированы для сохранения данных конфигурации. Это немного, но, вероятно, достаточно, чтобы вместить все программы, которые вы можете придумать. С помощью микропереключателей можно выбрать только программы с номерами 0–15 (1–14 для автозапуска), но команды «s» и «l» будут работать с полным диапазоном 0–62.

Это выглядит немного неаккуратно. Можете ли вы его прибрать?

Да! В моей последней версии здесь я фактически просто использовал голый чип Atmega 328P (вместе с кристаллом 16 МГц и конденсаторами) вместо Arduino UNO. Стабилизатор напряжения на UNO здесь не нужен, поскольку Arduino в любом случае напрямую использует 5 В от нашего источника питания. Единственная потеря заключается в том, что теперь нам приходится использовать отдельный преобразователь USB-to-serial (FTDI или аналогичный) для связи с Atmega. Общий вид этого гораздо лучше сочетается с остальной частью макетного компьютера:

Еще одна оптимизация - удаление загрузчика с Arduino / Atmega. Это избавляет от двухсекундной задержки при запуске загрузчика Arduino. Я опубликую инструкции, как это сделать, если людям интересно. Напишите в комментариях!

Код

Программист макетных плат

Схема