Boards are boring.
Or at least, that’s what you would think, given the differences in attention and tools spending for boards versus things like FPGAs and ICs.
OK, I guess the spending part doesn’t quite work there if you’re talking about FPGAs, since we all know that FPGA tools are free.
So let’s just assume that the FPGAs you buy are what pay for the tools. Because it’s true. Those tools aren’t free; it just feels like it to the poor shlubs trying to make FPGA tools without actually making a piece of silicon to subsidize them.
In fact, let’s look instead at the dollars invested in developing tools. There’s plenty of that going around in the FPGA world, even if accounting makes it look like there’s no ROI there.
So it would look like PC boards are to FPGAs like resistors are to ICs. Old technology, permissive layout rules. Yeah, your 40-layer board sounds impressive. But hey, any idiot can route anything given 40 layers. Much harder to route something on only 7 layers of metal or when your routing structure is hard-coded into the FPGA architecture.
Yawn.
So where do boards fit into the hierarchy of things? Usually at the bottom. Or worse, off to the side.
Let’s face it: designers had to put pressure on the FPGA guys in order for them to acknowledge that the things that used to work for 24-pin Skinny-DIP packages don’t work for a thousand-pin package. You can’t do it by hand. Even dealing with a spreadsheet is hard.
No, the FPGA guys have pretty much left those details to the user: the FPGA has always been the pinnacle. You start your FPGA design in FPGA-land, spend your difficult months with your smartest guys figuring out how to optimize what’s in the FPGA, getting the performance, packing as much in there as you dare while leaving some room for changes… and then, when that’s all done, you hand the awesome, shiny, breath-taking result to someone else, to applause all around, for them to put somewhere on a board.
And maybe they could get you some coffee at the same time.
Of course, at some point, the concept of “system design” became trendy. (In fact, it’s rather on the forefront of some minds since ESC this year…). So, for FPGAs, that means thinking through how you can do a whole system in an FPGA.
Or perhaps how to generate an accelerator for a processor and put that in the FPGA. Maybe even generate the accelerator automatically using an HLS tool. But, even so, the designer has to figure out how to connect the accelerator to the processor, using whatever IP is necessary to make the connection. There’s very little out there for pulling an entire system together.
But, then again, even those attempts at addressing that problem do so on a somewhat abstract level. A high-level tool would presumably do something like allow an abstract view of functionality in some high-level format – like SystemC or C or C++ or M – and then let you play with it and split it up and figure out what goes in the FPGA, what’s soft, what’s hardware, what’s a peripheral, what’s IP, etc.
And when all of that is done and boiled down and implemented and compiled and placed and routed, then the awesome, shiny, breath-taking result can be handed to someone else, with applause all around, for them to put together on a board.
And maybe they could get you some coffee at the same time.
So it’s a little surprising when you look at the way Altium works. The board isn’t at the bottom or off to the side. And it’s nowhere near the coffeemaker.
It’s at the top. It’s the beginning. The alpha. Not the omega.
It takes a minute for that to sink in when you first see it. What? Why is the board at the top of the hierarchy?
Looking at Altium’s history, your next reaction is, ah… they were originally a PC board tool company. Now it all makes sense. When you’re a PC board company first, then everything else becomes subservient to the PC board tools. Other tools become just a way to add value to the PC board tools.
It’s kind of like a pizza box maker trying to figure out how to sell more pizza boxes. And getting into the pizza business to help drive box sales. Where the pizza adds value to the box.
It’s an insult to the FPGA world. Being put under the board… Bah! The nerve!
Or is it?
In fact, if we take a few long, cleansing breaths, clear our minds of the accumulated clutter, put our egos into standby mode, well, we can in fact agree that pretty much everything ends up on a board.
Which means that everything on the board is a component of the board. Which means that, hierarchically speaking, you can start with the board and drill down into the various components, like the processor, the FPGA, and, yes, even the decoupling caps and other such grotty bits.
Which means the board would be at the top of the tree, and you’d have to double-click in a level or two to get to the FPGA. Or the software project that lies on top of the processor that’s on the board.
Altium refers to this as “platform-based design” and positions it as a way to resolve the many tool-chains that deal with specific “islands” on the board, typically to the exclusion of anything outside that island. Not surprisingly, they approach the problem with a unified methodology and toolset that allows engineers dealing with the different islands to exchange information and have their results flow into a single result: a PC board having numerous elements soldered onto it, any of which may have other high-falutin’ design stuff attached to them.
The only thing missing is the box it all goes into. (And they even play nice with mechanical tools. Sounds so… 20th century… aren’t we beyond bending metal by now?)
So the next time a project starts, you might find an engineer designing the PC board, partitioning and handing off bits and pieces to various design teams.
“Hey, you over there, we need some software on this processor that’s going to do some stuff.
“Oh, and you guys, can you put some stuff in this FPGA thingy?
“And, while you’re up, could you get me some coffee?”
More info: Altium
