FPGA Fundamentals: What are FPGAs & why do embedded design engineers need them?...
01 February 2021
Optimal processing solutions are often provided by combinations of RISC, CISC, graphics processors & FPGAs, by FPGAs on their own, or by FPGAs that include hard processor cores as part of their fabric. However, many designers are unfamiliar with the capabilities of FPGAs, how they’ve evolved & how to use them.
The full version of this tutorial was originally featured in the February 2021 issue of EPDT magazine [read the digital issue]. Sign up to receive your own copy each month.
Here, Rolf Horn, Applications Engineer at electronics component distributor, Digi-Key Electronics outlines the fundamentals of FPGAs, discussing what they are and explaining why embedded design engineers need them, before introducing some example solutions from major providers.
Designers are constantly looking for ways to architect their systems to provide optimal computing solutions that address all their application requirements. In many situations, that optimal solution will often demand the use of field-programmable gate arrays (FPGAs), but many designers are woefully unfamiliar with the capabilities of these devices and how to go about incorporating them. This tutorial will briefly describe design scenarios that can benefit from the use of FPGAs. It will then delve into the fundamentals of how they work, before introducing some interesting FPGA solutions and development kits.
Why use FPGAs?
There are a wide range of computing applications, each of which may be best served by a different approach, including off-the-shelf microprocessors (MPUs) and microcontrollers (MCUs), off-the-shelf graphics processing units (GPUs), FPGAs and custom system-on-chip (SoC) devices. Deciding which one to use requires a close look at the application requirements and considerations.
For example, when working on the cutting edge of technology, like 5G base stations, designers need to consider that the underlying standards and protocols are still evolving. This means that designers need to be able to respond quickly and efficiently to any changes in specifications that are beyond their control.
Likewise, they need the flexibility to respond to future changes in standards and protocols that occur after the systems have been deployed in the field. Similarly, it is also necessary to be able to respond to unexpected bugs in system functionality or holes in system security, to modify existing functionality, or add new functionality in order to extend the life of the system.
While the highest performance is typically provided by an SoC, this route is expensive and time consuming. Furthermore, any algorithms that are implemented in the fabric of the chip are essentially ‘frozen in silicon’. This inherent inflexibility becomes a problem given the considerations outlined above. In order find the sweet spot of optimum performance and flexibility, an alternate route is required. That route is often provided by FPGAs, combinations of microprocessors/microcontrollers and FPGAs, or by FPGAs that boast hard processor cores as part of their fabric.
What are FPGAs?
This is a tricky question, because FPGAs are many things to many people. Also, there are many different types of FPGAs, each with different combinations of capabilities and functions.
At the heart of any FPGA – the defining aspect of ‘FPGA-dom’, as it were – is its programmable fabric, which is presented as an array of programmable logic blocks (Figure 1a). Each of these logic blocks contains a collection of elements – including a look-up table (LUT), a multiplexer and a register – all of which can be configured (programmed) to act as required (Figure 2).
Read the full tutorial article in EPDT's February 2021 issue...
Contact Details and Archive...