5
\$\begingroup\$

Where I work, we are transitioning to a Agile methodology for our software development. We would also like to explore the same for hardware development, but the mental impedance mismatch might get in the way. Specifically, a big part of most Agile methodologies is that you work on a prioritized set of features. In software, that's fine because you can always go back and refactor/rework past code. But in hardware-- at least for a large, sophisticated design-- means you're respinning boards at each iteration. Or, you're building your system around programmable logic.

So why not just start with (and end with) a FPGA-based design? Well, as a software engineer I have no problem with that, but sometimes the hardware folk have legitimate reasons not to. But putting that aside, I'm curious if developing with a FPGA for speed and agility but at the end of hardware deelopment transitioning to discrete logic is something that is commonly (or at least sometimes) done.

\$\endgroup\$
  • 1
    \$\begingroup\$ This depends on what kind of hardware you talk about. IC design is readily done with FPGAs at first to verify the logic, etc. But you can't simulate a PCB with an FPGA :D. I find that not all methodologies can work in every single situation. \$\endgroup\$ – Gustavo Litovsky Mar 4 '13 at 19:38
  • 1
    \$\begingroup\$ For the FPGA part of the design, maybe you can do this. But every FPGA design also needs some support circuits. Power supplies at least, but maybe also external memory, ADC, DAC, analog signal conditioning...There are just some things FPGAs can't do on their own. \$\endgroup\$ – The Photon Mar 4 '13 at 19:38
  • \$\begingroup\$ Also think about where PSOC fits in. \$\endgroup\$ – Russell McMahon Mar 5 '13 at 5:22
  • \$\begingroup\$ Did you really mean "discrete" logic? \$\endgroup\$ – Ben Voigt Mar 5 '13 at 17:15
  • \$\begingroup\$ Yes, I meant discrete logic. \$\endgroup\$ – John Passaniti Mar 5 '13 at 20:47
3
\$\begingroup\$

There is something other than an FPGA which allows you to experiment with different circuits. It's the PSoC from Cypress.

PSoc3

The chip contains dozens of digital and analogue building blocks. The digital blocks are a lot like those found in FPGAs, allowing you to create all kinds of digital functions: gtes, flip flops, adders, shifters, LUTs, etc. The analogue blocks allow you to create things like OpAmps, comparators, filters, a few values of resistor, ADC, DAC, etc.

The development environment allows you to literally wire up a schematic, and have it implemented inside the chip.

PSoC Creator

Having got your circuit working well, you might decide to re-implement it using discrete components. However, just as with the FPGA, the chip is capable of so much that discrete components could end up costing much more money and board space.

\$\endgroup\$
2
\$\begingroup\$

I think it would be a very strange system that would migrate to discrete logic from an FPGA. You can fit so much logic in an FPGA, even a small one, that you'd have to hold yourself in check to a huge degree if you wanted to ensure that what you had prototyped was a sensibly small amount of discrete logic. In which case, I'd expect it to be reasonably straightforward to get it right first-time (ish :)

\$\endgroup\$
1
\$\begingroup\$

Absolutely, there are any number of accelerator card and simulation environments for ASIC flows that dump the design into FPGA's for "almost" real time simulation. And that is done so the SW and support electronics can also be debugged. This is done for "functional" test but never final sign off. And here functional doesn't mean the same as the functional paradigm of SW.

The main "impedance" mismatch is that distinction between real sign off and functional test. Most software exists exclusively in the functional side of things, unless you're doing parallel programming and heavy threading with the concern with race conditions etc.

In teh early explorational part of development this is done a lot, but as the design progresses it must be locked down and uncontrolled conditions dealt with.

Another element is that really big and flexible FPGA's are very expensive, and indeed there are certain devices that are basically only used for this.

\$\endgroup\$
  • \$\begingroup\$ Thanks for the reply. Yes, I wouldn't expect that developing with a FPGA would mean that when ready to commit to discrete logic that it was equivalent to a final sign off on the hardware. Certainly all of that will have to be retested. But what I am looking for is a way to develop the hardware with equal agility as the software. This at least seems like a valid approach then. \$\endgroup\$ – John Passaniti Mar 4 '13 at 21:38
1
\$\begingroup\$

Unless you are transitioning to an ASIC or have very simple digital logic requirements an FPGA(or CPLD) will be comparable or cheaper in cost and a better final solution. FPGAs will only replace the digital portion of the hardware design with the exception of some basic DAC and ADC functionality.

Depending on the design complexity, an FPGA board can be a complex hardware development effort. You can buy quite a selection of FPGA development boards that include all kinds of analog and digital peripherals that make for great prototyping environments without having to design your own FPGA board up front.

For example: http://www.xilinx.com/products/boards-and-kits/EK-K7-KC705-G.htm

With lots of expansion card options: http://www.xilinx.com/products/boards_kits/fmc.htm

Or on the opposite end of the price complexity spectrum: http://www.latticesemi.com/products/developmenthardware/developmentkits/machxo2picokit.cfm

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.