Home/Glossary/FPGA Design
Semiconductor knowledge

FPGA Design

The development of digital logic for a field-programmable gate array. FPGA tools map a hardware description into the device's configurable logic, memories, interconnect and dedicated resources.

← All glossary termsTechnical guide · 6 min read
In this article

The development of digital logic for a field-programmable gate array. FPGA tools map a hardware description into the device's configurable logic, memories, interconnect and dedicated resources.

An iterative ASIC development flow
Reviews and feedback connect the stages. This conceptual flow is not a fixed project schedule.

Designing for a configurable device

An FPGA contains programmable logic and routing together with device-dependent memories, arithmetic blocks and interfaces. FPGA design maps an application onto those resources. It shares hardware-description and verification practices with ASIC development, but its implementation target is a premanufactured device. This changes architectural choices. A memory organization that fits an FPGA block RAM can be efficient, while another organization may require many small resources or additional cycles. Start by connecting the system requirements to the actual resources and interfaces of the selected device family.

Clocks, interfaces and implementation

Clock planning deserves attention before the logic is large. Identify independent clock domains, define how data crosses between them and choose appropriate reset behavior. Interface timing must match the surrounding board and connected devices. Pin assignments, voltage banks and clock-capable pins can restrict implementation choices. Synthesis success alone does not establish that these constraints are satisfied. Review implementation reports, timing paths and resource utilization together, because an apparently small change can alter placement, routing or the availability of a dedicated hardware resource.

Verification at useful boundaries

Simulation checks expected behavior and difficult corner cases without requiring a physical board. Hardware testing then adds real interfaces, software, clocking and environmental conditions. Neither should be treated as a substitute for the other. A board demonstration may exercise only a narrow set of inputs, while a simulation model may omit a real-world electrical interaction. Build tests around observable requirements and preserve the configurations used. If a fault appears only after a long run, include diagnostic counters and status information that can help distinguish its cause.

Prototyping and production use

An FPGA can be the final product or a development platform for a later ASIC. Those goals lead to different optimization priorities. A production FPGA design can use vendor-specific features directly; an ASIC prototype may need wrappers around those features and a strategy for replacing them. Keep portable application behavior separate from device-specific infrastructure where practical. Decide which aspects the prototype validates, such as software interaction or datapath functionality, and which remain unproven, such as ASIC timing, analog behavior or final power consumption.

Questions about FPGA projects

Does an FPGA prototype prove that an ASIC will work?

It provides valuable evidence about selected functions and software interaction. It does not prove ASIC physical sign-off, process behavior, package performance or every production test requirement.

Should every design avoid vendor-specific blocks?

No. Dedicated blocks can be valuable in a product that remains on the FPGA. Portability is a project decision with engineering costs; it should follow the expected lifecycle rather than an absolute coding rule.

Requirements that can be checked

Turn each important behavior into a requirement with an observable result. Describe valid inputs, invalid inputs, ordering rules, throughput expectations and the response to interrupted transactions. Identify which clocks and resets are involved. A good review asks whether another engineer could write an independent test from the description. Where the answer is unclear, improve the requirement before adding more implementation detail. Keep assumptions about the surrounding system visible, including how long an interface can stall and whether input data can arrive while a block is unavailable. These details determine whether the implementation and its test environment are solving the same problem.

Verification across normal and unusual operation

Check ordinary workloads alongside stressful combinations of events. Reset during activity, a full queue, simultaneous requests and an error response can expose behavior that an ideal sequence misses. Use appropriate simulation, assertions or formal methods for the properties being examined. Preserve reproducible inputs and expected results. If a check is excluded, record why and who reviewed the decision. Coverage helps organize evidence, but its interpretation depends on what the tests actually check. A regression that executes many cycles without observing meaningful outcomes can provide less confidence than a smaller set of well-targeted checks tied to requirements.

Implementation handover

The source design needs constraints, technology assumptions and integration context before a receiving team can use it reliably. Include the intended operating modes, clock relationships, IP versions and any known limitations. Check that source files, models and reports describe the same configuration. Define how changes are communicated while implementation is in progress. When physical results challenge an assumption, route the finding back to the responsible architecture or logic owner. A controlled handover keeps the project from optimizing an obsolete version or interpreting an undocumented exception as an intentional requirement.

Evidence for the next decision

Separate predicted results from measured behavior and state the conditions behind both. An early synthesis estimate can support architecture exploration, but it is not equivalent to a final implemented result. A prototype can support software integration without proving final ASIC timing. Before a release, identify the evidence required for the particular stage and list unresolved issues with owners. Preserve the approved revision and enough context to reproduce the relevant checks. This makes later debugging, engineering changes and product maintenance more efficient than relying on a single successful run whose inputs are no longer clear.

Primary reference for further reading

A practical cross-discipline review

Before committing the next stage, bring the design, verification and product-engineering owners together around the same revision. Confirm the assumptions that pass between them: operating modes, interfaces, test access and the evidence expected at release. List unresolved issues with a responsible owner and a concrete way to close them. An open question is easier to manage when its consequence is understood than when it is hidden inside a general progress estimate. Preserve the decision record so a later change can be evaluated against the original reasoning. This review is useful even for a narrow specialist task, because the surrounding product still determines whether the delivered result is usable.

Include the receiving team's acceptance question in the review: what must be demonstrated before this result can be used safely in the next engineering stage? Agree how that demonstration will be recorded and how a subsequent change triggers a focused reassessment of the affected evidence.

Explore the related Avnet offering or discuss your project requirements.

Let's talk about your next project.

Explore design, technology enablement and manufacturing with Avnet ASIC Solutions.

Contact our team →