Eris 2010 8-Bit Computer
Eris 2010 is homebrew 8-Bit computer in the style of the microcomputers of the 1970/80s. Here you find a little description of the project including some screenshots and a video, as well as the complete source code for the soft- and hardware.
- Overview ⟸ General information. Continue reading.
- User Manual ⟸ Got an Eris 2010? Get it running!
- Developer Documentation ⟸ The gory details.
- Repository (Clone) ⟸ Eris 2010 source code. It’s free!
Eris 2010 is build around the WDC 65C02 MPU. This is a slightly updated version of the legendary MOS 6502 used for example in the Commodore VIC20 and the Apple I and ][. The other main components are 32 KB (parallel) RAM and 8 KB EEPROM. While the old home computers from the 1970/80s came with a keyboard and connected to a TV or monitor, this design provides a serial communication interface. Therefore it is more similar to modern microcontrollers or very early home computers like the Altair 8800 than to later computers of the home computer era like the Commodore 64 or the Apple ][. The serial interface is provided by a 6551 ACAI. This chip has been used in computers from the era like the Commodore PET and the Commodore Plus/4 to connect a modem. In the Eris 2010, the 6551 ACAI connects to a (modern) USB2Serial adapter. This allows to use a standard laptop or desktop computer as a terminal for the 8-bit machine.
The second auxiliary chip is a 6522 VIA. Among other things, this chip provides a bunch of GPIO lines. A few of them are used to connect an SD card reader, providing a mass storage device to the Eris 2010. The remaining lines are freely programmable I/O ports. SD cards are written in a very simple, proprietary data format. When the computer is powered, the “operating system” in EEPROM presents a list of the programs on the SD card and acts as a bootloader. Alternatively, programs can be uploaded via the serial interface.
The bus is orchestrated by an ATF16V8 EEPLD. While the first chips with programmable logic were developed in the 1970/80s, most computers of the era did not use programmable logic, but discrete logic chips. Using an EEPLD allows to keep the chip count low, and I wanted to play with programmable logic a bit.
Reset logic is based on the good old 555 chip. We find similar circuits in home computers as well.
The first version of the computer was build on a breadboard. Once the breadboard design was functionally complete and stable at 4 Mhz, the design was fixed on a PCB in through-hole technology. In order to allow connection of additional peripheral devices and extensions, two interfaces were added: A user port to provide access to the free I/O ports, and an expansion port exposing the buses and other internal lines. The KiCad design files of the PCB are included in the repository.
Here is a little video of Eris 2010 in action.
sw/ contains the game of Tic-Tac-Toe (no fan of WarGames
should go without one), the famous 10 PRINT program (check out this
book on the cultural significance of
10 PRINT if you do not know it already), and some test programs. The
contrib/ directory contains additional third party software ported
to Eris 2010. Besides Wozmon, Steve Wozniak’s “operating system” for
the Apple I, this repository contains a port of Microchess, the first
commercial game for microcomputers. The contrib directory also
contains a port of Tiny BASIC, so you can even program the system in
BASIC, just like in the old days.
All components of the system (except for the third party software in contrib) are free soft- and hardware. You can find all source code in the repository linked at the top of this page.
So you are one of the lucky few who got a pre-assembled Eris 2010 computer including an SD card with some software!
Insert the SD card that comes with your Eris 2010 into the SD card reader. The standard way to communication with this 8 bit computer is via the USB2Serial adapter. For this connect your Eris 2010 via a Mini USB cable to your computer. On your desktop or laptop computer, you need a terminal program.
Run a terminal program like tio. tio should be available in the
package store of your distribution. If not try minicom or picocom. The
interface is probably available as
/dev/ttyUSB0. Connect to Eris 2010
tio -b 19200 /dev/ttyUSB0
Press a key or the reset button on Eris 2010. If this does not work,
try the command above with
When you connect Eris 2010 to your desktop or laptop computer, you first have to install the device driver for the USB2Serial connector. You can download it from the manufacturer. Now connect Eris2010 to a USB port. Next, you have install a terminal program. For Windows users, a common terminal program is PuTTY. After installation, there is a folder PuTTY in your start menu. From this folder, choose PuTTY.
When putty starts, click the radio button “Serial”. Set “Serial line” to “COM3”, and “Speed” to “19200”. Click “Open”. In the terminal windows, type any character or push the reset button on Eris 2010. You should now be connected to the computer. If this does not work, try “COM1”, “COM2”, … for “Serial Line”. Note that some programs (e.g. 10print will not work, because putty does not support Unicode).
You should now see a choice of programs. Typing a number starts the corresponding program. The three most interesting programs are:
This should be self explanatory.
Press ‘c’ to set up a new board. Enter moves by giving the field numbers followed by enter, e.g. ‘6444'. Push ‘p’ for the next move of the computer. You can switch the board with ‘e’. ‘q’ quits the game.
Microchess is third party software.
All input must be in caps!
Tiny BASIC is third party software.
Repository Directory Structure
case/- Minimal case consisting of top and bottom plates for laser cutting.
contrib/- Third party software. See
contrib/README.mdfor a description.
hw/- Hardware description (pcb not complete yet)
tools/- PC programs to upload programs and write SD card
roms/- ROM images. See
roms/README.mdfor a description.
sw/- “Userland” software to be loaded into RAM by a suitable ROM. See
sw/README.mdfor a description.
The computer is based on a 65C02 running at 4 Mhz with 32K RAM (AS6C62256-55PCN) and 8 K EEPROM (AT28C64B-15PU). A W65C51N ACAI provides a serial communication interface. A VIA 65C22 provides a GPIO interface. Four of the lines connect an SD card reader via SPI. Bus logic is provided by a ATF16V8B EEPLD. The reset logic is based on a NE555 in a monostable configuration with a little help (an inverter on the AFT16V8B).
The hardware design is rather straightforward; see
hw/pcb/eris2010/eris210.sch for schematics (this is a KiCad file). The
bus logic is documented in
hw/bus_logic/bus_logic.pld. The only tricky
part was getting RAM access synced with the CPU clock.
Lowest 32K are RAM, highest 8K are ROM. Up to 4 I/O devices (ACAI or
VIA) can be accessed at addresses below the ROM. One ACAI and one VIA
are required to operate the computer, because they provide a serial
interface (ACIA) and an interface to the SD card reader (VIA). Two
more devices can be connected via the Extension Port. The third I/O
device is active when
io_select5 is high and
io_select4 low. The
fourth I/O device is active when
io_select5 is low and
hw/bus_logic/BUS_LOGIC.PLD for details.
Resets can be triggered in two ways: A reset button is connected to an
NE555 in a monostable configuration. Alternatively, a reset can be
triggered by setting DTR of the serial interface to high. The latter
is used to automatically trigger a reset before program
tools/boot.py uses this to trigger a reset and get Eris 2010
ready for progrm upload. The disadvantage of wiring DTR to rest is
that Eris 2010 ony operates when a terminal is connected; when no
terminal is connected, it stays in reset mode. Therefore a hardware
switch allows to disconnect DTR from the reset line, allowing Eris
2010 to run even if no terminal is connected. In this configuration,
resets for program upload have to be triggered manually. See also
section Boot Sequence.
Another way to run Eris 2010 even if no terminal program is running on
your main computer is to to configure your computer’s serial interface
to keep DTR low at all times (Linux:
stty -F <serial interface> -hup).
Note that the reset line of the 65C02 is active on low. We use the AFT16V8B - which mainly provides the bus logic - as an inverter.
The “standard” ROM is
roms/os/os.bin. This ROM includes the standard
library (for serial communication, accessing SD card, RNG, …). It
provides three methods to load a program:
- Via serial line
After a reset, the ROM listens for a serial data transmission at 19200 BPS 8N1. If byte $ff is sent, the download sequence is initated. The next byte is the number of half-blocks of 256 bit to be loaded. (Block size is 512 bit, because this is the block size of SD cards.) The number of half-blocks is followed by the data. Data is stored at $0200. Once the upload is completed. The upload program returns a two-byte checksum. The first byte is the sum of all bytes transmitted mod 256. The second byte is the xor of all bytes transmitted. The upload program than starts executing the loaded program at $0200.
On the PC, use
tools/boot.py for upload.
- From SD Card
The boot ROM includes
program to load programs from SD card. This program is executed when
no program is transmitted via serial line.
SD cards can store up to 10 programs. The filesystem format is as follows:
Block $00000000 is loaded on initialization. The first two byte shoulds be $E215. This indicates the file sytem type. The third byte should be $00. This is the version of the file system. The fourth byte is the number of the program to start automatically, or $ff. In case of $ff, a menu of the programs on the card is presented for the user to choose.
The storage space for the first program starts at $00000001. The storage space for the second program starts at $00010001, for the third program at $00020001, … Thus, each program has a total of $ffff blocks of 512 bytes each available. The first block of each program is the program header. It contains the number of blocks to be loaded, and the app name, a null-terminated string. The actual program code starts with the next block. The program is loaded to address $0200 and executed.
On the PC, use
tools/kfs.py to write the SD card.
Two interface modules are part of the computer system: A serial interface connected to a USB2Serial adapter provides character I/O and program upload facilities. An SD card reader provides access to SD cards with a rudimentary file system. The default operating system allows to read and execute programs stored on an SD card.
In addition, a user port on the PCB provides access to all GPIO lines not occupied by the SD card communication interface, and an expansion port provides access to the buses and other internal lines. The expansion port carries two select lines for additional peripheral devices. See section Memory Map above.
The I/O interfaces are wired to IRQ. NMI can be triggered by pushing a physical button. While user programs can write their own ISRs for IRQs, the standard ROM fixes NMI servicing to an ISR that dumps the RAM.
You can find
all files related to the hardware design in
design uses some additional library
additional symbols are copyright (c) 2018, Nicholas Parks Young and
licensed under the GNU LGPL v2.1. The hardware schematics and PCB
layout were designed in KiCad. FreeRouting (part of LayoutEditor) has
been used for routing.
An ATF16V8B-15PU EEPLD is used for the bus logic. It is programmed in GALasm.
Both the EEPROM and the EEPLD can be burned with minipro.
All software for Eris 2010 has been assembled with 64tass. The Makefiles generate binary code both for Eris 2010 and Symon. Symon, a 6502 emulator written in Java, has been used for debugging.
A standard library is part of the boot ROM located at
order to use it, import
roms/os/os.inc into your program.
The standard library includes a data stack with subroutines and macros
for local variables and parameter passing. See
sw/stack_test/stack_test.asm for examples.
The following functionality is provided:
- Serial communication interface
All serial communication is conducted at 19200BPS with 8N1. Various input and output functions are provided, including a function that initializes the RNG (see LFSR) by counting ticks when waiting for user input.
- ANSI Terminal
On top of the serial communication interface, the core ANSI escape sequences are supported.
A 16 bit LFSR with maximum period length is provided as PRNG.
SPI messages can be send via the VIA.
- SD Card
SD cards can accessed in SPI mode. All addresses are 32 bit, referring to 512 bit blocks on the card. Note that this implementation does not work with all cards. See section bugs below.
- Data Stack
A data stack in software for local variables and parameter passing. In
difference to most stacks, the stack grows from bottom to top. The
recommended memory layout is program code, followed by heap (if
applicable), followed by stack. You have to manually create and delete
stack frames with calls to create_stack_frame and delete_stack_frame.
Pull and push operations do not push actual data on the stack, but
just move the stack pointer. Local variables on the stack are
represented by integers and accessed by
sta_LOCAL \<number\>, and similar macros. Parameters passed by
sta_PARAM \<number\> can be accessed by the callee by
lda_LOCAL \<number\>. Macro
CALL may be used to call a subroutine with
parameters. Refer to
sw/load_from_card/load_from_card.asm for examples.
Program for formatting, listing, and writing SD card in a format readable by Eris 2010.
Script to upload programs via serial line.
Triggers a reset by toggling DTR.
The main purpose of the case is to expose the main board. :-)
Therefore it just consists of a top and bottom acrylic plates,
seperated by spacer bolts. Laser cutter cutout files are located in directory
The communication protocol for SD cards is rather complex. The implementation for Eris 2010 worked with 4 out of 5 cards tested. If it does not work with your card, try a different card (or fix the protocol implementation). :-)
First public version.
Copyright and License
The software in directory contrib/ comes from third parties. Check the subdirectories of contrib/ for author, copyright, and licensing information.
Copyright © 2021 Gerd Beuster email@example.com
This project is free soft- and hardware: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This project is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this project. If not, see http://www.gnu.org/licenses/.