National Instruments' Business and Technology Fellow Mike Santori discusses how field-programmable gate arrays (FPGAs) are changing the way engineers design, prototype and deploy embedded systems.
What do you see as growing embedded design trends?
In contrast to the escalating use of embedded technologies, few engineers have a lot of embedded expertise, which leads them to search for new tools that can make embedded technology more accessible and easier to use. Traditional text-based embedded programming tools are attempting to simplify the design process by providing reference designs and reusable libraries and drivers, intellectual property (IP) vendors are selling tested and packaged IP blocks for use in traditional system design tools and graphical system-level design tools are providing higher levels of abstraction to design entire embedded systems.
Graphical system design is a modern approach to embedded design that blends graphical programming and flexible commercial off-the-shelf (COTS) hardware to help engineers and scientists more efficiently design, prototype and deploy embedded systems. With this approach, engineers can use a single environment for all design stages to increase productivity, save money and ultimately get a working system or product to market more quickly.
Why are FPGAs growing in popularity?
FPGAs are fundamentally programmable hardware. You get the flexibility of a software-based solution combined with the high-performance capabilities of custom hardware design. With the availability of higher-level graphical design tools, engineers and scientists can use FPGAs to meet demanding performance and timing requirements without being embedded experts. We've seen applications in which FPGAs replace processor-based designs to achieve high processing performance and meet tight timing requirements for control.
Why is IP important for FPGAs?
An FPGA is programmable hardware, which means an engineer writes software to define the functions performed on the FPGA. As engineers design an application, they identify and implement individual functions and operations – commonly called IP. Later, they combine and integrate these IP blocks to form the larger application. Through the process of architecting systems and developing different applications over time, a group or community of developers creates IP libraries representing common operations and reuses them to build future applications more quickly. Besides promoting the reuse of existing code, modular design also increases code testability and maintainability, so developers and designers can focus on application-specific features and code segments.
In the LabVIEW FPGA Module, IP cores consist of subVIs, which are reusable LabVIEW software modules. With IP in the LabVIEW FPGA Module, engineers can implement different functions and operations once, optimize their implementation for the FPGA platform and apply them in different applications to perform a variety of operations.
Download FPGA functions or IP.