Logic architecture
Partitioning between logic and software, clock domain planning and resource budgeting before RTL is written.
T · [CLIENT TO PROVIDE] E · [CLIENT TO PROVIDE]
Overview
An FPGA adds cost, power draw, board complexity and engineering effort. It is worth it when a function genuinely cannot be done well in software: hard deterministic timing, many parallel channels, high-rate data handling, or an interface no available processor supports.
We approach FPGA work as part of the system rather than as an isolated deliverable. What belongs in logic and what belongs in software is a partitioning decision made early, with the interface between them defined and documented.
RTL is written to be readable and verifiable, timing constraints are stated rather than inferred, and verification is planned alongside the design so timing closure is not a discovery at the end.
Decision
Use logic when
Use software when
FPGA scope
Functions chosen because logic is genuinely the better implementation.
Partitioning between logic and software, clock domain planning and resource budgeting before RTL is written.
Synthesisable design written for clarity and verification, with the intent documented alongside the implementation.
Interfaces between devices, buses and protocols that no available processor peripheral supports directly.
Simultaneous channel acquisition and processing where a sequential processor cannot keep up.
Constraints defined properly, timing analysed against them and the design adjusted until the result is reproducible.
Simulation and on-hardware verification planned from the start, so behaviour is confirmed rather than hoped for.
Logic process
An FPGA project succeeds or fails on the decisions made before the first line of RTL.
What belongs in logic, what belongs in software, and the interface contract between the two.
Family and part selected on resource requirements, I/O, power, toolchain and long-term availability.
Clock domains, data paths, memory usage and resource budget defined before implementation starts.
Design written module by module, each simulated as it is built rather than at the end.
Logic integrated with the processor system and the surrounding hardware, with the interface exercised.
Constraints applied, timing analysed and the design refined until results are consistent across builds.
Behaviour confirmed on real hardware under representative conditions and data rates.
Applications
Used selectively, programmable logic solves problems that are awkward or impossible in software alone.
FAQ
Questions that decide whether programmable logic belongs in a design.
Usually it comes down to one of three things: timing a processor cannot meet, parallelism a processor cannot sustain, or an interface no processor supports. If none of those apply, software on a capable processor is normally cheaper and easier to maintain.
Yes. The critical piece is defining the interface between logic and software early — register map, timing, error behaviour — so both sides can develop against a stable contract.
Yes. Simulation-based verification and on-hardware verification are planned alongside the design. The depth is agreed per project based on the risk and complexity of the function.
Device selection includes availability and lifecycle review, since FPGA supply has been volatile. Where a family is a risk, that is flagged during selection rather than after the board is built.
Related
Describe the timing, the data rate and the interfaces. We will tell you honestly whether logic is the right answer.
System architecture across hardware and software.
Open →02Architecture, circuits and board-level design.
Open →03Deterministic scheduling and real-time control.
Open →04Stack-up, placement, routing and integrity.
Open →05Verification across hardware and firmware.
Open →Next step
Tell us what the product has to do and we will tell you what engineering it needs.