Gigatron (компьютер на рассыпухе)

[Lavr]

Я поискал компилятор ассемблера для Gigatron-а... от авторов вроде как его нет, поскольку ядро системы
они вроде как написали на python...

Но нашел я по пути пару статеек, где автор, которому, похоже, Gigatron понравился, подробно расписал
как и что в этом скромном железе работает:

Gigatron TTL microcomputer

Программная архитектура Gigatron TTL microcomputer

[b2m]

Ассемблерный текст выглядит так:

Code: Select all

#-----------------------------------------------------------------------
#
#  ROM page 0: Boot
#
#-----------------------------------------------------------------------

align(0x100, 0x100)

# Give a first sign of life that can be checked with a voltmeter
ld(0b0000);                     C('LEDs |OOOO|')
ld(syncBits^hSync, OUT)         # Prepare XOUT update, hSync goes down, RGB to black
ld(syncBits, OUT)               # hSync goes up, updating XOUT

# Simple RAM test and size check by writing to [1<<n] and see if [0] changes or not.
ld(1);                          C('Quick RAM test and count')
label('.countMem0')
st([memSize],Y);                C('Store in RAM and load AC in Y')
ld(255)
xora([Y,0]);                    C('Invert value from memory')
st([Y,0]);                      C('Test RAM by writing the new value')
st([0]);                        C('Copy result in [0]')
xora([Y,0]);                    C('Read back and compare if written ok')
bne(pc());                      C('Loop forever on RAM failure here')
ld(255)
xora([Y,0]);                    C('Invert memory value again')
st([Y,0]);                      C('To restore original value')
xora([0]);                      C('Compare with inverted copy')
beq('.countMem1');              C('If equal, we wrapped around')
ld([memSize])
bra('.countMem0');              C('Loop to test next address line')
adda(AC);                       C('Executes in the branch delay slot!')
label('.countMem1')

Но это не что иное, как программа на питоне. Просто в начале файла подключается asm.py
Это, как бы, "микрокод". Он делает много чего: вывод видео, звука, и наконец выполняет инструкции либо vCPU (собственно процессор, как он был задуман), либо 6502 (более поздняя дополнительная реализация).

Ассемблера для vCPU вроде нет, но программы пишутся на более высокоуровневом "языке" GCL (gcl0x.py), который компилируется в команды vCPU, и там вроде как есть возможность делать inline-вставки. Сама прорамма записывается в ПЗУ в виде таблицы (в листинге это видно):

Code: Select all

              fae8 0011  ld   $11         ;05ac LDWI
              fae9 00a0  ld   $a0
              faea 007f  ld   $7f
              faeb 00cf  ld   $cf         ;05af CALL
              faec 0018  ld   $18         ;05af vAC
              faed 00b4  ld   $b4         ;05b1 SYS
              faee 00e2  ld   $e2
              faef 0006  ld   $06         ;| RAM segment address (high byte first)
              faf0 00f9  ld   $f9         ;|
              faf1 0007  ld   $07         ;| Length (1..256)
              faf2 0011  ld   $11         ;06f9 LDWI
              faf3 0000  ld   $00
              faf4 0002  ld   $02
              faf5 005e  ld   $5e         ;06fc ST
              faf6 001c  ld   $1c
              faf7 00cf  ld   $cf         ;06fe CALL
              faf8 0018  ld   $18         ;06fe vAC
              faf9 007f  ld   $7f         ;| RAM segment address (high byte first)
              fafa 00a0  ld   $a0         ;|
              fafb fe00  bra  ac          ;+-----------------------------------+
              fafc fcfd  bra  $fafd       ;|                                   |
              fafd 1404  ld   $04,y       ;| Trampoline for page $fa00 lookups |
              fafe e065  jmp  y,$65       ;|                                   |
              faff c218  st   [$18]       ;+-----------------------------------+
              fb00 0017  ld   $17         ;| Length (1..256)
              fb01 00e3  ld   $e3         ;7fa0 ADDI
              fb02 000b  ld   $0b
              fb03 002b  ld   $2b         ;7fa2 STW
              fb04 001a  ld   $1a         ;7fa2 '_vLR'
              fb05 0011  ld   $11         ;7fa4 LDWI
              fb06 003d  ld   $3d
              fb07 00dc  ld   $dc
              fb08 002b  ld   $2b         ;7fa7 STW
              fb09 0024  ld   $24
              fb0a 00b4  ld   $b4         ;7fa9 SYS
              fb0b 00e2  ld   $e2
              fb0c 0011  ld   $11         ;7fab LDWI
              fb0d 0000  ld   $00
              fb0e 0002  ld   $02
              fb0f 002b  ld   $2b         ;7fae STW
              fb10 001a  ld   $1a         ;7fae '_vLR'
              fb11 0011  ld   $11         ;7fb0 LDWI
              fb12 006f  ld   $6f
              fb13 00e8  ld   $e8
              fb14 002b  ld   $2b         ;7fb3 STW
              fb15 0024  ld   $24
              fb16 00b4  ld   $b4         ;7fb5 SYS
              fb17 00e2  ld   $e2
              fb18 0000  ld   $00         ;End of Apps/MainMenu/MainMenu_v4.gcl, size 939

Наличие "трамплинов" вроде как говорит о том, что программа копируется в ОЗУ, т.к. в компиляторе GCL на мой взгляд эти трамплины никак не учитываются. Считать что-либо из ПЗУ обычным способом возможности нет, поэтому данные грузятся выполняя команду ld через "трамплин". Т.е. в ПЗУ блок данных содержит этакие "дырки". Не думаю, что команды vCPU выполняются прямо из ПЗУ. Собственно, вот тут видно:

Code: Select all

              a54e 0090  ld   $90         ;0ff2 BRA
              a54f 00a0  ld   $a0
              a550 0000  ld   $00         ;End of Apps/Racer/Racer_v2.gcl, size 1868
                                          ;+-----------------------------------+
                                          ;| Apps/Mandelbrot/Mandelbrot_v1.gcl |
                                          ;+-----------------------------------+
Mandelbrot:   a551 0002  ld   $02         ;| RAM segment address (high byte first)
              a552 0000  ld   $00         ;|
              a553 00ef  ld   $ef         ;| Length (1..256)
              a554 00cd  ld   $cd         ;0200 DEF
              a555 00e8  ld   $e8
              a556 0075  ld   $75         ;0202 PUSH
              a557 0059  ld   $59         ;0203 LDI

[b2m]

Ассемблер для vCPU всё же есть: vasm.py, два года назад, когда я скачивал репозиторий его не было.

Программа на vasm

Code: Select all

# Please build this from the Makefile
from vasm import *

p=0x30                          # User variables start from $30 in zero page

ORG(0x200)                      # User programs can start from $200
-               LDWI(0x800)     # Top left pixel
-               STW(p)          # Pointer variable p
L('Loop');      POKE(p)         # Update pixel
-               ADDI(1)         # Increment vAC
-               BRA('Loop')     # Loop forever

END(0x200)                      # Execution start address

[Lavr]

Ассемблер для vCPU всё же есть: vasm.py, два года назад, когда я скачивал репозиторий его не было.

Репозиторий я тоже скачал 28 июля 2020 г., сам еще толком не разбирался, что там, но пишут, что:

...существует единый компилятор для нативного асма, vCpu и Gcl в одном флаконе — он там же в исходниках лежит.

С таким "винигретом" ковыряться было неохота, и я решил поискать отдельный компилятор ассемблера.
Gigatron всё же довольно популярным оказался: его и на ПЛИС уже повторили, и софт народ пытается
писать - может кто и слепил уже отдельный удобный компилятор ассемблера...

[b2m]

Если почитать документ по языку GCL, то становится понятно, что этот язык и ассемблер vCPU - это практически одно и то-же, просто разные варианты синтаксиса.

[Lavr]

Нет желания ковыряться в их хитровыдуманных языках GCL и виртуальном ассемблер vCPU...

Есть такая мысль, что Gigatron в принципе нетрудно повторить в Proteus, и на родном ассемблере
он, по идее, должен довольно шустро шевелиться даже в виде модели...

Непонятным для такого проекта представляется устройство ввода: в оригинале - это либо "джойстик"
от "Денди", либо PS/2 клавиатура через адаптер на ATTiny...

[b2m]

Gigatron в принципе нетрудно повторить в Proteus, и на родном ассемблере
он, по идее, должен довольно шустро шевелиться даже в виде модели

Ну, светодиодами поморгать ты "на родном ассемблере" в Proteus-е сможешь, а вот формировать видео-сигнал и паралельно делать что-либо полезное у тебя вряд-ли получится.

[Lavr]

...светодиодами поморгать ты "на родном ассемблере" в Proteus-е сможешь, а вот формировать видео-сигнал и паралельно делать что-либо полезное у тебя вряд-ли получится.

Это просто будет очень медленно, но непреодолимых препятствий этому нет, и на хорошем современном
компьютере шевелиться всё будет.
Библиотека dll с исходным кодом для цветного дисплея у нас в Proteus-е давно есть - это не проблема.

ixesNBG.png

Большая, но тоже принципиально преодолимая проблема - это как раз устройство ввода.

Клавиатуру или "джойстик" придётся "нарисовать" заново, как я делал в проекте EDUC-8 Microcomputer.
Просто это выполнимая, но объёмная и совершенно неинтересная работа...

[Lavr]

Дешифрация кода команды сделана, действительно, по образу 6502 ...

По образу-то, действительно по образу, вот только коды, к сожалению, не совпадают даже частично...

6502refcard_.gif

refcard.gif

Была у меня слабенькая надежда на хотя бы частичное их совпадение...

Ассемблерные коды Gigatron взяты отсюда: Programming the Gigatron

 Ассемблерные коды Gigatron

Code: Select all

inst    #  pseudo-C                      mnemonic
-------------------------------------------------------------
02    586: /*nop*/                       //   nop

00  54305: A = oper                      //   ld   $00
01    505: A = RAM[oper]                 //   ld   [$00]
03      1: A = IN                        //   ld   in
05     26: A = RAM[X]                    //   ld   [x]
09      2: A = RAM[(Y<<8)|oper]          //   ld   [y,$00]
0d     32: A = RAM[(Y<<8)|X]             //   ld   [y,x]
10      1: X = oper                      //   ld   $00,x
11     27: X = RAM[oper]                 //   ld   [$00],x
12     11: X = A                         //   ld   ac,x
14    326: Y = oper                      //   ld   $00,y
15     19: Y = RAM[oper]                 //   ld   [$00],y
16      2: Y = A                         //   ld   ac,y
18     14: OUT = oper                    //   ld   $00,out
19      6: OUT = RAM[oper]               //   ld   [$00],out

20     33: A &= oper                     //   anda $00
21      8: A &= RAM[oper]                //   anda [$00]
25      2: A &= RAM[X]                   //   anda [x]
29      2: A &= RAM[(Y<<8)|oper]         //   anda [y,$00]
30      9: X = A & oper                  //   anda $00,x

40     14: A |= oper                     //   ora  $00
41     17: A |= RAM[oper]                //   ora  [$00]
45      3: A |= RAM[X]                   //   ora  [x]
50      6: X = A | oper                  //   ora  $00,x
5d      3: OUT = A | RAM[(Y<<8)|X++]     //   ora  [y,x++],out

60     16: A ^= oper                     //   xora $bf
61     11: A ^= RAM[oper]                //   xora [$00]
69      5: A ^= RAM[(Y<<8)|oper]         //   xora [y,$00]

80    402: A += oper                     //   adda $00
81     28: A += RAM[oper]                //   adda [$00]
82     36: A *= 2                        //   adda ac
85      2: A += RAM[X]                   //   adda [x]
89      6: A += RAM[(Y<<8)|oper]         //   adda [y,$00]
8d      4: A += RAM[(Y<<8)|X]            //   adda [y,x]
90     11: X = A + oper                  //   adda $00,x
91      1: X = A + RAM[oper]             //   adda [$00],x
92      2: X = 2*A                       //   adda ac,x
95      1: Y = A + RAM[oper]             //   adda [$00],y

a0     28: A -= oper                     //   suba $00
a1      3: A -= RAM[oper]                //   suba [$00]
a5      5: A -= RAM[X]                   //   suba [x]
b0      3: X = A - oper                  //   suba $00,x

c0      4: RAM[oper] = oper              //   st   $00,[$00]
c2    662: RAM[oper] = A                 //   st   [$00]
c3      2: RAM[oper] = IN                //   st   in,[$00]
c6      8: RAM[X] = A                    //   st   [x]
ca      6: RAM[(Y<<8)|oper] = A          //   st   [y,$00]
ce      9: RAM[(Y<<8)|X] = A             //   st   [y,x]
d2      7: RAM[oper] = A; X = A          //   st   [$00],x
d6      8: RAM[oper] = A; Y = A          //   st   [$00],y
de     27: RAM[(Y<<8)|X++] = A           //   st   [y,x++]
dc     52: RAM[(Y<<8)|X++] = oper        //   st   $00,[y,x++]

e0    314: PC = (Y<<8)|oper              //   jmp  y,$00
e1      2: PC = (Y<<8)|RAM[oper]         //   jmp  y,[$00]
e2     13: PC = (Y<<8)|A                 //   jmp  y,ac

e4      3: if (A > 0) PC = hi(PC)|oper   //   bgt  $00
e8     14: if (A < 0) PC = hi(PC)|oper   //   blt  $00
ec     30: if (A != 0) PC = hi(PC)|oper  //   bne  $00
f0     10: if (A == 0) PC = hi(PC)|oper  //   beq  $00
f4      5: if (A >= 0) PC = hi(PC)|oper  //   bge  $00
f8      2: if (A <= 0) PC = hi(PC)|oper  //   ble  $00
fc    497: PC = hi(PC)|oper              //   bra  $00
fd      2: PC = hi(PC)|RAM[oper]         //   bra  [$00]
fe    612: PC = hi(PC)|A                 //   bra  ac

[Lavr]

Пишут Марсель умер: https://forum.gigatron.io/viewtopic.php?f=5&t=235

Да, я тоже по случаю прочитал вот тут: In Memoriam - Marcel van Kervinck что-то типа эпитафии...

[Lavr]

Есть такая мысль, что Gigatron в принципе нетрудно повторить в Proteus, и на родном ассемблере
он, по идее, должен довольно шустро шевелиться даже в виде модели...

Есть вот какое предположение на этот повод:

1. В оригинале Gigatron работает с "джойстиком" от "Денди", следовательно, на родном ассемблере
он должен быть способен поддерживать и родную клавиатуру от "Денди", которая работает через
порт "джойстика":




Такую клавиатуру смоделировать в Proteus и просто, и даже интересно!

2. Конечно, это круто, что Gigatron работает на VGA-монитор без лишнего железа!
Но это и съедает его довольно неслабую тактовую частоту в 6.25 МГц...
А вот если исключить эту опцию, в которой и прелести-то особой нет: всего-то 160х120 точек,
и подключить на этот порт обычный LCD дисплейчик с интерфейсом SPI, то процессор станет свободен
от необходимости постоянного видеовывода, и его мощности можно обратить на полезную программу.



LCD дисплейчик не обязательно брать от NOKIA 3310, сейчас выбор дисплейчиков побогаче!

С этими двумя решениями Gigatron и под Proteus должен приемлемо шевелиться...

Только вот с софтом у Gigatron-а всё довольно запутанно...

[b2m]

Конечно, это круто, что Gigatron работает на VGA-монитор без лишнего железа!
Но это и съедает его довольно неслабую тактовую частоту в 6.25 МГц...

Да, если процессору vCPU остаются такты только во время обратного хода луча по вертикали, то он получит не больше 9% времени. (из 525 остаются только 45 и то не полность). Но!

Размер точки Gigatron-а 4х4 пикселя, то есть он повторяет каждую сканлинию 4 раза. И есть режимы, когда некоторые сканлинии остаются чёрными (в первой версии только одна из 4-х, в последних до трёх из 4-х). То есть даже если имеем только одну чёрную, то будет (45+120)/525 уже почти 30%, а с тремя будет уже около 77%. Правда в таком режиме картинка уже выглядит коряво.

Режим переключается кнопкой на джойстике в любой момент.

[Shaos]

так как там видео генерируется программно, то надо полагать весь существующий софт ожидает телевизора...

[b2m]

Почему телевизора? Там же написано, VGA 640x480 59.94Hz

[Shaos]

Почему телевизора? Там же написано, VGA 640x480 59.94Hz

Ну в штатах почти все телеки умеют VGA 59.94Hz