The Cody Computer is an 8-bit retrocomputing project built around the Propeller 1 and the 65C02. In many respects it can be viewed as part of the same lineage as the Prop-6502 and Propeddle, but with different tradeoffs resulting from different end goals; the key similarities involve the use of the Propeller to replace most (but not all) other logic, and of course the data/address bus multiplexing used in those designs to keep pin counts manageable. Rather than emulate an existing system, the primary goal of the Cody Computer is to be a modern take on a late 1970s or early 1980s home computer, one that could be built relatively cheaply by an intermediate-experienced "maker" as an educational project.
I'm hoping to have the system finally finished by the end of the year, at which point I plan to upload all design files, including KiCad schematics and PCBs, STL files, and assembly sources for the Cody Basic interpreter. What I'd really like to do is write a cartoony little book (featuring a cartoony little Pomeranian named Cody) that walks you through the theory of operation and the build of the system, similar to introductory computer books of the 1980s, but we'll see how far things get.
The computer's named after my Pomeranian, Cody, who was actually very instrumental in the entire process of getting this off the ground at all. I used to talk about getting a Commodore PET to hack on and my wife pointed out that I already had a "Commodore pet" (Cody) who seemed to share an interest in many of the same hobbies, I started wondering how truly difficult it would be to build a simplified 8-bit along the lines of something like a "Commodore 64 Junior" for lack of a better term. Basically, I experimented with several different approaches and the ones that Cody seemed to get the most excited about is what I went with. Regrettably, he succumbed to veterinary treatment in June of 2020, living to see the final build get to the "TV Typewriter" stage of development but not much beyond.
The long-term goal is to have a finished machine completely capable of being constructed at home using through-hole components on PCBs, with the surrounding enclosure, case, and even the keyboard being produced on a home-quality 3D printer. As I haven't finalized the design for the main PCB, there's no enclosure, but the keyboard's successfully been constructed using PCB-mount Cherry keyswitches on a nonstandard spacing, along with 3D printed plates and keycaps.
The hardware consists of a 65C02 clocked at 1 MHz by the Propeller, a '541 buffer for arbitrating the lower byte of the address bus, a 128Kx8 SRAM (less than half of which is used) a 65C22 for I/O operations, a 4051 used as a keyboard row decoder (joystick inputs are mapped as "rows"), and a '138 used as a decoder for SPI chip selects.
In terms of operation, the Propeller acts much like the TED of the Commodore Plus/4 series, encapsulating video and audio along with a variety of additional logic all into one device. One core has a tightly-written main loop that handles bus accesses from the 65C02 (also ensuring based on cycle-counting that hub accesses will always be aligned so that a 1 MHz system clock is always achievable). Other cores are responsible for video and audio generation. This functionality is all exposed to the 65C02 by mapping 16 kilobytes of hub memory into the top 16K of the 65C02's address space (which means that the Propeller's internal memory also acts as the computer's ROM, video buffer, and "registers" for video and audio).
For software I've implemented Cody Basic, which can be considered a tokenized dialect of 1970s Tiny Basic with additional extensions. It also supports byte and word arrays, strings, DATA statements, and so on, but DEC or Microsoft BASIC it is not; most all of that works by treating variables as holding pointers, similar to how some Tiny Basic dialects implemented similar features in a C-like or BCPL-like fashion. The kernel and the BASIC interpreter clock in at around 6 kilobytes, which isn't bad for what it does, but I do suspect a more proficient 65C02 assembly programmer could have optimized it better. Much of the interpreter relies on a minimal "kernel" layer for basic operations, but the line between the kernel and the BASIC is not particularly enforced.
Storage is provided via cartridges; each contains a typical SPI EEPROM or FeRAM (the only restriction being that they have to be 3.3 volts and support the same basic read/write operations built into the kernel). There's no filesystem as despite the modern-day technology used, the inspiration was more from the era of tape storage (or at best the stringy floppy); where back in the day you'd record the values on a tape counter, here you just specify the starting page in the EEPROM, and kernel code and Basic commands take care of the rest; a virtual "head" is positioned using a SEEK command, LOAD and SAVE commands save starting at the current location, and the HEAD command tells you the current page and device.
(No, it currently doesn't have a game called Poms Ahoy; it's a reference to a Ducks Ahoy game cartridge that I had as a toddler.)
I also have a bit more detailed information posted in the Cody Computer topic on the 6502.org hardware forums, but I'm happy to post some additional information here as well if there's interest. I know that the Propeller community and forums were an incredibly useful resource when working on this. The only reason that I never really had to ask questions was that so many people here and there had answered them all in advance; the existing examples and tutorials were sufficient that someone could figure out the rest on their own. Hopefully this can serve as a bit of inspiration as well, and in the end, perhaps be another resource out there along with all the others.