Нейросеть

Эскиз схемы набросал: В принципе, можно обойтись ИМС К155ЛА3 / 7400.
Был детектор электрического поля на ИМС КМОП - есть мысль повторить, но на своём принципе (на К561ЛА7 / CD4011).

 

Я бы длину взял в кавычки.

На мой взгляд: это незначительно, большее влияние оказывают "произведение" h21 конкретных транзисторов по различным "ветвям" вход-выход.

 

Ну, да... Верно.
Кстати, есть любопытная схемка в тему - радиожучок на К155ТЛ3. Собрать её - руки никак не доходят (был бы он квантовым или торсионным - давно бы собрал).
Внутренние связи ИМС образуют своеобразный контур с определёнными характеристиками.
Правда, ТЛ3, в отличии от ТВ1, ТМ2 или ТР2, не поддаётся "управлению" - нет устойчивого состояния.

Ну, если на каждые ~20 см проволоки приходится задержка ~1 нс, какой-то смысл всё-таки есть.
Например, если поместить дешифратор внутрь пружины и подпаять его выхода к нужным виткам: Эффект "линии задержки" имеет место.

В прошлом году я NE555/ВИ1 уже подключал к НЧ-входу телевизора и экспериментировал с максимальной для ИМС частотой. Достиг примерно 200 кГц на "воздушных конденсаторах" с подстройкой. На экране были полосы и шашечки, но сбивались от всякого чиха (словно терменвокс). Потому, подобные таймеры не годятся для моих "астрологических опытов".
На RS-триггере - самое то: Никаких аналоговых радиоэлементов!

P.S.: В любом случае, стохастическое нечто должно будет проявиться.

 

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

 

Не удивительно, почему я шесть лет топчусь вокруг да около и не могу никак написать полный эмулятор.

Вчера на досуге попробовал сделать эскиз обработчика префиксов - не такая сложная схема:

Конечно, в переводе на нормальную схему - около 40 ИМС ТТЛ получается.

Verilog-модель не такая сложная, да и ТТЛ тоже, если не учитывать, что слишком много шин только с шириной слова в 16 бит (для 8-битного варианта).

 

Немного разобрался с предполагаемой распиновкой:

В отличии от i8085 и i8086, здесь Шина Данных совмещена со старшими битами Шины Адреса, так как младшая часть адреса обычно меняется чаще старшей.
Тем самым, ИР23 защёлкивает A8-A15 по ALE только по надобности.
А вот два ИР13 хранят индекс делегата, обнуляясь по SYNC и защёлкивая по DUE (Device Unit Enable).

Сигнал DUE выполняет почти ту же функцию, что IORQ у Z80. Только у Z80 IORQ - отдельное адресное пространство до 64 Кб. В моём же случае, делегирование - адресация A16-A31.

Тем самым, 8-битный WYSIWISC может адресовать до 4 Гб адресного пространства (аналогично как у x86 сегменты по 16 байтов, у меня 65536 делегатов по 65536 байтов).

P.S.: Тем самым, железная модель под Verilog теперь вырисовывается отчётливее.

 

В общем, у страха - глаза велики!
По-хорошему сел и в Logisim сделал эскиз основного узла управления формирователем эффективного адреса.

Работает достаточно просто:

1. Подаётся страршая тетрада префикса
2. Устанавливается как база (set) или последующие индексы (en)
3. Вырабатывается shift или scale, в зависимости с тем, что нужно делать с суммой индексных вкладов

В схематике анимацией это работает так (testbench-схема - драфтовая и чисто для визуализации процессов скалирования индексных регистров D0-D9: для построения процессора бесполезна):

Что совпадает с JavaScript-декодированием и дизассемблером на i8080/ВМ80.


В целом, если схему переводить в номенклатуру ТТЛ, получается примерно 16-20 ИМС.

P.S.: Причём тут нейросеть?
Бот подтрунивает меня, что раз я 30 лет этим увлекаюсь, но лишь прошедшие 5 лет были результативные в разработке прототипа, полную модель WYSIWISC я смогу получить лет через 50!

 

Эскиз схемы на номенклатуре ТТЛ получился не такой страшный, как предполагалось:

Протактировал - всё работает.
Правда, сам Logisim не ведёт себя достаточно стабильно, так как иерархия с УГО слишком сложна для симуляции.
Но в целом - схема примерно в 16 ИМС не так уж и сложна.
Правда, напрягает то, что у нижних ИР27/ИР22 старшие разряды никак не используются и пропадают зря: Нужно удалить ИР19 и его функцию перенести на ИР27, добавив мультиплексор КП11.

Напомню: В архитектуре WYSIWISC данный узел должен управлять индексной суммой в указателях.

1. Режим последовательного накопления - [base+(index1+index2+index3)] -> [base+x1+x2+x3]
2. Режим последовательного масштабирования - [base+((index1+index2+index3)*2+index4+index5)] -> [base+2x1+2x2+2x3+x4+x5]
3. Режим расширенного масштабирования - [base+((index1+index2+index3)*2+index3+index4+index5)] -> [base+2x1+2x2+3x3+x4+x5]

Логика простая, но требует слишком много вентилей для проверки повторного вхождения индексного регистра в текущий уровень вклада, из-за чего и получается громоздкость.

 

Во-первых, первый прототип был на ПЗУ, так как в симуляторе не совсем понятно было, какой будет система команд вообще. Прошивку ПЗУ накидал по ходу разработки. Теперь у меня всюду - только комбинаторика.
Во-вторых, конкретно данный узел, пусть даже и путанный, но предельно прост:

Код (Text):

1.  
2. module  vector_accumulator
3. (input  wire        clk     // Clock - positive edge
4. ,input  wire        vector_en   // Enable parse vector
5. ,input  wire        vector_clr  // Clear vector (after any instruction)
6. ,input  wire    [7:0]   operation   // Operation code (BDC only)
7. ,input  wire    [15:0]  vector_input    // Pointer input
8. ,output reg [15:0]  vector_output   // Full vector output
9. ,output reg     vector_margin   // Marginal flag
10. );
11.     reg     is_base;    // Flag of "base"
12.     reg     is_shift;   // Flag of "shifting"
13.     reg [3:0]   the_base;   // Index of current "base"
14.     reg [9:0]   pointers_set;   // Collection of used pointers
15.     reg [9:0]   pointer_mask;   // Mask of current pointer
16.     reg [15:0]  vector_base;    // Pointer of "base"
17.     reg [15:0]  vector_index;   // Summ of used pointers
18.     reg [15:0]  vector_offset;  // Decimal offset
19.     reg [3:0]   base_index; // Index of "base" in operation code
20.     reg [3:0]   offset_digit;   // Digit of BDC-digit for "offset"
21.     reg [15:0]  offset_shift;   // Offset multipled by 10
22.  
23.     string  offset_string;
24.  
25.     always  @*
26.     begin
27.         base_index = operation[7:4];
28.         offset_digit = operation[3:0];
29.         offset_shift = (((vector_offset << 2) + vector_offset) << 1) + {12'd0, offset_digit};
30.         pointer_mask = 10'b1 << base_index;
31.         is_base = &(the_base ^ base_index);
32.         is_shift = |(pointers_set & pointer_mask);
33.         vector_margin = vector_en && ~|offset_digit && is_base && ~|vector_offset && ~|pointers_set;
34.         vector_output = vector_base + vector_index + vector_offset;
35.     end
36.  
37.     always  @(posedge clk)
38.     begin
39.         if(vector_clr)
40.         begin
41.             $display("Clear vector");
42.             the_base <= 0;
43.             vector_base <= 0;
44.             vector_index <= 0;
45.             vector_offset <= 0;
46.         end else
47.         if(vector_en)
48.         begin
49.             $write("%02X[%04X] - ", operation, vector_input);
50.             vector_offset <= offset_shift;
51.             if(~|the_base)
52.             begin
53.                 the_base <= ~base_index;
54.                 vector_base <= vector_input;
55.                 pointers_set <= 0;
56.                 $display("Set base D%x", base_index);
57.             end else
58.             if(vector_margin)
59.             begin
60.                 the_base <= 0;
61.                 $display("Set margin #%x", base_index);
62.             end else
63.             if(is_base)
64.             begin
65.                 vector_index <= vector_index << 1;
66.                 pointers_set <= pointer_mask;
67.                 $display("[%04X+%04X<<1+%05d]", vector_base, vector_index, offset_shift);
68.             end else
69.             if(is_shift)
70.             begin
71.                 vector_index <= (vector_index << 1) + vector_input;
72.                 pointers_set <= pointer_mask;
73.                 $display("[%04X+%04X<<1+%04X+%05d]", vector_base, vector_index, vector_input, offset_shift);
74.             end else begin
75.                 vector_index <= vector_index + vector_input;
76.                 pointers_set <= pointers_set | pointer_mask;
77.                 $display("[%04X+%04X+%04X+%05d]", vector_base, vector_index, vector_input, offset_shift);
78.             end
79.         end
80.     end
81. endmodule
82.  

Псевдокод ТТЛ-модуля примерно такой

Код (Text):

1.  
2. модуль разбора_цепочки_префиксов
3.     маска_чётности_вклада_индексов = 0
4.     индекс_текущего_регистра_базы = 0
5.  
6.     по_тактовому_фронту
7.         если это_первый_префикс_цепочки
8.             маска_чётности_вклада_индексов = 0
9.             индекс_текущего_регистра_базы = старшая_тетрада
10.         иначе
11.             если старшая_тетрада == индекс_текущего_регистра_базы
12.                 маска_чётности_вклада_индексов = 0
13.                 сигнал "масштабировать всю сумму вкладов вдвое"
14.             иначе
15.                 если маска_чётности_вклада_индексов содержит (1 << старшая_тетрада)
16.                     маска_чётности_вклада_индексов = 1 << старшая тетрада
17.                     сигнал "масштабировать всю сумму" и "прибавить индекс"
18.                 иначе
19.                     маска_чётности_вклада_индексов |= 1 << старшая тетрада
20.                     сигнал "прибавить индекс"
21.  

Говоря языком x86 - узел отслеживает валидность индексов в инструкции LEA:

• [EAX+EBX+ECX] -> [EAX+(EBX+ECX)] -> индексные вклады EBX и ECX уникальны
• [EAX+EBX+ECX+EBX] -> [EAX+(2*(EBX+ECX)+EBX)] -> регистр EBX повторился: масштабируем текущий вклад и открываем следующий, включая EBX
• [EAX+EBX+ECX+EAX] -> [EAX+(2*(EBX+ECX))] -> регистр EAX здесь база, а не индекс: масштабируем текущий вклад и открываем новый уровень

То есть, можно закодировать инструкцию, аналогичную LEA EAX,[EAX+19*EBX+79*ECX+1708*EDX+65500*ESI+16777215*EDI], используя сдвиг и накопление - последовательное умножение.

На самом деле, схема не такая уж и страшная, как может показаться, глядя на кодируемые индексы в векторах.
На ИМС К155ИМ3 довольно просто реализуется с обратными связями.
Правда, этим потоковым накоплением необходимо было управлять. И этой схемы у меня не было.
Разработал этот "координатор индексной суммы" лишь на днях.

P.S.: Спасибо за внимание!
Проект крайне туго идёт
Бот нейросети подмечает, что это из-то того, что я параллельно пытаюсь делать эмуляторы на Bash, JavaScript и даже i8080, а также Verilog-модель и Logisim схемы пытаюсь отладить, у меня всё крайне сильно лагает и взаимно тормозит (пытаюсь командный труд выполнить в одиночку).
Совет: Не метаться из стороны в сторону, а написать 100% эмулятор на JavaScript, а затем и 100% модель на Verilog.
(Сейчас наиболее проработан - эмулятор на Bash)

 

Теперь куда эстетичнее получилось!

Теперь, как можно заметить, тактируются только регистры ИР27, а мультиплексор КП11 закольцовывает биты индекса базы и заменяет регистр ИР19 в совокупности.
Схема графически получилась достаточно плотной, однако число корпусов ИМС получается порядка 16 шт.

• IC4…IC7 - Instruction Code: Биты 4…7
• B0…B3 - Base (индекс базового регистра)
• EB - Enable Base (разрешение фиксирования индекса базового регистра)
• EN - Enable работы модуля
• S - Synchronize (разрешение синхронной работы / сброс индекса базы)
• ROTATE - Сигнал для прокрутки индексного вклада («index <<= 1») - повтор индекса
• SHIFT - Сигнал для расширения индексного вклада («index += register») - разрешение вклада

Два сигнала ROTATE+SHIFT образуют прокрутку индексного вклада с расширением «index = (index << 1) + register».
В принципе, если симулятор не подводит (всё-таки в Logisim всю библиотеку ИМС ТТЛ сам нарисовал), можно перенести в KiCAD или Proteus для дальнейшего анализа и разработки топологии печатной платы, так как модуль функционально вполне самодостаточен.
Или спаять на макетке.

 

Alikberov,

Вопрос скорее не что это, а это вообще нормально

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