Intelligent peripherals relieve a system's CPU of a lot of work that would have been done in software, so a system built of them can offer higher performance and new features. In addition, if the system is designed to take advantage of intelligent peripherals, it's likely the software effort can be reduced.
Systems built from FPGAs become perfect places to implement phased-in hardware or functions with makers selling base-level hardware and offering updates via the Web. They can be further enhanced by using the concept of "logic upgrade," analogous to the SDRAM DIMM upgrades of today. A company offering systems built this way and using intelligent peripherals can sell products that have long life and profitability.
The choice of implementation may also affect the decisions that a system engineer can make. For example, if the engineer knows that the logic functions in a gate array or standard cell must be implemented, then it is impossible to field-upgrade the system unless hardware elements are physically replaced. Some companies capitalize on this idea with planned obsolescence — that is, forcing the customer to buy a new product or upgrade it periodically — so that if they can make the initial sale, they have a high probability of gaining more revenue.
If the system engineer can use field-programmable logic such as the Xilinx Virtex series of field-programmable gate arrays (FPGA), there are new ways to update the product at the customer's site. This paradigm already exists — for example, the use of E2PROM in 56k modems. Almost every manufacturer of such modems incorporates a flash E2PROM to permit the software to be updated in the field because the 56k standard was evolving even as the products were being shipped. Customers could then pull software updates off the Web and use a "flasher" application to write the update into the flash E2PROM. This same technique also allows the manufacture of future feature enhancements.
The primary difference between the flash E2PROM and the FPGA is that the software can be updated with E2PROMs, while it's the hardware (and possibly software) that's updated with FPGAs. This reconfiguration of the hardware is a serious advantage to system companies that require fast time-to-market. The best use of the FPGA in this context may be to allow room for features to change or for various performance improvements later in the field. In fact, companies already use these kinds of techniques to offer product enhancements by downloading new "hardware" off the Web.
The consideration for the system designer then is to evaluate a variety of factors. One important one is what can be left off the initial product while leaving room in the FPGA to add more functionality. For example, perhaps 3-D graphics acceleration is not required when the product is introduced. This could be left off and added via an update. Thus, if time-to-market is more critical than the features supported, the FPGA offers the required flexibility.
Another important consideration is what features might need to change. If the system is emerging along with an industry standard, the hardware can be modified in the field to fit the final standard. Still another criterion to evaluate is the cost difference between adding hardware in the field and simply updating it. While it may seem obvious to ship with a standard-cell logic component instead of an FPGA, the cost of one against the other is not simply the unit cost of the devices: The cost over its expected lifetime must also be evaluated. This leads to another important factor to consider: product life expectancy. In general, products with FPGAs have a longer life than those that utilize nonfield-programmable solutions. Accordingly, the system engineer must evaluate the system's lifespan, including any planned upgrades.
The FPGA represents another major area in which the system designer can implement intelligent peripherals and better systems. It permits the optimum mixture of future expansion at low cost that echoes the software-distribution model. Because hardware code can be distributed for FPGA-based systems as easily as software, it will continue to gain acceptance as an effective means for building good, future-proof, systems.
FPGAs also permit various changes that can occur as a function of the system during its operation. In this case, the FPGA can be reconfigured during the operation of the system to affect different hardware.
An example of such a structure is the need to alter a DSP algorithm. Since modern FPGAs offer features like partial reconfiguration, these kinds of hardware modifications are now possible on-the-fly. The system engineer would need to identify the management process for reconfiguring the FPGA to update the hardware portion. One key advantage in systems built utilizing this principle is the possibility of using a smaller device to perform a larger set of functions. These kinds of on-the-fly algorithmic changes are not really possible with conventional standard-cell or gate-array architectures.
Another avenue that is opened by the combination of FPGAs and intelligent peripherals is highlighted by a DSP done in an FPGA. In the past, very high-performance DSP CPUs have been required to perform various functions.
Today, those same functions can be done with an 80C51 and an FPGA. By using the FPGA to implement the intelligent peripheral, it is possible to put together a high-performance system that is very highly integrated and easily updatable.
