Technical illustration of FPGA logic blocks handling parallel data paths and interface bridging
Programmable logic design

Overview

Programmable logic where it earns its place

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

When programmable logic earns its place

Use logic when

  • Timing is beyond what a processor can guarantee
  • Many channels must be handled in parallel
  • An interface has no processor peripheral support
  • Data rates exceed sequential processing

Use software when

  • A capable processor can meet the timing
  • Unit cost and power are the dominant constraints
  • Maintainability matters more than raw throughput
  • The function will change often

FPGA scope

What we do with programmable logic

Functions chosen because logic is genuinely the better implementation.

01

Logic architecture

Partitioning between logic and software, clock domain planning and resource budgeting before RTL is written.

02

RTL development

Synthesisable design written for clarity and verification, with the intent documented alongside the implementation.

03

Interface bridging

Interfaces between devices, buses and protocols that no available processor peripheral supports directly.

04

Parallel data handling

Simultaneous channel acquisition and processing where a sequential processor cannot keep up.

05

Timing closure

Constraints defined properly, timing analysed against them and the design adjusted until the result is reproducible.

06

Verification

Simulation and on-hardware verification planned from the start, so behaviour is confirmed rather than hoped for.

Logic process

From partitioning decision to verified logic

An FPGA project succeeds or fails on the decisions made before the first line of RTL.

  1. Partitioning

    What belongs in logic, what belongs in software, and the interface contract between the two.

  2. Device selection

    Family and part selected on resource requirements, I/O, power, toolchain and long-term availability.

  3. Architecture

    Clock domains, data paths, memory usage and resource budget defined before implementation starts.

  4. RTL implementation

    Design written module by module, each simulated as it is built rather than at the end.

  5. Integration

    Logic integrated with the processor system and the surrounding hardware, with the interface exercised.

  6. Timing closure

    Constraints applied, timing analysed and the design refined until results are consistent across builds.

  7. Hardware verification

    Behaviour confirmed on real hardware under representative conditions and data rates.

Applications

Where FPGAs are the right answer

Used selectively, programmable logic solves problems that are awkward or impossible in software alone.

RTL designSimulationTiming constraintsClock domain crossingProcessor integrationOn-hardware verification
Application 01
High-rate sensor or converter data acquisition
Application 02
Deterministic control loops beyond processor capability
Application 03
Custom or legacy interface bridging
Application 04
Parallel processing across many channels
Application 05
Signal pre-processing ahead of a processor
Application 06
Glue logic consolidation on dense boards

FAQ

FPGA engineering questions

Questions that decide whether programmable logic belongs in a design.

Ask our team

Next step

Ready to move this forward?

Tell us what the product has to do and we will tell you what engineering it needs.