Making FPGAs work for embedded developers - Part 2 - Embedded.com

Making FPGAs work for embedded developers – Part 2

The key to unlocking the potential of FPGAs lies in breaking down thetraditional barriers between software and hardware design. Currentlythe FPGA design process is considered separate from the softwaredevelopment process, and indeed both tend to be isolated from theboard-level design flow. Most developers think about the overallelectronic product design in terms of separate board, FPGA and softwaredesign disciplines and the design tools we use reflect this separation.

FPGA design has developedas a specialized design discipline with a work flow that has evolvedfrom chip design methodologies. From an embedded perspective this tendsto place FPGAs in the hardware design camp and makes them of little useto those creating the real intelligence of the embedded system ” thesoftware.

But FPGAs really straddle the divide between software and hardwareand, as such have, the potential to become part of the embeddedintelligence of an electronic product, not just a platform to host it.Indeed it is only when we start looking at electronic productdevelopment as a single process that we can really see the 'bigpicture' represented by programmable hardware technology.

Rather than treating embedded software development as separate fromhardware design, programmable device technology allows developers toreach into and change the system hardware interactively as they developthe software. The hardware is no longer a fixed platform. In essence,system optimization can encompass both the hardware and software, withboth the platform and the embedded software running it open toon-the-fly reconfiguration.

Design unification is the key
Of course achieving this level of hardware/software unification is notsimply a matter of changing the way we think about the design process.In order for developers to exploit the potential offered byprogrammable design the design tools we use must support the process.To effectively allow automation across traditionally disparate designdisciplines, design systems themselves must support the unification ofhardware, software and programmable hardware development.

Figure2a/2b: Unifying hardware design and software development allowsembedded developers to influence and modify the underlying systemhardware during software development without having to become hardwaredesigners themselves.

This goes beyond simple integration of separate design editors. Thedesign system must, at a fundamental level, support all of theprocesses necessary to design both hardware and software. Toeffectively hide the hardware design process from embedded developersyet allow them to effectively change the underlying hardware platform,the design tools must intimately link code development with hardwaredescription.

From the other side, board level designers must be able to create aphysical platform that makes use of programmable devices to abstractprocessor and peripheral device connection without having to deal withthe complexities of the FPGA device itself.

What needs to happen then is that the currently disparate designtools that support hardware, software and programmable hardware designmust be unified within a single environment in order to make full useof the potential of FPGAs as an embedded development platform. But whatwould unifying design entail and how would this be implemented at adesign tool level?

A unified hardware design framework
A fundamental requirement of a unified design system is that it allowsdevelopers to easily and consistently manipulate both discrete and'soft' FPGA-based hardware.

This can be done by moving away from the traditional HDL-basedapproach to FPGA design and extending the concept of ready-to-use,off-the-shelf component-based design toprogrammable devices. In suchan environment, system components implemented inside the FPGA aredescribed using the same methodology and language used to describe theboard-level circuitry.

Figure3: Unifying hardware and programmable hardware design allowslarge-scale FPGA devices to effectively be used by board-leveldesigners to construct embedded systems using familiar component-basedgraphical design methodologies

By using extensive libraries of pre-synthesized, pre-verifiedIP in the form of 'soft components', developers can define systemfunctionality inside the FPGA using a graphical block diagram orschematic approach. Indeed within a unified environment a singleschematic editor can be used to capture both board and FPGA-levelcircuitry, eliminating the overhead of separate design capture systemsfor discrete and programmable circuitry.

The use of pre-synthesized blocks of logic ” components ” ratherthan HDL-based source libraries has several advantages duringdevelopment. Firstly, the blocks are treated as 'black boxes' duringhardware synthesis, allowing this process to proceed very quickly.Secondly, like their discrete counterparts at the board level,FPGA-based component blocks are ready to use and require nounderstanding of the underlying code structure in order to make themwork. While the logic behind the components can be complex, thedesigner only needs to understand the basic function in order to usethem.

Figure4: Providing extensive libraries of ready-to-use, pre-synthesized andpre-verified IP in component form streamlines the development ofsystems within FPGAs and allows the construction of hardware that istransportable between FPGA devices and architectures.

Also, if the component blocks are pre-synthesized and pre-verifiedfor a wide range of FPGA architectures, the designer can createapplications that are independent of the target FPGA device. Thisallows design transportability and eliminates the need to becomeintimate with the particular FPGA architecture you are targeting.

Providing a single design environment for both discrete andprogrammable hardware can also provides benefits derived from the closelinking between the two types of projects. For example, I/O definitionand pin assignment can be synchronized automatically, and developersdoing board-level routing can take direct advantage of the pinreprogramability of FPGAs to optimize device pinout for routing.

Unifying hardware and softwaredesign
From an embedded designers perspective, a unified environment willallow the direct linking of software development with the design of theunderlying hardware platform. This is important because devicesimplemented inside the fabric of the FPGA are easily updateable duringdevelopment in a similar way to traditional software. This will allowembedded developers to choose hardware and software solutions to designproblems with equal ease.

A practical implementation of this would involve the inclusion inthe FPGA hardware system of components whose function can be specifiedfrom the embedded software during compilation. The developer wouldspecify particular C functions that should be executed in hardware andthe unified compiler would then create the hardware description filesnecessary for synthesis, as well as compiling the remaining code andautomatically adding the appropriate instructions necessary foraddressing the functions moved into hardware.

From a designers perspective this process would be completelytransparent ” they simply check option boxes to determine whetherparticular functions are executed by the processor or directly inhardware. Effectively the programmer is creating dedicated coprocessorson-the-fly during code development.

The practical advantage is that developers can interactively try ourdifferent implementation strategies without the need to involvehardware engineers or endure endless waits for updated prototype boardsto be manufactured just to see whether the performance gains have beenachieved. In essence hardware and software generation simply becomeoutput options of the unified compiler.

Figure5: Perhaps the most exciting prospect for embedded developers usinglarge-scale FPGAs is the potential to transparently move selected Cfunctions between software and hardware, opening the way for on-the-flyrepartitioning of application functionality and on-tap hardwareacceleration.

Turning development on its head
Perhaps the most powerful aspect of a unified approach to embeddeddevelopment is the ability free the designer from having to lock downcritical design elements early in the design cycle. The processor,peripheral devices and target FPGA can all be changed relatively easilyduring development, as can the partitioning of functions betweensoftware and hardware. This allows the design process to be approachedin a completely new way.

For example, let's say we are designing an application that puts amoving 3D image ” a corporate logo for instance ” on a screen. In aunified environment the hardware engineers would create a basichardware platform consisting of processor, generic coprocessor, memory,keyboard input driver and a display driver using ready-to-use FPGAcomponents picked from a library and connected together in a schematicdiagram.

Within the unified environment we would link our embedded project tothe hardware design and automatically transfer I/O and memory mappingsfrom the schematic, as well as automatically loading any softwarelibraries containing driver code for the peripherals used.

When we have finished writing your code we can download the hardwareand software to a suitable FPGA-based development board for debugging.If we find the graphics rending is too slow, we can configure thecoprocessor to execute the 3D to 2D mapping functions in hardware byselecting the functions from a list in the component configurationdialog. If necessary we can also go back to the schematic and changethe processor type from a soft core to a discrete device to gain someextra speed.

Figure6: In a unified design environment crucial design parameters such asperipheral and memory address mapping can be automatically propagatedbetween the hardware and software development processes.

The bottom line is that system hardware no longer needs to be fixed.Development can start with a default platform and then evolve to meetchanging requirements as the system is developed. This eliminates theneed to scrupulously define hardware at the beginning of thedevelopment cycle ” when system requirements are not fully known! ” andprovides the freedom to alter the hardware to meet the needs of thesoftware as it is developed.

The rise of embedded intelligence
The emergence of cost-effective large-scale FPGAs has set the scene forembedded developers to embrace and exploit the potential offered byprogrammable devices.

With the right development environment and a unified approach todesign, the large reconfigurable design space offered by current FPGAsenables a new approach to be taken to embedded systems and allowsdesigners to revolutionize way electronic products are created. Thisrevolution is shaping up to rival that of the software-based designparadigm enabled by the introduction of microprocessors themselvesseveral decades ago.

A unified design environment will allow developers to combinesoftware and programmable hardware in order to create smarter productsfaster. Rather than having the intelligence of the product residecompletely within the software, developers can make use ofreconfigurable logic to create embedded intelligence that combines bothsoftware and hardware portions.

Designers are free to choose the best implementation path for anyparticular algorithm and control how functions are executed withouthaving to explicitly define fixed hardware for signal processingfunctions. What's more, they are free to modify the way code isexecuted ” even to change the underlying processor ” on-the-fly duringdevelopment.

Perhaps most importantly, a unified design system will allowembedded developers to exploit the benefits of programmable deviceswithout necessarily forcing them to become hardware designers. In thesame way that C itself once opened up embedded development to virtuallyall engineers, unified design environments will open up FPGA-based'soft' system design to all embedded developers.

To read Part 1 in this series, go to ” Thelimitations of current FPGA tools in  embedded systems design.”

Rob Irwin is Product Manager forthe Altium Designerat Altium Limited. He has a Bachelor of Engineering (Electrical) fromthe University of Sydney, Australia, and over 20 years experience inthe electronic design industry.You can reach Rob at rob.irwin@altium.com.au.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.