06/23/2019 at 19:54 •
Today my Gigatron believes it's an Apple-1 instead of a TTL computer. It's running the original 6502 wozmon code with mockup terminal I/O patched to it. Of course the patching, and some relocation, make up for the system differences. With a tongue in the cheek, we can say it turns the Gigatron into an Apple-1 clone!(*)
Here we can see the "Apple-1 on TTL" running MicroChess code for the first time, with kudos to @oscarv for helping out.
(*) After all: "Apple1 = 6502 + RAM + WozMon ROM + PIA", and "PIA = DSP + KBD". There wasn't more to it and we emulate it all!
In reality, any original Apple-1 software will likely need some relocation and a tiny bit of patching for I/O. More technical details in the user forum: https://forum.gigatron.io/viewtopic.php?p=774#p774
06/13/2019 at 00:15 •
The computer without microprocessor is becoming dual core.
Today it ran its first 6502 program.
All of the 6502 addressing modes are implemented, and a fair amount of instructions as well. The v6502 interpreter runs in place of the standard 16-bits application vCPU. Switching between the two virtual processors vCPU and v6502 is a matter of modifying a zero page variable. The video driver dispatches at the next available scan line, so very lightweight.
The impressive thing about the 476-byte Baum-Wozniak 6502 disassembler isn't just its size: it's that it seems to be secretly designed for 26 character wide displays. Now that's quite a foresight by these gentlemen! Here you see it running on the Gigatron, disassembling it's own code:
More details on the user forum: https://forum.gigatron.io/viewtopic.php?f=4&t=128
11/15/2018 at 11:15 •
The joy of using hypermodern multiple e-beam direct-write lithography to "advertise" TTL technology from the 1960s... This is an electron microscope image of the Gigatron startup screen. This time it isn't displayed on a VGA monitor (or on a supercon badge), but printed on a silicon test wafer as used for IC making. The image was printed using a Mapper FLX-1200 e-beam writer. For comparison, a human hair is typically 75 µm in thickness.
The Mapper principle is much like that of an ink jet printer head with hundreds of nozzles, except we're using accelerated electrons here instead of ink, and silicon wafers instead of paper (and there are no colors). The beams each have a spot size of under 30 nm and they're scanning the surface with a positioning accuracy of below 3 nm. They're all perfectly stitched together to seamlessly cover the large area needed to make complex devices. The wafer was coated with a thin layer of resist material, and everywhere a sufficient number of electrons landed, an image formed that could be developed.
This tiny area of 24 µm x 18 µm shown above was printed in just a few milliseconds by a couple of hundred parallel and independently controlled electron beams, all focussed on the wafer in a high-vacuum chamber. This image is a small part of a much larger test pattern. The resolution is in the 40-50 nm range here. The e-beam writer has tens of thousands of beams all working in parallel. The data stream to support that is about 3 Tbit/second and is generated by a large rack filled with FPGAs.
A SEM is needed to view the result because the details are too small for optical microscopes. This super fast e-beam technology is developed to make new types of security ICs possible, but it has other applications in nano-fabrication as well (one is entertaining the engineers working with it).
The image contains a schematic of the iconic 7400 quad NAND chip, introduced in the late 1960s. An actual NAND gate, or even a single transistor from the day, would be much larger than this entire image. The typical line widths in those early days of IC manufacturing were in the order 10 µm.
[Edit 2019-02-11: Unfortunately, Mapper is no more. Looking for a job now! ]
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