I didn't plan on ending up here. I started by wanting to learn
about transistors. Things got out of hand.
The project started a few years back when I decided I wanted to
learn about transistors. My work at the time was a mix of software
and FPGAs for various radio communication systems. As part of this
I got involved in conversations with the folk doing the analogue
electronics design and wanted to better understand what they were
up to. It took me a while to get round to but eventually somewhen
around 2011/2012 I bought myself a few components and wired up a
little test circuit with a transistor and a couple of variable
resistors so I could twiddle things and see what happened. The
board below is the one I used for my early experiments, the
original circuit is probably long gone but the pots are still
there on top left.
The first circuit was not much fun, not very interesting, didn't
hold my attention for more than a couple of minutes. I quickly
decided that the only way to learn about transistors was to build
something. But what ? I couldn't think of anything so I put the
board to one side and did something else.
Inspiration came a few months later. A potential project came in
for a telemetry system that would have to operate in a hostile
environment (just behind the drill bit of an oil well). Hot. Very
hot. My colleagues and I cast around trying to find components,
and in particular processors, that could operate under the
required conditions. Initially we couldn't find processors, but we
could find some discrete logic devices that could handle the heat.
It seemed to me that the required system was sufficiently simple
that it was quite feasible to build it from discrete logic. I
recall being gently mocked for the suggestion. I can't remember
quite how the conversation went after that but at some point I
made the throwaway remark that when it came to debugging
discrete logic then at least we'd be able to see everything that
was happening in the logic. We could even put LEDs on all the
signals and watch it operate. Which would be fun. But then we did
manage to find some high temperature processors and shortly
afterwards the project went away anyway,. Which rather ended the
discussion. Or at least it should have. But it had got me thinking
about what it would be like to see logic working with LEDs. And
then I remembered my abandoned transistor. So I decided that the
first thing I should build was a logic gate, and I should put an
LED on it. I think that's on the board above as well.
Having built the circuit it struck me that not only could you see
the logic state with the LED, you could also layout the board to
see all of the transistors and how they were connected together.
And then I tried to imagine what it would be like to see an entire
processor with all of its transistors laid out for you to see, and
with all the logic levels visible so you could watch it work. You
would actually SEE the logic. And not just that. It would likely
be fairly large so you would want to make it in a sort of
wraparound way so you could see everything at the same time. Which
would mean that you would be actually sitting inside a processor.
How cool would that be!
So how would you do it ? At that time I don't think I had any
intention of actually building such a thing. It was more an
interesting thought experiment... how would you do it?
I messed around with a few ideas looking at various aspects of a
processor wondering what might be doable and then thought why not
actually build something. Best way to learn, which afterall is
what the original point of the exercise was. So I did. Initially I
tried to do it by wiring components together on prototype boards
but that was pretty tedious and I spent more time sorting out my
wiring than anything else. So I thought why not try doing a PCB.
And here it is:
It was a collection of fragmentary ideas so that I could try
things out, but at least starting with things correctly wired
together. You might be able to see its called "WiC Trial Board". I
was originally calling the project my "Walk in Computer". The name
changed to Megaprocessor sometime in 2014. I learnt quite a lot
from this board.
Whilst absorbing the lessons from the trial board I turned my
attention to the logic design for the processor itself. What
should it do, how would it do it. I spent many happy hours trying
out different architectures and choices of instruction sets.
Eventually I had a reasonably stable idea as to what would
be big enough to plausibly claim to be a proper processor (I could
see no merit at all in building the simplest possible processor)
yet small enough to be feasible. So I coded up a model in software
to try and get a feel for how big it would be. It didn't look to
scary. So I tried to work out how large each of the logic gates
would be, printed out pictures and built myself a paper processor.
This was mid 2013.
It was about 2m a side. Now that to me seemed an entirely sensible
size. To be sure not big enough to walk in but actually that meant
it was small enough to be practicable as maybe a piece of wall
art. Perhaps not to everyones taste, but I could see it taking up
a wall in my study. A fair challenge but feasible. Should be fun.
Lets do it.
(I think my guess at the time was for the project taking maybe a
year or so of a few evenings a week, costing maybe a few thousand.
On the electronics side things progressed reasonably well. This
was doing the various boards I need. The 8 bit adder/subtractor
arrived April 2014. It's is my favourite board.
On the logic design side progress was not so straightforward. A
couple of things happened. Firstly I became a bit more ambitious.
It's my processor, it should do multiply and divide. I was
interested in how these operations could be done, and the point of
this project was still to learn stuff so I thought I should
implement them. This added a bit of complexity. The second thing
that happened was more subtle but much more costly. The starting
point for this adventure had been the idea of actually being able
to see logic work. But the more I contemplated my initial paper
layout the more uneasy I felt about this. To be sure you'd be able
to see the logic levels, but would their operation make sense.
Would it be possible to see how things were connected and why what
happened was happening? So I started restructuring the layout to
group together related logic in a much more explicit manner. This
is when the size really started to bloat; to show the
relationships between elements you had to have some space.
In Sep 2014 I had another go at trying to work out what the
processor might look like. And now I really should have noticed
the warning signs. I had to do it quarter scale to fit on my
living room floor.
It was 3m long and about 30 cm tall quarter scale. So full size
12×1 m. Hmmm. This is where I should have stopped. I live in a
bungalow. Its not huge. But it is quite long. In fact the hallway
is about 12m long and I could just picture having the processor
mounted along one wall. Bit like the Bayeux tapestry. (But even
better). So nearly there, I thought, lets just go a bit further
and see if this would work.
End of 2014/early in 2015 the realisation began to dawn on me that
there was a dreadful horror buried in my new layout. Connectivity.
I'd split the processor into nearly 40 modules. Each of the
modules had a nice clearly defined purpose, and showed how the
control logic caused the operation of the module. But this led to
an insane number of connections as signals had to be routed to
multiple modules. After a bit I decided that this wasn't really
buildable. So I threw away that layout and started again trying to
group things together not just by common function, but also by
common signals. This led to the current structure of 14 modules
mounted in 5 frames. It's still about 12m long, but is now 2m
tall. (This is going to be a problem for my house).
By Sep 2014 I was sufficiently confident to begin construction and
completed the first module in Jan 2015. The soldering and
construction finished about Jan 2016. At time of writing (April
2015) we're in the integration (and documentation) phase.