is a Forth
CPU that I built with TTL
Goals of Mippy
Mippy was my first electronics project. With this project I
wanted to learn more about processor architecture, design, and
The design of Mippy is open to others. Ths web site will
have all the schematics of Mippy. Also, I will be sure to state
when I made bad decisions and mistakes. This is, after all, a
learning project. ;-)
is a 1MHz, 16 bit Forth
machine built from scratch using 74HCT00 series TTL chips. The
data bus and address bus are separate, each 16 bits wide.
- two stacks: data stack & return stack
- a full ALU
- instructions with embedded immediate values
- micro-code sequencer
There are only 3 programmer visible registers and one state
- 16 bit Program Counter (PC)
- 16 bit data Stack Pointer (SP)
- 16 bit Return stack Pointer (RP)
- Interrupts Enabled bit
Instructions are decoded into a micro-code address and fed
into the sequencer.
was born when I had some
time after leaving a job. I had a bunch of free time on my
hands and decided, like everybody else in the computer world,
that I wanted to build a CPU to my specifications. I read the
PDP-11 specifications (only later did I learn about the whole PDP family
its architectural beauty).
Thinking about what to do with a CPU if I built one, I
thought about the frustrations of a development environment.
Ideally, the system would be self hosted. This requires I/O (a
terminal would suffice for my needs), some sort of storage (a
serial line to a host system would suffice.
But, the software: Assembler? That's a tough environment to
do much work in. I know, I know: lots have done it before me.
Sure, and I've written my share of assembler (6502, 68000,
PowerPC, Alpha, and MIPS64). But, that wasn't what I'd want. C
wasn't ideal for two reasons: first, it required an assembler
(because of low-level code that can't be expressed in high
level C, and really a C compiler should generate assembly for
review) and a C compiler is a bear (now there's the Icc
, but at the
time I hadn't seen it).
is of course out as a systems language because it
depends on the primitives that it would need to implement.
Then I thought about Forth. Hmmm. There's a system that's
fully self-contained. The assembler, compiler, and editor are
all part of the same environment. Further, a Forth system can
usually be developed in very few K of memory.
Indeed, a Forth language on top of whatever processor
architecture I devised would be my goal. From there I could
build compilers (C and Pascal leap to mind).
That's when it occured to me, why not just build a Forth
Last, you might be wanting to ask, "Where did the name
come from?" Early in the
development phase I used a Basic Stamp II as a front side bus.
Each CPU clock cycle was initiated by the Basic Stamp. After
strobing the clock, the stamp would read the Data Bus, Address
Bus, and control signals and send them to a Linux host system.
The software on the Linux system then decided what course of
action to take based on the bus state. It then shipped back a
response over the serial port and that was then fed into the
front side bus and another CPU clock cycle was initiated.
That's a terribly slow process. Roughly one clock cycle per
second. A friend pointed out that there are only 32 million
seconds in a year, so my computer couldn't be that fast (by
comparison modern processors are operating at 1, 2, and 3
billion clock cycles per second). That's when I decided that my
CPU was capable of Millions of Instructions Per Year: MIPY.
Spelling it Mippy just seemed better.
Here is the text
demo software that dad
and I showed at the 5th Annual
Vintage Computer Fair
dup 1 = over 2 = or
if 'C' else '!' endif
swap 1 - dia'
rtz emit dia-emit
SENTINEL swap dia'
And here's the output of that algorithm (actually this isn't true):
OK 9 diamond