10/30/2018 at 17:21 •
The 8-Bit Guy just published his review of Pluggy McPlugface, Tiny BASIC v2 and the new games in ROM v3. And oh... we'll show it at the Superconference this weekend!
For those interested, I brought a very limited number of kits to Pasadena. They can go for a nice discount because I don't want to bring them back home.
Update: The conference badge was screaming for this hack:
The emulation is slow as molasses, running at 3 frames per second, instead of 60 frames. Contrary to my expectation, the slowdown doesn't come from the LCD update. Instead it's all due to the cycle-exact simulation which is based on the gtemu.c reference.
Hex file and modified sources attached to the project. Game controller button [A] is mapped to the DEL button. The BKSP button takes over the role of [Select] for switching between video/speed modes. You don't see the different scan line effects, because the LCD always only displays the first out of every 4 VGA scan lines (even in "full mode", aka "mode 0"), with the odd LCD lines always black. The applications still run faster depending on the mode. Continuous presses don't work, you have to simulate them by repeating. I managed to play Racer that way. Typing in Tiny BASIC v2 goes remarkably well.
Credits must go to @shaos, @jaromir and @rogerrandom for helping me plow through all the PIC stuff, as I never worked with any of that before.
09/16/2018 at 18:27 •
Today, a circle closed at the Centre for Computing History in Cambridge, UK.
How? Well, one week before this project started here on Hackaday, I was at the Computer History Museum in Mountain View, US, and jokingly posted the following remark on Facebook:
That's an original Apple-1. The Apple-1 next to the Gigatron is a beautifully done replica. It's fully functional, complete with cassette interface. The PCB is drawn in the same way and the chips even have 1970s date codes on them. It's on display in an operational state. I could play around and type commands in the original Woz Mon to verify that the Gigatron version works the same.
Many thanks to David Williams for the great opportunity!
08/12/2018 at 16:27 •
One of my side projects is to convert a board to original TTL series where possible, or at least to 74LS series with the oldest chips I can find. The breadboard prototype was fully 74LS, the kit edition is 74HCT.
At a local electronics shop I recently found quite a few ICs that were manufactured more than 43 years ago, in 1975. These are "new old stock": never used before and the pins still unbent. Some are indeed original TTL series as existed in the 1960s, not 74LS (Low-power Shottky) as introduced in 1971. They're plug-in compatible with the Gigatron design and the system works fine at full speed:
Although it is cool, it also gets hot! Original TTL consumes an order of magnitude more power. Due to this so far I only "upgraded" to original TTL the upper half the logic unit, the X register, the memory address unit and the program counter. Those 14 chips, together with a few 74LS replacements as well, already increase the current to 740 mA, or about a ten-fold from the kit version. Above that the multi-fuse and MCP start to do their thing. Remember that USB safety is the reason the kit comes with much more power-efficient 74HCT components in the first place.
The nice thing about the 7400-series is that improved series remained compatible in pin layout and voltage levels.
- 1966: introduction of the original 7400 series
- 1971: introduction of 74LS series
- 1983: introduction of 74HC(T) series
I have them all on a board now. The difference in generations is clearly visible. The old TTLs get up to 60 degree Celsius. The blue square isn't a cool oasis in the middle of a hot desert. It is a reflection on the gold plated ceramic lid of a vintage SRAM.
07/24/2018 at 20:33 •
I almost forgot about the project's original objective that I had in mind when it started one and a half year ago: to build a circuit from TTL components that can play Tic-Tac-Toe on an LED matrix. So lets correct that: today, with minor adjustments, Tom Pittman's Tic-Tac-Toe from 1977 is running on the Gigatron :-) Source code in GitHub.
Ok, the planned LED matrix has morphed into a video screen along the way. That's just feature creep.
07/16/2018 at 08:17 •
We've recently celebrated a dream milestone: there are now more Gigatrons out there than Apple-1's ever produced!
06/22/2018 at 15:38 •
06/12/2018 at 20:05 •
I've ported the Apple-1 built-in monitor program: WozMon.gcl
The original is 254 bytes, my version is $254 bytes . About half of that is for terminal output (character printing). The Apple-1 had dedicated hardware for that... With this, all original Apple-1 firmware has been ported to the Gigatron :-)
Now you can inspect memory locations, write to them and execute code.
Tutorials for the original WozMon, such as this nice one, are applicable as I tried to deviate as little as possible from the original: the differences are essentially cosmetic or slightly improved usability. The Gigatron-specific differences are:
- Welcome message is "*** WozMon" instead of error prompt ('\')
- Can use lowercase as well as uppercase for hex letters
- Delete shows effect on screen, no need for '_' (RUBOUT)
- Always print address at start of line in block examine mode
- Input buffer has the same size as screen width
- Executed code can go back to monitor with RET instruction ($ff)
- Faster screen update, and cursor symbol instead of '@'
- A bit more careful with empty lines
06/07/2018 at 21:59 •
There are several methods brewing for hooking up a keyboard. The one most in line with the system is WattSekunde's four chip design for a matrix keyboard interface. But such keyboards might be hard to find, while PS/2 keyboards are still easy to get. But their protocol is convoluted and it is unclear how to handle that with a few simple logic chips. So... we cheat!
PS/2 is simply too modern, and we need a time machine to translate its fast and complex signals to the simple signals that the Gigatron will understand. The ATtiny85 will be our Babel fish.
To get some idea: the ATtiny85 must be configured to run at 8 MHz to do its magic. 1 MHz won't be good enough to catch and transfer simple key strokes. Here is the system in action:
05/26/2018 at 15:53 •
Proud to present at the Belgrade conference today. I uploaded my slides here.
05/10/2018 at 14:32 •
Using an Arduino Uno to handle the PS/2 protocol. Computer is still running stock ROM v1. The Arduino is abusing the Loader application to inject a Terminal application. To reduce cable clutter, the computer is now also supplying power to both peripherals.