Need help with 8bit-cpu?
Click the “chat” button below for chat support from the developer who created it, or find similar developers for support.

About the developer

vascofazza
248 Stars 16 Forks MIT License 47 Commits 0 Opened issues

Description

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

Services available

!
?

Need anything else?

Contributors list

# 299,074
assembl...
webasse...
micropr...
assembl...
47 commits

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.
    • mk1computeruploader/: 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
  • start9programminginterface/:
    • programming_interface/: KiCad project, schematics and PCB design of the Start9 programming board.
    • code/start9programminginterface/: Arduino code for the programming interface.
  • helixdisplayinterface/:
    • display_interface/: KiCad project, schematics and PCB design of the Helix display interface board.
    • code/helixdisplayinterface/: 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

We use cookies. If you continue to browse the site, you agree to the use of cookies. For more information on our use of cookies please see our Privacy Policy.