EEVblog Electronics Community Forum
EEVblog => EEVblog Specific => Topic started by: EEVblog on May 03, 2018, 12:03:03 am
-
Review of the Gigatron.io TTL 8 bit RISC computer kit.
http://www.gigatron.io (http://www.gigatron.io)
https://www.youtube.com/watch?v=6vbI-r5aXJI (https://www.youtube.com/watch?v=6vbI-r5aXJI)
-
Nice. Would be interesting to implement a CLANG backend for the RISC architecture (or GCC, but this is more complicated, even just compiling GCC is complicated), so that you can just compile C programs for it.
-
Too bad they didn't make this like a 8051 core or some other similarly old design, making it possible to use some c compiler or some assembler.
-
It is not too difficult for CLANG with LLVM:
https://llvm.org/docs/WritingAnLLVMBackend.html
At least much easier than writing a GCC backend.
-
Surely there must be more ROMs out there somewhere.
-
Is there a link where I can download the schematic?
-
Lots of stuff is scattered around on the web at different places.
Some of the schematics are in the Hackaday logs.
Not everything is online yet, but we will catch up somewhere in this month, then it will be full open source.
We're doing a new spinout of the boards with some minor things improved (nothing in the logic).
Those will be the ones that get published on the site when done.
-
When we started this, the objective was always
1. minimum number of chips, and
2. absolutely no complex chips.
Personally I consider the shift register that is in there a violation of this objective already :-)
That certainly ruled out adopting an existing ISA.
Incidentally, that self-imposed constraint is also why we didn't figure out how to do a direct keyboard hookup yet. But there are some ideas brewing in that department... For the kit version, minimalism is key.
-
I don't think one should view this as a computer kit, but more as a CPU or computer you can poke and prod around in while it's ticking away. It'd be especially awesome if it were possible to somewhat conveniently work with the instruction set, as the very concise set should simplify things for an accessible introduction.
-
cool computer kit, good design but software development tools maybe needed for us hobbyist's
that are not hard core into assembler. but a challenge is a good thing.
color images, yes instruction manual is the most important part of any build it yourself computer kit
just a suggestion little off-topic, I would like to see two new versions of the classic commodore 64.
I do know about the THEC64 MINI. a tiny 50% scale replica of this much loved machine
https://thec64.com/ (https://thec64.com/) is ok however better Idea is to have
a full size classic commodore 64 would be the ultimate build it yourself computer kit
also another Idea is for a better C64 mini would be a portable self-contained pre assembled C64 handheld game console
built-in screen , Joystick = joypad including on screen keyboard.
as will as USB ports for full size keyboard. that runs classic C64 games.
the idea here is a handheld C64 type console that will plug in to your HDMI TV and plug in a USB full size keyboard when at home.
like the nintendo switch does.
as modern-day software development on the C64 never really stopped.
Im a gamer ;D
-
cool computer kit, good design but software development tools maybe needed for us hobbyist's
that are not hard core into assembler. but a challenge is a good thing.
color images, yes instruction manual is the most important part of any build it yourself computer kit
The assembly language is quite limited, too. Only 8 instructions.
(what do you want with just a handful of TTL chips?)
just a suggestion little off-topic, I would like to see two new versions of the classic commodore 64.
I do know about the THEC64 MINI. a tiny 50% scale replica of this much loved machine
https://thec64.com/ (https://thec64.com/) is ok however better Idea is to have
a full size classic commodore 64 would be the ultimate build it yourself computer kit
also another Idea is for a better C64 mini would be a portable self-contained pre assembled C64 handheld game console
built-in screen , Joystick = joypad including on screen keyboard.
as will as USB ports for full size keyboard. that runs classic C64 games.
the idea here is a handheld C64 type console that will plug in to your HDMI TV and plug in a USB full size keyboard when at home.
like the nintendo switch does.
as modern-day software development on the C64 never really stopped.
Im a gamer ;D
Easily done with a Raspberry Pi. There's Pi emulators for just about any old machine you can imagine.
https://hothardware.com/reviews/commodore-64-emulator-with-raspberry-pi-diy
-
I'm most impressed that they got 64 colours out of it. Even the C64 only had 16 which was impressive back in the 80s.
-
It is using 2 bits for each color (RGB), so 2^6 is 64. Is generating VGA RGB less demanding than NTSC/PAL color video signal?
-
Would be nice if someone can make an implementation on FPGA for those who want to play with it but don't want something that's more expensive than a beginner FPGA board and far less useful.
Incidentally, that self-imposed constraint is also why we didn't figure out how to do a direct keyboard hookup yet.
But there are some ideas brewing in that department...
A few D latches and a bit of software are all you need to scan a keyboard matrix.
-
Would be nice if someone can make an implementation on FPGA for those who want to play with it but don't want something that's more expensive than a beginner FPGA board and far less useful.
Well once a schematic is released I'll look into that. Shouldn't be very difficult.
-
Would be best to add a keyboard without increasing the IC count.
-
Can it execute code from the RAM chip or is it limited to running interpreters?
(I mean without changing the ROM every time you want to load a program)
It look s to me like it can only run code from the ROM.
-
The 8-bit native code runs from the EPROM. So that needs a programmer and an UV eraser to update. I got mine from Aliexpress, they aren't expensive. In reality, at that level you do your programming in an emulator until you think it is right, and then burn it into the EPROM. There are several emulators around already.
That is very limiting of course, especially if you want to mix application code with keeping the hardware signals active. It means that you have to cycle count everything you do. That gets annoying real quick.
So there is also a virtualised CPU in there (vCPU), implemented in 8-bits code, that takes its instructions from RAM. It runs whenever the video/audio/IO loop has nothing to do. For convenience it implements 16-bit operations. It also takes care of counting cycles: it knows at what point to give control back to the video/audio/IO loop.
My applications are written for this vCPU. Also the ones that are in the menu: they literally first get loaded from ROM to RAM prior to execution. (Having said that: Racer uses two snippets of code that are written in the 8-bit machine language for speed.) Even the menu itself is vCPU code. And most of the reset sequence as well.
Now this interpreter opens the door for hacking without changing the ROM. The Loader is the escape hatch: it listens on the control port and allows an external device to push data into RAM and execute it.
I'm now using an Arduino as such a device because they are flexible and cheap.
Using this route you can push precompiled programs into the system. And that program can in turn accept other kind of signals, such as those of a keyboard. I have just agreed with the emulator guys on a standard file format for such object files. But you can also imagine that you hookup a keyboard to the Arduino. (That is my hope for this weekend in fact).
These are things under active development. Every week it gets a bit easier. Every week documentation gets a bit clearer. The hardware is there. ROM v1 demonstrates pretty well the capabilities. Now it is time to expand on the eco system.
What you can also do is this: develop a program as a vCPU object file. And then burn that in an EPROM, replacing one of the built-in applications (for example, replacing Menu.gcl). Then your code will always start after boot, without ever having to go down to the 8-bit level.
Another approach is simply to ignore video. One guy I know is planning to hookup an LED display, make a compiler that generates 8-bit object code, and ignore VGA/sound generation altogether.
In the blog section I show what we can do now: https://gigatron.io/?p=937
-
If you can find an appropriately sized EEPROM that will greatly speed up the time it takes to change programs and eliminate the need for a UV eraser. There is some charm to the old UV EPROMs though.
-
Oh sure. I don't know if a pin compatible EEPROM exists (please tell me!), but you can always make an adaptor board. Someone mentioned planning to plug in a ROM simulator. This board is open for hacking, and people are already doing crazy stuff with it: replacing chips with their own, linking into the circuit, changing the control unit wiring, writing compilers, assemblers, operating systems, emulators, cutting out all caps to see if it breaks... It is a nice little chaos of activity.
-
Excellent project you have created! A fine example what you can do with handful of simple chips. Also a great educational tool for learning basics of a microcontroller architecture.
If one wants to be able to perform on-the-fly firmware updates, a simple old school trick is to build a RAM-based EPROM emulator and use Arduino as a program loader accepting firmware in Intel HEX format or something like that over a USB interface.
-
or it could be designed with a write patch from data ram to code rom. It only uses 32KB ram anyway, other 32KB could be mapped to two 16KB ram
chips squeezed over code rom. Maybe this could be even implemented in an adapter board plugged in rom/ram sockets.
-
http://forum.6502.org/viewtopic.php?f=4&t=4627 (http://forum.6502.org/viewtopic.php?f=4&t=4627)
Fun topic! My version of TTL CPU.
-
It would be cool! :-+
It would been very nice to have the schematic, since the code is open source. In fact, many people could use it to study how a computer works!
I remember SAP-1 that is a quite more simple than Gigatron.
Together, both projects can be very usefull to help people learn in depth how the computers works!
-
Lots of stuff is scattered around on the web at different places.
Some of the schematics are in the Hackaday logs.
Not everything is online yet, but we will catch up somewhere in this month, then it will be full open source.
We're doing a new spinout of the boards with some minor things improved (nothing in the logic).
Those will be the ones that get published on the site when done.
:clap:
-
For those who were waiting, the gigatron creators made avaliable the full schematic: 8)
https://hackaday.io/project/20781/files
General project:
https://hackaday.io/project/20781-gigatron-ttl-microcomputer
Code:
https://github.com/kervinck/gigatron-rom
Gigatron Creators webstite:
https://gigatron.io/
Thank you Marcel and Walter!
-
For anyone just discovering this (I'm posting this after someone re-posted Dave's review a few places on Reddit etc today), there were some further developments:
- sadly, Marcel van Kervinck (posting as marcelk here) died in May 2020.
- they stopped selling kits in mid 2020, not long before I discovered the project during lockdown and would have bought one. Over 1000 were sold.
- in addition to the custom interpreted vCPU 16 bit instruction set they made up, and which the menu system and games were written in, a ROM was later developed that instead implemented the 6502 ISA at about 1/8th the speed of a real 6502, making the board able to run Apple I programs including WozMon.