Harnessing Programmable Devices

In a typical electronic product today, much of the ‘intelligence’ is embodied in the embedded software running on a microprocessor. Consider then the impact of the emergence of low-cost, high-capacity programmable devices such as FPGAs. These allow the intelligent portions of the design to encompass not only software in the traditional sense, but the soft-wired blocks of hardware implemented inside an FPGA.

Altium Designer is unique in that it allows you to change the way you think about developing electronic products and fully exploit the potential offered by today's large-capacity programmable devices. By unifying FPGA design and software development and using the programmable fabric of an FPGA as a system platform, you can work within an easily updateable soft realm where you can change software and hardware with equal ease.

The recent emergence of low-cost, high-capacity programmable devices such as FPGAs is redefining the boundaries between software and hardware, and leading to shift in how designers think about adding intelligence to their products.

Programmable devices such as FPGAs continue to rapidly increase in power and capacity as costs for the devices plummet. Rather than just embedded software, you can now imbue your products with true ‘embedded intelligence’ spanning both software and programmable hardware.

By moving functionality from the board into programmable hardware, you can shorten design cycles while adding functionality with little or no increase in manufacturing costs. The software, processor and peripheral hardware can all be moved inside the FPGA. All are easily changeable because the entire system exists within a ‘soft’ realm. In this scenario critical design decisions do not have to be locked down until later in the design cycle, and the entire intelligence of the product can be easily updated right up until the product ships – or even beyond.

The bottom line is the move to a ‘soft’ design paradigm gives you the freedom to approach electronics design in a new way, a way that provides complete flexibility in functional implementation and opens the door to creating more intelligent products in shorter time frames and with lower production costs.

With Altium Designer you can take ready-to-use FPGA-based components and wire them together at the block level within Altium Designer's schematic editor to create the circuit design.

Extensive FPGA component libraries

To facilitate this graphical approach to FPGA design, Altium Designer includes extensive libraries of ready-to-use FPGA components. Components range from generic logic functions such as counters, multiplexers and various logic gates, right through to complete 32-bit processors and high-level peripheral devices – all you need to create the entire system functionality of your design.

FPGA components are supplied as schematic symbols linked to sets of pre-synthesized, pre-verified models suitable for implementation on any FPGA device supported by the system. The components are supplied on a royalty-free basis, eliminating the difficulty of sourcing FPGA-based IP from external suppliers and allowing you to concentrate on the task at hand – using the components to create your designs.

Within Altium Designer, the ability to simply drag components from a library and wire them together to create the FPGA design means that you can work at the high level of abstraction with programmable devices. You can harness the potential of programmable devices without losing the convenience of working with off-the-shelf, ready-to-use components.

Target any FPGA

Altium Designer is a completely FPGA vendor-neutral design environment. Use the supplied components to construct your system functionality and you can target the design to a wide variety of FPGAs from multiple FPGA vendors. This gives you complete freedom in the specification of your target devices.

What’s more, with Altium Designer there is no need to settle on any particular target device before you start a design. The system allows you to easily retarget your design during development to any suitable FPGA supported by the system.

Perhaps the most important advantage is that with Altium Designer you are not locked in to any particular FPGA vendor or device family. As new devices are released, or as device availability and cost fluctuate, you have the freedom to migrate your design across devices to capitalize on opportunities and avoid potential risks.

Mix HDL and schematic capture

The wide range of FPGA components supplied with Altium Designer will allow you to create most, if not all, of the system functionality you require. But there will always be occasions when you need to create custom IP blocks yourself, or define particular logic functionality using a hardware description language.

Altium Designer supports the use of both VHDL and Verilog to capture design logic and allows you to easily incorporate HDL source files within your overall system schematics. Altium Designer’s fully-featured code editor supports syntax highlighting for both VHDL and Verilog code, providing a complete HDL development environment.

With Altium Designer you can use HDL to capture as much or as little of the design as you need. You have complete freedom to mix VHDL and Verilog sources with schematic-based FPGA components to create your overall system definition. This allows you to choose the most appropriate capture method for each step of the design process.

Test using FPGA-based virtual instruments

To test the overall functionality of your design, Altium Designer provides you with a set of FPGA-based virtual instruments that can be used in an analogous way to bench test instruments at the board level. This allows you to probe and stimulate interconnections within the system running on the programmable device. The virtual instruments are incorporated in your design at the schematic level and connected to the appropriate nets within the design.

When the design is processed and downloaded to the programmable device, the Altium Designer system communicates with the instruments via a secondary JTAG chain established within the FPGA. Soft front panels then allow you to stimulate and interrogate your circuit interactively, allowing you to debug problems and verify circuit performance. You can then make changes to your design, reprocess it and repeat the testing.

With its extensive range of virtual instruments and interactive test environment, Altium Designer brings the convenience and speed of board-level debug to the FPGA design process and allows you to work interactively with FPGA components during system development.

The rise of the microprocessor revolutionized electronics design by allowing functionality to be moved from the hard-wired constraints of the board to the easily changeable realm of software. This allowed the ‘intelligence’ of the product to be separated to some degree from the underlying hardware, and provided a development methodology that allowed more features and functionality to be embedded into the product without increasing the hardware cost, component count or board real estate.

Choose your processor platform

Altium Designer offers you a wide choice of processor platforms, allowing you to work with a range of soft processors or hybrid hard-processor/FPGA devices. This means you can choose the appropriate execution platform for your specific application.

Altium Designer comes supplied with a versatile 32-bit RISC soft processor – the TSK3000 – and a range of general purpose 8-bit soft processors (PIC, Z80 and 8051 compatible instruction sets). These processors are target-independent and can be used on any suitably-sized FPGA device supported by the system. Like all Altium Designer FPGA components, the processors are supplied pre-synthesized for a wide range of target devices.

Altium Designer’s TSK3000, internally based on the Harvard architecture, features a simplified memory structure and sophisticated interrupt handling to make coding simpler. It has been specifically designed to simplify the development of 32-bit systems targeted for FPGA implementation and to allow the migration of existing 8-bit systems to the 32-bit domain with relative ease and low risk. The processor also simplifies the connection of peripherals with support for the Wishbone microprocessor bus.

Third-party processor support

Altium Designer supports a range of soft processors supplied by major FPGA device vendors. Because these processors are targeted and optimized for specific FPGA device families, these processors can offer a higher level of performance, but lock you in to specific target FPGAs. The Altium Designer system includes special schematic-based components that provide direct access to these vendor-specific soft processors from within the Altium Designer environment. This allows you to work with these processors in the same way that you design with the native Altium Designer soft processors – simply place the components from the libraries to construct your system.

In a similar way you can target hard processors within hybrid processor/FPGA devices, or discrete processors coupled to an external FPGA. Altium Designer provides ‘wrapper’ core components that are implemented within the FPGA to interface to the processor. This gives you full access to the power and performance of these devices from within the Altium Designer environment.

Easily modify or change the execution platform

In traditional board-level design flows, the hard-wired execution platform is defined and fixed early in the design process. The processor is selected, the peripherals specified and the partitioning of functions between hardware and software is tied down at the start of the design cycle to allow prototype hardware to be manufactured and software development to proceed. Discovering late in the design cycle that you need to implement a function in dedicated hardware because the processor is running out of steam can mean major re-engineering and extensive delays in manufacturing new prototype boards. This can play havoc with release schedules.

Altium Designer has been created to overcome these barriers and give you complete freedom to change both the software and the execution platform that it runs on throughout the development process. It does this by allowing you to harness the potential of large-scale programmable devices to provide a soft-wired execution platform in which the processor, peripheral devices and glue logic can all be easily changed and reconfigured ‘on-the-fly’ to accommodate design modifications.

Because Altium Designer provides hardware- and software-level compatibility between processors and lets you work in a consistent way regardless of the target, you are free to choose the appropriate processing platform for your specific application. If necessary, you can even change processors during development with minimal system re-engineering.

Connect processor peripherals

Altium Designer simplifies the connection of processors to peripherals and memory by making extensive use of the Wishbone bus, an open source standard that has been specifically designed for processor/peripheral interconnect within a chip.

The Altium Designer FPGA component libraries include configurable Wishbone interconnect components that can be used to connect both peripheral devices and memory to the processor core at the schematic level. Once placed, you can configure these devices directly on the schematic sheet, adding and defining devices as needed. The schematic symbol is automatically updated to include the defined sets of connections. You can then simply add Wishbone-compatible peripheral and memory controller devices from the supplied FPGA component libraries to complete the processor system.

The ease and simplicity that the Wishbone bus brings to system configuration allows you to rapidly define system functionality, and lets you reconfigure or add hardware functionality to the execution platform at any stage of the development process.

Develop and debug embedded software

Altium Designer’s unification of the electronic product development process extends to the creation of embedded software running on FPGA-hosted processors. From within the Altium Designer environment you can create and edit your code, compile and simulate your program and undertake complete source-level debugging on the target system.

Altium Designer includes full compiler tool chains for all supported processors. The compilers are based on Altium’s advanced Viper compiler framework, which provides fast, highly-optimized code that is finely tuned to the target processor architecture. The Viper technology provides C-level code compatibility across all processor platforms, allowing you to easily migrate your application code between processors. This complements the hardware-level processor compatibility and facilitates complete system migration between different execution platforms.

All Altium Designer processors feature on-chip debug capabilities. When the design is downloaded to a suitable FPGA development board, such as Altium’s NanoBoard, Altium Designer communicates with the processors via a secondary JTAG communications chain established within the FPGA. You can then debug your software from the source code or disassembly view, with full control over processor execution. Altium Designer natively supports the simultaneous debugging of multiple processors, allowing independent debug sessions for each processor running in the design.

Altium Designer allows you to connect live to the programmable elements within your design, and interact with the system under development.

One of the problems of designing with programmable devices is that it’s difficult to visualize what’s going on inside the device. While you can monitor the pins of the device, you have no physical access to the signals with the operating circuit. You are effectively disconnected from the design.

A unique aspect of Altium Designer is that it allows you to connect live to the programmable elements within your design, and interact with the system under development. With the addition of a LiveDesign-enabled development board, such as Altium’s target-independent NanoBoard, you can process and download the design to the FPGA and dynamically interact in real-time with active devices such as the processors and Altium Designer’s virtual instruments. Working in this way you can take an interactive and iterative approach to the design of systems within FPGAs, minimizing the traditional reliance on simulation. Altium calls this process LiveDesign.

To manage the LiveDesign process, Altium Designer provides a centralized interface from which you can process and synthesize your project, transparently invoke the FPGA vendor tools for device-specific mapping and routing, and download both the hardware and software program files to the target devices.

Once programmed, you can interact with active devices through the interface. You can monitor and set signals within the FPGA-based system using virtual instrument ‘soft’ control panels, and initiate software debug sessions for all processors running in the system. As you make changes you can reprocess and download the new software or hardware and immediately see the effect of the changes.

At the pin level, you can monitor the I/O status of the target programmable device and dynamically reflect this status to the source FPGA project schematics. Altium Designer can also provide a live display of the pin status of FPGAs from within the PCB editor. By providing the appropriate connections on your PCB design, you can even connect your prototype or production board to the system via the NanoBoard and continue the LiveDesign process on your target hardware.

The interactive nature of the LiveDesign process brings the entire development process to life, and allows you to rapidly develop and debug FPGA-based systems. Altium Designer gives you the power to reach into and control the programmable elements of your design, and connects you ‘live’ to your system during development.

Go back to the Altium Designer 6.0 Product Overview or select a process from above.