I am making a full sized Sol-20 reproduction, the first fully assembled microcomputer with a built-in keyboard and television output.
To make the experience fit your profile, pick a username and tell us what interests you.
I've been working on this project for a few weeks now. In that time I did a fair amount of research, but mostly I was writing a Sol-20 emulator. I thought about using Jim Battle's Solace emulator, but it is Windows based and ultimately I hope to run my Sol-20 reproduction on a Raspberry Pi 4.
Since the Sol-20 was based on the Intel 8080 microprocessor I thought that would be the logical place to start. Fortunately for me, Space Invaders and some of the other early arcade machines also used the 8080. Because there is a very active gaming community helping to preserve these retro classics, there are a number of great 8080 emulators to be found on GitHub. I ended up cloning py8080 because it's Python based and I'm more comfortable right now with Python than I am with C++.
So with a working virtual 8080 processor it was a pretty easy task to allocate some memory for it (64K because why not), load a monitor program (Solos since it was the default shipped), set the instruction pointer to the start of the program (0xC000), and run the emulator. Success! Technically I had a Sol-20 running in emulation, but it was pretty boring since I had no way to interact with it. Time to create some virtual devices.
The system memory used by the Sol-20 is as follows:
C000-C7FF - System ROM. Sol-20 "Personality Modules" like Solos are mapped here. C800-CBFF - System RAM. Reserved by the system. CC00-CFFF - Display RAM. Shared memory between the CPU and VDM-1 video circuit.
Although most systems shipped with only 8K or 16K of memory (or less) in those days, I have to wonder why they didn't map these addresses up into the F000-FFFF space to allow a contiguous 60K memory space for user programs. At any rate the important thing to note for display purposes is the CC00-CFFF shared video RAM. This 1K space was used to store 16 lines of text each of which is 64 characters long. Any text written to this memory would automatically be displayed on the screen.
Using PyGame I created my virtual screen. I could have written the characters from the shared video memory directly to the screen but the Sol-20 used a lot of unique character glyphs.
So based on the original 6574 character ROM I created a set of character tiles that I could easily "blit" to the screen. I wrote a function to iterate over the 64 x 16 array of characters in the shared video memory and write them out to the screen and added this function to the main loop of my emulator. When I did that I was rewarded with this. I know the aspect ratio is off here. I'll deal with that later.
Wow. Still super boring but I see a > prompt so progress. I realized that the display was being updated every time through the main loop so I added a check in the 8080 emulator to set a dirty flag whenever the shared video memory was written to and now only update the screen when the dirty flag is set. Good enough for now.
The 8080 can communicate with peripherals through shared memory locations like the Sol-20 display does, or through I/O ports. I/O ports are accessed via the 8080 op codes IN and OUT. There are 256 possible ports numbered 0x00-0xFF. When an IN instruction is executed the 16-bit address bus is set with the port number of the request in both the upper and lower bytes of the address, the IORQ (Input/Output Request) line is held high, and a data byte is retrieved from the 8-bit data bus. Similarly, for an OUT instruction, the 16-bit address bus is set with the response port number in both the upper and lower bytes of the address, the IORQ line is held high, and a data byte is written to the 8-bit data bus. You can think of this block of ports as a separate "memory space" for the 8080.
For the exception of the memory mapped display, all communication between the Sol-20 and peripherals is accomplished via I/O ports. I have added code that "handles" the IN and OUT op codes and emulates device interaction....Read more »
If you are interested in the details of how the Sol-20 came to be, I highly recommend you read Lee Felsenstein's own story published in ROM magazine, July 1977. Here I want to focus on the people involved all of whom are luminaries in the early personal computer era.
Lee Felsenstein was the principal designer of the Sol-20. The design was based on a Tom Swift Terminal concept he had been working on and the VDM-1 graphics card he had developed for Processor Technology. There is also some reports that Gordon French, founder of the Homebrew Computer Club, was also involved in he development. Lee would later go on to design the Osborne 1 in the early 80s.
Processor Technology Corporation was a personal computer company founded in April 1975 by Gary Ingram and Bob Marsh in Berkeley, California. Based on their relationship with the development of the VDM-1 graphics card and other projects, Bob Marsh commissioned Lee Felsenstein to design and build the Sol-20. Bob and Lee were also founding members of the Homebrew Computer Club.
The design was originally suggested by Les Solomon, the editor of Popular Electronics. Les Solomon was instrumental in getting the Altair 8800 launched with a featured article on the cover of the January 1975 issue of Popular Electronics. He asked Bob Marsh if he could design a smart terminal for use with the Altair 8800. So the Sol-20 was initially positioned as a smart terminal to satisfy Les Solomon's request, but of course was a capable stand alone computer under the covers.
One final thought. This is an excerpt from a March 31st, 2014 Engadget article:
Many readers won't be aware of the importance of the SOL-20 to Apple's legacy. According to legend (aka Walter Isaacson's book Steve Jobs) in 1976 at the first annual Personal Computer Festival, held on Labor Day weekend, Steve Jobs and Steve Wozniak arrived with the Apple I in a cigar box. While Jobs walked around the exhibition hall, he was reassured that the Apple I was better than the competition in terms of functionality.
There was just one thing nagging at him; the SOL-20. According to Isaacson, Jobs was confident that his product had the best circuitry, but the SOL-20 was better looking. It came in a beautiful metal case, with a built-in keyboard and power supply. When compared to the scrappy Apple I, the SOL-20 looked more like a professional machine.
Funny coincidence that the Apple II also looked more like a professional machine with a built-in keyboard and power supply.
Normally when I undertake a reproduction project like this, I spend a lot of time on the internet researching my intended target. Usually the information I need is scattered across many sites and is often hard to find. Not this time though.
Jim Battle has done an amazing job of gathering a huge treasure trove of Sol-20 materials into one site. A one stop shop for the would be Sol-20 replicator, or anyone with an interest in this wonderful retro computer. Not only that, Jim created a great Sol-20 emulator Solace which stands for Sol Anachronistic Computer Emulation. I especially like his virtual cassette interface.
With much attention to detail it faithfully simulates reading tapes at either 300 or 1200 bits per second and will complain if data was "saved" at 300 and you try to read it back at 1200 :-) Of course you can turn these "features" off. Very cool.
Thanks Jim for all your hard work.
When I announced my fledgling Sol-20 project a couple of days ago, the last thing that I expected was to appear in Featured Projects let alone be mentioned in a Hackaday-IO Bits email blast. There is so much work yet to do. Thanks to the editors for their confidence in my ability to deliver on my promise. As of this writing there are 30+ people following this project. To all of you thank you. I'll be posting my progress as I go. I hope you enjoy the ride.
So my plan is to make a full size case that will be as authentic looking as possible, with beautiful walnut sides for sure. I may 3D print the blue panels instead of using sheet metal so the build would be accessible to more people should they decide to make one.
For the keyboard I have been in touch with Dave from osiweb.org who has designed a complete replacement keyboard for the Sol-20 using modern Cherry key switches. From the Unified Retro Keyboard Project:
The keyboard is not a replica of the original. It doesn't use the same capacitive circuit or keys. But it does have exactly the same layout with the same functionality, including the 3 LEDs (UPPER CASE, SHIFT LOCK, LOCAL) and 3 outputs (RESET, BREAK, LOCAL). It uses cherry MX or Futaba MD-4PCs keys. Neither has quite the same feel as the capacitive keys, but the Futaba keys approach the travel of the keytronic switches, and do have a nice feel.
I'm getting the keyboard as a kit and looking forward to putting it together.
On the inside I'm going to emulate the Sol-20 hardware on a Raspberry Pi 4. To that end I have a working (very basic at this point) Python based emulator I'm going to post to GitHub shortly.
I haven't decided what to do for a monitor yet. Certainly a CRT of some sort would be ideal, but I may have to go with a LCD.
Become a member to follow this project and never miss any updates