PCB Tech - Why embedded developers should use FPGAs

In a field, if the only constant is change, then there is no need to review the development and changes of electronic technology and design methods to witness how changes enable design engineers to create the next generation of innovative products. After the large-scale application of microprocessors, new inexpensive and high-quality technologies have opened the door to the design of innovative software-based electronic products. This is a good example. In short, after transferring the main element of design-here is the control "intelligence"-into the soft domain, design engineers can create better, smarter, and cheaper products in a shorter period of time.

This change means that embedded software developers are the main drivers of today's definition of the functions and characteristics of electronic products, and will eventually produce hardware. The success factor of this method lies in the reduction of hardware complexity and the open flexibility brought by the transformation of the control elements of the design to the programmable field.

Today, the arrival of high-capacity, low-cost programmable devices has brought the same hope to the development of electronic product design, because it has become possible to define the system hardware itself in the soft field. Large-scale devices such as large-capacity FPGAs are ideal for meeting this demand. These periods can generally be used to construct large parts of the system peripheral logic function blocks, including bus interfaces, I/O blocks, and even memory. The introduction of a large amount of logic into the FPGA field has a profound impact on hardware development and opens the door to a new era of'soft' design, which provides unprecedented flexibility for design and has unlimited potential to reduce board size and complexity .

Although it has the potential to revolutionize the electronic product development process, most embedded software developers still work as before-choose discrete hardware processors at the beginning of the design process, create a physical platform, and then write software Use the platform. People's lack of exploration in the "soft" and hardware fields of embedded system development is mainly due to the lack of tools for C programmers to use their skills at the programmable hardware level. Indeed, most of the current FPGA design flows mainly come from the field of chip design and require very professional skills.

Take soft design to the next level

To go beyond FPGA glue logic applications requires a broader vision, including making full use of programmable devices and introducing as much hardware as possible into the soft domain. This includes the introduction of processor functions themselves. Today, soft processors in FPGAs are increasingly being transformed into embedded platforms. Fundamentally speaking, switching to a soft processor with FPGA will bring the advantages of structural flexibility, smaller board size, and simpler. But deeper applications will bring more attractive advantages.

When the programmable feature of FPGA is used to obtain the abstraction layer on the top of the processor, it opens up infinite possibilities for embedded developers, not only to realize the abstract level design in software, but also in hardware. Imagine a system where the processor is connected to its memory and peripherals through configurable hardware (essentially a hardware package)-this abstracts the interface of the processor. Simply reprogramming the FPGA changes the hardware package, and the system designer can easily change the processor core, or even switch between hard and soft processors, without modifying other system hardware. From a system perspective, all processors are similar, which simplifies the hardware design process. Of course, extending this to the field of application software also requires a compiler that can provide C-level compatibility between processors.

The advantage of this system is that there is no need to make a choice of the processor "in advance". The system may be developed using a certain processor, but the development stage found that higher performance was needed and faster devices were used. Due to the wrapping layer, the processor can be soft, hard, or even the hardware processor core inside the FPGA, without affecting the surrounding hardware, because the conversion layer only creates a standard interface for connecting peripherals. In fact, the connection of the peripheral device itself can be abstracted in the same way. In this scheme, FPGA provides universal connectivity for all components of the embedded system, and effectively becomes the system interconnection structure. In other words, it effectively becomes the "backbone" of the standard interface, and both hardware and software can easily communicate with the processor and peripherals.

Finally, the introduction of a transparent wrapper on the processor will create an FPGA-based development environment that provides true processor independence. The speed of software and hardware development has increased, processor selection can be carried out in the later stages of the design process, and effective software/hardware co-design becomes possible.

Convert between software and hardware

An extension of the idea of creating a processor and peripheral wrapper layer in configurable hardware is to automatically generate application-specific system hardware and execute software algorithms in the hardware-a kind of ‘own’ hardware coprocessor.

The idea of directly generating hardware from C code is not new. Several systems have been implemented. The idea up to now is to create a complete system hardware through a C-like language. In essence, this is no different from using HDL (such as VHDL or Verilog) to design FPGAs, requiring software developers to learn and adopt new design methods. What really works for embedded developers is to make the process transparent. The design tool must be able to process the input of standard ANSI C code and convert the functions selected by the programmer into hardware. Not only that, the system must be able to generate all the code needed to use the generated hardware. In this way, embedded programmers offload the dedicated algorithm from the processor to the dedicated hardware without knowing any design details of the underlying hardware.

Use the full potential of FPGA

Obviously, from a tool point of view, making full use of the opportunities presented by programmable devices (such as FPGAs) requires a system that improves the abstraction level of the development process, so that the core elements of the design can be easily changed through similar design techniques and processes. Such a system must be able to unify the entire electronic product development process and integrate the development of hardware, software, and programmable hardware in a single, consistent environment.

Figure 1. Taking full advantage of FPGA's potential means bringing all elements of the design (including hardware and software) to the reprogrammable field.

Altium Designer introduces a simple, high-level processor to achieve this goal, meeting software, FPGA and PCB requirements, and an integrated product development environment that integrates all required processes in a single application (Figure 1). Hardware and software development are unified at the platform level, making rapid software/hardware co-design possible. With FPGA-based processors and processor-wrapped cores, designers can target Altium Designer or any supported third-party processor, while retaining all the features of the design, including easy connection to FPGA peripherals. Altium Designer's Viper-based compiler guarantees C-level code compatibility among all processor architectures supported by the system.

In addition to the potential for rapid product development, the integrated nature of Altium Designer also brings new design and functional possibilities for embedded developers. Altium has also developed a new integrated hardware/software compiler technology, which will be supported by Altium Designer soon. This technology generates highly optimized executable code and concurrent hardware FPGA implementation from standard C code at the same time, and generates the code required to link the two together at runtime. In practice, this means that developers can specify C code functions that are offloaded from the processor to the hardware, and the integrated software/hardware environment of Altium Designer makes the process fast and transparent (Figure 2).

Figure 2. With advanced software tools, embedded developers can influence, modify and debug the underlying system hardware when they become hardware engineers.

Such systems provide embedded developers with the option of selecting system checkboxes to gain the potential for final performance and cost improvements in transferring dedicated software functions to hardware. This allows developers to effectively transfer functions between hardware and software, and continue to integrate on optimized application solutions. An interesting phenomenon worth noting is that software developers who use this feature of Altium Designer and other high-level features (such as embedded package cores and library-based pre-synchronized software components) can effectively use the hardware inside the FPGA mechanism. In short, software engineers using this system can use their existing skills to easily use FPGA hardware without involving the underlying structure of the target device or RTL programming (Figure 3).

Figure 3, the integration of the design flow including hardware, programmable hardware, and software enables FPGA devices to be utilized and create complete embedded systems, and this requires only common technologies.

The combination of Altium Designer's integrated development environment and low-cost large-scale FPGAs allows embedded developers to fully exploit the potential of programmable devices. After using the correct development environment, the large reconfigurable design space brought by the current FPGA makes a new embedded design method possible, and designers can bring revolutionary innovations to the development of electronic products, just like a few decades ago. The introduction of processors has revolutionized the electronics industry.