

Arduino eeprom programmer
Schematics & code for my 74LS-based 8-bit MK1 CPU
- Size
- 68.7 × 53.5 mm
- Copper layers
- 2
- Thickness
- 1.6 mm
- Parts
- 9
- Nets
- 33
- Pads
- 104
- Tracks, vias
- 317, 4
- Pours
- 3
- Routed
- Yes
- KiCad
- KiCad 5 (file 20171130)
- Created
- 1 Mar 2020
- Updated
- 12 Dec 2022
Overview
Arduino eeprom programmer is an open-source printed circuit board by vascofazza, from the vascofazza/8bit-cpu repository on GitHub, published under the MIT licence. It is a 2-layer board of 68.7 × 53.5 mm with 9 parts on 33 nets, routed with 317 tracks and 4 vias.
It is built around the 74HC595. Its parts include 3 ICs, 2 resistors and 2 diodes. It belongs with the retro computing and games and interfaces and adapters boards and the AVR (ATmega, ATtiny) and NXP (LPC, Kinetis, i.MX RT) boards of this library.
Main components
1README
README.mdMK1 8bit Computer
Schematics and code for my home-made 8-bit CPU and its companion boards.
Articles about this project:
Overview
During the past month, I designed and built a programmable 8-bit CPU from scratch, out of basic series 74LS logic ICs.
This repository contains pictures, schematics, and code for this project and its companion boards.
- V 1.0 assembled:
- V 2.0b assembled:
- Helix Display Interface in action:
- V 1.0 in action:
DEMO VIDEO (YouTube)
Architecture
The MK1 CPU is composed of several modules, all connected trough a common 8-bit BUS, the status of each module is shown by dedicated LEDs.
- The clock module is designed to allow step-by-step execution; in automatic mode the clock speed can be adjusted from 1Hz up to 32KHz.
- The computer programs are stored in RAM and the CPU can be programmed both manually, by inserting binary machine code through dip-switches, and automatically via a USB PC interface.
- The Programming interface is designed to be used in conjunction with an Arduino Nano or the Start9 programming board.
- The Start9 programming board allows the loading of multiple programs stored on an on-board flash memory without the aid of an external computer device.
- The Addressable memory space is 1024 byte, data, stack and code spaces are separated, the code address space is not writable.
- The instructions are variable-length (see instruction-set here) 1 or 2 bytes long (first byte for the opcode, the second one for the argument), there are 4 general purpose registers (
A,B,C,D) and astack pointerregister for subroutine calls. - The Arithmetic Logic Unit has a dedicated register for the second operand and supports the following operations:
- Addition
- Subtraction
- OR
- AND
- NOT
- Left/Right Shift
- Left/Right Rotation
- The Control Unit combinatory logic is implemented using EEPROMs (see microcode here) whilst each instruction is realized through a variable number of micro-instruction for a maximum of 6 micro-steps per instruction, including the fetch cycle. The instruction-set supports both direct and indirect memory access as well as absolute and conditional jumps on carry (
CF) and zero (ZF) ALU flags. - The computation output can be visualized on a 4-digit display, with a dedicated register, able to represent positive and 2-complement negative numbers both in decimal and hexadecimal format.
- The CPU can be extended thanks to the external BUS interface capable of handling up to 2 peripheral. The communication is bidirectional, the devices can send interrupts to the CPU to notify when new data is available. Interrupts are cleared once the data has been processed.
- The only available peripheral at the moment is the Helix display interface, an ATmega328-driven 2x16 LCD output display.
Structure
- MK1 CPU/:
- 8bit-computer/: KiCad project, schematics and PCB design of the MK1 CPU.
- code/:
- microcode.py: generates the binary EEPROM microcode.
- out_display.py: generates the binary output display EEPROM code.
- uploader.py: uploads a binary MK1 program to the CPU.
- mk1_computer_uploader/: Arduino programmer interface sketch.
- assembler/: fork of the hlorenzi's assembler, improved and customized for the MK1
- programs/: a collection of programs for the MK1 CPU plus the assembler definition
- start9_programming_interface/:
- programming_interface/: KiCad project, schematics and PCB design of the Start9 programming board.
- code/start9_programming_interface/: Arduino code for the programming interface.
- helix_display_interface/:
- display_interface/: KiCad project, schematics and PCB design of the Helix display interface board.
- code/helix_display_interface/: Arduino code for the display interface.
- eeprom_programmer/: KiCad project, schematics and PCB design of a simple Arduino-based eeprom programmer
- bus_breakout/: KiCad project, schematics and PCB design of the external bus connector breakout board.
Changelog
V2.0d:
- minor hardware revision
- revisited PCB design
- new memory architecture, code memory section is read-only, stack and data live on separated spaces
V2.0b:
- minor hardware revision
- Variable-length instructions (1 or 2 bytes)
- new custom assembler, thanks to https://github.com/hlorenzi/customasm
- few new instructions
- revisited microcode and instruction-set
V2.0:
- 4 general purposes registers (A, B, C, D)
- Stack Pointer implemented as an up-down counter
- External interface and interrupt handling
- Output display decodes HEX and ASCII values
- Clock speed multipliers
- Control Unit extended with 4 EEPROMs
- Variable step microcode counter length (each instruction uses the minimum amount of micro-steps)
- revisited microcode and instruction-set
V1.0:
- Bugfixes.
HLandSTKaddress signals available in theMARdip-switch.
V0.1:
- Initial release
Parts
9| Qty | Value | Footprint | References |
|---|---|---|---|
| 2 | 220 | Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_Horizontal | R1, R2 |
| 2 | 74HC595 | Package_DIP:DIP-16_W7.62mm_Socket | U1, U2 |
| 1 | 28C64 | Package_DIP:DIP-28_W15.24mm_Socket | U3 |
| 1 | Arduino_Uno_Shield | Arduino:Arduino_Uno_Shield | XA1 |
| 1 | LOGO | Symbol:parrot | G*** |
| 1 | READ | LED_THT:LED_D5.0mm | D1 |
| 1 | WRITE | LED_THT:LED_D5.0mm | D2 |
More from vascofazza/8bit-cpu
4- 2 layers297.2 × 180.3 mm

- 2 layers96.5 × 55.2 mm

- 2 layers53.3 × 48.3 mm

Programming interface
vascofazza/8bit-cpu
Schematics & code for my 74LS-based 8-bit MK1 CPU
15 parts317MIT - 2 layers57.1 × 41.9 mm

Similar boards
- 2 layers45.7 × 31.8 mm

LEDx16 board
tardate/LittleArduinoProjects
a collection of "Little Electronic & Arduino Projects", most involving electronics or an Arduino in one way or another!
36 parts803MIT - 2 layers228.6 × 100 mm

Mongus48
ChrisChrisLoLo/beyblock20
The magnetic, modular, 20-key macropad that can join together to form an ortholinear board
124 parts335GPL-3.0 - 2 layers245.1 × 160 mm

8-Bit CPU 32k
slu4coder/Minimal-64x4-Home-Computer
My DIY TTL home computer with VGA and PS/2 and 4x the processing power of a Commodore C64 or Apple II.
139 parts326 - 2 layers100 × 95.1 mm

Protoboard-6x4-breakout
electroniceel/protoboard
Advanced protoboard layout with 1.27mm pitch for smd parts
4,745 parts311CC-BY-4.0 - 4 layers140 × 100 mm

Dc usv
TobleMiner/DC-UPS
A small DC UPS, designed to keep small appliances like consumer network equipment running during power outages
351 parts223CERN-OHL-P-2.0 - 2 layers100.5 × 218.3 mm

- 2 layers287.8 × 126.7 mm

- 2 layers100 × 100 mm

Questions
How big is the Arduino eeprom programmer PCB?
It measures 68.7 × 53.5 mm and has 2 copper layers, 1.6 mm thick.
What parts does the Arduino eeprom programmer use?
9 parts, built around the 74HC595. The full list of its parts is on this page, with links to each part's symbol and footprint where PCBKit's library has them.
Where can I download the Arduino eeprom programmer KiCad files?
From the vascofazza/8bit-cpu repository on GitHub, at the commit this page was made from: the board is eeprom_programmer/arduino_eeprom_programmer/arduino_eeprom_programmer.kicad_pcb. PCBKit opens the board in the browser, with nothing to install.
Can I use the Arduino eeprom programmer design in my own project?
Its repository publishes it under the MIT licence: you may reuse it on that licence's terms (keep the author's notice, and for a copyleft licence share your changes alike).
