
Build your own FPGA - VeXocide
http://blog.notdot.net/2012/10/Build-your-own-FPGA
======
rrmm
Superneat project. Now someone needs to synthesize a CPU and build a big
enough discrete fpga to run it (very slowly) on.

A few comments for those playing at home: 1) Use less solder. When you get
boards done at the pcb house, they usually put a solder mask. There is enough
solder on the pads that you can solder SMD parts without adding more.

Just flux it with a fluxpen, lay the part on top, and remelt it. Much neater
and much faster. You just have to check that there is actually enough solder
on the pad to make a solid joint (a light and a magnifier help to verify).

2) Always clean the flux off, even if it's no-clean.

3) Autorouters produce less than ideal results. If you start with an
autorouter pass, you can then go back and tear up lines and reposition parts
to use fewer vias and straighter lines.

When I first started doing pcbs I wanted to use autorouters, but the results
were always ugly. I met a guy who had done a 6-layer ARM board in some old DOS
program manually which convinced me it probably wasn't that big of a deal to
route by hand. It's calming if nothing else.

~~~
nicksdjohnson
I probably overdid the solder a bit, but there's no way most of the pads had
enough solder on them for SOICs without my adding any. I've soldered SOICs
before, but this is by far the largest volume I've done in a sitting.

As I mentioned briefly in the post, the autorouter was something I used
largely as a result of time constraints - with 200-odd wires to route and very
little time to do them in if I wanted the PCBs back in time, I decided to give
it a go. That said, I was surprised with the quality of the results - I'd be
surprised if I can find any easy-to-remove vias left in its solution. The tool
is also very good for assisted hand routing, since it lets you nudge traces
around without ripping them up every time.

~~~
rrmm
I understand; I'm just back-seating anyway.

Where did you get the boards done?

Also, do you have any idea how fast the counter you made can go?

~~~
nicksdjohnson
I got them done at Hackvana (hackvana.com, or #hackvana on irc.freenode.net);
similar prices to Seeed, and excellent customer service.

I'm not sure about the maximum speed. The flipflop, for instance, has a delay
of 14ns; if we take that as average, each slice has to go through 5 parts
(input mux, LUT, flipflop, async select mux, output enable) for a total delay
of 70ns, so in theory one slice could do about 14MHz. Since it's a ripple
counter, I guess we should divide that by the number of slices, so 4MHz seems
like a reasonable upper bound.

~~~
rrmm
It's a really outstanding project. Thanks for sharing it with everyone.

Regarding configuration memory, could you have the arduino read out from a
serial flash? They're pretty easy to bit bang or control over SPI, and you can
get a 64Mb pretty easily.

~~~
nicksdjohnson
I'm guessing you're talking about the SRAM-based alternative I discussed at
the end? Yes, that would be an option, as would an SD card. 64Mb would be
enough for plenty of 256 kilobit slices.

I do prefer the idea of using EEPROM if I was going down that route, though,
so it'd be more like a CPLD than an FPGA. I just need a good way to load the
only bit of remaining discrete state - the output enables - on startup. My
best idea thus far is to dedicate half the EEPROM to configuration data, store
the latch states at address 0, and use two RC networks to create rising edges
first on a register latch pin then on the highest address pin to latch in the
config before enabling the EEPROM in 'operating mode'.

------
bitcracker
This is the first step to true open hardware.

I am concerned how fast IT evolves to DRM-locked devices. The PC will become
obsolete by tablets so we will lose control over our computers. Currently DRM
looks harmless but when you consider the long-term consequences it doesn't
look good at all.

First we fought TCPA and Trusted Computing, now we have the first global
players (Apple, Microsoft) put DRM into their gadgets to get maximum control
and minimum competition. And the customers buy, consume, and play, without
considering the consequences.

Our technology today is the foundation for the political systems of tomorrow,
and when you consider the global demographic development you know what I mean.
Within the next twenty years we will have a completely different global
political and economical system, and I don't want to have them total control
over us with their super-safe cascaded DRM chips which nobody will be able to
break.

Unfortunately we can't stop Apple, Microsoft & Co. from using DRM. That's why
I appreciate pioneer projects like this selfmade FPGA very much as they help
to jump over the big hurdle from open source to true open hardware. Someday
when all commercial chips will be DRM-locked I hope we will be able to
3D-print our own processors and RAM chips.

I am convinced that Open Hardware will become vital for the survival of our
freedom of speech and liberty in general.

~~~
mindslight
I agree with your entire comment except for the first sentence. When working
for a ideological goal, it is important to continually and earnestly evaluate
what goals the imagined solution will actually fulfill, lest one end up
misplacing faith in an implementation that can never achieve the desired ends.

First, this FPGA is _still_ not implemented by things that are the lowest
level - how do you know that 7404 doesn't actually contain secret logic
looking for specific patterns on the 6 "independent" inputs (based on your
widely-propagated design) that alter it's behavior?

Second, if one wanted to build an auditable CPU, they would not start by
building auditable reconfigurable logic in order to develop a soft core CPU on
top of it. This is a needless extra layer of interpretation, and the number
one constraint you're trying to overcome is the constant factors that are left
out of the Big-Oh notation.

We don't buy Intel processors because we're lazy and have money to burn, but
because they contain a billion transistors switching a billion times a second.
If you build something with 10k transistors switching at 10M Hz, something
that would take 1 second on the modern CPU will take roughly 3 _months_.

So I think there's two properties to be achieved for actual Free Computing.
The first is roughly getting something that can compute. These days, this can
be done by buying a standard PC and installing your own software on it. This
may not continue to be possible (so we would have to eg rely on integrating
our own ARM chips, then FPGAs, then microcontrollers, etc), but trying to put
a solution forward before it is necessary isn't going to get very far. There
also is available computation that is unlikely to go away - Javascript in web
browsers, available to all but sandboxed programming toy apps, etc.

Which brings us to the second quality of Free Computing, which is auditability
- guaranteeing that the code running is doing what it says, rather than a
subtle corruption which renders the whole sensitive algorithm broken. To get
performance, we would like it if such a CPU could be made in a necessarily
non-trusted fab, rather than independently assembled from discrete
transistors. This seems like a harder, but yet better defined problem -
meaning it might actually be possible to solve through some combination of
clever proofs and bootstrapping trust up from an extremely simple auditable
CPU.

~~~
bitcracker
> I agree with your entire comment except for the first sentence.

I meant the term "first step" historically. It is really the first step to
true open hardware because it is the first project (as far as I know) that
solely relies on basic electronics you can solder together on your own pcb.

There are many open hardware projects but all of them are based on complex
hardware (FPGA kits etc.). There are several good open cores you can download
into your fpga but what if someday your fpga stops working and you can't buy
another one because these fpgas are not produced anymore?

I agree with you that selfmade processors will never be able to compete with
modern processors. But even a 1 MHz 8 bit cpu can do a lot of things. Remember
the huge success of Commodore 64. And if you are able to 3d-print one such a
cpu you can also print many, and build a multicore system.

Who says that selfmade processors have to work with silicon and copper? If
someone finds a way to produce cheap conductive plastic filaments that would
be a huge leap forward for printed circuits. I believe that there are several
smart hardware hackers who could achieve a solution we could live well with.
3D printing is just in the beginning. I expect amazing times to come.

~~~
mindslight
1\. Plenty of CPUs have been built from discrete logic.

2\. As soon as you start talking about complex printed items (including PCBs),
you're necessitating either a trusted computational device to compile the
design and drive the printer, or the ability to audit the output of the
printer (eg read and understand the traces on a 2-layer PCB).

------
aortega
This is what I like about FPGAs and soft-cpus. Some "open-hardware" designs
use ARM cpus, that are as closed and patented as they can be (I.E. Arduino,
Raspberry PI, etc.)

You may argue that commercial FPGAs are also closed and while it's true, the
principle of operation is so simple (lots of interconnected gates) that can be
easily replicated, like this cool project shows.

~~~
zokier
> You may argue that commercial FPGAs are also closed and while it's true, the
> principle of operation is so simple (lots of interconnected gates) that can
> be easily replicated, like this cool project shows.

Basic CPUs are not all that complex either, there are plenty of homebrew CPU
projects made of discrete components. Both those and this project share the
common trait that they are almost impossible to scale up to be useful.

I would also be very surprised if FPGAs aren't also heavily patented.

------
sh_vipin
Nothing to discourage the efforts here but close to 10 companies were closed
which tried to enter in FPGA market in last 10 years alone. Here is the list :
TierLogic , CSwitch, Ambric, MathStar, Agate Logic, Nusym, AboundLogic (M2000)

Only one successful acquisiton. Lattice acquired --> Silicon Blue

In the past, ST Micro tried 2 times to enter in FPGA Market, once even with
the "open Source " concept - GOSPL. Intel for once for sure. Other several
companies failed too.

Xilinx and Altera hold close to 90% market share in FPGA market. 90% of other
efforts to enter this market have failed earlier. Mostly because, companies
underestimated Software importance.

~~~
ippisl
Even the lattice acquisition was a small one , the VC's made no profit on it.

~~~
sh_vipin
Exactly !! So i would say FPGA research as an academic project is a good idea
but as a viable business has many challenges.

------
OldSchool
Kudos. Just plain awesome and so recursively witty.

------
easytiger
Hmmm. did he have any indication of cost?

~~~
nicksdjohnson
Enough parts for 20 boards cost me about 100 pounds; the board fabrication
cost about $60, but a lot of that was because I wanted it in a rush. All up,
that works out to about 8 pounds, or 13 USD per board. It'd be somewhat
cheaper - around $10-$11 - if you're not in a rush for the boards, and of
course cheaper again in larger quantities.

~~~
easytiger
Yea that's interesting. Would be interesting to see how this scales when you
start including more complex components.

For instance a board with a 10GigE connector or putting a clock onto the board
itself.

