Микросхема троичного микроконтроллера Triador-3000

[Shaos]

Ок, попробуем подойти к задаче аналитически - итак, у нас имеется 1 байт, который можно разбить на 4 пары битов, каждая из которых может быть 11 или может быть xx (что значит 00 для O, 01 для P или 10 для N). Вариант когда ни одна из пар не является 11 обозначается xx-xx-xx-xx. Как и в прошлом сообщении просто заменяем такие комбинации на 4 трита в соответствующих позициях и приписываем слева пятый трит O:

Code: Select all

xx-xx-xx-xx -> Otttt

Далее у нас есть комбинации у которых одна пара является 11 - их преобразуем так:

Code: Select all

11-xx-xx-xx -> PNttt
xx-11-xx-xx -> POttt
xx-xx-11-xx -> PPttt

Так мы покрыли все Oxxxx и Pxxxx - теперь раскидываем Nxxxx:

Code: Select all

xx-xx-xx-11 -> NNttt

И теперь переходим к комбинациям с двумя 11:

Code: Select all

11-11-xx-xx -> NONtt
xx-11-11-xx -> NOOtt
xx-xx-11-11 -> NOPtt
11-xx-11-xx -> NPNtt
xx-11-xx-11 -> NPOtt
11-xx-xx-11 -> NPPtt

Врод всё - оставшиеся комбинации с тремя и четырьмя 11:

Code: Select all

11-11-11-xx -> 3
11-11-xx-11 -> 3
11-xx-11-11 -> 3
xx-11-11-11 -> 3
11-11-11-11 -> 1

в количестве 256-243=13 штук могут выдавать ошибку либо перекодироваться в копии каких-то близких комбинаций для упрощения декодера...

[Shaos]

Вот программа на сях, генерирующая такое задание для DDT:

Code: Select all

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct
{char t[6];
 unsigned char a;
}tab[256];

int main(int argc, char** argv)
{
 int k = 0;
 int i,j,c;
 char s[8] = "NNNNN";
 char ss[8];
 ss[5] = 0;
 for(i=0;i<256;i++)
 {
   tab[i].t[0] = ' ';
   tab[i].t[1] = ' ';
   tab[i].t[2] = ' ';
   tab[i].t[3] = ' ';
   tab[i].t[4] = ' ';
   tab[i].t[5] = 0;
   tab[i].a = 0;
 }
 FILE *f;
 f = fopen("8b5t.ddt","wt");
 if(f==NULL) return -1;
 for(i=0;i<256;i++)
 {
    ss[0]='O';

    if(i&0x80) ss[1]='N';
    else if(i&0x40) ss[1]='P';
    else ss[1]='O';
    if((i&0xC0)==0xC0) tab[i].a|=8;

    if(i&0x20) ss[2]='N';
    else if(i&0x10) ss[2]='P';
    else ss[2]='O';
    if((i&0x30)==0x30) tab[i].a|=4;

    if(i&0x08) ss[3]='N';
    else if(i&0x04) ss[3]='P';
    else ss[3]='O';
    if((i&0x0C)==0x0C) tab[i].a|=2;

    if(i&0x02) ss[4]='N';
    else if(i&0x01) ss[4]='P';
    else ss[4]='O';
    if((i&0x03)==0x03) tab[i].a|=1;

    switch(tab[i].a)
    {
        case 8:
          tab[i].a=0;
          ss[0]='P';
          ss[1]='N';
          break;
        case 4:
          tab[i].a=0;
          ss[2]=ss[1];
          ss[0]='P';
          ss[1]='O';
          break;
        case 2:
          tab[i].a=0;
          ss[3]=ss[2];
          ss[2]=ss[1];
          ss[0]='P';
          ss[1]='P';
          break;
        case 1:
          tab[i].a=0;
          ss[4]=ss[3];
          ss[3]=ss[2];
          ss[2]=ss[1];
          ss[0]='N';
          ss[1]='N';
          break;
        case 12:
          tab[i].a=0;
          ss[0]='N';
          ss[1]='O';
          ss[2]='N';
          break;
        case 6:
          tab[i].a=0;
          ss[3]=ss[1];
          ss[0]='N';
          ss[1]='O';
          ss[2]='O';
          break;
        case 3:
          tab[i].a=0;
          ss[4]=ss[2];
          ss[3]=ss[1];
          ss[0]='N';
          ss[1]='O';
          ss[2]='P';
          break;
        case 10:
          tab[i].a=0;
          ss[3]=ss[2];
          ss[0]='N';
          ss[1]='P';
          ss[2]='N';
          break;
        case 5:
          tab[i].a=0;
          ss[4]=ss[3];
          ss[3]=ss[1];
          ss[0]='N';
          ss[1]='P';
          ss[2]='O';
          break;
        case 9:
          tab[i].a=0;
          ss[4]=ss[3];
          ss[3]=ss[2];
          ss[0]='N';
          ss[1]='P';
          ss[2]='P';
          break;
    }

    if(!tab[i].a)
    {
      strcpy(tab[i].t,ss);
    }

    fprintf(f,"%i%i%i%i%i%i%i%i=%s\n",
             (i&0x80)>>7,
             (i&0x40)>>6,
             (i&0x20)>>5,
             (i&0x10)>>4,
             (i&0x08)>>3,
             (i&0x04)>>2,
             (i&0x02)>>1,
             (i&0x01),ss);
    printf("0x%2.2X=%s",i,ss);
    if(tab[i].a) printf(" %2.2X",tab[i].a);
    printf("\n");
 }
 printf("\n");
 for(i=0;i<243;i++)
 {
    c = ' ';
    for(j=0;j<256;j++)
    {
       if(!strcmp(tab[j].t,s))
       {
          k++;
          c = '+';
          break;
       }
    }
    printf("%03d=%s %c\n",i,s,c);
    if(++s[4]=='Q')
    {
       s[4] = 'N';
       if(++s[3]=='Q')
       {
          s[3] = 'N';
          if(++s[2]=='Q')
          {
             s[2] = 'N';
             if(++s[1]=='Q')
             {
                s[1] = 'N';
                ++s[0];
             }
          }
       }
    }
 }
 printf("\n");
 fclose(f);
 printf("Covered %i out of 243 (%2.2f%%)\n",k,k/2.43);
 return 0;
}

И само получившееся задание:

Code: Select all

00000000=OOOOO
00000001=OOOOP
00000010=OOOON
00000011=NNOOO
00000100=OOOPO
00000101=OOOPP
00000110=OOOPN
00000111=NNOOP
00001000=OOONO
00001001=OOONP
00001010=OOONN
00001011=NNOON
00001100=PPOOO
00001101=PPOOP
00001110=PPOON
00001111=NOPOO
00010000=OOPOO
00010001=OOPOP
00010010=OOPON
00010011=NNOPO
00010100=OOPPO
00010101=OOPPP
00010110=OOPPN
00010111=NNOPP
00011000=OOPNO
00011001=OOPNP
00011010=OOPNN
00011011=NNOPN
00011100=PPOPO
00011101=PPOPP
00011110=PPOPN
00011111=NOPOP
00100000=OONOO
00100001=OONOP
00100010=OONON
00100011=NNONO
00100100=OONPO
00100101=OONPP
00100110=OONPN
00100111=NNONP
00101000=OONNO
00101001=OONNP
00101010=OONNN
00101011=NNONN
00101100=PPONO
00101101=PPONP
00101110=PPONN
00101111=NOPON
00110000=POOOO
00110001=POOOP
00110010=POOON
00110011=NPOOO
00110100=POOPO
00110101=POOPP
00110110=POOPN
00110111=NPOOP
00111000=POONO
00111001=POONP
00111010=POONN
00111011=NPOON
00111100=NOOOO
00111101=NOOOP
00111110=NOOON
00111111=OONNN
01000000=OPOOO
01000001=OPOOP
01000010=OPOON
01000011=NNPOO
01000100=OPOPO
01000101=OPOPP
01000110=OPOPN
01000111=NNPOP
01001000=OPONO
01001001=OPONP
01001010=OPONN
01001011=NNPON
01001100=PPPOO
01001101=PPPOP
01001110=PPPON
01001111=NOPPO
01010000=OPPOO
01010001=OPPOP
01010010=OPPON
01010011=NNPPO
01010100=OPPPO
01010101=OPPPP
01010110=OPPPN
01010111=NNPPP
01011000=OPPNO
01011001=OPPNP
01011010=OPPNN
01011011=NNPPN
01011100=PPPPO
01011101=PPPPP
01011110=PPPPN
01011111=NOPPP
01100000=OPNOO
01100001=OPNOP
01100010=OPNON
01100011=NNPNO
01100100=OPNPO
01100101=OPNPP
01100110=OPNPN
01100111=NNPNP
01101000=OPNNO
01101001=OPNNP
01101010=OPNNN
01101011=NNPNN
01101100=PPPNO
01101101=PPPNP
01101110=PPPNN
01101111=NOPPN
01110000=POPOO
01110001=POPOP
01110010=POPON
01110011=NPOPO
01110100=POPPO
01110101=POPPP
01110110=POPPN
01110111=NPOPP
01111000=POPNO
01111001=POPNP
01111010=POPNN
01111011=NPOPN
01111100=NOOPO
01111101=NOOPP
01111110=NOOPN
01111111=OPNNN
10000000=ONOOO
10000001=ONOOP
10000010=ONOON
10000011=NNNOO
10000100=ONOPO
10000101=ONOPP
10000110=ONOPN
10000111=NNNOP
10001000=ONONO
10001001=ONONP
10001010=ONONN
10001011=NNNON
10001100=PPNOO
10001101=PPNOP
10001110=PPNON
10001111=NOPNO
10010000=ONPOO
10010001=ONPOP
10010010=ONPON
10010011=NNNPO
10010100=ONPPO
10010101=ONPPP
10010110=ONPPN
10010111=NNNPP
10011000=ONPNO
10011001=ONPNP
10011010=ONPNN
10011011=NNNPN
10011100=PPNPO
10011101=PPNPP
10011110=PPNPN
10011111=NOPNP
10100000=ONNOO
10100001=ONNOP
10100010=ONNON
10100011=NNNNO
10100100=ONNPO
10100101=ONNPP
10100110=ONNPN
10100111=NNNNP
10101000=ONNNO
10101001=ONNNP
10101010=ONNNN
10101011=NNNNN
10101100=PPNNO
10101101=PPNNP
10101110=PPNNN
10101111=NOPNN
10110000=PONOO
10110001=PONOP
10110010=PONON
10110011=NPONO
10110100=PONPO
10110101=PONPP
10110110=PONPN
10110111=NPONP
10111000=PONNO
10111001=PONNP
10111010=PONNN
10111011=NPONN
10111100=NOONO
10111101=NOONP
10111110=NOONN
10111111=ONNNN
11000000=PNOOO
11000001=PNOOP
11000010=PNOON
11000011=NPPOO
11000100=PNOPO
11000101=PNOPP
11000110=PNOPN
11000111=NPPOP
11001000=PNONO
11001001=PNONP
11001010=PNONN
11001011=NPPON
11001100=NPNOO
11001101=NPNOP
11001110=NPNON
11001111=ONONN
11010000=PNPOO
11010001=PNPOP
11010010=PNPON
11010011=NPPPO
11010100=PNPPO
11010101=PNPPP
11010110=PNPPN
11010111=NPPPP
11011000=PNPNO
11011001=PNPNP
11011010=PNPNN
11011011=NPPPN
11011100=NPNPO
11011101=NPNPP
11011110=NPNPN
11011111=ONPNN
11100000=PNNOO
11100001=PNNOP
11100010=PNNON
11100011=NPPNO
11100100=PNNPO
11100101=PNNPP
11100110=PNNPN
11100111=NPPNP
11101000=PNNNO
11101001=PNNNP
11101010=PNNNN
11101011=NPPNN
11101100=NPNNO
11101101=NPNNP
11101110=NPNNN
11101111=ONNNN
11110000=NONOO
11110001=NONOP
11110010=NONON
11110011=ONNON
11110100=NONPO
11110101=NONPP
11110110=NONPN
11110111=ONNPN
11111000=NONNO
11111001=NONNP
11111010=NONNN
11111011=ONNNN
11111100=ONNNO
11111101=ONNNP
11111110=ONNNN
11111111=ONNNN

Компиляция в лоб даёт 140 микросхем DG403 (159 функций):

Code: Select all

Generate file ddt_8b5t.c with 159 functions (140 x DG403)

А пермутации входов дают 90 микросхем DG403 (110 функций):

Code: Select all

8 inputs detected (worst solution is 16400)

OLD 7|6|5|4|3|2|1|0 e12=145 e21=134 DG403=140
NEW 7|6|5|4|3|2|0|1 e12=145 e21=134 DG403=140
NEW 7|6|3|2|5|4|1|0 e12=145 e21=126 DG403=136
NEW 7|6|3|2|5|4|0|1 e12=145 e21=126 DG403=136
NEW 7|6|3|2|4|5|1|0 e12=142 e21=123 DG403=133
NEW 7|6|3|2|4|5|0|1 e12=142 e21=123 DG403=133
NEW 7|6|1|0|5|4|3|2 e12=129 e21=113 DG403=122
NEW 7|6|1|0|5|4|2|3 e12=129 e21=113 DG403=122
NEW 7|6|1|0|3|2|5|4 e12=128 e21=112 DG403=120
NEW 7|6|1|0|3|2|4|5 e12=128 e21=112 DG403=120
NEW 7|6|0|1|3|2|5|4 e12=128 e21=112 DG403=120
NEW 7|6|0|1|3|2|4|5 e12=128 e21=112 DG403=120
NEW 7|1|0|6|5|4|3|2 e12=121 e21=107 DG403=115
NEW 7|1|0|6|5|4|2|3 e12=121 e21=107 DG403=115
NEW 7|1|0|6|3|2|5|4 e12=120 e21=106 DG403=113
NEW 7|1|0|6|3|2|4|5 e12=120 e21=106 DG403=113
NEW 7|1|0|5|4|6|3|2 e12=122 e21=102 DG403=112
NEW 7|1|0|5|4|6|2|3 e12=122 e21=102 DG403=112
NEW 7|1|0|3|2|6|5|4 e12=116 e21=97 DG403=107
NEW 7|1|0|3|2|6|4|5 e12=116 e21=97 DG403=107
NEW 7|1|0|2|3|6|5|4 e12=116 e21=97 DG403=107
NEW 7|1|0|2|3|6|4|5 e12=116 e21=97 DG403=107
NEW 7|0|1|3|2|6|5|4 e12=116 e21=97 DG403=107
NEW 7|0|1|3|2|6|4|5 e12=116 e21=97 DG403=107
NEW 7|0|1|2|3|6|5|4 e12=116 e21=97 DG403=107
NEW 7|0|1|2|3|6|4|5 e12=116 e21=97 DG403=107
NEW 5|1|0|4|7|6|3|2 e12=116 e21=98 DG403=107
NEW 5|1|0|4|7|6|2|3 e12=116 e21=98 DG403=107
NEW 5|1|0|4|6|7|3|2 e12=115 e21=97 DG403=107
NEW 5|1|0|4|6|7|2|3 e12=115 e21=97 DG403=107
NEW 5|0|1|4|7|6|3|2 e12=116 e21=98 DG403=107
NEW 5|0|1|4|7|6|2|3 e12=116 e21=98 DG403=107
NEW 5|0|1|4|6|7|3|2 e12=115 e21=97 DG403=107
NEW 5|0|1|4|6|7|2|3 e12=115 e21=97 DG403=107
NEW 4|1|0|5|7|6|3|2 e12=116 e21=98 DG403=107
NEW 4|1|0|5|7|6|2|3 e12=116 e21=98 DG403=107
NEW 4|1|0|5|6|7|3|2 e12=115 e21=97 DG403=107
NEW 4|1|0|5|6|7|2|3 e12=115 e21=97 DG403=107
NEW 4|0|1|5|7|6|3|2 e12=116 e21=98 DG403=107
NEW 4|0|1|5|7|6|2|3 e12=116 e21=98 DG403=107
NEW 4|0|1|5|6|7|3|2 e12=115 e21=97 DG403=107
NEW 4|0|1|5|6|7|2|3 e12=115 e21=97 DG403=107
NEW 3|2|1|0|7|6|5|4 e12=100 e21=92 DG403=96
NEW 3|2|1|0|7|6|4|5 e12=100 e21=92 DG403=96
NEW 2|3|1|0|7|6|5|4 e12=100 e21=92 DG403=96
NEW 2|3|1|0|7|6|4|5 e12=100 e21=92 DG403=96
NEW 1|0|3|2|7|6|5|4 e12=96 e21=84 DG403=90
NEW 1|0|3|2|7|6|4|5 e12=96 e21=84 DG403=90
NEW 1|0|2|3|7|6|5|4 e12=96 e21=84 DG403=90
NEW 1|0|2|3|7|6|4|5 e12=96 e21=84 DG403=90
NEW 0|1|3|2|7|6|5|4 e12=96 e21=84 DG403=90
NEW 0|1|3|2|7|6|4|5 e12=96 e21=84 DG403=90
NEW 0|1|2|3|7|6|5|4 e12=96 e21=84 DG403=90
NEW 0|1|2|3|7|6|4|5 e12=96 e21=84 DG403=90

Optimal solution has 90 chips instead of 140
Ratio optimal/worst is 0%
113 functions were used

Можно ещё попробовать попереставлять комбинации и поглядеть можно ли будет получить более компактное решение...

[Shaos]

Если ещё и трит ошибки генерировать (для непокрытых 13 значений), то решение будет потяжелее - 99 микросхем вместо 90:

Code: Select all

8 inputs detected (worst solution is 19680)

OLD 7|6|5|4|3|2|1|0 e12=151 e21=140 DG403=146
...
NEW 0|1|2|3|7|6|5|4 e12=104 e21=93 DG403=99
NEW 0|1|2|3|7|6|4|5 e12=104 e21=93 DG403=99

Optimal solution has 99 chips instead of 146
Ratio optimal/worst is 0%
125 functions were used

Интересно, что если ошибочные комбинации заменять на POOOOO (старший трит это трит ошибки), то решение будет пооптимальнее:

Code: Select all

8 inputs detected (worst solution is 19680)

OLD 7|6|5|4|3|2|1|0 e12=144 e21=133 DG403=139
...
NEW 2|3|0|1|7|6|5|4 e12=102 e21=90 DG403=96
NEW 1|0|3|2|7|6|5|4 e12=98 e21=83 DG403=91
NEW 1|0|3|2|7|6|4|5 e12=98 e21=84 DG403=91
NEW 1|0|3|2|6|7|5|4 e12=98 e21=84 DG403=91
NEW 1|0|2|3|7|6|5|4 e12=98 e21=83 DG403=91
NEW 1|0|2|3|7|6|4|5 e12=98 e21=84 DG403=91
NEW 1|0|2|3|6|7|5|4 e12=98 e21=84 DG403=91
NEW 0|1|3|2|7|6|5|4 e12=98 e21=83 DG403=91
NEW 0|1|3|2|7|6|4|5 e12=98 e21=84 DG403=91
NEW 0|1|3|2|6|7|5|4 e12=98 e21=84 DG403=91
NEW 0|1|2|3|7|6|5|4 e12=98 e21=83 DG403=91
NEW 0|1|2|3|7|6|4|5 e12=98 e21=84 DG403=91
NEW 0|1|2|3|6|7|5|4 e12=98 e21=84 DG403=91

Optimal solution has 91 chips instead of 139
Ratio optimal/worst is 0%
117 functions were used

И всего лишь на одну микросхему больше, чем без трита ошибки!

Но всё равно - слишком много блоков получается

8b5t.zip

Так что всё-таки через ПЗУ придётся делать...

[Shaos]

Вобщем так - декодер надо будет делать на двух ПЗУ в которых будет использоваться только 256 байт - каждая ПЗУ будет хранить 4 трита (каждые 2 бита будут представлять 1 трит) - 3 трита информации и 1 трит "троичной чётности":

Code: Select all

NNN=O
NNO=N
NNP=P
NON=N
NOO=P
NOP=O
NPN=P
NPO=O
NPP=N
ONN=N
ONO=P
ONP=O
OON=P
OOO=O
OOP=N
OPN=O
OPO=N
OPP=P
PNN=P
PNO=O
PNP=N
PON=O
POO=N
POP=P
PPN=N
PPO=P
PPP=O

Проверка корректности по "троичной чётности" будет состоять в сложении всех 4 тритов, что в младшем трите суммы должно дать O

Далее выходы данных этих двух ПЗУ будут собираться в 6 тритов, один из которых будет сигнализировать об ошибке (выход за пределы оговоренных 243 троичных значений):

Code: Select all

10000000=POOOOO
10000001=POOOOO
10000010=POOOOO
10000011=POOOOO
10000100=POOOOO
10000101=POOOOO
10000110=POOOOO
10000111=ONNNNN
10001000=ONNNNO
10001001=ONNNNP
10001010=ONNNON
10001011=ONNNOO
10001100=ONNNOP
10001101=ONNNPN
10001110=ONNNPO
10001111=ONNNPP
10010000=ONNONN
10010001=ONNONO
10010010=ONNONP
10010011=ONNOON
10010100=ONNOOO
10010101=ONNOOP
10010110=ONNOPN
10010111=ONNOPO
10011000=ONNOPP
10011001=ONNPNN
10011010=ONNPNO
10011011=ONNPNP
10011100=ONNPON
10011101=ONNPOO
10011110=ONNPOP
10011111=ONNPPN
10100000=ONNPPO
10100001=ONNPPP
10100010=ONONNN
10100011=ONONNO
10100100=ONONNP
10100101=ONONON
10100110=ONONOO
10100111=ONONOP
10101000=ONONPN
10101001=ONONPO
10101010=ONONPP
10101011=ONOONN
10101100=ONOONO
10101101=ONOONP
10101110=ONOOON
10101111=ONOOOO
10110000=ONOOOP
10110001=ONOOPN
10110010=ONOOPO
10110011=ONOOPP
10110100=ONOPNN
10110101=ONOPNO
10110110=ONOPNP
10110111=ONOPON
10111000=ONOPOO
10111001=ONOPOP
10111010=ONOPPN
10111011=ONOPPO
10111100=ONOPPP
10111101=ONPNNN
10111110=ONPNNO
10111111=ONPNNP
11000000=ONPNON
11000001=ONPNOO
11000010=ONPNOP
11000011=ONPNPN
11000100=ONPNPO
11000101=ONPNPP
11000110=ONPONN
11000111=ONPONO
11001000=ONPONP
11001001=ONPOON
11001010=ONPOOO
11001011=ONPOOP
11001100=ONPOPN
11001101=ONPOPO
11001110=ONPOPP
11001111=ONPPNN
11010000=ONPPNO
11010001=ONPPNP
11010010=ONPPON
11010011=ONPPOO
11010100=ONPPOP
11010101=ONPPPN
11010110=ONPPPO
11010111=ONPPPP
11011000=OONNNN
11011001=OONNNO
11011010=OONNNP
11011011=OONNON
11011100=OONNOO
11011101=OONNOP
11011110=OONNPN
11011111=OONNPO
11100000=OONNPP
11100001=OONONN
11100010=OONONO
11100011=OONONP
11100100=OONOON
11100101=OONOOO
11100110=OONOOP
11100111=OONOPN
11101000=OONOPO
11101001=OONOPP
11101010=OONPNN
11101011=OONPNO
11101100=OONPNP
11101101=OONPON
11101110=OONPOO
11101111=OONPOP
11110000=OONPPN
11110001=OONPPO
11110010=OONPPP
11110011=OOONNN
11110100=OOONNO
11110101=OOONNP
11110110=OOONON
11110111=OOONOO
11111000=OOONOP
11111001=OOONPN
11111010=OOONPO
11111011=OOONPP
11111100=OOOONN
11111101=OOOONO
11111110=OOOONP
11111111=OOOOON
00000000=OOOOOO
00000001=OOOOOP
00000010=OOOOPN
00000011=OOOOPO
00000100=OOOOPP
00000101=OOOPNN
00000110=OOOPNO
00000111=OOOPNP
00001000=OOOPON
00001001=OOOPOO
00001010=OOOPOP
00001011=OOOPPN
00001100=OOOPPO
00001101=OOOPPP
00001110=OOPNNN
00001111=OOPNNO
00010000=OOPNNP
00010001=OOPNON
00010010=OOPNOO
00010011=OOPNOP
00010100=OOPNPN
00010101=OOPNPO
00010110=OOPNPP
00010111=OOPONN
00011000=OOPONO
00011001=OOPONP
00011010=OOPOON
00011011=OOPOOO
00011100=OOPOOP
00011101=OOPOPN
00011110=OOPOPO
00011111=OOPOPP
00100000=OOPPNN
00100001=OOPPNO
00100010=OOPPNP
00100011=OOPPON
00100100=OOPPOO
00100101=OOPPOP
00100110=OOPPPN
00100111=OOPPPO
00101000=OOPPPP
00101001=OPNNNN
00101010=OPNNNO
00101011=OPNNNP
00101100=OPNNON
00101101=OPNNOO
00101110=OPNNOP
00101111=OPNNPN
00110000=OPNNPO
00110001=OPNNPP
00110010=OPNONN
00110011=OPNONO
00110100=OPNONP
00110101=OPNOON
00110110=OPNOOO
00110111=OPNOOP
00111000=OPNOPN
00111001=OPNOPO
00111010=OPNOPP
00111011=OPNPNN
00111100=OPNPNO
00111101=OPNPNP
00111110=OPNPON
00111111=OPNPOO
01000000=OPNPOP
01000001=OPNPPN
01000010=OPNPPO
01000011=OPNPPP
01000100=OPONNN
01000101=OPONNO
01000110=OPONNP
01000111=OPONON
01001000=OPONOO
01001001=OPONOP
01001010=OPONPN
01001011=OPONPO
01001100=OPONPP
01001101=OPOONN
01001110=OPOONO
01001111=OPOONP
01010000=OPOOON
01010001=OPOOOO
01010010=OPOOOP
01010011=OPOOPN
01010100=OPOOPO
01010101=OPOOPP
01010110=OPOPNN
01010111=OPOPNO
01011000=OPOPNP
01011001=OPOPON
01011010=OPOPOO
01011011=OPOPOP
01011100=OPOPPN
01011101=OPOPPO
01011110=OPOPPP
01011111=OPPNNN
01100000=OPPNNO
01100001=OPPNNP
01100010=OPPNON
01100011=OPPNOO
01100100=OPPNOP
01100101=OPPNPN
01100110=OPPNPO
01100111=OPPNPP
01101000=OPPONN
01101001=OPPONO
01101010=OPPONP
01101011=OPPOON
01101100=OPPOOO
01101101=OPPOOP
01101110=OPPOPN
01101111=OPPOPO
01110000=OPPOPP
01110001=OPPPNN
01110010=OPPPNO
01110011=OPPPNP
01110100=OPPPON
01110101=OPPPOO
01110110=OPPPOP
01110111=OPPPPN
01111000=OPPPPO
01111001=OPPPPP
01111010=POOOOO
01111011=POOOOO
01111100=POOOOO
01111101=POOOOO
01111110=POOOOO
01111111=POOOOO

В данном случае для простоты адрес ПЗУ представляется как байт со знаком (signed char), по значению которого восстанавливается троичная комбинация (5 тритов данных и 1 трит сигнализирующий об ошибке).

P.S. Эти ПЗУ можно описать на VHDL (спрятав внутри прошивки FPGA) - тогда "троичную чётность" можно убрать, просто имея ROM на 256 слов по 12 бит каждое...

[Shaos]

Пока до следующего троичного чипа далековато, наверное сейчас надо выкатить софт-корку гипотетического троичного микроконтроллера для обычного двоичного FPGA, пользуясь наработками из темы Использование двоичного FPGA для реализации троичного компа

Увеличил "тритность" шины адреса до 6:

Screenshot from 2025-03-28 21-55-30.png

Счёт начинается с OOOOOO, потом OOOOOP, потом OOOOPN, потом OOOPOO и т.д.

[Shaos]

Вот как левая-верхняя часть схемы моей версии Триадора отображается на VHDL код:

ternary_Triador1_2025_03_29.png

Code: Select all

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

use work.ternary.all;

entity test3 is
    Port ( clk : in bit;
           res : in bit;
           s0 : out FakeTrit;
           s1 : out FakeTrit;
           s2 : out FakeTrit;
           s3 : out FakeTrit;
           s4 : out FakeTrit;
           s5 : out FakeTrit
         );
end test3;

architecture Behavioral of test3 is
signal a1,b1,c1,ss,ss0,ss1,ss2,ss3,ss4,ss5 : FakeTrit;
signal pclk,pclk1,nclk,nclk1,clr,m1,m2,m3,m4,m5,m6,h1,h2,h3,h4,h5,h6,g1,g2,g3,g4,g5,g6 : FakeTrit;
signal tmp_clk_std, tmp_iclk_std : STD_LOGIC;
signal tmp_clk : BIT;

COMPONENT Ternary_Clock
PORT (
       B_C : IN BIT;
       T_C : OUT FakeTrit
);
END COMPONENT;

COMPONENT Half_Adder
Port ( a : in FakeTrit;
       b : in FakeTrit;
       s : out FakeTrit;
       c : out FakeTrit
      );
END COMPONENT;

begin

tmp_clk <= clk;

clr(0) <= '0';
clr(1) <= res;

clk1: Ternary_Clock port map( B_C => tmp_clk, T_C => ss );

-- BLN
pclk(0) <= ss(0);
pclk(1) <= '0';
-- BLP
nclk(0) <= '0';
nclk(1) <= ss(1);
-- E12
mux1: ternary_mux port map( T_S => clr, T_N => N, T_O => pclk, T_P => pclk, T_C => pclk1 );
-- E12
mux2: ternary_mux port map( T_S => clr, T_N => P, T_O => nclk, T_P => nclk, T_C => nclk1 );

mem1: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss0, T_Q => m1 );
ha1: Half_Adder port map( a => P, b => m1, s => h1, c => g1 );
mem2: ternary_mem port map( T_S => nclk1, T_N => h1, T_P => O, T_Q => ss0 );
mem3: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss1, T_Q => m2 );
ha2: Half_Adder port map( a => g1, b => m2, s => h2, c => g2 );
mem4: ternary_mem port map( T_S => nclk1, T_N => h2, T_P => O, T_Q => ss1 );
mem5: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss2, T_Q => m3 );
ha3: Half_Adder port map( a => g2, b => m3, s => h3, c => g3 );
mem6: ternary_mem port map( T_S => nclk1, T_N => h3, T_P => O, T_Q => ss2 );
mem7: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss3, T_Q => m4 );
ha4: Half_Adder port map( a => g3, b => m4, s => h4, c => g4 );
mem8: ternary_mem port map( T_S => nclk1, T_N => h4, T_P => O, T_Q => ss3 );
mem9: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss4, T_Q => m5 );
ha5: Half_Adder port map( a => g4, b => m5, s => h5, c => g5 );
mem10: ternary_mem port map( T_S => nclk1, T_N => h5, T_P => O, T_Q => ss4 );
mem11: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss5, T_Q => m6 );
ha6: Half_Adder port map( a => g5, b => m6, s => h6, c => g6 );
mem12: ternary_mem port map( T_S => nclk1, T_N => h6, T_P => O, T_Q => ss5 );

s0 <= ss0;
s1 <= ss1;
s2 <= ss2;
s3 <= ss3;
s4 <= ss4;
s5 <= ss5;

end Behavioral;

Теперь приделываем ROM и начинаем крутить троичные программы

[Shaos]

EX-команды обращения к памяти данных WMM, RML, RMH будут обращаться к внутренней памяти данных через схемы, описанные выше (те что 1 блок, 2 блока и 3 блока). Возможно наружу надо вытянуть все EX-команды с кодами от 0 и меньше, а не только CUSTOM CIRCUITS (EX -12, EX -11 и EX -10), а то уж очень не хочется мне 13 регистров PEX хранить внутри чипа...

Либо можно двигаться фазами:

• TRI1000 - микроконтроллер с базовым набором команд без EX (и соответственно без памяти данных) - любая попытка вызова EX-команды введёт микроконтроллер в режим HLT (возможно тут уже можно добавить внешний интерфейс EX-команд);
• TRI2xxx - микроконтроллер с EX-командами доступа к внутренней памяти данных (на 1, 2 или 3 блока) и внешним интерфейсом EX-команд;
• TRI3xxx - микроконтроллер с реализацией всех EX-команд и внутренней памятью данных (также на 1, 2 или 3 блока).

1, 2 или 3 блока данных будут предоставлять соответственно 123, 225 или 309 трайтов (см. выше), поэтому полные наименования таких микроконтроллеров будут TRI3123, TRI3225 и TRI3309 соответственно (и у всех память программ будет располагаться снаружи)...

P.S. Надо прикинуть сложность реализации EX-команды JPI - может быть сразу в TRI1000 её добавить (или это уже будет TRI1000A?)

P.P.S. А в будущем можно ещё и интерфейс к SPI-памяти прикрутить с кэшем на 27 команд внутри чипа или сразу на встроенный FLASH замахнуться?...

Я там в 2017 году уже разбивал триадор на классы:

TRIADOR-0 : 4 регистра без EX-инструкций и с 3-тритной шиной адреса
TRIADOR-1 : 13 регистров без EX-инструкций и с 6-тритной шиной адреса (R13 используется при передаче управления)
TRIADOR-2 : 13 регистров с 6-тритной шиной адреса и некоторым набором EX-инструкций (программируемых переключателями)
TRIADOR-3 : 13 регистров с 6-тритной шиной адреса и полным набором EX-инструкций (программируемых программно) и дополнительной памятью данных с 6-тритным адресом...

Можно как-то отсюда плясать наверное...

[Shaos]

Сделал троичное ПЗУ программ для тестов (адрес 6 тритов, данные 5 тритов):

Code: Select all

use work.ternary.all;

entity Ternary_ROM is
    Port ( a : in FakeTryte;
           d : out bit_vector(9 downto 0));
end Ternary_ROM;

architecture Behavioral of Ternary_ROM is
begin
    process(a)
    begin
        case a is
                when O & O & O & O & O & O => d <= O & O & O & O & O;
                when O & O & O & O & O & P => d <= O & O & O & O & P;
                when O & O & O & O & P & N => d <= O & O & O & P & N;
                when O & O & O & O & P & O => d <= O & O & O & P & O;
                when O & O & O & O & P & P => d <= O & P & P & P & P;
                when others =>                d <= O & O & O & O & O;
        end case;
    end process;
end Behavioral;

В архиве всё что надо для запуска через GHDL:

ternary-test-2025-04-05.zip

Ещё в коде добавился декодер команд (через dmux-ы):

ternary_Triador1tl_2025_04_05.png

Немного осциллограмм:

Screenshot from 2025-04-05 10-44-36.png

Тут pclk1/nclk1 во время ресета находятся в активном состоянии (см. в самое начало) - думается это неправильно (хотя вроде как полностью соответствует логисимовской модели).

P.S. А хотя нет - это же третье состояние клоков - начальная установка!

P.P.S. Я понял! Меня смутил ненулевой dOO вначале, а ненулевой он потому, что я не поставил блок BLN на сигнал управления демультиплексорами, как было в логисимовской схеме! Надо будет исправить…

[Shaos]

Текущее состояние дел (всё ещё переношу левый-верхний угол схемы):

[Shaos]

Текст VHDL получается абсолютно нечитаемый т.к. по сути это нетлист:

Code: Select all

...
clk1: Ternary_Clock port map( B_C => tmp_clk, T_C => ss );
-- BLN
pclk(0) <= ss(0);
pclk(1) <= '0';
-- BLP
nclk(0) <= '0';
nclk(1) <= ss(1);
mux1: ternary_mux port map( T_S => clr, T_N => N, T_O => pclk, T_P => pclk, T_C => pclk1 );
-- BLN2
pclk0(0) <= pclk1(0);
pclk0(1) <= '0';
mux2: ternary_mux port map( T_S => clr, T_N => P, T_O => nclk, T_P => nclk, T_C => nclk1 );
mem1: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss0, T_Q => m1 );
ha1: Half_Adder port map( a => P, b => m1, s => h1, c => g1 );
mem2: ternary_mem port map( T_S => nclk1, T_N => h1, T_P => O, T_Q => ss0 );
mem3: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss1, T_Q => m2 );
ha2: Half_Adder port map( a => g1, b => m2, s => h2, c => g2 );
mem4: ternary_mem port map( T_S => nclk1, T_N => h2, T_P => O, T_Q => ss1 );
mem5: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss2, T_Q => m3 );
ha3: Half_Adder port map( a => g2, b => m3, s => h3, c => g3 );
mem6: ternary_mem port map( T_S => nclk1, T_N => h3, T_P => O, T_Q => ss2 );
mem7: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss3, T_Q => m4 );
ha4: Half_Adder port map( a => g3, b => m4, s => h4, c => g4 );
mem8: ternary_mem port map( T_S => nclk1, T_N => h4, T_P => O, T_Q => ss3 );
mem9: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss4, T_Q => m5 );
ha5: Half_Adder port map( a => g4, b => m5, s => h5, c => g5 );
mem10: ternary_mem port map( T_S => nclk1, T_N => h5, T_P => O, T_Q => ss4 );
mem11: ternary_mem port map( T_S => pclk1, T_N => O, T_P => ss5, T_Q => m6 );
ha6: Half_Adder port map( a => g5, b => m6, s => h6, c => g6 );
mem12: ternary_mem port map( T_S => nclk1, T_N => h6, T_P => O, T_Q => ss5 );
dmux1: ternary_dmux port map( T_S => com4, T_C => pclk0, T_N => dm1, T_O => dm2, T_P => dm3 );
dmux2: ternary_dmux port map( T_S => com3, T_C => dm1, T_N => dNN, T_O => dNO, T_P => dNP );
dmux3: ternary_dmux port map( T_S => com3, T_C => dm2, T_N => dON, T_O => dOO, T_P => dOP );
dmux4: ternary_dmux port map( T_S => com3, T_C => dm3, T_N => dPN, T_O => dPO, T_P => dPP );
mux3: ternary_mux port map( T_S => asign, T_N => dOO, T_O => O, T_P => O, T_C => mu3 );
dmux5: ternary_dmux port map( T_S => ic2, T_C => mu3, T_O => dm0, T_P => dm00 );
dmux6: ternary_dmux port map( T_S => ic1, T_C => dm0, T_O => dm4, T_P => dm5 );
dmux7: ternary_dmux port map( T_S => ic1, T_C => dm00, T_N => dm6, T_O => dm7, T_P => dm8 );
dmux8: ternary_dmux port map( T_S => ic0, T_C => dm4, T_P => wr1 );
dmux9: ternary_dmux port map( T_S => ic0, T_C => dm5, T_N => wr2, T_O => wr3, T_P => wr4 );
dmux10: ternary_dmux port map( T_S => ic0, T_C => dm6, T_N => wr5, T_O => wr6, T_P => wr7 );
dmux11: ternary_dmux port map( T_S => ic0, T_C => dm7, T_N => wr8, T_O => wr9, T_P => wr10 );
dmux12: ternary_dmux port map( T_S => ic0, T_C => dm8, T_N => wr11, T_O => wr12, T_P => wr13 );
mux4: ternary_mux port map( T_S => com1, T_N => N, T_O => com0, T_P => P, T_C => mu4 );
mux5: ternary_mux port map( T_S => com2, T_N => N, T_O => mu4, T_P => P, T_C => asign );
mux7: ternary_mux port map( T_S => com2, T_N => O, T_O => asign, T_P => O, T_C => mu7 );
mux8: ternary_mux port map( T_S => com1, T_N => O, T_O => mu7, T_P => O, T_C => mu8 );
mux9: ternary_mux port map( T_S => asign, T_N => mu8, T_O => asign, T_P => asign, T_C => mu9 );
inv2: ternary_mux port map( T_S => com0, T_N => P, T_O => O, T_P => N, T_C => ic0 );
inv3: ternary_mux port map( T_S => com1, T_N => P, T_O => O, T_P => N, T_C => ic1 );
inv4: ternary_mux port map( T_S => com2, T_N => P, T_O => O, T_P => N, T_C => ic2 );
mux17: ternary_mux port map( T_S => com4, T_N => N, T_O => com3, T_P => P, T_C => osign );
min1: ternary_min port map( T_A => dOO, T_B => mu9, T_C => mi1 );
...

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

[Shaos]

Потихоньку двигаюсь дальше:

ternary_Triador1_2025_04_09.jpg

VHDL пока не выкладываю, но вот осциллограммы:

Screenshot from 2025-04-09 22-05-34.png

Сигнал clrc (на схеме clrC) надо бы переименовать в copyC т.к. оно работает как сигнал копирования нового значения флага C (сигнал op3) после инструкции потритовой операции op (ONxxx)

Сигналы стробов основных блоков инструкций:
dno (на схеме dNO) - инструкции потритовой операции - ONxxx
doo (на схеме dOO) - инструкции копирования из и в регистр R1 - OOxxx (см. ниже)
dop (на схеме dOP) - инструкции записи произвольного 3-тритного числа в регистр R1 - OPxxx
dpn (на схеме dPN) - инструкции записи произвольного 3-тритного числа в регистр R2 - PNxxx
dpo (на схеме dPO) - инструкции записи произвольного 3-тритного числа в регистр R3 - POxxx
dpp (на схеме dPP) - инструкции записи произвольного 3-тритного числа в регистр R4 - PPxxx

Сигналы стробов записи в регистры wr1-wr13 срабатывают только в блоке OOxxx, а запись произвольного числа в регистры R1,R2,R3,R4 будет идти через спецстробы rw1c,rw2c,rw3c,rw4c (пока не перенесены в VHDL, но уже есть на картинке)

Code: Select all

NNNNN -121 -> 87 - EX -13 ; implementation specific extension -13
NNNNO -120 -> 88 - EX -12 ; implementation specific extension -12
NNNNP -119 -> 89 - EX -11 ; implementation specific extension -11
NNNON -118 -> 8A - EX -10 ; implementation specific extension -10
NNNOO -117 -> 8B - EX -9  ; implementation specific extension -9
NNNOP -116 -> 8C - EX -8  ; implementation specific extension -8
NNNPN -115 -> 8D - EX -7  ; implementation specific extension -7
NNNPO -114 -> 8E - EX -6  ; implementation specific extension -6
NNNPP -113 -> 8F - EX -5  ; implementation specific extension -5
NNONN -112 -> 90 - EX -4  ; implementation specific extension -4
NNONO -111 -> 91 - EX -3  ; implementation specific extension -3
NNONP -110 -> 92 - EX -2  ; implementation specific extension -2
NNOON -109 -> 93 - EX -1  ; implementation specific extension -1
NNOOO -108 -> 94 - EX 0   ; implementation specific extension 0
NNOOP -107 -> 95 - EX +1  ; implementation specific extension +1
NNOPN -106 -> 96 - EX +2  ; implementation specific extension +2
NNOPO -105 -> 97 - EX +3  ; implementation specific extension +3
NNOPP -104 -> 98 - EX +4  ; implementation specific extension +4
NNPNN -103 -> 99 - EX +5  ; implementation specific extension +5
NNPNO -102 -> 9A - EX +6  ; implementation specific extension +6
NNPNP -101 -> 9B - EX +7  ; implementation specific extension +7
NNPON -100 -> 9C - EX +8  ; implementation specific extension +8
NNPOO  -99 -> 9D - EX +9  ; implementation specific extension +9
NNPOP  -98 -> 9E - EX +10 ; implementation specific extension +10
NNPPN  -97 -> 9F - EX +11 ; implementation specific extension +11
NNPPO  -96 -> A0 - EX +12 ; implementation specific extension +12
NNPPP  -95 -> A1 - EX +13 ; implementation specific extension +13
NONNN  -94 -> A2 - JP -13 ; jump to address 27*R13 - 13
NONNO  -93 -> A3 - JP -12 ; jump to address 27*R13 - 12
NONNP  -92 -> A4 - JP -11 ; jump to address 27*R13 - 11
NONON  -91 -> A5 - JP -10 ; jump to address 27*R13 - 10
NONOO  -90 -> A6 - JP -9  ; jump to address 27*R13 - 9
NONOP  -89 -> A7 - JP -8  ; jump to address 27*R13 - 8
NONPN  -88 -> A8 - JP -7  ; jump to address 27*R13 - 7
NONPO  -87 -> A9 - JP -6  ; jump to address 27*R13 - 6
NONPP  -86 -> AA - JP -5  ; jump to address 27*R13 - 5
NOONN  -85 -> AB - JP -4  ; jump to address 27*R13 - 4
NOONO  -84 -> AC - JP -3  ; jump to address 27*R13 - 3
NOONP  -83 -> AD - JP -2  ; jump to address 27*R13 - 2
NOOON  -82 -> AE - JP -1  ; jump to address 27*R13 - 1
NOOOO  -81 -> AF - JP 0   ; jump to address 27*R13
NOOOP  -80 -> B0 - JP +1  ; jump to address 27*R13 + 1
NOOPN  -79 -> B1 - JP +2  ; jump to address 27*R13 + 2
NOOPO  -78 -> B2 - JP +3  ; jump to address 27*R13 + 3
NOOPP  -77 -> B3 - JP +4  ; jump to address 27*R13 + 4
NOPNN  -76 -> B4 - JP +5  ; jump to address 27*R13 + 5
NOPNO  -75 -> B5 - JP +6  ; jump to address 27*R13 + 6
NOPNP  -74 -> B6 - JP +7  ; jump to address 27*R13 + 7
NOPON  -73 -> B7 - JP +8  ; jump to address 27*R13 + 8
NOPOO  -72 -> B8 - JP +9  ; jump to address 27*R13 + 9
NOPOP  -71 -> B9 - JP +10 ; jump to address 27*R13 + 10
NOPPN  -70 -> BA - JP +11 ; jump to address 27*R13 + 11
NOPPO  -69 -> BB - JP +12 ; jump to address 27*R13 + 12
NOPPP  -68 -> BC - JP +13 ; jump to address 27*R13 + 13
NPNNN  -67 -> BD - SK -13 ; skip_if_not_negative_r4
NPNNO  -66 -> BE - SK -12 ; skip_if_not_zero_r4
NPNNP  -65 -> BF - SK -11 ; skip_if_not_positive_r4
NPNON  -64 -> C0 - SK -10 ; skip_if_not_negative_r3
NPNOO  -63 -> C1 - SK -9  ; skip_if_not_zero_r3
NPNOP  -62 -> C2 - SK -8  ; skip_if_not_positive_r3
NPNPN  -61 -> C3 - SK -7  ; skip_if_not_negative_r2
NPNPO  -60 -> C4 - SK -6  ; skip_if_not_zero_r2
NPNPP  -59 -> C5 - SK -5  ; skip_if_not_positive_r2
NPONN  -58 -> C6 - SK -4  ; skip_if_not_negative_r1
NPONO  -57 -> C7 - SK -3  ; skip_if_not_zero_r1
NPONP  -56 -> C8 - SK -2  ; skip_if_not_positive_r1
NPOON  -55 -> C9 - SK -1  ; skip_if_borrow
NPOOO  -54 -> CA - SK 0   ; skip_if_no_overflow
NPOOP  -53 -> CB - SK +1  ; skip_if_carry
NPOPN  -52 -> CC - SK +2  ; skip_if_negative_r1
NPOPO  -51 -> CD - SK +3  ; skip_if_zero_r1
NPOPP  -50 -> CE - SK +4  ; skip_if_positive_r1
NPPNN  -49 -> CF - SK +5  ; skip_if_negative_r2
NPPNO  -48 -> D0 - SK +6  ; skip_if_zero_r2
NPPNP  -47 -> D1 - SK +7  ; skip_if_positive_r2
NPPON  -46 -> D2 - SK +8  ; skip_if_negative_r3
NPPOO  -45 -> D3 - SK +9  ; skip_if_zero_r3
NPPOP  -44 -> D4 - SK +10 ; skip_if_positive_r3
NPPPN  -43 -> D5 - SK +11 ; skip_if_negative_r4
NPPPO  -42 -> D6 - SK +12 ; skip_if_zero_r4
NPPPP  -41 -> D7 - SK +13 ; skip_if_positive_r4
ONNNN  -40 -> D8 - OP -13 ; tritwise unary function NNN -> R1=-13, flag C=-1
ONNNO  -39 -> D9 - OP -12 ; tritwise unary function NNO -> SHD (Shift Down)
ONNNP  -38 -> DA - OP -11 ; tritwise unary function NNP
ONNON  -37 -> DB - OP -10 ; tritwise unary function NON
ONNOO  -36 -> DC - OP -9  ; tritwise unary function NOO -> BLP (Block Positive = reverse diode)
ONNOP  -35 -> DD - OP -8  ; tritwise unary function NOP -> no operation
ONNPN  -34 -> DE - OP -7  ; tritwise unary function NPN
ONNPO  -33 -> DF - OP -6  ; tritwise unary function NPO
ONNPP  -32 -> E0 - OP -5  ; tritwise unary function NPP
ONONN  -31 -> E1 - OP -4  ; tritwise unary function ONN -> NHI
ONONO  -30 -> E2 - OP -3  ; tritwise unary function ONO
ONONP  -29 -> E3 - OP -2  ; tritwise unary function ONP
ONOON  -28 -> E4 - OP -1  ; tritwise unary function OON
ONOOO  -27 -> E5 - OP 0   ; tritwise unary function OOO -> R1=0, flag C=0
ONOOP  -26 -> E6 - OP +1  ; tritwise unary function OOP -> BLN (Block Negative = forward diode)
ONOPN  -25 -> E7 - OP +2  ; tritwise unary function OPN -> ROU (Rotate Up)
ONOPO  -24 -> E8 - OP +3  ; tritwise unary function OPO
ONOPP  -23 -> E9 - OP +4  ; tritwise unary function OPP -> SHU (Shift Up)
ONPNN  -22 -> EA - OP +5  ; tritwise unary function PNN -> NTI
ONPNO  -21 -> EB - OP +6  ; tritwise unary function PNO -> ROD (Rotate Down)
ONPNP  -20 -> EC - OP +7  ; tritwise unary function PNP
ONPON  -19 -> ED - OP +8  ; tritwise unary function PON -> R1=-R1, flag C=-C
ONPOO  -18 -> EE - OP +9  ; tritwise unary function POO
ONPOP  -17 -> EF - OP +10 ; tritwise unary function POP
ONPPN  -16 -> F0 - OP +11 ; tritwise unary function PPN -> PTI
ONPPO  -15 -> F1 - OP +12 ; tritwise unary function PPO -> PHI
ONPPP  -14 -> F2 - OP +13 ; tritwise unary function PPP -> R1=+13, flag C=+1
OONNN  -13 -> F3 - RR -13 ; copy R1 to R13
OONNO  -12 -> F4 - RR -12 ; copy R1 to R12
OONNP  -11 -> F5 - RR -11 ; copy R1 to R11
OONON  -10 -> F6 - RR -10 ; copy R1 to R10
OONOO   -9 -> F7 - RR -9  ; copy R1 to R9
OONOP   -8 -> F8 - RR -8  ; copy R1 to R8
OONPN   -7 -> F9 - RR -7  ; copy R1 to R7
OONPO   -6 -> FA - RR -6  ; copy R1 to R6
OONPP   -5 -> FB - RR -5  ; copy R1 to R5
OOONN   -4 -> FC - RR -4  ; copy R1 to R4
OOONO   -3 -> FD - RR -3  ; copy R1 to R3
OOONP   -2 -> FE - RR -2  ; copy R1 to R2
OOOON   -1 -> FF - RR -1  ; decrement R1 and reflect borrow in flag C
OOOOO    0 -> 00 - RR 0   ; no operation
OOOOP    1 -> 01 - RR +1  ; increment R1 and reflect carry in flag C
OOOPN    2 -> 02 - RR +2  ; copy R2 to R1
OOOPO    3 -> 03 - RR +3  ; copy R3 to R1
OOOPP    4 -> 04 - RR +4  ; copy R4 to R1
OOPNN    5 -> 05 - RR +5  ; copy R5 to R1
OOPNO    6 -> 06 - RR +6  ; copy R6 to R1
OOPNP    7 -> 07 - RR +7  ; copy R7 to R1
OOPON    8 -> 08 - RR +8  ; copy R8 to R1
OOPOO    9 -> 09 - RR +9  ; copy R9 to R1
OOPOP   10 -> 0A - RR +10 ; copy R10 to R1
OOPPN   11 -> 0B - RR +11 ; copy R11 to R1
OOPPO   12 -> 0C - RR +12 ; copy R12 to R1
OOPPP   13 -> 0D - RR +13 ; copy R13 to R1
OPNNN   14 -> 0E - R1 -13 ; write -13 to R1
OPNNO   15 -> 0F - R1 -12 ; write -12 to R1
OPNNP   16 -> 10 - R1 -11 ; write -11 to R1
OPNON   17 -> 11 - R1 -10 ; write -10 to R1
OPNOO   18 -> 12 - R1 -9  ; write -9 to R1
OPNOP   19 -> 13 - R1 -8  ; write -8 to R1
OPNPN   20 -> 14 - R1 -7  ; write -7 to R1
OPNPO   21 -> 15 - R1 -6  ; write -6 to R1
OPNPP   22 -> 16 - R1 -5  ; write -5 to R1
OPONN   23 -> 17 - R1 -4  ; write -4 to R1
OPONO   24 -> 18 - R1 -3  ; write -3 to R1
OPONP   25 -> 19 - R1 -2  ; write -2 to R1
OPOON   26 -> 1A - R1 -1  ; write -1 to R1
OPOOO   27 -> 1B - R1 0   ; write 0 to R1
OPOOP   28 -> 1C - R1 +1  ; write +1 to R1
OPOPN   29 -> 1D - R1 +2  ; write +2 to R1
OPOPO   30 -> 1E - R1 +3  ; write +3 to R1
OPOPP   31 -> 1F - R1 +4  ; write +4 to R1
OPPNN   32 -> 20 - R1 +5  ; write +5 to R1
OPPNO   33 -> 21 - R1 +6  ; write +6 to R1
OPPNP   34 -> 22 - R1 +7  ; write +7 to R1
OPPON   35 -> 23 - R1 +8  ; write +8 to R1
OPPOO   36 -> 24 - R1 +9  ; write +9 to R1
OPPOP   37 -> 25 - R1 +10 ; write +10 to R1
OPPPN   38 -> 26 - R1 +11 ; write +11 to R1
OPPPO   39 -> 27 - R1 +12 ; write +12 to R1
OPPPP   40 -> 28 - R1 +13 ; write +13 to R1
PNNNN   41 -> 29 - R2 -13 ; write -13 to R2
PNNNO   42 -> 2A - R2 -12 ; write -12 to R2
PNNNP   43 -> 2B - R2 -11 ; write -11 to R2
PNNON   44 -> 2C - R2 -10 ; write -10 to R2
PNNOO   45 -> 2D - R2 -9  ; write -9 to R2
PNNOP   46 -> 2E - R2 -8  ; write -8 to R2
PNNPN   47 -> 2F - R2 -7  ; write -7 to R2
PNNPO   48 -> 30 - R2 -6  ; write -6 to R2
PNNPP   49 -> 31 - R2 -5  ; write -5 to R2
PNONN   50 -> 32 - R2 -4  ; write -4 to R2
PNONO   51 -> 33 - R2 -3  ; write -3 to R2
PNONP   52 -> 34 - R2 -2  ; write -2 to R2
PNOON   53 -> 35 - R2 -1  ; write -1 to R2
PNOOO   54 -> 36 - R2 0   ; write 0 to R2
PNOOP   55 -> 37 - R2 +1  ; write +1 to R2
PNOPN   56 -> 38 - R2 +2  ; write +2 to R2
PNOPO   57 -> 39 - R2 +3  ; write +3 to R2
PNOPP   58 -> 3A - R2 +4  ; write +4 to R2
PNPNN   59 -> 3B - R2 +5  ; write +5 to R2
PNPNO   60 -> 3C - R2 +6  ; write +6 to R2
PNPNP   61 -> 3D - R2 +7  ; write +7 to R2
PNPON   62 -> 3E - R2 +8  ; write +8 to R2
PNPOO   63 -> 3F - R2 +9  ; write +9 to R2
PNPOP   64 -> 40 - R2 +10 ; write +10 to R2
PNPPN   65 -> 41 - R2 +11 ; write +11 to R2
PNPPO   66 -> 42 - R2 +12 ; write +12 to R2
PNPPP   67 -> 43 - R2 +13 ; write +13 to R2
PONNN   68 -> 44 - R3 -13 ; write -13 to R3
PONNO   69 -> 45 - R3 -12 ; write -12 to R3
PONNP   70 -> 46 - R3 -11 ; write -11 to R3
PONON   71 -> 47 - R3 -10 ; write -10 to R3
PONOO   72 -> 48 - R3 -9  ; write -9 to R3
PONOP   73 -> 49 - R3 -8  ; write -8 to R3
PONPN   74 -> 4A - R3 -7  ; write -7 to R3
PONPO   75 -> 4B - R3 -6  ; write -6 to R3
PONPP   76 -> 4C - R3 -5  ; write -5 to R3
POONN   77 -> 4D - R3 -4  ; write -4 to R3
POONO   78 -> 4E - R3 -3  ; write -3 to R3
POONP   79 -> 4F - R3 -2  ; write -2 to R3
POOON   80 -> 50 - R3 -1  ; write -1 to R3
POOOO   81 -> 51 - R3 0   ; write 0 to R3
POOOP   82 -> 52 - R3 +1  ; write +1 to R3
POOPN   83 -> 53 - R3 +2  ; write +2 to R3
POOPO   84 -> 54 - R3 +3  ; write +3 to R3
POOPP   85 -> 55 - R3 +4  ; write +4 to R3
POPNN   86 -> 56 - R3 +5  ; write +5 to R3
POPNO   87 -> 57 - R3 +6  ; write +6 to R3
POPNP   88 -> 58 - R3 +7  ; write +7 to R3
POPON   89 -> 59 - R3 +8  ; write +8 to R3
POPOO   90 -> 5A - R3 +9  ; write +9 to R3
POPOP   91 -> 5B - R3 +10 ; write +10 to R3
POPPN   92 -> 5C - R3 +11 ; write +11 to R3
POPPO   93 -> 5D - R3 +12 ; write +12 to R3
POPPP   94 -> 5E - R3 +13 ; write +13 to R3
PPNNN   95 -> 5F - R4 -13 ; write -13 to R4
PPNNO   96 -> 60 - R4 -12 ; write -12 to R4
PPNNP   97 -> 61 - R4 -11 ; write -11 to R4
PPNON   98 -> 62 - R4 -10 ; write -10 to R4
PPNOO   99 -> 63 - R4 -9  ; write -9 to R4
PPNOP  100 -> 64 - R4 -8  ; write -8 to R4
PPNPN  101 -> 65 - R4 -7  ; write -7 to R4
PPNPO  102 -> 66 - R4 -6  ; write -6 to R4
PPNPP  103 -> 67 - R4 -5  ; write -5 to R4
PPONN  104 -> 68 - R4 -4  ; write -4 to R4
PPONO  105 -> 69 - R4 -3  ; write -3 to R4
PPONP  106 -> 6A - R4 -2  ; write -2 to R4
PPOON  107 -> 6B - R4 -1  ; write -1 to R4
PPOOO  108 -> 6C - R4 0   ; write 0 to R4
PPOOP  109 -> 6D - R4 +1  ; write +1 to R4
PPOPN  110 -> 6E - R4 +2  ; write +2 to R4
PPOPO  111 -> 6F - R4 +3  ; write +3 to R4
PPOPP  112 -> 70 - R4 +4  ; write +4 to R4
PPPNN  113 -> 71 - R4 +5  ; write +5 to R4
PPPNO  114 -> 72 - R4 +6  ; write +6 to R4
PPPNP  115 -> 73 - R4 +7  ; write +7 to R4
PPPON  116 -> 74 - R4 +8  ; write +8 to R4
PPPOO  117 -> 75 - R4 +9  ; write +9 to R4
PPPOP  118 -> 76 - R4 +10 ; write +10 to R4
PPPPN  119 -> 77 - R4 +11 ; write +11 to R4
PPPPO  120 -> 78 - R4 +12 ; write +12 to R4
PPPPP  121 -> 79 - R4 +13 ; write +13 to R4

EX, JP и SK (skips) пока не делаю...

[Shaos]

Сигналы стробов записи в регистры wr1-wr13 срабатывают только в блоке OOxxx, а запись произвольного числа в регистры R1,R2,R3,R4 будет идти через спецстробы rw1c,rw2c,rw3c,rw4c (пока не перенесены в VHDL, но уже есть на картинке)

Добавил "спецстробы" wr1c, wr2c, wr3c и wr4c - как-то длинноват по-моему wr1c в инструкциях копирования из Rx в R1 (слева) и в OP PON (справа):

Screenshot from 2025-04-09 23-12-49.png

По идее его надо стробировать клоком pclk1 - это значит надо добавить ещё один блок min, хоть там уже и есть один min...

P.S. Вот жеж блин!!! У меня косяк в MIN был

[Shaos]

Вот теперь всё чётко

[Shaos]

Перенёс в VHDL регистр R1 и логику формирования произвольных потритовых операций (MEM-ы раскрашены разными цветами в зависимости от того по какой фазе клока они срабатывают):

ternary_Triador1_2025_04_10.jpg

И оно даже работает

Screenshot from 2025-04-11 01-13-52.png

На осциллограмме r1t0,r1t1,r1t2 это триты регистра R1, adr - адрес на шине, com - 5-тритовая команда из ПЗУ программ, com0,com1.com2 - младшие 3 трита команды, wr1c - строб записи в регистр R1, стробы don (на схеме dON) показывают где по времени случились команды потритовых операций над R1 - сначала OP PON (инверсия регистра R1), а следом OP OOO (обнуление регистра R1).

[Shaos]

Вроде сделал (но пока без регистров R5-R13) - получилось 48 отдельно стоящих троичных мультиплексоров (среди которых есть упрощённые - 5 x E12 и 12 x E21, т.е. полных только 31), 37 блоков памяти, которые на тримуксах реализуются двумя троичными мультиплексорами каждый, т.е. ещё 74 троичных мультиплексора, 2 блока MIN и 7 блоков MAX (которые при реализации на дискретных компонентах требуют только диоды), 12 троичных демультиплексора (которые реализуются на тех же троичных селекторах/мультиплексорах) и 13 троичных полусумматоров, каждый из которых реализауется на 4 полных мультиплексорах, одном E12 и одном E21, т.е. ещё 52 полных троичных мультиплексора, 13 x E12 и 13 x E21. Итого: 31+74+12+52=169 полных троичных мультиплексоров, 18 неполных E12 и 25 неполных E21, что выливается примерно в 191 микросхему DG403 (в 2017 году я наcчитал 272 в версии со всеми регистрами вплоть до R13) или 107 сдвоенных тримуксов (ещё можно прикинуть сколько оно может занять на дешёвых CMOS-микросхемах) - теперь интересно сколько ресурсов оно займёт во всяких разных FPGA:

ternary_Triador1_2025_04_11.jpg

Screenshot from 2025-04-11 22-57-21.png