Skip to the content
2 layers68.7 × 53.5 mmArduino eeprom programmer, the printed circuit board in 3D

Arduino eeprom programmer

vascofazza/8bit-cpu317

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

1

README

README.md

MK1 8bit Computer

Schematics and code for my home-made 8-bit CPU and its companion boards.

Articles about this project:

Hackaday.com

Hackster.io

InformaticaLab.com

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)

MK1 Computer - home-made Programmable 8bit CPU

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 a stack pointer register 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.
  • HL and STK address signals available in the MAR dip-switch.
V0.1:
  • Initial release

Parts

9
QtyValueFootprintReferences
2220Resistor_THT:R_Axial_DIN0207_L6.3mm_D2.5mm_P7.62mm_HorizontalR1, R2
274HC595Package_DIP:DIP-16_W7.62mm_SocketU1, U2
128C64Package_DIP:DIP-28_W15.24mm_SocketU3
1Arduino_Uno_ShieldArduino:Arduino_Uno_ShieldXA1
1LOGOSymbol:parrotG***
1READLED_THT:LED_D5.0mmD1
1WRITELED_THT:LED_D5.0mmD2

More from vascofazza/8bit-cpu

4
  • 2 layers297.2 × 180.3 mm8bit computer, the printed circuit board in 3D

    8bit computer

    vascofazza/8bit-cpu

    Schematics & code for my 74LS-based 8-bit MK1 CPU

    377 parts317MIT
  • 2 layers96.5 × 55.2 mmDisplay interface, the printed circuit board in 3D

    Display interface

    vascofazza/8bit-cpu

    Schematics & code for my 74LS-based 8-bit MK1 CPU

    16 parts317MIT
  • 2 layers53.3 × 48.3 mmProgramming interface, the printed circuit board in 3D

    Programming interface

    vascofazza/8bit-cpu

    Schematics & code for my 74LS-based 8-bit MK1 CPU

    15 parts317MIT
  • 2 layers57.1 × 41.9 mmBus breakout, the printed circuit board in 3D

    Bus breakout

    vascofazza/8bit-cpu

    Schematics & code for my 74LS-based 8-bit MK1 CPU

    4 parts317MIT

Similar boards

  • 2 layers45.7 × 31.8 mmLEDx16 board, the printed circuit board in 3D

    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 mmMongus48, the printed circuit board in 3D

    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 mm8-Bit CPU 32k, the printed circuit board in 3D

    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 mmProtoboard-6x4-breakout, the printed circuit board in 3D

    Protoboard-6x4-breakout

    electroniceel/protoboard

    Advanced protoboard layout with 1.27mm pitch for smd parts

    4,745 parts311CC-BY-4.0
  • 4 layers140 × 100 mmDc usv, the printed circuit board in 3D

    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 mmTraktorino, the printed circuit board in 3D

    Traktorino

    silveirago/traktorino

    The open-source DIY MIDI Controller for DJs.

    96 parts220
  • 2 layers287.8 × 126.7 mmNoName, the printed circuit board in 3D

    NoName

    AlaaSaadAbdo/battoota

    Keyboards

    267 parts188
  • 2 layers100 × 100 mmTommyPROM32-595, the printed circuit board in 3D

    TommyPROM32-595

    TomNisbet/TommyPROM

    Simple Arduino-based EEPROM programmer

    36 parts187

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