From: Kevin Schoedel <schoedel(a)kw.igs.net>
Neat. I occasionally spend a little time working toward
building myself
a
simple processor. My priorities are rather different,
though; I want to
make the 'moving parts' visible as far down as is practical and
affordable (which for me will probably mean SSI TTL, except for the
memory), rather than to make the programming model simple.
In the end buildability means a simple machine, not always a
simple programming model.
Could one build "nixie tube emulators", for
instance using seven-segment
LEDs, and then borrow real ones from some other device for special
occasions?
No. Nixie is one of 10 output (highvoltage very low current) and
7Segment
is different in every other way. For an era machine 7 segment using
incandescent lamps would be valid!
4 - CLEAR
Reset the accumulator (and flags).
Example: 400 - clears the state of the machine.
Note: This seems a waste of a major opcode.
I've tentatively decided that I'll go for a store-and-clear operation, ?
la EDSAC and PDP8, since, in the few sample programs I tried, the value
in the accumulator was still needed after fewer than half the stores.
This might conflict with your goal of simplicity, but on the other hand,
the question of how to retain (regain) the accumulator after a store
might make a good 'Exercise 1'.
PDP-8 or the PDP-5 are a good example of minimal but useful instruction
sets.
PDP-8 savethe AC and store is done one of two ways. You can use the MQ
but that requies three locations.
SWP
DCA N
SWP
The tighter version is also compatable across all the PDP 5/8 series.
CLL
DCA N
TAD N
Three words still but doesn't use a register that may not exist.
Alternatively you could clear with a STORE,SUB pair, at
the cost of a
scratch location.
You could have a microcoded bit that if set clears the AC. Depends
on the number of bits you have to use.
7 - READ
After several partial designs than included IN and OUT operations, I
decided to punt I/O almost completely. In my current plans, one
operation
can take the switch register as source, and the
accumulator lights
(and/or other lights) are the only output.
Limts the machine significantly.
9 - CALL
I have provisionally punted the CALL, too, as a separate operation;
instead, the same operation that can load the switch register into the
accumulator can similarly load the PC. Unfortunately my current design
requires the PC to then be adjusted explicitly in the subroutine.
Look at how PDP-5/8 and other did it. Since memory was a universal
store the first location of the JMS is the subroutine return address.
That give a very simple implmentation but a real Jump to Suroutine.
JMS SUB1
Breaks down to
PC-> SUB1, SUB1->PC, PC+1->, fetch PC
makes for simple state logic.
I'm still at the stage of designing and
"building" fragments in a
simulator, since I have no real experience; I keep making things too
complicated, and then backtracking to simply again. (And I don't work on
it very often.) My current plan is roughly an 8-bit,
stripped-down-PDP8-ish architecture:
Suggestion:
Eliminate the ISZ from the PDP8 ops and make IOT and ISZ in to
INPUT(to ac) and OUTPUT(from AC). Keep indirect addressing
and drop page 0 addressing.
AND
TAD
DCA
JMP
JMS
OPR (skips, shifts, clears, misc ops)
INP
OUT
three bit opcode, one bit for indirect address and 4bits for in
page address. Direct addressing 256 bytes using indirect
addressing.
Any bits in the instruction may of course end up
complemented depending
on the nature of available gates :-) I want to hard-wire this one; if I
eventually finish it, next will come a 16-bit (or perhaps 12- or 18- or
24- bit) device with a more sophisticated instruction set and wide dumb
microcode in EEPROMs.
Sounds like fun.
One is an 8-bit processor, built from TTL on an
8"x14" prototyping
board,
with point-to-point soldered wire. The ALU is a pair of
74181s, and
seems
to use 7475s for the registers. There are five sets of
8 LEDs -- memory
address register, program counter, instruction register, memory, and
A good design to look at for simplicity and also to illustrate 8bit
machine
that could become the microcoded core of something bigger check out
the controller used in the RX01. It had all the basic elements and was
really simple. A variation of the disign was used in the LA120 printer.
A somewhat related 'thing' I picked up last
week is some sort of logic
trainer. In a clear plastic frame about 12" x 20" x 6" thick, it has six
*huge* flip-flops (built with power transistors) each with a pair of
output lamps, a jumper area for "programming", and input in the form of
a
telephone-style dial. (I assume people here know what a
telephone dial
is
:-) Haven't traced this one out yet either, but at
its scale it won't
be
hard.
Aint seen one of those for years. Memory serves there were only a
few FFs and verly little other logic.
Allison