ZX Spectrum из коронавируса и палок (на самом деле, не совсем)

    Вторая часть здесь

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

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

    image

    Надо сказать, я этот процессор очень люблю. Наверное, больше него мне нравится только 486й чип, но до него руки дойдут еще нескоро, ибо вставить его в макетку сложно и бессмысленно. Придется паять. А вот паять пока не хочется. И еще больше, чем сам Z80, я люблю построенный на его основе компьютер ZX Spectrum. Но родной спектрум страдает бедой в виде микросхемы кастомной логики ULA, а клоны его на рассыпухе хотя и не особо сложны в постройке и доработке, но все же не для макетки, да и вообще, зачем столько забот, когда есть ардуино?

    Умный, уравновешенный и адекватный читатель тут уже либо прекратит чтение, либо бросит что-то типа «1 микросхема FPGA вместит компьютерный класс Спектрумов», перед тем, как прекратить. Я же не умный, не адекватный, хотя и уравновешен, но про FPGA знаю только то, что это круто. Я умею только в ардуино. Но очень хотется потыкать проводочками в Z80. Очень.

    Начнем?

    Конечно, начнем. Но сначала — Дисклеймер. Пожалуйста, относитесь ко всему, что я пишу, с изрядной долей скепсиса. Я — любитель в самом плохом смысле этого слова. У меня нет никакого соответствующего тому, о чем я пишу, образования. Если вы вдруг решите повторить то, что сделал я (нет, ну а вдруг?), знайте, что почти все, что сделано тут, будь то хард или софт, сделано неправильно. Выкладываю я это на всеобщее обозрение потому, что убиться этим сложно, а детали, используемые в поделке, стоят сущие копейки, и их не жалко.

    Начнем с того, что такое адекватный 8-битный компьютер. Это, собственно, процессор, соединенный с ПЗУ и ОЗУ, а сбоку — пара-тройка счетчиков, чтобы на экран по композиту выводить. Иногда, таймер, чтобы пищало. ZX Spectrum ничем от традиционной схемы не отличается, кроме одного но. Там есть ULA. Это, собственно, «чипсет» спектрума. ULA заведует периферией, типа магнитофона, пищалки, клавиатуры (частично), вывода на экран (да, да, в чипсете спектрума интегрированная видяха появилась еще до того, как это стало мэйнстримом). Там же была и шаред-мемори, первые 16 КиБ ОЗУ (адреса с 0x4000 по 0х5В00). Из нее ULA рисовала композитом на экран, а чтобы Z80 не шарился там, когда не надо, ULA могла остановить процессор, если надо, ведь тактовый сигнал на Z80 шел именно от нее. То есть, если ULA работала с памятью, и детектила, что процессор тоже лезет в эту память (для этого она постоянно мониторила MREQ и линии A15 и A14), она просто останавливала тактирование процессора пока сама не закончит делать то, что ей надо. Кстати, дабы избежать порчи данных на шине, части шины со стороны процессора и со стороны ULA были разграничены… резисторами… Причем память сидела на шине со стороны ULA и, соответственно, в случае коллизии, полностью игнорировала данные и адрес со стороны процессора.

    Кроме того, в спектруме было ПЗУ (адреса 0х0000 — 0х3FFF) и собственная память процессора (0x8000 — 0xFFFF), к которым ULA доступа не имела, и которые работали быстрее, чем 16 КиБ разделяемой памяти, так как процессор не мешал ULA в этой области. Но это было только на 48К версии компьютера. В базовой версии были только ПЗУ и совместная с ULA память в 16 КиБ. С нее и начнем.

    Удобно, что процессор Z80 умеет регенирировать DRAM, но мне как-то не хочется с ней возится, ибо SRAM найти проще и у меня нет мультиплексора (или я не могу его найти). Так что, будем использовать именно SRAM. Для начала соберем основной скелет, на который потом можно будет навесить все остальное. Скелетом будет процессор, ПЗУ с прошивкой, замапленое на адреса ПЗУ спектрума, ОЗУ, замапленое на первые 16 КиБ после ПЗУ и немного микросхем, чтобы все заверте… Надо сказать, что у меня долго все не хотело вертеться, так как макетки у меня китайские по $1 за 2 штуки на ибее. Но, по мне, возня того стоит. Если не хотите возиться долго, берите хорошие макетки.

    Итак, установим Z80.

    Как видно из даташита,



    У процессора 40 выводов, разделенных на группы: шина адреса, шина данных, контроль системы, контроль процессора, контроль шины процессора, ну и питание и тактовый сигнал. Далеко не все из этих выводов используются в реальных системах, таких, как ZX Spectrum, как видно из схемы. Из группы «контроль процессора» в самом Спектруме используются только сигналы INT и RESET. Из группы «контроль системы» не используется сигнал M1, группа «контроль шины» не используется совсем. Тому есть причина. Старые 8-битные системы были очень просты, а Спектрум создавался с идеей быть максимально простым и все, что можно было игнорировать, игнорировалось. Конечно, производители периферии могли использовать прерывания (сигналы INT и NMI), они были разведены на слот расширения, но в самом спектруме NMI не использовался. Как видно из вышеприведенной схемы, сигналы NMI, WAIT, BUSREQ подтянуты резисторами к питанию, так как это входы, активируемые низким уровнем (об этом говорит черта над названием сигнала), и там должна быть логическая единица (то есть +5В), чтобы не дай бог не сработал ненужный сигнал. А вот выводы, BUSACK, HALT, M1, так и висят в воздухе, ни к чему не подключенные. Кстати, обратите внимание, что кнопки сброса в спектруме нет. Вывод сброса подключен через RC-цепочку к питанию (RESET тоже активируется низким уровнем), так как, согласно даташита, после включения RESET должен быть активен по меньшей мере 3 такта, чтобы процессор перешел в рабочий режим. Эта RC-цепочка держит низкий уровень, пока конденсатор не зарядится до высокого уровня через резистор.

    Давайте кратко пробежимся по остальным сигналам:
    M1. Нам не нужен. Он сообщает, что процессор начал выполнять очередную инструкцию.
    MREQ. Нужен. Он сообщает, что процессор обращается к памяти. Если этот сигнал становится низким (то есть соединенным с землей питания), то нам надо будет активировать память, подключенную к процессору.
    IOREQ. Нужен. Он сообщает, что процессор обращается к периферийному устройству. Например, к клавиатуре.
    RD. Нужен. Сообщает, что процессор будет читать данные из памяти (если активен MREQ) или периферии (IOREQ).
    WR. Нужен. Сообщает, что процессор будет писать данные в память/периферию.
    RFSH. Нужен. Вообще, этот сигнал нужен для динамической памяти (DRAM). Её использовать я не планирую, так как и адресация у нее сложнее (матричная, а не линейная, то есть надо будет мультиплексор ставить), и вообще, в наше время микросхемы SRAM малой емкости добыть легче. Но так как процессор сам регенерирует DRAM, перебирая адреса на шине памяти, этот сигнал позволит нам игнорировать циклы регенерации и не активировать память при активном RFSH.
    HALT. Не нужен. Сообщает, что процессор остановлен.
    WAIT. Не нужен. Этот сигнал нужен, чтобы попросить процессор остановиться и подождать немного. Используется обычно медленной периферией или памятью. Но не в спектруме. Когда в спектруме периферия (ULA) решает остановить процессор, то она просто перестает подавать на него тактовый сигнал. Это надежнее, так как после получения WAIT процессор не сразу остановится.
    INT. Прерывание. Пока непонятно. Будем считать, что не нужен пока. Потом разберемся.
    NMI. Немаскируемое прерывание. Супер-прерывание. Не нужно.
    RESET. Без него не полетит.
    BUSREQ. Не нужен. Просит процессор отключиться от шин данных/адреса, а так же контрольных сигналов. Нужен, если какое-то устройство хочет заполучить контроль над шиной.
    BUSACK. Не нужен. Служит для того, чтобы сообщить устройству, выполнившему BUSREQ, что шина свободна.
    CLOCK. Тактовый сигнал. Понятно, он нужен.
    Питание тоже нужно. Слава разработчикам, только +5V/GND. Никаких тебе 3х напряжений.
    A0-A15 — шина адреса. На нее процессор выводит либо адрес памяти (MREQ активен), либо адрес порта ввода-вывода (IOREQ активен) при соответствующих обращениях. Как видно, шина в 16 бит шириной, что позволяет напрямую адресовать 64 КиБ памяти.
    D0-D7 — шина данных. На нее процессор выводит (WR активен), либо читает с нее (RD активен) запрошенные данные.

    Итак, разместим процессор на макетке. Вот так его выводы расположены физически:

    image

    Подключим питание (пин 11 и 29). Я на всякий случай поставил еще и конденсатор на 10 пФ между этими ногами. Но он мне не помог в итоге. Пины 27, 23, 18 пусть останутся ни к чему не подключенными. Пины 26, 25, 24, 17, 16 подключим через резисторы (я использовал 10 кОм) к питанию. Шину адреса (пины 1-5 и 30-40) я вывел на противоположную сторону макетки, а шину данных (пины 7-10 и 12-15) — на сделаную из макеточных шин питания отдельную шину данных.
    Пины 6 (тактовый сигнал) и 26 (RESET) подключим (потом) к Ардуине, чтобы с нее можно было управлять процессором.

    Получилось вот так:



    Пока не обращайте внимания на провода сверху, они идут от ПЗУ, к нему перейдем немного позже. Также, на фото рядом с процессором видно еще одну микросхему. Она нам нужна, чтобы декодировать верхние биты адреса. Как я уже говорил выше, в спектруме есть 3 типа памяти. Нижние 16 КиБ адресного пространства — это ПЗУ. Соответственно, если выводы A14 и A15 в низком состоянии (0 Вольт), нам надо отключить от шины все, кроме микросхемы ПЗУ. Далее идет 16 КиБ разделяемой памяти. Соответственно, эту память нам надо подключить к шине (а остальное отключить), если вывод A15 в низком состоянии, а A14 — в высоком (+5 Вольт). Ну и потом идет 32 КиБ быстрой памяти. Эту память мы приделаем попозже, и активировать будем, если вывод A15 в высоком состоянии. Кроме того, не стоит забывать, что память мы активируем только при активном (здесь активный — низкий, 0 Вольт) выводе MREQ и неактивном (здесь, неактивный — высокий, +5В) RFSH. Все это довольно просто реализовать на стандартной логике, на тех же NAND, типа 74HC00, или православных К155ЛА3, и я понимаю, задача эта — примерно для подготовительной группы детского сада, однако я думать в таблицах истинности могу только на воле, а в неволе у меня вот там лежит полная схема Harlequin'а, из которой можно просто взять часть, где нарисована U4 (74HC138, благо у меня таких около сотни). U11 пока проигнорируем для ясности, так как верхние 32КиБ пока нас не интересуют.

    Подключаем очень просто.



    Как видно из краткого описания, микросхема представляет из себя декодер, принимающий на выводы с 1го по 3й двоичное число от 000 до 111 и активирующее соответствующий этому числу один из 8 выводов (ноги 7 и с 9 по 15). Так как в 3х битах можно хранить лишь 8 разных чисел, выводов тоже всего восемь. Как можно заметить, выводы инвертированы, то есть тот, который будет активен, будет иметь уровень 0В, а все остальные +5В. Кроме того, в микросхему встроен ключ в виде 3-х вводного гейта типа «И», и два из трех его входов также инвертированы.

    В нашем случае, мы подключаем сам декодер следующим образом: старший бит (3я нога) к земле, там всегда будет 0. Средний бит — к линии А15. Там будет 1 только если процессор будет обращаться к верхним 32КиБ памяти (адреса 0х8000 — 0хFFFF, или 1000000000000000 — 1111111111111111 в двоичной записи, когда старший бит всегда выставлен в 1). Младший бит мы подключаем к линии А14, там высокий уровень будет в случае обращения либо к памяти после первых 16 КиБ, но до верхних 32 КиБ (адреса 0х4000 — 0х7FFF, или 0100000000000000 — 0111111111111111 в двоичном виде), либо к самым последним 16 КиБ адресного пространства (адреса 0хB000 — 0xFFFF, или 1100000000000000 — 1111111111111111 в двоичном виде).

    Давайте посмотрим, какой вывод будет в каждом из случаев:

    • Если линии А14 и А15 обе в низком состоянии, то есть процессор обращается к нижним 16 КиБ памяти, где у Спектрума ПЗУ, на входе декодера будет 000, или 0 в двоичном формате (все входы в низком состоянии), и будет активен вывод Y0 (15й пин). Его мы и подключим к ПЗУ, чтобы оно включалось в этом случае.
    • Если линия А14 в высоком состоянии, а линия А15 — в низком, то есть процессор обращается к памяти после первых 16 КиБ, но до 32 КиБ, на входе будет 001, или 1 в двоичном формате, и будет активен вывод Y1 (14й пин). К нему мы подключим разделяемое ОЗУ, первые 16 КиБ, где находится в том числе экранная память.
    • Если линия А14 в низком состоянии, а линия А15 — в высоком, процессор обращается к памяти где-то от 32 КиБ до 48 КиБ, на входе микросхемы 010, то есть активен вывод Y2 (13й пин). У нас пока этой памяти нет, так что вывод в воздухе.
    • Если обе линии (А14 и А15) активны, процессор обращается к верхним 16 КиБ памяти, от 48 до 64 КиБ, её у нас нет, так что вывод Y3 (12й пин) тоже в воздухе.

    Кроме того, благодаря еще одному элементу, микросхема будет активировать свои выводы только в том случае, если вводы 4 и 5 в низком состоянии, а 6 — в высоком. 4й ввод у нас всегда в низком состоянии (он подключен напрямую к земле), 5й будет в низком только когда процессор обращается к памяти (помните, MREQ в низком состоянии означает обращение к памяти), а 6й будет в высоком когда процессор не выполняет цикл обновления DRAM (у нас SRAM, так что циклы обновления DRAM безопаснее всего просто игнорировать). Получается здорово.

    Дальше ставим ПЗУ.

    Я взял W27С512 так как дешево, сердито, все помеcтится и еще и банковать можно. 64КиБ! 4 прошивки можно залить. Ну и у меня этих микросхем примерно миллион. Я решил, что буду шить только верхнюю половину, так как на Арлекине нога А15 привязана к +5В, а А14 перемычкой регулируется. Таким образом, смогу протестировать на Арлекине прошивку, чтобы долго не возиться. Сморим даташит. Ставим микросхему на макетку. Я опять поставил в правый угол, чтобы шину адреса разместить слева. Притягиваем ногу А15 к питанию, А14 проводком к земле. Проводком — это для того, чтобы можно было менять банки памяти. Так как на А15 всегда будет высокий уровень, нам будут доступны лишь верхние 32 КиБ флешки. Из них линией А14 будем выбирать верхние (+5В) или нижние (земля) 16 КиБ. В них я программатором залил тестовый образ и прошивку 48К бейсик.

    Остальные 14 адресных линий (А0 — А13) подключаем к шине адреса слева. Шину данных (Q0 — Q7) подключаем к нашей импровизированной шине в виде шин питания от макеток. Не забываем про питание!

    Теперь управляющие сигналы. OE — это output enable. Нам надо, чтобы ПЗУ отдавало данные на шину данных, когда процессор их читает. Так что подключаем напрямую к выводу RD процессора. Удобно, что оба вывода, и OE у ПЗУ, и RD у процессора активны в низком состоянии. Это важно, ничего инвертировать не надо. Кроме того, ПЗУ имеет ввод CS, также активный в низком состоянии. Если этот ввод не активен, ПЗУ будет игнорировать все остальные сигналы и ничего не будет выводить на шину данных. Этот ввод мы подключим к выводу Y0 (15му пину) микросхемы 74HC138, который тоже активен в низком состоянии. На схеме Арлекина этот сигнал, почему-то, подключен через резистор. Сделаем так же. Зачем, я не знаю. Может, умные люди подскажут в комментариях…

    Подсказали. Спасибо, sterr:
    Это интегрирующая цепочка. По идее после резистора должен стоять конденсатор, как в схемах «Ленинграда» Зонова. Но видимо здесь емкости входа достаточно и не нужна такая большая задержка.




    Все.

    Теперь ОЗУ.

    С ним сложнее, так как с ОЗУ (с нашими 16 КиБ) работает не только процессор, но и ULA, или, в нашем случае, Ардуино. Так как надо же чем-нибудь читать то, что выводится на экран. Поэтому нам надо уметь отключать управляющие сигналы и шину адреса ОЗУ от процессора. Шину данных не будем отключать, поступим, как в оригинальном спектруме (и в Арлекине): разделим шину резисторами (470-500 Ом). С одной стороны резисторов будут процессор и ПЗУ, с другой — ОЗУ и Ардуино. Таким образом, в случае конфликта на шине данных, она будет работать как 2 отдельные шины. А вот для остального используем 74HC245, как в Арлекине (U43, U44 на схеме), хотя в настоящем Спекки тоже были резисторы (между IC1 с одной стороны, это ULA, и IC3, IC4 — с другой).

    74HC245 представляет из себя буфер шины на 8 бит. У нас же есть 2 сигнала управления (RD — в случае чтения из памяти и CЕ для активации самого ОЗУ. С WR в случае записи в память разберемся позже) и 14 бит адреса: помните, выше мы уже генерируем сигнал на память с помощью 74HC138 только в том случае, если процессор активировал A14 при неактивной А15, так что никакого дополнительного декодирования адреса нам делать не надо, память будет работать только при обращении в первые 16 КиБ после ПЗУ. Ну и, конечно, чтобы адресовать 16 КиБ нужно как раз 14 линий адреса (А0-А13). Всего получается 16 сигналов, так что нам надо 2 микросхемы 74HC245. Подключим их на макетку слева, на место шины адреса.

    Из даташита на 74HC245 видно, что, в общем то, не важно, какой стороной подключать микросхемы, но, так как я начал наращивать макетки снизу вверх, и все остальные микросхемы установлены первым пином налево, шина адреса будет подключаться к стороне А (выводы 2-9 микросхемы, в даташите обозначены как A0-А7). Направление передачи всегда — от процессора к ОЗУ, так как ОЗУ никогда не устанавливает адрес, а лишь принимает его. В 74HC245 за направление передачи отвечает пин 1 (DIR). Согласно даташита, чтобы на стороне B появился вывод равный вводу со стороны А, DIR должен быть установлен в HIGH. Так что подключим 1й пин обеих микросхем к +5В. OE (20й пин, активируется низким уровнем) подключим с помощью проводка к земле, чтобы можно было его переставить быстро на +5В и отключить память от процессора. Дальше проще. Подключим питание для обеих микросхем. Самые правые пины правой микросхемы (8й и 9й пины, вводы A6 и A7) будут управляющими сигналами. А7 я подключил к выводу RD процессора, а A6 — к выводу Y1 микросхемы 74HC138, так как там низкий уровень будет только в том случае, когда процессор обращается к нашему ОЗУ. Остальные выводы со стороны А обеих микросхем (ноги 2-9 для левой и ноги 2-7 для правой) я подключил к адресной шине, выводам А13-А0. Старшие 2 бита адреса нам не нужны, ведь они уже декодированы в сигнале с 74HC138. Теперь про само ОЗУ. Естественно, я использовал то, что у меня уже было: микросхему кэш-памяти из старой материнки. Мне попалась IS61C256 на 20 нс, но подойдет любая. Спекки работал на частоте 3,5 МГц, а мы пока вообще с Ардуинки трактовать будем. Если выйдет 100 кГц, будет счастье! Итак, подключаем. Само собой, не надо забывать про питание. Выводы I/O0 — I/O7 подключаем на макетку шины данных ПОСЛЕ резисторов. Мне повезло (на самом деле, нет), на моих китайских макетаках шины питания разделены ровно посередине. Эту фичу я и использовал для разделения шины резисторами. Если на ваших макетах не так, придется извращаться делать вторую шину данных, и соединять её резисторами с первой. Выводы А0-А13 кидаем на соответствующие B-выводы микросхем 74HC245, не забывая, что самые правые у нас подключены не к шине данных, а к управляющим сигналам. А14 — по выбору, либо к земле, либо к +5В. Микросхема на 32 КиБ, так что этот вывод определит, какую половину мы будем использовать. Если вы найдете SRAM на 16 КиБ, линии A14 в ней не будет. Остаются выводы WE (write enable), CE (chip enable) и OE (output enable). Все активируются низким уровнем. OE надо подключить к RD процессора, но, естественно, не напрямую, а через правую 74HC245, где RD у меня приходит на ногу A7, соответственно выходит с ноги B7 (11й пин). Туда и подключим. CE надо подключить к Y1 от 74HC138, которая декодирует адрес. Её сигнал приходит у меня на A6 правой микросхемы 74HC245, соотвественно, выходит из ноги B6 (12 пин). WE я напрямую подключил к выводу WR процессора. Еще я установил провод-перемычку от сигнала OE и воткнул его просто в неиспользуемую часть макетки. Подключив этот провод к земле питания, я смогу принудительно активировать ОЗУ, когда буду читать его с Ардуинки. Еще, я притянул все управляющие сигналы ОЗУ к +5В с помощью резисторов в 10 кОм. На всякий случай. Получилось вот так:



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


    И вообще, если вы не подписаны на этот канал и интересуетесь электроникой как любитель, а не как профессионал, я вам его крайне рекомендую. Это очень качественно сделаный контент.

    В общем, это почти все. Теперь только надо понять, как читать данные из ОЗУ в Ардуино. Для начала, посчитаем, сколько выводов Ардуинки нам понадобится. Нам надо отдавать тактовый сигнал и управлять RESETом, это 2 вывода. 8 бит шины данных — еще 8 выводов. Плюс 13 бит адреса, итого, 23 вывода. Кроме того, надо с Ардуинкой общаться, будем делать это через её последовательный интерфейс, это еще 2 пина. К сожалению, на моей УНО всего 20 выводов.

    Ну да не беда. Я не знаю ни одного человека, у которого есть Ардуино и нет 74HC595. Мне кажется, их продают только в комплекте. По крайне мере, у меня только микросхем типа 74HC00 больше, чем 595х. Так что их и используем. Тем более, что я сэкономлю место в статье, ведь работа 595х с ардуино прекрасно описана тут. 595ми будем генерировать адрес. Микросхем понадобится 2 штуки (так как у нас 13 бит адреса, а 595я имеет 8 выводов). Как соединить несколько 595х для расширения шины, подробно описано по ссылке выше. Замечу лишь, что в примерах по той ссылке OE (пин 13) 595х притягивают к земле. Мы же делать этого категорически не будем, мы пошлем туда сигнал с Ардуинки, так как выводы 595х будут подключены непосредственно к шине адреса ОЗУ, и нам не надо никакого паразитного сигнала там. После подключения выводов 595х к шине адреса ОЗУ, больше на макетах ничего делать не надо. Время подключать ардуинку. Но сначала напишем скетч:

    // CPU defines
    #define CPU_CLOCK_PIN 2
    #define CPU_RESET_PIN 3
    
    // RAM defines
    #define RAM_OUTPUT_ENABLE_PIN 4
    #define RAM_WRITE_ENABLE_PIN 5
    #define RAM_CHIP_ENABLE_PIN 6
    #define RAM_BUFFER_PIN 7
    
    // Shift Register defines
    #define SR_DATA_PIN 8
    #define SR_OUTPUT_ENABLE_PIN 9
    #define SR_LATCH_PIN 10
    #define SR_CLOCK_PIN 11
    
    //////////////////////////////////////////////////////////////////////////
    
    void setup() {
      // All CPU and RAM control signals need to be configured as inputs by default
      // and only changed to outputs when used.
      // Shift register control signals may be preconfigured
    
      // CPU controls seetup
      DDRC = B00000000;
      pinMode(CPU_CLOCK_PIN, INPUT);
      pinMode(CPU_RESET_PIN, INPUT);
    
      // RAM setup
      pinMode(RAM_WRITE_ENABLE_PIN, INPUT);
      pinMode(RAM_OUTPUT_ENABLE_PIN, INPUT);
      pinMode(RAM_CHIP_ENABLE_PIN, INPUT);
      pinMode(RAM_BUFFER_PIN, OUTPUT);
      digitalWrite(RAM_BUFFER_PIN, LOW);
    
      // SR setup
      pinMode(SR_LATCH_PIN, OUTPUT);
      pinMode(SR_CLOCK_PIN, OUTPUT);
      pinMode(SR_DATA_PIN, OUTPUT);
      pinMode(SR_OUTPUT_ENABLE_PIN, OUTPUT);
      digitalWrite(SR_OUTPUT_ENABLE_PIN, HIGH); // active low
    
      // common setup
      Serial.begin(9600);
      Serial.println("Hello");
    }// setup
    
    //////////////////////////////////////////////////////////////////////////
    
    void shiftReadValueFromAddress(uint16_t address, uint8_t *value) {
      // disable RAM output
      pinMode(RAM_WRITE_ENABLE_PIN, OUTPUT);
      digitalWrite(RAM_WRITE_ENABLE_PIN, HIGH); // active low
      pinMode(RAM_OUTPUT_ENABLE_PIN, OUTPUT);
      digitalWrite(RAM_OUTPUT_ENABLE_PIN, HIGH); // active low
      // set address
      digitalWrite(SR_LATCH_PIN, LOW);
      shiftOut(SR_DATA_PIN, SR_CLOCK_PIN, MSBFIRST, address>>8); 
      shiftOut(SR_DATA_PIN, SR_CLOCK_PIN, MSBFIRST, address);  
      digitalWrite(SR_LATCH_PIN, HIGH);
      digitalWrite(SR_OUTPUT_ENABLE_PIN, LOW); // active low
      // write value to RAM
      digitalWrite(RAM_OUTPUT_ENABLE_PIN, LOW); // active low
      delay(1);
      DDRC = B00000000;
      *value = PINC;
      digitalWrite(RAM_OUTPUT_ENABLE_PIN, HIGH); // active low
      // disable SR
      digitalWrite(SR_OUTPUT_ENABLE_PIN, HIGH); // active low
      pinMode(RAM_WRITE_ENABLE_PIN, INPUT);
      pinMode(RAM_OUTPUT_ENABLE_PIN, INPUT);
    }// shiftWriteValueToAddress
    
    //////////////////////////////////////////////////////////////////////////
    
    void runClock(uint32_t cycles) {
      uint32_t currCycle = 0;
      pinMode(CPU_CLOCK_PIN, OUTPUT);
      while(currCycle < cycles) {
        digitalWrite(CPU_CLOCK_PIN, HIGH);
        digitalWrite(CPU_CLOCK_PIN, LOW);
        currCycle++;
      }
      pinMode(CPU_CLOCK_PIN, INPUT);
    }// runClock
    
    //////////////////////////////////////////////////////////////////////////
    
    void trySpectrum() {
      pinMode(RAM_WRITE_ENABLE_PIN, INPUT);
      pinMode(RAM_OUTPUT_ENABLE_PIN, INPUT);
      pinMode(CPU_RESET_PIN, OUTPUT);
      digitalWrite(CPU_RESET_PIN, LOW);
      runClock(30);
      digitalWrite(CPU_RESET_PIN, HIGH);
      runClock(12500000);
    }// trySpectrum
    
    //////////////////////////////////////////////////////////////////////////
    
    void readDisplayLines() {
      uint8_t value;
      digitalWrite(RAM_BUFFER_PIN, HIGH);
      pinMode(RAM_CHIP_ENABLE_PIN, OUTPUT);
      digitalWrite(RAM_CHIP_ENABLE_PIN, LOW);
      for(uint16_t i=16384; i<16384+6144;i++) {
        shiftReadValueFromAddress(i, &value);
        Serial.println(value);
      }
      pinMode(RAM_CHIP_ENABLE_PIN, INPUT);
    }// readDisplayLines
    
    //////////////////////////////////////////////////////////////////////////
    
    void loop() {
      trySpectrum();
      Serial.println("Hope we are ok now. Please set up memory for reading");
      delay(40000);
      Serial.println("Reading memory");
      readDisplayLines();
      Serial.println("Done");
      delay(100000);
    }// loop

    Как видно из скетча (ну правда, вдруг, кто-то прочитал), я читаю шину данных в порт C. Как может помнить Ардуищик, в УНО порт C — это 6 пинов. То есть я читаю только 6 бит. Да, для простоты процесса, я игнорирую 2 старших бита в каждом байте экранного буфера. Это выльется в то, что каждые 2 пикселя через 6 будут всегда цвета фона. Пока прокатит, потом поправим. Это же скелет.

    Теперь по самому подключению. В принципе, все расписано в самом верху скетча:

    // CPU defines
    #define CPU_CLOCK_PIN 2 - пин 2 ардуины подключаем к пину 6 процессора (тактовый сигнал)
    #define CPU_RESET_PIN 3 - пин 3 ардуины подключаем к пину 26 процессора (RESET)
    
    // RAM defines
    #define RAM_OUTPUT_ENABLE_PIN 4 - пин 4 аруины подключаем к пину 22 ОЗУ (OE)
    #define RAM_WRITE_ENABLE_PIN 5 - пин 5 ардуины не подключаем никуда. Это остаток от старых скетчей.
    #define RAM_CHIP_ENABLE_PIN 6 - пин 6 ардуины тоже не подключаем никуда. Я пытался сделать управление памятью полностью с Ардуины, но на макетке это у меня не заработало. То ли из-за питания, то ли из-за качества макетки. Но скорее всего, по обеим причинам.
    #define RAM_BUFFER_PIN 7 - так же, как и пин 6, пока никуда не идет.
    
    // Shift Register defines
    #define SR_DATA_PIN 8   - пин 8 ардуины подключаем к пину 14 "младшей" 595й. У старшей этот пин подключен к пину 9 младшей, так что перепутать не получится.
    #define SR_OUTPUT_ENABLE_PIN 9 - к пинам 13 обеих 595х
    #define SR_LATCH_PIN 10 - к пинам 12 обеих 595х
    #define SR_CLOCK_PIN 11 - к пинам 11 обеиз 595х.
    

    Все просто. Вот как это выглядит у меня все в сборе (ардуинка порезалась на картинке, но там смотреть особо нечего):



    При запуске, Ардуино весело скажет Hello в последовательный порт компьютеру (пусть и виртуальный), и начнет мучить процессор. Основательно его помучив (пару минут), программа остановит беднягу и предложит вам ручками переставить джамперы на макетке, отключив память от шины адреса и управляющих сигналов процессора.

    Теперь надо ручками переставить проводок, подсоединенный к пинам 19 обеих 74HC245 c земли на +5В. Таким образом мы отключаем процессор от ОЗУ. Пин 22 самой микросхемы ОЗУ надо подключить к земле (я выше писал про проводок, который я воткнул просто в макетку пока, в неиспользуемое место). Таким образом мы принудительно включаем ОЗУ.

    После этого, подождав немного, Ардуинка начнет читать содержимое памяти и выводить его в столбик в последовательный порт. Будет много-много цифр. Теперь можно эти данные скопировать оттуда и вставить, скажем, в текстовый файл, не забыв подчистить весь ненужный текст (сверху пара строк, и «Done» внизу), нам нужны только цифры. Это то, что наш Спекки записал в видеопамять. Остается только посмотреть, что же там было, в видеопамяти. А видеопамять у Спектрума непростая

    Как видно, сами пикселы хранятся отдельно от цвета. Цвет пока будем игнорировать, давайте читать только сами пикселы. Но и их не так просто раскодировать. После долгих мучений Visual Studio, я пришел вот к такому элегантному решению:

    
    #include "stdafx.h"
    #include <windows.h>
    #include <stdint.h>
    #include <stdio.h>
    
    LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
    uint8_t *scrData;
    
    VOID OnPaint(HDC hdc) {
    	size_t arrSize = 6144;//sizeof(scrData) / sizeof(scrData[0]);
    	//int currRow = 0, currX = 0, currBlock = 0, currY = 0, currBase = 0;
    	for (size_t arrPos = 0; arrPos < arrSize; arrPos++) {
    		int blockPos = arrPos % 2048;
    		int currBase = (blockPos % 256) / 32;
    		int currX = blockPos % 32;
    		int currBlock = arrPos / 2048;
    		int currRow = blockPos / 256;
    		int currY = currBlock * 64 + currBase * 8 + currRow;
    		for (int trueX = 0; trueX < 8; trueX++) {
    			char r = ((scrData[arrPos] >> trueX) & 1)*255;
    			SetPixel(hdc, currX * 8 + (8-trueX), currY, RGB(r, r, r));
    		}
    	}
    }
    
    void loadData() {
    	FILE *file;
    	errno_t err;
    	if ((err = fopen_s(&file, "data.txt", "r"))) {
    		MessageBox(NULL, L"Unable to oopen the file", L"Error", 1);
    	}
    	scrData = (uint8_t*)malloc(6144);
    	int currDataPos = 0;
    	char buffer[256];
    	char currChar = 0;
    	int currLinePos = 0;
    	while (currChar != EOF) {
    		currChar = getc(file);
    		buffer[currLinePos++] = currChar;
    		if (currChar == '\n') {
    			buffer[currLinePos] = 0;
    			scrData[currDataPos++] = (uint8_t)atoi(buffer);
    			currLinePos = 0;
    		}
    	}
    	fclose(file);
    }
    
    INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, PSTR, INT iCmdShow) {
    	HWND                hWnd;
    	MSG                 msg;
    	WNDCLASS            wndClass;
    	wndClass.style = CS_HREDRAW | CS_VREDRAW;
    	wndClass.lpfnWndProc = WndProc;
    	wndClass.cbClsExtra = 0;
    	wndClass.cbWndExtra = 0;
    	wndClass.hInstance = hInstance;
    	wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
    	wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
    	wndClass.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
    	wndClass.lpszMenuName = NULL;
    	wndClass.lpszClassName = TEXT("GettingStarted");
    	RegisterClass(&wndClass);
    	hWnd = CreateWindow(
    		TEXT("GettingStarted"),   // window class name
    		TEXT("Getting Started"),  // window caption
    		WS_OVERLAPPEDWINDOW,      // window style
    		CW_USEDEFAULT,            // initial x position
    		CW_USEDEFAULT,            // initial y position
    		CW_USEDEFAULT,            // initial x size
    		CW_USEDEFAULT,            // initial y size
    		NULL,                     // parent window handle
    		NULL,                     // window menu handle
    		hInstance,                // program instance handle
    		NULL);                    // creation parameters
    	loadData();
    	ShowWindow(hWnd, iCmdShow);
    	UpdateWindow(hWnd);
    	while (GetMessage(&msg, NULL, 0, 0)) {
    		TranslateMessage(&msg);
    		DispatchMessage(&msg);
    	}
    	return msg.wParam;
    }  // WinMain
    
    LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) {
    	HDC          hdc;
    	PAINTSTRUCT  ps;
    	switch (message) {
    	case WM_PAINT:
    		hdc = BeginPaint(hWnd, &ps);
    		OnPaint(hdc);
    		EndPaint(hWnd, &ps);
    		return 0;
    	case WM_DESTROY:
    		PostQuitMessage(0);
    		return 0;
    	default:
    		return DefWindowProc(hWnd, message, wParam, lParam);
    	}
    } // WndProc
    

    Программа открывает файл data.txt из своей директории. В этом файле текстовый вывод ардуинки (после удаления всех лишних строк, как сказано выше.)

    Скормим ей полученный файл, и что в итоге:



    Да, пока результат очень далек от идеала, но это определенно вывод на экран. Причем, именно тот, что нужен. От ПЗУ с диагностической прошивкой.

    Ну, скелет компьютера готов. Да, пока использовать его никак нельзя, но зато видно, как предельно просто были устроены старые 8-битные компьютеры. Я еще побился немного над макеткой, но вывод стал только хуже. Похоже, следующий шаг — паять на нормальной, распаячной макетке, с нормальным питанием.

    Вот только надо ли?

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

    Надо ли ваять продолжение?

    • 82,4%да229
    • 8,6%нет24
    • 9,0%наверное25
    AdBlock похитил этот баннер, но баннеры не зубы — отрастут

    Подробнее
    Реклама

    Комментарии 132

      +2
      Сначала не понял, но проводки красиво лежат…
      Потом тоже не понял, но проводков больше — ещё лучше, вот тут:


      Понял!)
      Круто) не догадался бы в такой минимализм
      • НЛО прилетело и опубликовало эту надпись здесь
          +5
          Я его слепила из того, что было )
          Потом, прикрутить SPI-озу и пзу к Z80, это совсем нетривиальная задача )
          • НЛО прилетело и опубликовало эту надпись здесь
              +6
              Ах, так вы не читали…
              • НЛО прилетело и опубликовало эту надпись здесь
                  +11
                  Я надеялся, что человек, говорящий, где я сделал что-то не так, как следовало бы, хотя бы попытается понять, о чем он советы раздает. Но, оказалось, что это просто «не видел, но осуждаю». Это печально.
                  • НЛО прилетело и опубликовало эту надпись здесь
                      +5
                      Печально это то, что Вы не смогли в самом начале в паре абзацев нормально всё обобщить.

                      А вы уверены, что вы прочитали первые 2 абзаца, чтобы делать такой вывод? Или опять, не читали, но осуждаете?
                    +3
                    Как вы ловко комментарии переписываете, однако ))
                      +1

                      НЛО все удалило. Что там за диалог-то был?

                        +2
                        Да в целом бессодержательный. Человек интересовался, почему я такие древние микросхемы подключаю к такому бестолковому микроконтроллеру и зачем я все это здесь пишу. Прочитав только название и теги статьи.
                  +6
                  Какой ещё Z80

                  «Слона-то я и не приметил»©
              +2
              Наверное, больше него мне нравится только 486й чип
              А что в нём интересного? 386 на стероидах. Вот 386 после 286 была вещь, да ведь по факту до сих пор на нём сидим.
                +1
                Я не знаю, это какое-то личное отношение. Когда у меня был 386й, я очень завидовал друзьям с 486ми, они могли спокойно играть в Дум, Wong Commander 3 и т.п., которые у меня тормозили. После 386 у меня сразу появился Пентиум, и 486го у меня никогда не было. Но это магическое ощущение осталось.
                  +3
                  Вы путаете скорость с архитектурой. Конечно, 486DX100 ещё как обгонял 386DX33. Но по факту это был абсолютно тот же процессор, ну пау команд добавили, да, прям очень значимых (нет). Шину ускорили. А архитектура современного x86 до сих пор жива с 386.
                    +2
                    Если вы про ISA, то да, но она до AMD64 просто эволюционировала, пополняясь MMXами и SSE… А вот конвейера в 386м не было, он появился в 486м. Кэш 1го уровня, встроенный сопроцессор для плавающей точки, ИМХО, довольно значительные изменения архитектуры. Шину, кстати, особо не ускорили в 486м, если не брать монстрика 486DX-50, который без умножения работал. В остальных это были те же 33 (у АДМ — 40) МГц максимум, что и в 386.
                    Но это религиозные споры ))
                    Для меня и 386 и 486 — великолепные процессоры, просто 386 у меня был, когда я был подростком, а 486 появился только когда я начал хлам собирать. От этого такое отношение
                      +1
                      Были ещё, кстати, процессоры Pentium Overdrive, которые умели в сокете i486 работать!
                        0
                        с кэшем 1го уровня немножко ошибаетесь. я несколько лет работал на машине IBM PS/VP на основе 386SLC (https://en.wikipedia.org/wiki/IBM_386SLC). процессор включал в себе 8кбайт кэша и несмотря на узенькую шину, успешно обгонял по производительности 386DX-33 и чуток не дотягивал до 486SX-25. на нем успешно работали OS/2, сервер Lotus Notes, клиент Lotus Notes, емулированный осю Win 3.1, а в последнем Lotus 1-2-3, M$ Word и факс. это не показушная сборка для изложения, а работал на ней успешно пару лет.

                        по поводу великолепных процессоров можно, конечно, спорить. при наличии нужного количества пива, спорить можно с пеной у рта…
                        для Вас это 80386 и i486 (заметьте, кстати, разницу в официальных названиях!), а для меня это Am2900 и Am29000. с последними я познакомился еще в лохматом 1982 году, а Intel дошли до 32-битового уровня только в 1985м.
                        также многие молятся на Intel и с потолка объявляют Intel Hyperthreading прорывом и открытием века. кое-кто знает про первенство IBM Power4 Symmetric Multithreading, но мало кто видел зачатки последнего в 3м и 4м изданиях IBM RS64 (a.k.a. Power3).

                        а настоящими не просто великолепными, а велики процессорами стоило бы признать System/360, CDC 6600 и Cray-1. это титаны, наработками которых пользовались и IBM POWER, и Intel x86, и эти ваши ARM телефончики.
                        вот там уже можно говорить о религии ;)
                          0
                          Про 386SLC я в курсе, но он появился в 1991м, а 486й у Интел — в 1989м, то есть в 486м кэш появился раньше. А насчёт великолепия, вы правы, спорить можно очень очень долго. Я с Am29000 не сталкивался, но уверен, что это великолепный процессор, как и iAPX432 или i960.
                            0
                            да, IBM-овский вышел позже. замечание было в плане, что и 386-м присобачивали кэш с неплохим успехом. тем более, что не 486 изобрел это колесо.

                            насчет Am29000 сам в растеряности. читал о 2900 и 29000 в книге, вышедшей в оригинале в 1981 году. педивикия утверждает, что это другой процессор конца 80х. те, о которых читал, являлись секционными, Am2900 состоял из 4-битовых секции попроще, а секции Am29000 были 2-битовыми, но посложнее и побогаче. мой возторг им был вызван тем, что у Intel-а только появились 16-битовые процессоры, а до этого из секции можно было соорудить хоть 32-битовый. нехилое достижение, учитывая ограничения S/360 и даже S/370. также по сути это первые процессоры, позволяющие реализовать то, что потом назовут VLIW.

                            но да, великолепные это религия. у каждого своя.
                              0
                              Вики утверждает, что 29000 — это конец 80х.
                              Ну и у Интел 486й — это не первый 32х битник. iAPX — это начало 80х как раз.
                              i960 — это середина 80х. Он как раз был конкурентом 29000му.
                                0
                                будучи далеко от родного дома, не могу поднять старую книгу. но что читал ее в переводе где-то в 1983-84 годах и что была переводом книги с 1981, помню.
                                педивикия тоже указывает, что 2900 выпущен еще в 1975 году, так что все равно опережает и iAPX 432, и IBM 801. i960 намного позже. сперва i860, но оба позже Am2900. в последнем впервые увидел микропрограммирование, хотя не знаю первый ли ввел оного. в комплекте было ПЗУ, по адресам которого приходили внешние команды, а на выходах данных получались команды секции. часть адресов можно было оставить внутренними и крутануть цикл или микропрограмму. что с тем Am29000, что я помню, не знаю, но не суть.
                            +2
                            80386 и i486 (заметьте, кстати, разницу в официальных названиях!)

                            Можете уточнить, в чём именно разница?



                            На первом чипе нанесены бренд i386 и модель A80386DX-20; на втором — бренд i486 и модель A80486DX-25.
                              0
                              Легко. Приятно удивительно, но cpu-world знает толк в таких деликатесах:
                              — технология — 1,5 против 1 микрон,
                              — сокет — PGA132 против PGA168,
                              — частота и щина — 20 против 25 МГц,
                              — кеш L1 — 0 против 8 КБ,
                              — макс. тепловыделение — 2,63 против 3,68 Вт (были же счастливые времена!).
                                +1
                                Это прекрасное сравнение, но Caureus указывал на якобы разницу в официальных названиях, а не в технических характеристиках.
                                  0
                                  Соррею, не догадался. Политика именования процессоров — отдельная дикость. Нестандартно, малоинформативно и весьма тенденциозно.
                                    +2
                                    Вряд ли раскрою секрет, если как бывший сотрудник ARM вам расскажу, что в выборе названий для процессоров инженеры не участвуют никак, и новые названия они узнают из пресс-релизов одновременно со своими пользователями.
                                      0
                                      А цифровой индекс чипа, типа того же 80486 (или 80502 и 80503 для Пентиум и Пентиум ММХ), это тоже от маркетинга идет, или это другая кухня?
                              0
                              в официальных названиях, не в маркировке процессоров. выглядят, конечно, одинаково, но дошли разными путями. у 80386 стали появляться клоны и Intel захотели зарегистрировать как торговый знак. но им отказали, потому что числа не их изобретение. адвокаты покумекали и дошли до решения, что «Intel 80386» с пробелом нельзя, но «i386» можно зарегистрировать. так что оригинально процессор назывался 80386 официально, а i386 позднее изменение. когда выходит i486 в 1989 году, на него впервые ставят официальное название i486, а 80486 всего лишь неофициальная маркировка на корпусе. торговый знак i386 зарегистрирован только в 1991 году, тоесть после выпуска i486.

                              несмотря на годы авторского права, показанные Вами корпусы более поздного производства. в начале только 80386, потом с появлением 80386SX прежную модель переименовали на DX. от аналогии с 8086/8088 и 80186/80188 пришлось отказаться, поэтому буквы. аналогично сперва появился i486 на 20 MHz, а потом с появлением i486SX также переименовывают оригинал на DX. так что сами надписи на корпусе доказывают более поздние модели.
                              работал на машинках с 80386 и с i486 без никаких DX-ов, видел лично.
                          +5
                          Но по факту это был абсолютно тот же процессор

                          Ничосе заява!
                          И 486 и 68040 были знаковыми процессорами. Мейнстрим CISC довели до возможности выполнения команды за такт, что до этого было только на RISC, путём глубокой конвейеризации. Также на кристалл переехал FPU, который до этого был внешней микросхемой.
                            0
                            Не совсем так, 386-ые были последними чистыми CISC микропроцессорами. А 486-е за счет RISC ядра, которое наружу выглядело CISC, получало большой бенефит в производительности по сравнению с 386 на той же тактовой частоте.
                            Вот тут подробно об отличиях 386 и 486.
                              +1
                              Будьте добры источник на «RISC ядро» в 486.
                              В рувики это указано без ссылки, и в разделе отличий как раз не указано; в английской ничего подобного нет.
                                +1
                                Из IXBT «Архитектуры CISC и RISC: братанье после битвы?» плюс 4-х томник по архитектуре 486 где (если не изменяет память) говорилось тоже (сейчас к сожалению физически недоступен из-за «самоизоляции»).
                                В англоязычной вики в сноске «The 386, 286, and even the 8086 all had overlapping fetch, decode, execution (calculation), and write back; however, tightly pipelined usually means that all stages perform their respective duties within the same length time slot. In contrast loosely pipelined implies that some kind of buffering is used to decouple the units and allow them to work more independently. Both the original 8086 and the x86-chips of today are „loosely pipelined“ in this sense, while the 80486 and the original Pentium worked in a „tightly pipelined“ manner for typical instructions. This included most „CISC“ type instructions as well as the simple load/store-free „RISC-like“ ones, although the most complex also used some dedicated microcode control.»

                                И еще у Э Таненбаума в «Архитектура компьютера» 4-е издание
                                «Во-первых, компьютеры RISC были несовместимы с другими моделями, а многие компании вложили миллиарды долларов в программное обеспечение для продукции Intel. Во-вторых, как ни странно, компания Intel сумела воплотить те же идеи в архитектуре CISC. Процессоры Intel, начиная с 486-го, содержат ядро RISC, которое выполняет самые простые (и обычно самые распространенные) команды за один цикл тракта данных, а по обычной технологии CISC интерпретируются более сложные команды. В результате обычные команды выполняются быстро, а более сложные и редкие — медленно. Хотя при таком «гибридном» подходе работа происходит не так быстро, как у RISC, данная архитектура имеет ряд преимуществ, поскольку позволяет использовать старое программное обеспечение без изменений»
                              +1
                              А 486-е за счет RISC ядра, которое наружу выглядело CISC

                              Это неправда. Никакого RISC ядра там не было, ни снаружи, ни внутри.
                              Собственно нет и сейчас, хотят некоторые авторы любят говорить о мифическом RISC-ядре у современных CISC процессоров.

                              Если уж говорить о внутреннем RISC ядре, то надо смотреть в сторону K6-2.
                              Там они явно преобразовывали х86 операции в свой внутренний набор «RISC86».
                                0
                                НУУУ… ДЕКОДЕР команд в х86 и всякие МОПы наводят на мысли что нас всех обманывают(( А внутри стоит какое-нить RISC ядро… Хотя там по сути может быть вообще любое ядро стоять, вспоминая те приколы с внутренней VLIW архитектурой в ARM процессорах. Но явно не чистый CISC, об этом и сказанно
                                  +1
                                  Декодер команд есть в каждом процессоре, даже в 8008 (1972):

                                  В 8008 вам тоже привиделось RISC-ядро?
                                    –1
                                    Я вообще пошутил, надо было тэг добавить… Сам развлекаю себя написанием всяких CPU на FPGA.
                                    В 8008 вам тоже привиделось RISC-ядро?
                                    Но ведь кто-то именно так и думает. Да, спасибо
                                    0
                                    Без МОПов (ну, не традиционных МОПов, но стадий исполнения инструкции) CISC немыслим. В CISC много сложных инструкций. Они все делятся на стадии: загрузить значение из памяти в регистр, сложить с другим регистром и тп. Шагов много. Для этого придется делать декодер. Можно хард-ваерд, как любили в Cyrix, а можно и EPROM приделать.
                                    0
                                    Очень давно просил уважаемого khim написать про RISC и CISC. Все еще надеюсь )))
                                      +1
                                      Это неправда. Никакого RISC ядра там не было, ни снаружи, ни внутри.

                                      CISC в чистом виде остался в 80-х, как и ортодоксальный RISC. И Интел при создании 486 уперся в потолок архитектуры CISC, незначительные улучшения, значительно усложняло процессор. Плюс при анализе выяснилось конвейер 386 частенько простаивает, поскольку его «тормозят» сложные команды. И в попытках решить эти проблемы Интел пришел к идее использования наработок из мира RISC: кэша на процессоре, глубокого конвейера, микрокоманд (микроопераций), предсказания переходов, а потом и суперскалярность, спекулятивное исполнение команд и переименование регистров. Но все это появилось конечно далеко не сразу. Вот тут подробно
                                      Собственно нет и сейчас, хотят некоторые авторы любят говорить о мифическом RISC-ядре у современных CISC процессоров.

                                      PentiumPro и К5 укоризненно смотрят на вас недоумении, они уже с 1995 года RISCуют всем, как и их потомки, а вы им прямо так безапелляционно в лицо «Нет вас, и точка!»
                                      И если посмотреть в сторону AMD c RISC86, то вы ошиблись с поколением процессоров. Все началось гораздо раньше ещё во времена K5 в 1995году.
                                      Цитата из документации на K5
                                      The AMD-K5 processor uses an independently developed “superscalar RISC-based design” manufactured in AMD’s 0.35-micron complementary metal-oxide semiconductor (CMOS) process. The design stems from a rich history of experience in RISC and x86 technology, providing a solid foundation for the development of our proprietary 4.3-million-transistor AMD-K5 processor.

                                        0
                                        CISC в чистом виде остался в 80-х, как и ортодоксальный RISC.

                                        Что вы подразумеваете под «чистым CISC»?
                                        Bonnel 2008г вполне чистый CISC, конвейеризированный и суперскалярный конечно.
                                        MIPS/Sparc/RISC-V вполне ортодоксальные RISC. Cortex-A53(55), простой in-order RISC работает в большинстве современных смартфонов (впрочем ARM это RISC не на 100%).

                                        наработок из мира RISC: кэша на процессоре

                                        Каким боком кэш относится к RISC? Кэш был на IBM S/360, к примеру, как впрочем и OoO, loop buffer, префетч двух веток branch-а. В 60х-годах.
                                        И на 386 он был (внешний), и на 68030 (на чипе). А вот на ARM2 не было. Да и на многих современных ARM-ах нет кэшей.

                                        Остальные упомянутые вещи также ортогональны RISC/CISC-овости (и некоторые даже VLIW-ности). Это просто средства повышения производительности.

                                        PentiumPro и К5 укоризненно смотрят на вас недоумении, они уже с 1995 года RISCуют всем, как и их потомки, а вы им прямо так безапелляционно в лицо «Нет вас, и точка!»

                                        Я не утверждал что K6-2 был единственным, но он был самым популярным из этой серии.
                                        Не изучал эту микроархитектуру подробно, но с поверхностного взгляда сходство прослеживается.

                                        А вот в PentiumPro нет RISC-подобного ядра.
                                        Я говорил как раз об этом — о поверхностном понимании вещей.
                                        Pentium Pro это CISC с OoO, как и K7.

                                        Кстати говоря, высокопроизводительные RISC и CISC процессоры внутри практически не отличаются.
                                        Cortex-A77 имеет uop кэш, как и Sandy Bridge, разбивает команды на микрокоманды и собирает из них макрокоманды.
                                        ПЗУ микрокоманд используются и в RISC процессорах.
                                        Или вот Ares, серверный вариант Cortex-A76, похоже что может патчить команды, что обычно в RISC не делается.
                                          +2
                                          Что вы подразумеваете под «чистым CISC»?
                                          Конкретно я считаю последними массовыми «чистыми» CISC это Intel 386 и Motorola 68020/68030, поскольку начало их проектирования пришлось на 1981-1982 года и идеи RISC не успели как-то повлиять на их дизайн.
                                          Bonnel 2008г вполне чистый CISC, конвейеризированный и суперскалярный конечно.
                                          Вы ошибаетесь, я говорю это как пользователь данной микроархитектуры: "Bonnell is a CPU microarchitecture used by Intel Atom processors which can execute up to two instructions per cycle.[1][2] Like many other x86 microprocessors, it translates x86 instructions (CISC instructions) into simpler internal operations (sometimes referred to as micro-ops, effectively RISC style instructions) prior to execution. The majority of instructions produce one micro-op when translated, with around 4% of instructions used in typical programs producing multiple micro-ops. The number of instructions that produce more than one micro-op is significantly fewer than the P6 and NetBurst microarchitectures. In the Bonnell microarchitecture, internal micro-ops can contain both a memory load and a memory store in connection with an ALU operation, thus being more similar to the x86 level and more powerful than the micro-ops used in previous designs.[3] This enables relatively good performance with only two integer ALUs, and without any instruction reordering, speculative execution or register renaming. A side effect of having no speculative execution is invulnerability against Meltdown and Spectre.

                                          The Bonnell microarchitecture therefore represents a partial revival of the principles used in earlier Intel designs such as P5 and the i486, with the sole purpose of enhancing the performance per watt ratio. However, Hyper-Threading is implemented in an easy (i.e. low-power) way to employ the whole pipeline efficiently by avoiding the typical single thread dependencies.[3]"

                                          Плюс на IXBT есть шикарный цикл статей именно об архитектуре Atom, с разбором «Как? Почему? Зачем?» «Процессор Intel Atom: Всё, что вы хотели знать, но не могли найти» Часть 1, часть 2, часть 3.
                                          Выдержка из первой части: «Декодирование команд происходит двумя простыми трансляторами и одним микросеквенсором. Это несколько отличается от обычной схемы, где один из трансляторов является сложным, т. к. генерирует более одного мопа за такт (как правило — 3–4, по числу конвейеров). Все трансляторы декодируют по одной команде за такт. Микросеквенсор выдаёт по нескольку мопов (для Атома, разумеется, не более двух), но в течение нескольких тактов и только для особо сложных команд, требующих микрокода. Однако по оценке Intel лишь 4% команд потребуют более 1 мопа — микрослиянию подвергается 16% команд, в т. ч. такие относительно сложные как Load-Op-Store (с модификатором в памяти), которым ранее требовалось 2–3 мопа (из других x86-архитектур так умеет лишь AMD K10). Т. е. для Атома микрослияние уменьшило число обращений в микрокод впятеро. Таким образом, стремление к разбиению команд на простые RISC-операции для ускорения исполнения, очевидное сегодня и 15 лет назад (этим от P5 отличался P6, он же Pentium Pro), в данном случае обратилось вспять — за неимением возможности перетасовать команды, крайне расточительно забивать весь конвейер мопами (тем более, что он и так очень узкий) — а скорости и без этого достаточно.

                                          Выход декодера подключен к 32-моповой очереди, которая статически делится надвое при включенной HT. Весь front-end («голова конвейера» от предсказателя до очереди мопов) может работать в отрыве от back-end (исполнительного «хвоста») в случае задержек данных или исполнении долгой команды, наполняя очередь мопами про запас.»

                                          MIPS/Sparc/RISC-V вполне ортодоксальные RISC.

                                          MIPS настолько ортодоксален что официально имеет Application-specific extensions, которые описывают расширения команд от MIPS MCU и MIPS SIMD architecture до MDMX и MIPS-3D.
                                          Может у SPARC более чист и ортодоксален? А нет, есть Visual Instruction Set is a SIMD instruction set extension for SPARC V9 microprocessors developed by Sun Microsystems. There are five versions of VIS: VIS 1, VIS 2, VIS 2+, VIS 3 and VIS 4.
                                          Может RISC-V чистый и ясный, без следов легаси порадует взгляд пуриста и ортодокса? Нет, не порадует, расширения (15) сразу заложены в стандарт из них шесть зафиксированы, а оставшиеся в процессе разработки и наполнения.
                                          О чем это говорит? О том что все эти архитектуры не академическая разработка созданная чтоб доказать чистоту «крови и идей», а вполне прикладные, идущие навстречу обычному пользователю, стоящие на земле.
                                          Cortex-A53(55), простой in-order RISC работает в большинстве современных смартфонов (впрочем ARM это RISC не на 100%).
                                          Так Android больше и не надо, более того скажу Android x86 вполне комфортно себя чувствует на одноядерном P4 с Hyper-Threading, и даже на Atom-е. И про ARM (что это RISC не на 100%) поставим галочку. ;)
                                          Каким боком кэш относится к RISC?
                                          Тем боком, что на первом коммерческом микропроцессоре с архитектурой MIPS R2000, представленный в 1985 году, уже был кэш на процессоре. Причем не смешные 256 байт кэша команд 68020-го, а вполне приличные, даже по нынешним временам, 64кб под инструкции и 32кб под данные.
                                          Кэш был на IBM S/360, к примеру, как впрочем и OoO, loop buffer, префетч двух веток branch-а. В 60х-годах.
                                          IBM S/360 в 60-х существовал в виде одной интегральной схемы? Или хотя бы одной платы? В 60-е естественно? Нет? Тогда наверное и не стоит это обсуждать.
                                          И на 386 он был (внешний), и на 68030 (на чипе). А вот на ARM2 не было.
                                          У R3000 он был и на чипе 64кб+64кб, плюс 256Кб внешнего кэша, супротив максимального внешнего кэша в 128кб(обычно был 64кб) у 386, или 256+256 байт(0,5кб) кэша на процессоре у 68030 внешний кэш тоже был вроде 128кб максимум, но могу ошибаться. И у ARM3 кэш уже был, унифицированный на 4кб.
                                          Да и на многих современных ARM-ах нет кэшей.
                                          Большинство которых является микроконтроллерами, которым кэш нужен как рыбе зонтик.
                                          Остальные упомянутые вещи также ортогональны RISC/CISC-овости (и некоторые даже VLIW-ности). Это просто средства повышения производительности.
                                          Можно я процитирую «RISC vs. CISC: the Post-RISC Era»?
                                          «Instead of RISC or CISC CPUs, what we have now no longer fits in the old categories. Welcome to the post-RISC era. What follows is a completely revised and re-clarified thesis which found its first expression here on Ars over a year ago, before Ditzel spoke his mind on the matter, and before I had the chance to exchange e-mail with so many thoughtful and informed readers.

                                          In this paper, I'll argue the following points:

                                          1.RISC was not a specific technology as much as it was a design strategy that developed in reaction to a particular school of thought in computer design. It was a rebellion against prevailing norms--norms that no longer prevail in today's world. Norms that I'll talk about.
                                          2.»CISC" was invented retroactively as a catch-all term for the type of thinking against which RISC was a reaction.
                                          3.We now live in a «post-RISC» world, where the terms RISC and CISC have lost their relevance (except to marketing departments and platform advocates). In a post-RISC world, each architecture and implementation must be judged on its own merits, and not in terms of a narrow, bipolar, compartmentalized worldview that tries to cram all designs into one of two «camps.»"

                                          А вот в PentiumPro нет RISC-подобного ядра.
                                          P6 (microarchitecture)
                                          «P6 processors dynamically translate IA-32 instructions into sequences of buffered RISC-like micro-operations, and then analyze and reorder the micro-operations in order to detect parallelizable operations that may be issued to more than one execution unit at once. The Pentium Pro was not the first x86 chip to use this technique — the NexGen Nx586, introduced in 1994, also used it — but it was the first Intel x86 chip to do so.»
                                          Так что было.
                                          Кстати говоря, высокопроизводительные RISC и CISC процессоры внутри практически не отличаются.
                                          Cortex-A77 имеет uop кэш, как и Sandy Bridge, разбивает команды на микрокоманды и собирает из них макрокоманды.
                                          ПЗУ микрокоманд используются и в RISC процессорах.
                                          Или вот Ares, серверный вариант Cortex-A76, похоже что может патчить команды, что обычно в RISC не делается.

                                          Вот это фортель! Начали вы за здравие, а кончили за упокой.
                                          С чем вы изначально спорили «CISC в чистом виде остался в 80-х, как и ортодоксальный RISC», к этому выводу вы и вернулись «Кстати говоря, высокопроизводительные RISC и CISC процессоры внутри практически не отличаются.». А все потому что создатели процессоров работают не на «чистую идею», а ради пользователя который приносит им прибыль.
                                            0
                                            it translates x86 instructions (CISC instructions) into simpler internal operations (sometimes referred to as micro-ops, effectively RISC style instructions) prior to execution.

                                            Написанное не совсем верно. Да, сложные инструкции разбиваются, но их нельзя назвать RISC-овыми. Это просто микрооперации. CISC-овые load-op не разбиваются, а остаются одним МОП-ом.

                                            LOAD-OP инструкции это один из признаков CISC.(1)

                                            MIPS настолько ортодоксален что официально имеет Application-specific extensions, которые описывают расширения команд от MIPS MCU и MIPS SIMD architecture до MDMX и MIPS-3D.

                                            SIMD опять же никак не влияет на RISC-овость. С появлением SIMD вообще ничего не поменялось. Какой-нить ADD работает просто с другим набором регистров. Да можно даже этот набор не делать, как к примеру у DSP инструкциях ARMv6.
                                            А у CELL SPU — чистейшего RISC, как из книжки, вообще нет скалярной части. CISC архитектуры имеют load-op в SIMD, как правило. См. (1)

                                            IBM S/360 в 60-х существовал в виде одной интегральной схемы? Или хотя бы одной платы? В 60-е естественно? Нет? Тогда наверное и не стоит это обсуждать.

                                            Какое это имеет значение? Хоть на транзисторах реализуй — RISC отстанется RISC-ом.

                                            www.openpa.net/pa-risc_processor_pa-early.html
                                            These early CPUs still mostly were multi-chip processors with separate chips and components forming the central processing unit

                                            The TS-1 was the first PA-RISC production processor, introduced in 1986. It integrated version 1.0 of PA-RISC on six 8.4×11.3″ boards of TTL and was used in HP 9000 840 servers, the first PA-RISC computers.

                                            Кэш никак не связан с CISC/RISC подходом. Точка. Это часть иерархии памяти. Вынесите кэш из процессора (как в PA-RISC), и у него что, поменяется система команд? Господи, какая же ересь.

                                            Он есть и в VLIW и в любом другом процессора, где требуется оптимизация обращения к памяти.

                                            Пока что я вижу у вас непонимание смысла и признаков RISC.
                                            RISC — reduced INSTRUCTION SET architecture.
                                            Микроархитектура — это блэкбокс. Она действует по правилам, прописанным Архитектурой.

                                            Статьи, которые вы цитируете, я давно прочитал.

                                            P6 processors dynamically translate IA-32 instructions into sequences of buffered RISC-like micro-operations

                                            Можно документ от Интел увидеть? В вики кто только не пишет (как и статьи для неспециалистов на популярных сайтах).

                                            Вот это фортель! Начали вы за здравие, а кончили за упокой.

                                            Отнюдь. Мир не ограничивается одними только высокопроизводительными процессорами. Сходство микроархитектур не влияет на архитектуру, потому что микроархитектура лишь средство повышения производительности.

                                              –1
                                              Поспешил.
                                              Сходство микроархитектур не влияет на архитектуру, потому что микроархитектура лишь средство повышения производительности.

                                              Имел в виду что-то типа:
                                              Микроархитектура — физическая реализация Архитектуры, даёт возможность повышения производительности теми или иными методами, но всё это происходит в рамках Архитектуры.

                                              Вот проплывает облако, похоже на слона. Но это не делает его слоном.
                                              Так и с «RISC-like» микрооперациями.
                                              В P6 они действительно похожи на RISC, поэтому выражение RISC-like микрооперации можно использовать для объяснения сути (для людей, поверхностно знакомых с этими понятиями), а вот утверждать что у него RISC-ядро — нельзя.

                                              С чем вы изначально спорили «CISC в чистом виде остался в 80-х, как и ортодоксальный RISC»,

                                              Именно. Это не верное утверждение.
                                              RISC-V = ортодоксальный RISC (по крайней мере RV64IMAC).
                                              В RV32I даже умножения нет — слишком сложная инструкция :)
                                              Он не только не остался в 80-х, а наоборот, увеличивает присутствие.
                                              Ну и вообще RISC процессоров (почти таких же, как и в 80-е) сейчас выпускается огромное количество — ARM-ов в год продаётся > 20 миллиардов штук.
                                                +2
                                                Написанное не совсем верно. Да, сложные инструкции разбиваются, но их нельзя назвать RISC-овыми. Это просто микрооперации. CISC-овые load-op не разбиваются, а остаются одним МОП-ом.

                                                LOAD-OP инструкции это один из признаков CISC.(1)

                                                Вот в этой лекции "Исполнение процессорами инструкций x86 и x64 (Лекция)" подробно рассказывается про то как кодовый поток х86 разбивается на МОПы, и что делается чтоб процессор не захлёбывался на оборотах.
                                                «Кэш инструкций в процессоре P-4 очень сильно отличается от I-кэша в процессоре классической архитектуры. В нём преобразование исходных x86-инструкций в МОПы производится перед кэшем, а в кэш помещаются целые трассы, составленные из этих МОПов. Поэтому такой кэш в процессоре P-4 называется «кэш трасс»»
                                                Кусок из части Исполнение инструкций
                                                Большинство процессоров обрабатывают и исполняют инструкции архитектуры x86 (называемой также IA-32) и расширенной архитектуры x86-64 (называемой также AMD64 либо EM64T). Принципиальных различий по структуре машинной инструкции между архитектурами x86 и x86-64 нет, поэтому по тексту будем везде использовать общее наименование «x86-инструкции». Эти инструкции имеют очень сложный и нерегулярный формат и могут состоять из нескольких составных частей: одного или нескольких однобайтных префиксов, кода операции длиной от 1 до 3 байтов, описателя типа адресации операндов (ModR/M), указателя регистров базы, индекса и масштаба индексирования (SIB), поля смещения адреса и непосредственного операнда. Длина x86-инструкции может варьироваться от 1 до 15 байтов.
                                                Для суперскалярной обработки необходимо в каждом такте извлекать из входного потока несколько инструкций переменной длины и отправлять каждую из них в отдельный блок декодирования для преобразования в микрооперации (МОПы). Эта задача представляется очень трудоёмкой, поэтому необходимо применение специальных средств, которые позволили бы её облегчить. В разных процессорах x86 используются различные приёмы и механизмы, обеспечивающие бесперебойную обработку инструкций. Лишь для процессора PPC970 не требуется никаких ухищрений, так как в RISC-архитектуре IBM Power машинные инструкции имеют фиксированную длину (4 байта) и регулярный формат. По типу используемых механизмов рассматриваемые процессоры можно разбить на четыре класса:
                                                PPC970: Не используется никакой механизм, так как инструкции имеют фиксированную длину и формат.
                                                P-III, P8: После выборки из I-кэша производится разметка инструкций (определение их границ и положения кода операции) в устройстве, называемом определителем длины инструкций (Instruction Length Decoder, ILD).
                                                K8: Перед помещением блоков инструкций в I-кэш производится предварительное декодирование (предекодирование) с аналогичной разметкой, информация о разметке записывается в дополнительные биты при каждом байте в I-кэше.
                                                P-4: Перед помещением в кэш производится полное декодирование инструкций, сформированные МОПы записываются в этот кэш (Т-кэш) в виде трасс.
                                                Ниже будет для примера рассмотрен процесс исполнения инструкций только для архитектуры P-III и P-8. Более подробно об исполнении инструкций процессорами другой архитектуры можно узнать из статьи, ссылка на которую сделана в конце лекции.
                                                Процессоры Intel Pentium III, Pentium M и Core Duo
                                                В процессорах семейства P6 инструкции считываются из I-кэша выровненными блоками по 16 байтов за такт. Выборка производится с опережением – у процессора есть два буфера, в которые помещаются два последних считанных блока. На вход подсистемы декодирования в каждом такте передаётся порция байтов, начинающаяся с того места, где была прекращена обработка в предыдущем такте. Длина этой порции ограничена также 16 байтами. Порция байтов поступает на вход определителя длины инструкций (ILD), который производит её разметку – нахождение границ и положения кода операции в каждой x86-инструкции.
                                                Определитель длины инструкций должен быть обязательно реализован неконвейерным образом, с временем работы 1 такт – так как в следующем такте надо будет размечать новую порцию, начинающуюся после последней инструкции, размеченной в данном такте. Определитель содержит 16 одинаковых устройств, построенных на основе программируемых логических матриц (PLA). На вход каждого такого устройства подаётся фрагмент кода длиной 4 байта, начинающийся с одного из 16 байтов в обрабатываемой порции. Устройство (PLA) представляет собой примитивный декодер, который предполагает, что данный фрагмент является началом x86-инструкции (без префиксов), и пытается определить её длину. Кроме того, это устройство анализирует первый байт в фрагменте и определяет, не может ли он являться префиксом.
                                                Результаты работы всех таких устройств собираются воедино с помощью цепочки схем быстрого переноса. По существу, эти схемы последовательно выстраивают список инструкций на основе данных о длинах и признаках наличия префиксов, начиная с первой инструкции в обрабатываемой порции байтов. По результатам этого выстраивания в специальных массивах делаются пометки о позициях кода операции и последнего байта в каждой инструкции. Эта информация используется в последующем такте для извлечения инструкций из буфера и передачи их на вход трёх каналов декодера.
                                                В некоторых случаях определитель длины инструкций не может произвести разметку за один такт. Например, если встречается префикс, меняющий длину непосредственного операнда или смещения адреса в инструкции с 16 бит на 32 бита, либо наоборот, определитель переходит в «медленный» режим, размечая по 4 байта за такт. Однако такие случаи не часты и по существу представляют собой нарушение правил программирования. Кроме того, разметка замедляется, если в какой-то инструкции встречается два или более префиксов – в этом случае обработка каждого дополнительного префикса занимает один такт. На практике эта ситуация также очень редка.
                                                После разметки три выделенные x86-инструкции передаются в основной декодер – точнее, в три параллельно работающих канала декодирования. Эти три канала не являются полностью симметричными – только первый из них может обработать любую инструкцию, а оставшиеся два имеют ограничения: инструкция должна иметь длину до 8 байтов и порождать только один МОП. У первого канала декодирования таких ограничений нет – он может породить до 4 МОПов в одном такте, параллельно с работой двух других каналов. Для обработки самых сложных инструкций (более 4 МОПов) требуются дополнительные такты, и в этом случае обработка ведётся последовательно.
                                                Таким образом, схему работы декодера в процессоре P-III можно обозначить как «4-1-1 / >4»: он может обрабатывать в одном такте, либо три инструкции, порождающие до 6 МОПов (4+1+1), либо одну, порождающую более 4 МОПов. Порождаемые МОПы накапливаются в небольшой очереди перед отправкой (группами по три) в последующие тракты процессора. Схема «4-1-1» накладывает определённые ограничения на оптимальное размещение x86-инструкций в коде: сложные инструкции (в частности, инструкции типа Load-Op) должны чередоваться с простыми, а не следовать подряд друг за другом. Впрочем, даже при плотном размещении нескольких сложных инструкций всё равно в каждом такте будет порождаться как минимум 2 МОПа, а очередь МОПов после декодера позволит сглаживать возникающие неравномерности.
                                                В процессоре P-III при декодировании инструкций загрузки из памяти с последующим исполнением (Load-Op) порождаются отдельные МОПы для загрузки и для выполнения. Аналогично, для инструкций выгрузки в память также порождаются два отдельных МОПа: для вычисления адреса, и для осуществления записи. В обоих случаях два МОПа обслуживаются в последующих трактах процессора по отдельности и занимают его ресурсы. Из-за частой встречаемости инструкций, содержащих загрузку из памяти и выгрузку в память, среднее число МОПов на одну x86-инструкцию может находиться в диапазоне от 1.3 до 1.5.
                                                Начиная с процессора P-M, в декодере реализован механизм «слияния микроопераций» (micro-ops fusion), когда порождается единый МОП, содержащий два элементарных действия. Разделение на эти элементарные действия происходит при запуске МОПа на исполнение. Механизм слияния микроопераций похож на аналогичный механизм в процессорах AMD K7/K8. Этот механизм экономит ресурсы буферов и увеличивает эффективную пропускную способность трактов процессора. Благодаря такому механизму среднее число МОПов на одну x86-инструкцию значительно снижается и становится близким к единице. Кроме того, инструкции Load-Op могут теперь обрабатываться во всех трёх каналах декодера, что, практически, сводит на нет недостатки несимметричной схемы «4-1-1».

                                                SIMD опять же никак не влияет на RISC-овость.
                                                Набор инструкций увеличился и стал сложнее, команды явно не за один такт выполняются и это не оказывает влияние на конвергенцию с CISC?
                                                А у CELL SPU — чистейшего RISC, как из книжки, вообще нет скалярной части.
                                                Так у него (ядра на архитектуре POWER) сопроцессоров как у дурака фантиков. Правда разработчики игр на PS3 от такого богатства выбора тихо выли и готовы были стреляться, но «проблемы индейцев шерифа не волнуют». Так что мощный числогрыз, но нишевый.
                                                Какое это имеет значение? Хоть на транзисторах реализуй — RISC отстанется RISC-ом.
                                                Поскольку обсуждаются микропроцессоры (реализованные на одном чипе). А нам трааамзисторах тоже можно реализовать (на МП42), только в лучшем случае это будет калькулятор с системой команд RISC.
                                                Кэш никак не связан с CISC/RISC подходом.
                                                С RISC-ом кэш связан тем что он впервые смог поместится рядом с процессором, и мог работать с процессором в унисон, а не по заявке «когда там шина освободится, тогда байтики и поедут, а пока процессор сиди и жди пока флаг MRDY на шине не поднимется». А почему кэш на кристалл поместился? Возьмем к примеру кристалл 386 375000 транзисторов и процессор ARM2 — 27000 транзисторов. Если его разместить на кристалле 386 у нас останется незадействованными 348000 транзисторов. Много это или мало? Посчитаем для статической памяти и для динамической. Статическая ячейка памяти на один бит 6 транзисторов что дает нам 58000 бит или 7250 байт. Затратно? Затратно — но очень быстро и без задержек. На динамической все немного проще: 3 транзистора и конденсатор — 116000 бит или 14500 байт. Медленнее чем статика, но быстрее чем далекая память на шине. Надеюсь так я смог вам на пальцах объяснить как RISC приблизил кэш к процессору и объединился с ним на одном кристалле.
                                                Пока что я вижу у вас непонимание смысла и признаков RISC.
                                                RISC — reduced INSTRUCTION SET architecture.
                                                EXTENDED (MIPS/Sparc/RISC-V нужное подчеркнуть) reduced instruction set computer — Расширенный Сокращенный набор инструкций компьютера, немного как оксюморон звучит, не находите? ;)
                                                Микроархитектура — это блэкбокс. Она действует по правилам, прописанным Архитектурой.
                                                Блин, а я о чем говорю уже сколько времени? Для упрощения можно считать что I9-9990XE это все тот же 8086 из 1978 года с небольшими ограничениями, просто работающий 5 гигагерц вместо 5 мегагерц. Просто они оба следуют ISA x86.
                                                Статьи, которые вы цитируете, я давно прочитал.
                                                Но возможно я освежил ив в вашей памяти, плюс подсказал вам о RISC ядре у AMD K5.
                                                Можно документ от Интел увидеть?
                                                Постараюсь найти, но у меня такое чувство что Intelпосле определенного времени стал документацию выдавать только под NDA. Так может Интел и попросим поделиться с нами?
                                                В вики кто только не пишет (как и статьи для неспециалистов на популярных сайтах).
                                                Так сделайте мир чище, поправьте википедию, напишите статьи для неспециалистов.
                                                Отнюдь. Мир не ограничивается одними только высокопроизводительными процессорами.
                                                А я такого нигде не утверждал, вон Zilog Z80 на куче SoC крутится, руководя более мощными специализированными процессорами.
                                                Сходство микроархитектур не влияет на архитектуру, потому что микроархитектура лишь средство повышения производительности.
                                                Я цитировал эту фразу, процитирую её еще раз "RISC это не технология, RISC это стратегия дизайна. Когда то RISC был бунтом против норм, сейчас он — норма". А поскольку RISC это стратегия дизайна то она может быть приложена к любой технологии.
                                                Поспешил.
                                                Бывает, ни каких проблем.
                                                Имел в виду что-то типа:
                                                Микроархитектура — физическая реализация Архитектуры, даёт возможность повышения производительности теми или иными методами, но всё это происходит в рамках Архитектуры.

                                                Вот проплывает облако, похоже на слона. Но это не делает его слоном.
                                                Не совсем правильная ассоциация, правильная будет такая: вот акула, целакант, дельфин и касатка, выглядят они похоже, но происхождение у них разное, кто то всегда был морским жителем, чьи-то родственники вышли на сушу, но через огромный период времени их потомки вернулись в океан. За счет одинаковых условий стратегия развития у них была одна и та же. Поэтому и внешний вид у них похожий.
                                                Так и с «RISC-like» микрооперациями.
                                                В P6 они действительно похожи на RISC, поэтому выражение RISC-like микрооперации можно использовать для объяснения сути (для людей, поверхностно знакомых с этими понятиями), а вот утверждать что у него RISC-ядро — нельзя.
                                                Выше я уже приводил ссылку на лекцию, в которой прямо говориться о предварительном декодировании х86 команд в МОП, что МОПы загружаются в независимые конвейеры МОП, что МОПы реорганизуются в этих очередях, что регистры с которыми работают МОПы переименовываются, плюс с Р4 кэш команд заполняется именно МОПми, а не кодами х86. Разве этого мало чтоб назвать все это highly likely RISC-alike?
                                                Именно. Это не верное утверждение.
                                                RISC-V = ортодоксальный RISC (по крайней мере RV64IMAC).

                                                Ну в RV64IMAC как минимум есть следующие расширения:
                                                M — стандартное расширение для целочисленного умножения и деления
                                                A — стандартное расширение для атомарных инструкций
                                                C — стандартное расширение для сжатых инструкций
                                                В RV32I даже умножения нет — слишком сложная инструкция :)
                                                Умножение для слабаков, сдвиг наше все ;)
                                                Он не только не остался в 80-х, а наоборот, увеличивает присутствие.
                                                И RISC-V бодается с старичком MIPS-ом который родом именно из 80-х.
                                                Ну и вообще RISC процессоров (почти таких же, как и в 80-е) сейчас выпускается огромное количество — ARM-ов в год продаётся > 20 миллиардов штук.
                                                Так вы же сами говорили что ARM не кошерные настоящие? :D
                                                Тем более я и не спорил с тем что RISC себя оправдал. Он просто эволюционировал все эти годы. А если серьезно на вскидку что на RISC у меня, древний фотик с китайским SUNPLUS-ом MIPS, читалка на Samsung SoC MIPS, древний видеоплеер на ARM, игровая приставка на ARM, SmartTV приставка на ARM, TV приставка на MIPS. Это только на вскидку в моем хозяйстве. Ааа вспомнил — Diamond Stealth S220 (Rendition Verite V2100) у меня был — в его ядре MIPS лежал.
                              +1

                              Спасибо за статью! Было бы классно увидеть продолжение, очень понравился и сам подход, и результат. Больше Z80, хороших и разных)

                                0
                                Спасибо! Будем стараться.
                                +9
                                Нарядно, спасибо.
                                Наверное, больше него [Z80] мне нравится только 486й чип, но до него руки дойдут еще нескоро, ибо вставить его в макетку сложно и бессмысленно. Придется паять.
                                Где-то в середине 90-х один знакомый разработчик получил заказ на проектирование масспектрометра. Разработал он его на 386-ом процессоре. Тогда как раз разработчикам купили свеженькие компьютеры на 486-ых, да памяти по 2 МБ. Двухслойные печатные платы заказывали в конторе, где техпроцесс был расписан на неделю (печать фотошаблона, нанесение резиста, засветка, травление, сверление, пистонирование переходных отверстий, лужение).
                                И вот через неделю сообщают — всё пропало, отпал фоторезист, как раз на месте стоногого процессора — полупереваренная каша из меди. Пардоньте, через неделю будет в лучшем виде.
                                А у разработчика сроки горят. Что сделал бы нормальный разработчик — сообщил бы заказчику, дескать события непреодолимой силы, давайте сдвинем на недельку и улетел бы их спутник без спектрометра. Но наш был ненормальный (как и ТС, и это хорошо). Он срезал лезвием непротрав, продублировал дорожки тонкой лужёнкой, залил ПВА, запаял процессор, запустил и отладил плату, написал прошивку и сдал опытный образец изделия в срок.
                                Здравая доля ненормальнинки в разработчике может и должна быть.
                                Спасибо за статью.
                                  0
                                  Где-то в середине 90-х один знакомый разработчик получил заказ на проектирование масспектрометра.

                                  СЭЛМИ?
                                    0
                                    На тот момент небольшая частная фирма на территории распадающегося предприятия.
                                      0
                                      Так и не понял, Сумы это или нет ) Просто интересно, что там живо из научприборов сейчас.
                                        0
                                        Ответил в личку.
                                    +2
                                    Тру-разработчик!
                                    +3
                                    … 10 пФ слишком большое реактивное сопротивление, не будет шунтировать по питанию, 100nF или 1uF, или оба в параллель.
                                      0
                                      Спасибо, учту!
                                      +3
                                      «1 микросхема FPGA вместит компьютерный класс Спектрумов»

                                      Ахаха, вы сделали мой день!
                                        –1
                                        О, ну и идея у меня появилась. Потянет ли одно бюджетное Android-устройство эмуляцию не одного БК или ДВК, а всего КУВТ-86 из двенадцати БК и одного-двух ДВК вместе с локалкой? Уверен, что легко.
                                        +3
                                        Ох и порнография… Теплая ламповая пятничная порнография! Спасибо!

                                        Крякозябры на скриншоте экрана это от того, что только 6 из 8 бит считываются, или есть дополнительные проблемы? Будет ли ардуинка успевать считывать и передавать данные?

                                        Еще серьезная проблема есть с тем, что по сути реализован DMA как я понял. В релейном компе у меня похожий принцип работы индикаторной панели — мне нужно некоторую область ОЗУ вывести на матрицу 16*32.
                                        Проблема моего видео-МК была в том, что он мешает работе процессора. В итоге я его перевел в режим монитора.
                                        т.е. читаем ША и ШД с помощью 74HC165 и если пришедший адрес попадает в диапазон адресов видеопамяти, то считываем его и передаем дальше, если нет, ничего не делаем.

                                        Строб записи на 165 можно завести от логики Z80 — тогда он сам будет при каждом обращении к ОЗУ на запись обновлять содержимое буфера.
                                        Тут, правда, встает вопрос скорострельности записи и считывания — можно не успеть считать. 165-е.
                                          0
                                          Спасибо )
                                          Крякозябры не только из-за 6и бит. Внизу экрана непрорисованые горизонтальные линии — это либо отсутствие нужных данных в ОЗУ, либо ошибка чтения самой ардуиной. Ардуинки будет сильно мешать, по крайней мере в том виде, в котором она работает сейчас. Хардварно реализовывать видеовывод как-то не хочется, это получится очередной клон Спектрума, один из миллионов… буду думать )))
                                          +1
                                          На схеме Арлекина этот сигнал, почему-то, подключен через резистор. Сделаем так же. Зачем, я не знаю. Может, умные люди подскажут в комментариях…

                                          Этот сигнал параллельно подключен к слоту для периферии. Благодаря этому, периферия может принудительно отключать встроенное ПЗУ спектрума и подключать вместо него своё. Резистор нужен чтобы избежать конфликта между ULA и периферией. Эта функция используется, например, в Beta Disk Interface, DivMMC, ZX Dandanator Mini и т.д.
                                            0
                                            Спасибо!
                                            +3

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


                                            • Архитектура NES впечатляет и удивляет одновременно: неужели в 83 году имело смысл так экономить память? Спектрум в 82 имел 16-48кб памяти и это была low-end машина.
                                            • Game Boy и Sega Master System по своему интересны: в видеопамять все не помещалось, пришлось порезать количество спрайтов/тайлов (в Game Boy) или размер карты тайлов (Sega Master System).
                                            • Видеоподсистема Atari 2600 вообще где-то за гранью разумного. Вроде бы и понимаешь, почему было так сделано, но все равно ощущение какой-то жести и садизма для разработчиков.

                                            Кстати, для любителей поиграть на эмуляторе спектрума могу порекомендовать отличную для этого дела ретро-железку Nintendo DS. Она просто идеально подходит для эмуляции:


                                            • Экраны 256х192, как раз то, что надо
                                            • На верхнем экране игра, на нижнем клавиатура с резистивным тач скрином
                                            • Есть джойстик (на самом деле геймпад)
                                              +1
                                              Архитектура NES впечатляет и удивляет одновременно: неужели в 83 году имело смысл так экономить память? Спектрум в 82 имел 16-48кб памяти и это была low-end машина.

                                              Если вы имеете в виду набортную RAM, то её стоило экономить затем, чтобы в 64 Кб адресного пространства осталось место для 32 Кб картриджа. У Спектрума же не было сменных картриджей, и программы загружались в основную RAM.
                                                +1
                                                картриджи NES вроде умели подменять банки памяти. Хотя, конечно, это не так удобно, как линейная адресация.
                                                  +1
                                                  Когда создавалась архитектура NES, то картриджу выделили 32 Кб адресного пространства. Когда этого перестало хватать, то создателям картриджей пришлось изощряться и реализовывать подмену банков. Например, Prince of Persia, описанный в одном из недавних топиков, имел 128 Кб ROM — больше, чем всё адресное пространство целиком.
                                                    0

                                                    Так ведь вопрос не в ROM картриджа. Половину адресов отдать в картридж это ок. Когда ROM память подешевела началось с мапперами, банками памяти и прочим. Тут-то как раз все понятно, решение правильное и логичное.


                                                    Вопрос в остальных 32кб адресного пространства. RAM памяти-то всего 2кб. Конечно, не 128 байт, как у Atari 2600, например. Но, как мне кажется, в 83 году можно было бы и побольше поставить. Специально сравнил со спектрумом, у него в 82 было 16-48кб.


                                                    А еще видеопамять. Там тоже интересная архитектура. 2кб RAM для тайлов + 256 байт под спрайты в приставке и 8кб адресуется ROM на картридже. И в целом ок, но у видеоподсистемы NES такая ахитектура, что ей по-хорошему нужно 4кб под тайлы. Без этого довольно сложно делать игры, в которых прокрутка экрана по двум осям. Вопрос был в том, имел ли смысл экономить эти 2кб?


                                                    Хотя все-же еть предположение почему могло иметь смысл экономить. Возможно, в то время не было доступных микросхем с большим объемом памяти. В этом случае надо было бы ставить больше микросхем, усложнять разводку и т.п. Но это только предположение, я не знаю как было на самом деле.

                                                      +1
                                                      На Спектруме просто не было другого выбора, кроме как поставить много RAM: сменных ROM нет, программы можно запускать только из RAM.

                                                      Соотношение 1:16 между RAM и ROM отражает типичную потребность программ; можете сравнить со свеженьким micro:bit, в котором 16 Кб RAM и 256 Кб Flash.
                                              +4
                                              я как будто заново читал приложение к журналу Юный техник за кажется 1986 год. Только с поправками на современность. Те же эмоции :) Спасибо!
                                                0
                                                Браво!
                                                  +1
                                                  Когда-то, учась в школе, мечтал реализовать плату расширения для Спекки и втыкать в нее модули, как это было сделано в "Поиске". Даже несколько прототипов сделал и продал на местном радиорынке… Вот такую звуковуху сваял на коленке (прототип)

                                                  –10

                                                  Простите, аффтар, вы ПРИНЦИПИАЛЬНЫЕ СХЕМЫ умеете рисовать? Это вас в ардебилино-сообществах научили вместо чтоб нарисовать обычную и всем понятную схему — копипастить распиновку микросхемы и подписывать куда это якобы подсоединено? А потом еще портянку текста писать о том же:


                                                  В нашем случае, мы подключаем сам декодер следующим образом: старший бит (3я нога) к земле, там всегда будет 0.
                                                    +2
                                                    Нет, не умею. Я об этом написал вверху.
                                                    Ну и потом такую схему как-то странно рисовать. Там 5 корпусов всего…

                                                    Кстати, если подскажете какой-нибудь онлайн ресурс для рисования схем, буду признателен.
                                                      +1
                                                      А вы лучше возьмите какой-нибудь SPlan 7 (или какой там последний) и там можно весьма и весьма просто нарисовать схему и экспортировать, например, в gif. В Orcad тоже можно, но ради картинки осваивать orcad…
                                                        0
                                                        Вот с осваивать — очень тяжело, так как это просто хобби. Интересно, да, но тратить много времени просто не получается. Попробую SPlan, спасибо!
                                                          0
                                                          Я, например, SPlan и прочие так и не смог освоить, несмотря на то, что могу
                                                          такое
                                                          image
                                                          Я этим не горжусь, но при нескольких попытках не сумел преодолеть порог вхождения, нервы быстро заканчиваются. В результате для создания электрических (не электронных) схем сделал свою программу.
                                                          +2
                                                          Если лень качать и осваивать софт для профессионалов, то app.diagrams.net
                                                            +1
                                                            спасибо! Буду пробовать.
                                                            +1
                                                            Кстати, если подскажете какой-нибудь онлайн ресурс для рисования схем, буду признателен.

                                                            easyeda.com, прост как 2 копейки, огромная база компонентов, там же можно и платы разводить, и заказывать по 2 бакса за десяток.

                                                            За статью спасибо, сейчас сяду вторую часть осиливать
                                                          0
                                                          Не хватает нормальной схемы.
                                                            +4
                                                            Второй голос за схему. Значит, придется учиться рисовать.
                                                            В продолжении постараюсь сделать.
                                                            +4
                                                            Я не знаю ни одного человека, у которого есть Ардуино и нет 74HC595.
                                                            Я — такой человек :) Но я, конечно, не пытался подключать Ардуино к Z80.
                                                            Крутая статья!
                                                              +1
                                                              >Хардварно реализовывать видеовывод как-то не хочется, это получится очередной клон Спектрума, один из миллионов…
                                                              Я бы с огромным удовольствием прочитал статью (или цикл) об устройстве Спекки и его сборке с нуля по шагам. Схем в Инете полно, но самому разбирать их руки не дойдут, да и профиль не тот. А вот в виде описание что и как устроено и почему — с огромным удовольствием.
                                                                0
                                                                В этом случае очень настойчиво буду вам рекомендовать вот эту книгу. Её не только интересно прочитать, но и собрать клон, описаный в ней проще простого: это и есть тот самый Арлекин, про который я писал. И разведённые платы под него продаются почти во всех интернет-магазинах, связанных с ретро, в том числе на ибее. Есть в продаже и готовые наборы плата+комплектуха.
                                                                Я постараюсь в продолжении побольше рассказать об устройстве самого спекки, само собой, но с этой книгой сложно сравнится. Это очень большой труд очень талантливых людей. Оно того стоит, правда.
                                                                  0
                                                                  Does this book exist on Russian? :)
                                                                    0
                                                                    Кстати, да, вы правы… Об этом я не подумал.
                                                                    Вы мне придали вдохновения, на русском я подобной литературы пока не видел ). Спасибо!
                                                                      +1
                                                                      Я уже заказал ее на амазоне. Буду читать :)
                                                                      Но от этого Ваши статьи менее интересными не станут :)
                                                                        0
                                                                        Спасибо )
                                                                0
                                                                А двухпортового ОЗУ на нужный объём у вас, случайно, нет? С ним можно элементарно было бы решить всю работу с ULA. Правда, такие микросхемы довольно дорогие…
                                                                  0
                                                                  Нет, двухпортового, конечно же, нету. Но мне очень понравилась схема, предложенная radiolok, слушать, что процессор пишет в адреса видеобуфера, и выводить уже куда угодно. Надо будет подумать…
                                                                  +1
                                                                  ZX Spectrum ничем от традиционной схемы не отличается, кроме одного но. Там есть ULA.… а чтобы Z80 не шарился там, когда не надо, ULA могла остановить процессор, если надо, ведь тактовый сигнал на Z80 шел именно от нее.

                                                                  Могу что-то напутать за давностью лет… Собирал в своё время разные варианты Спеки, естественно и настраивал и в схемах разбирался. По способу вывода и приоритета доступа к памяти можно выделить 2 вида реализации.
                                                                  Для вывода на экран одной строки из 8 точек одного знакоместа надо было вычитать два 8-ми битных числа. Для тех кто не в курсе — каждое знакоместо 8х8 имело общие атрибуты ink, paper, bright, flash. Первые два трёхбитные кодировали цвет (RGB), итого 8 бит. Элемент строки представлял из себя однобитный код «точек» цветами ink или paper. Таким образом, одному знакоместу соответствует 8 байт с «точками» и 1 байт атрибутов. Как видно 3-мя счётчиками тут не обойтись…

                                                                  Так вот, в ранних реализациях на россыпи, в частности т.н. «Краснодарский» действительно выставлял «1» на /CLK, так как для вывода байт точек и атрибутов вычитывался из памяти в стык. Правда в том же «Краснодаре» было 2 набора памяти на РУ5 и РУ6 и CPU тормозился только когда хотел писать в область видеопамяти. Другие варианты задействовали вывод /WAIT для растягивания машинного цикла. Более поздние реализации чтения видеопамяти делали с расслоением — видео/CPU/видео/CPU. Последний при этом не только работал без задержек, но и была возможность турбировать комп по частоте в 2 раза, но с использованием /WAIT. Варианты 128К+ не вайтировали когда обращение шло к разным линейкам микросхем памяти.
                                                                    0
                                                                    Спасибо!
                                                                    Я писал поо оригинальный спекки. Там ULA останавливала клок.
                                                                      0
                                                                      Кстати, задумался вот об этом:
                                                                      Варианты 128К+ не вайтировали когда обращение шло к разным линейкам микросхем памяти.

                                                                      А как это получалось? Физически же одна шина, два адреса на нее не выставить…
                                                                        +1

                                                                        Фирменный вайтировали. Наши клоны (Пентагон) нет. Вроде бы это решалось буфером на защелке. Видеосхема брала данные из этого буфера. Буфер обновлялся когда не мешал процессору.

                                                                      0
                                                                      Спасибо за крутой материал! Я тоже давно хочу собрать свой Спектрум из микросхем и палок на макетке. Все основные чипы для этого давно есть. Но всё же мне кажется, что для любителей ардуинщиков это немного сложно. Скажите, если у меня есть Т34ВГ1, сильно проще будет добиться успеха?
                                                                        0
                                                                        Т34, если я правильно помню, это такая СССРовская ULA. Будет и проще и сложнее. Если вы хотите просто собрать клон, будет сильно легче! В принципе, вам особо много деталей и не нужно кроме Т34: мультиплексоры для DRAM (так как, если я ничего не путаю, Т34 работает с DRAM, и SRAM на нее так просто не прикрутить, но можно), да аналоговые цепи… Но на макетке… не знаю )
                                                                          +1
                                                                          Спасибо за разъяснения! Да, я застопорился как раз на проблеме выбора DRAM/SRAM.
                                                                          +3
                                                                          Видел где-то фото клона ZX Spectrum с платой размером с две банковские карты, или даже полторы. Потому что применили Т34ВГ1, а ещё микросхему ОЗУ такого объёма, что понадобился всего один корпус.
                                                                            0
                                                                            О, супер! Вот мне надо такой, чтоб минимум лапши. Искал такую ОЗУ одним чипом, но я не спец, не нашёл. РЕ с 48K-прошивкой у меня уже есть. Буду благодарен, если кинете мне эту схему.
                                                                              0
                                                                              Схему не видел, только фото, и не помню, где.
                                                                          0
                                                                          В клоны Спектрума кнопки сброса всё же ставили. Вот в БК не ставили (СБР на клавиатуре — это не то, оно зачастую гасило экран и вешало наглухо), но вывели на разъём, многие подключали для удобства.

                                                                          В некоторых клонах Спектрума (Орель БК-08) ставили кнопку NMI и помещали в ПЗУ несложный отладчик, вызываемый по нажатию этой кнопки.
                                                                            +1
                                                                            кнопка magic, которая сбрасывала дамп на дискету, работала как раз таким образом?
                                                                              0
                                                                              Насколько я помню, именно так.
                                                                            +1
                                                                            Также, возможно, вас заинтересует этот эксперимент:

                                                                            habr.com/ru/post/446048
                                                                              0
                                                                              Супер, спасибо!
                                                                              0
                                                                              мне кажется всё таки ракету проще построить чем в этом всё разобраться ))) Я так рад, что существуют такие люди как автор. Думаю, что если сейчас утратить все знания о электронике и компьютерах, то такие люди как автор снова изобретут компьютер. И это здорово.
                                                                              Пытался прочитать всю статью, но не смог, я слишком плохо соображаю в этой отрасли.
                                                                                +1
                                                                                Мне, конечно, очень лестно от вашего комментария, но это все правда очень просто. Просто требует много времени, чтобы разобраться. У меня, видимо, не особо хорошо получилось донести простоту старых 8-битных компьютеров, я попробую это исправить во второй части. Если вы хотите разобраться, могу накидать ссылок (правда, англоязычных — я очень мало знаю русскоязычных ресурсов по теме), где действительно хорошо доносят эти вещи, самых основ. Там просто разобраться. Но, опять же — требует много времени. У меня просто это хобби ))
                                                                                  0
                                                                                  В своей жизни я не встречал людей которые бы осознанно создавали логические схемы и даже обычные схемы с множеством радиоэлектронных компонентов. Все мои друзья и знакомые всегда брали схемы в интернете или журналах. И кого бы я не спрашивал «как заставить моргать лампочку подключенную к батарейке с помощью радиоэлектроники» — никто не знает. А всякие регистры, и шины данных это просто слова, никак не связанные с реальностью.
                                                                                  Мне что бы это понять не поможет время, это всё равно, что нейросеть, которая будет распознавать лицо человека, создать на основе спектрума.
                                                                                    +1
                                                                                    Дорогу осилит идущий! Начните, попробуйте! Не боги горшки обжигают!
                                                                                      0
                                                                                      тот у кого интеллект выше, наверное не может понять, что значит иметь более низкий интеллект. Я много раз пробовал разобраться в сложных вещах и у меня ничего получалось, поэтому осознаю на сколько это трудно и очень уважаю тех людей, которые могут создавать такие сложные вещи как компьютер.
                                                                                        +1
                                                                                        Полагаю, тут не в интеллекте дело. Тут дело в том, как изучать. Если бы всем достаточно было бы книжки, то в ВУЗ'ах лекции бы не читали — зачем, если есть книжка? Впрочем, могу посоветовать хорошую книжку «Код» Чарльза Петцольда. Там очень просто всё объяснено.
                                                                                      0
                                                                                      С интеллектом это никак не связано, результат порочного современного образования налицо. К счастью вы зашли на правильный ресурс ;)

                                                                                      Мне было 13, когда я начал знакомиться с цифровой техникой. Прошло 35 лет, а я до сих про помню то, чему тогда научился. Никаких секретов нет — замечательбый журнал Радио объяснял все с элементарных вещей, с азов, не понять было просто невозможно.

                                                                                      Вот здесь опубликован цикл тех статей, по которым я учился:
                                                                                      archive.radio.ru/web/1985/01/053
                                                                                      Затем хорошим источником примеров были статьи «Применение микросхем серии ...»:
                                                                                      archive.radio.ru/web/1984/04/026 Они были разными, о 176, 155, 555 сериях. В каждой была ценная информация.
                                                                                      Ну и обычные статьи того времени были довольно интересными, в них подробно описывалась работа того или иного устройства.

                                                                                      На втором курсе я спаял ZX Ленинград-48, а моей дипломной работой в Политехе было устройство, подключаемое к LPT порту, позволяющее функционально тестировать ТТЛ микросхемы. Сигналы подавались/снимались с помощью К580ВВ55. Все делала программа с библиотекой для сравнения входных/выходных сигналов.

                                                                                      При том, что в те времена 155ТМ2 и 155ЛА3 на халяву в магазине достать было просто невозможно. Сейчас у меня просто дух захватывает от доступности как элементной базы, так и любой информации по ней, включая живую поддержку и YouTube каналы.

                                                                                      Не смотря на то, что я почти 25 лет работаю программистом, магия электроники до сих пор не отпускает :) и я очень рад, что мне удалось получить такое качественное образование.

                                                                                      old_gamer, огромное спасибо за канал www.youtube.com/user/eaterbc, это просто невероятно, насколько он все просто и понятно объясняет! А книга «The ZX Spectrum Ula: How to Design a Microcomputer» придет в субботу ;)

                                                                                      С нетерпением жду второй части статьи. Спасибо!
                                                                                        +1
                                                                                        old_gamer, огромное спасибо за канал www.youtube.com/user/eaterbc, это просто невероятно, насколько он все просто и понятно объясняет! А книга «The ZX Spectrum Ula: How to Design a Microcomputer» придет в субботу ;)

                                                                                        С нетерпением жду второй части статьи. Спасибо!

                                                                                        Да, канал восхитительный, я его всем интересующимся рекомендую.
                                                                                        Вторая часть уже в работе, припой пришел, теперь дело техники.
                                                                                        Спасибо!
                                                                                          0
                                                                                          Я вот с самого начала вроде еще написал, что как правило люди с высоким интеллектом не могут осознать, что означает иметь более низкий интеллект. Собственно, как и наоборот. Ведь в одном классе школы учат примерно одинаково каждого ребёнка, но успехи совершенно разные. У меня не было проблем с обучением примерно до 8 класса, потом мне стало сложно. А когда началась высшая математика я никак не мог её понимать и решать и репетиторы не помогали. Но ведь многие мои одноклассники и в последствии одногруппники в институте спокойно справлялись с этими же задачками. Я старался понять, ходил на дополнительные занятия по математике, но всех стараний хватило только на то что бы мне тройки нарисовали в зачётке. А мой младший брат, спокойно решал математику, поступил на физфак на бюджетку, а родители у нас одни, учили одинаково. С тех пор я множество раз сталкивался со своей нехваткой интеллекта, я не способен усвоить длинные логические цепочки. И да, вина нашего образования в том, что таким как я дали диплом о высшем техническом образовании, я считаю это не справедливо.

                                                                                          В то же время у меня есть друг, мы знакомы уже 15 лет, и что такое ток и напряжение я объяснял ему миллион раз. Но он всё равно звонит мне и спрашивает какая мощность у лампочки если напряжение 12В а ток 5А. Миллион раз я объяснял что нужно просто перемножить эти два числа, но для него эти объяснения как белый шум. Я вспоминаю даже себя, когда я зубрил правила и формулы в которых были слова «прямо пропорциональный и обратно пропорциональный» для меня это был пустой звук который не имел никакого смысла, так же как и большинство терминов из этой стать. Но слава богу сейчас я хотя бы понимаю что значит «прямо пропорционально». Точно так же для моего друга все эти законы Ома с умножением и делением — просто пустые звуки, за 15 лет дружбы я ему этого так и не вдолбил. Думаете образование в этом виновато? Мне кажется мы просто стоим на разных интеллектуальных ступенях, я нахожусь где-то между Вами и моим другом. )))
                                                                                            0
                                                                                            Ну а по ссылкам, которые я дал, вы ходили?
                                                                                              0
                                                                                              да, переходил, спасибо. Что такое микросхема я представляю, но как с помощью логических элементов НЕ, ИЛИ и прочих сделать подобие программы я не представляю, и проходил я это в институте много раз. Для меня это всё равно что по китайски написано.
                                                                                                +1
                                                                                                Если понимаете по-английски, то я очень рекомендую видео про Megaprocessor.
                                                                                                Там автор очень наглядно показывает, как из дискретных логических элементов получается процессор, и как он работает.
                                                                                                  0
                                                                                                  Уще раз упомяну этот канал (спасибо old_gamer до сих пор пересматриваю!) На нем парень объясняет самые азы о том, как работает компьютер, начиная с тактового генератора: youtu.be/HyznrdDSSGM
                                                                                                  Все собрано на элемнтарной логике — элементы, триггеры, счетчики, регистры (о которых рассказывается в упомянутых мной статьях в ж. Радио)

                                                                                                  А в этом плэй-листе, он рассказывает азы низко-уровнего программирования на 8-битовом процессоре: youtu.be/LnzuMJLZRdU

                                                                                                  Канал на английском, но он говорит очень неторопливо. Если непонятно — уменьшите скорость.
                                                                                          0
                                                                                          я очень мало знаю русскоязычных ресурсов по теме

                                                                                          Их не мало, на самом деле. Заходите, если что
                                                                                          zx-pk.ru/forum.php
                                                                                          И да, вторую часть бы тоже почитал :)
                                                                                            0
                                                                                            Спасибо!
                                                                                            Вторая часть в работе. Столкнулся с непредвиденной логистической проблемой… Месяц назад кончился припой, все еще жду доставки нового.
                                                                                        0
                                                                                        Для бредборды припой вроде и не особо нужен. Впрочем как и для разработки в ФПГА :)
                                                                                        А схемы для Ардуинки удобно рисовать в Fritzing.
                                                                                        fritzing.org
                                                                                        Со схемой то есть шанс, что кто-то и повторит. :-)
                                                                                          0
                                                                                          Вы правы, на макетке больше шанс, что это будет кому-то интересно, но у меня на макетках все глючит страшно (я в конце написал об этом). Так что буду паять. Впрочем, может, действительно, параллельно пайке сделать схемы в фрицинге, на случай если у кого макетки есть нормальные… Буду думать.
                                                                                          0
                                                                                          Господа, коль уж вновь затронута тема ZX-Spectrum то позвольте прокомментировать тем, кто любит кассетные версии игр для ZX-Spectrum в релизах от Bill Gilbert'a и других хакеров, то милости прошу в группу ВК Tape Version image
                                                                                            0
                                                                                            Ждем с нетерпением продолжение! Проверяю страницу каждый день ;)
                                                                                              0
                                                                                              Я прошу прощения за столь долгую паузу, проект не забросил, все близиться к завершению 2й части. Все идет сильно медленнее, чем ожидалось, так как первая часть была написана в разгар локдауна за несколько дней, в вторая пишется в разгар выхода из локдауна, когда надо переделать кучу накопившихся дел… Но я уже близок к завершению, спасибо за лестный отзыв, это мотивирует!

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

                                                                                            Самое читаемое