===================
== frombelow.net ==
===================

Eris 2010. Led Pillar. Blinkenstrip.

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

Here is a little video.

Hardware

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.

Software

Directory 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.


User Manual

So you are one of the lucky few who got a pre-assembled Eris 2010 computer including an SD card with some software!

Getting started

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.

Linux

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 by

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 /dev/ttyUSB1, /dev/ttyUSB2, …

Windows

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).

Running programs

You should now see a choice of programs. Typing a number starts the corresponding program. The three most interesting programs are:

Tic-Tac-Toe

This should be self explanatory.

Microchess

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.

Tiny BASIC

All input must be in caps!

Tiny BASIC is third party software.


Developer Documentation

Repository Directory Structure

  • case/ - Minimal case consisting of top and bottom plates for laser cutting.
  • contrib/ - Third party software. See contrib/README.md for 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.md for a description.
  • sw/ - “Userland” software to be loaded into RAM by a suitable ROM. See sw/README.md for a description.

Main Components

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.

Memory Map

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 io_select4 is high. See hw/bus_logic/BUS_LOGIC.PLD for details.

Reset logic

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 upload. 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.

Booting

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 sw/load_from_card/load_from_card.asm, the 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.

Interfaces

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.

Interrupts

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.

Toolchain

Hardware

You can find all files related to the hardware design in hw/pcb/eris2010. The design uses some additional library symbols. These 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.

Software

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.

Standard Library

A standard library is part of the boot ROM located at roms/os/. In 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 roms/os/os.asm for documentation and 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.

  • LFSR

A 16 bit LFSR with maximum period length is provided as PRNG.

  • SPI

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 lda_LOCAL \<number\>, 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/stack_test/stack_test.bin and sw/load_from_card/load_from_card.asm for examples.

Tools

kfs.py

Program for formatting, listing, and writing SD card in a format readable by Eris 2010.

boot.py

Script to upload programs via serial line.

reset.py

Triggers a reset by toggling DTR.

Case

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 case/

Bugs

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). :-)

Changelog

  • v1.0
    First public version.

The software in directory contrib/ comes from third parties. Check the subdirectories of contrib/ for author, copyright, and licensing information.

Everything else:

Copyright © 2021 Gerd Beuster gerd@frombelow.net

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/.