Multi-Sensor Extended Kalman Filter — ACE90011

Accelerated Computing Engineering — IP Core Technical Datasheet

Fixed Latency
1,536 cycles
Max Clock
200 MHz
Throughput
130K ops/sec
Arithmetic
IEEE-754 FP32

Overview

The ACE90011 is a high-velocity, deterministic hardware accelerator designed for the real-time execution of Extended Kalman Filter (EKF) algorithms. It provides a production-ready "Math-to-Silicon" pipeline that transforms complex state-estimation mathematics into high-frequency, bit-perfect FPGA logic.

By offloading recursive mathematical kernels from a system’s primary processor, the core enables extreme computational throughput with zero execution jitter.

With its 130K operations per second, the ACE90011 may be used, in the Radar and EW field, to enable “pulse-by-pulse” tracking and, in a multi-sensor network, to fuse multiple sources in real time.

The core is engineered as a universal mathematical fabric for high-stakes tracking and navigation environments. It is specifically optimized for:

  • Multi-Sensor Fusion: Tracking targets using asynchronous data from stationary or mobile sensor platforms.
  • Flexible Observation Modeling: Processing any combination of sensor inputs, including Range, Azimuth, and Elevation. The architecture allows for the handling of non-measured quantities by setting their corresponding observation values to a mathematically large displacement, maintaining filter stability across diverse sensor types.
  • Dynamic State Estimation: Performing high-frequency state projections and covariance updates for autonomous robotics, aerospace navigation, and defense-sector target acquisition.

The ACE90011 maintains a surprisingly lean resource utilization footprint that enables its implementation on the majority of the FPGA models.

The core is optimized for a mid range FPGA (Artix-7), but ACE can easily port on any customer-selected FPGA (any vendor).

While the core is fully functional, ACE internal development procedures provide the possibility for the customer to adapt to their needs:

  • The algorithm
  • The FPGA model
  • The latency/resources trade off
  • The precision/resources trade off
  • Memory map
  • Core interfaces (e.g. the BRAM interfaces can be set to AXI)

Key Features

  • Deterministic 1,536 cycles Latency
  • Max Clock Frequency: 200 MHz
  • 130K operations per second at the max frequency
  • Utilization less than 20% of the resources on a budget friendly XC7A100TCSG324-1
  • Portable across FPGA families and vendors
  • BRAM-based control interface

Theory of Operation

The core executes a complete Extended Kalman Filter cycle, including the coordinates transformation necessary in order to track a target with sensor(s) installed on a moving platform or using a distributed network with sensors placed on multiple moving platforms.

The core execution may be functionally divided in 4 stages to estimate the ECEF coordinates of the target starting from the measurements (true bearing, true elevation and range) performed by a sensor, the sensor position at the time of the measurement and the time of the measurement itself.

The core is completely stateless, meaning that it can be used for multiple targets/sensors in time sharing. At the same time, it is designed to retain in memory some of the variables (e.g. $Q$ matrix, $R$ matrix) and to overwrite the old results (starting point) with the new ones, in order to minimize the writing operations when possible.

Its design also allows asynchronous measurements, since all the quantities that need to be scaled over time are updated with the necessary delta time ($\Delta t$) between the previous measurement and the new one.

In addition, while designed to manage three spherical coordinates, it can be used for sensors providing any combination of bearing, elevation and range, simply by scaling the corresponding element of the $R$ matrix (e.g. for a sensor measuring only range, the $\sigma$ relative to the bearing and elevation may be set to a very high value).

The algorithm model was used both for the definition and validation (against a golden model) of the ACE90011.

A summary of the operations executed from the core is given by:

  • Prediction (in ECEF coordinates): $\hat{x}_{k|k-1} = F \hat{x}_{k-1|k-1}, \quad P_{k|k-1} = F P_{k-1|k-1} F^T + Q$
  • Computation of the predicted results ($\text{ECEF} \rightarrow \text{NED} \rightarrow \text{Spherical coordinates}$): $h(\hat{x}_{k|k-1})$
  • Computation of the Jacobian of the observation model: $H_k = \left.\frac{\partial h}{\partial x}\right|_{\hat{x}_{k|k-1}}$
  • State update: $S_k = H_k P_{k|k-1} H_k^T + R, \quad K_k = P_{k|k-1} H_k^T S_k^{-1}, \quad \hat{x}_{k|k} = \hat{x}_{k|k-1} + K_k y_k, \quad P_{k|k} = (I - K_k H_k) P_{k|k-1}$

The ACE90011 core utilizes IEEE-754 Single-Precision (32-bit) floating-point arithmetic.

Golden Reference Model

% =================================================================
% ACE EKF REFERENCE MODEL - VALIDATION SUITE
% =================================================================
% x      : State vector [Pos_X; Pos_Y; Pos_Z; Vel_X; Vel_Y; Vel_Z] in ECEF (m, m/s)
% P      : State Covariance Matrix (6x6)
% Q      : Process Noise Covariance (6x6)
% z_obs  : Measurement vector [Range; Azimuth; Elevation]
% R_cov  : Measurement Noise Covariance (3x3)
% R_mat  : Rotation Matrix (3x3) - ECEF to Local NED/Navigation frame
% [Xs; Ys; Zs] : Sensor position in ECEF coordinates
% K_RAD  : Scaling factor (1/pi) to convert Radians to Scaled Radians [-1, +1]
% =================================================================

% --- PREDICT STEP ---
% Linear state projection based on time step (dt)
F = eye(6); F(1,4)=dt; F(2,5)=dt; F(3,6)=dt;
x_pred = F * x;
P_pred = F * P * F' + Q;

% --- OBSERVATION MODEL ---
% 1. Calculate relative displacement in ECEF
dx_e = x_pred(1:3) - [Xs; Ys; Zs];

% 2. Rotate displacement into the local sensor/navigation frame
local = R_mat' * dx_e;
dx = local(1); dy = local(2); dz = local(3);

% 3. Calculate intermediate geometry for Range/Azimuth/Elevation
dxy_sq = dx^2 + dy^2;
dxy = sqrt(dxy_sq);
r_sq = dxy_sq + dz^2;
r_est = sqrt(r_sq); % Estimated Range

% 4. Compute h(x) with angles in Scaled Radians [-1, +1]
% Azimuth = atan2(y,x), Elevation = atan2(-z, horizontal_dist)
h_x = [r_est;
       atan2(dy, dx) * K_RAD;
       atan2(-dz, dxy) * K_RAD];

% 5. Residual (Innovation) calculation
y = z_obs(n,:)' - h_x;

% 6. Angular Wrap-around (Modulo 2 logic for Scaled Radians)
if y(2) > 1, y(2) = y(2) - 2; elseif y(2) < -1, y(2) = y(2) + 2; end

% --- JACOBIAN (H) CALCULATION ---
% Partial derivatives of Range, Azimuth, and Elevation w.r.t Local Coordinates
dr_dl = [dx/r_est, dy/r_est, dz/r_est];
da_dl = [-dy/dxy_sq, dx/dxy_sq, 0] * K_RAD;
de_dl = [(dx*dz)/(r_sq*dxy), (dy*dz)/(r_sq*dxy), -dxy/r_sq] * K_RAD;

% Chain rule: transform local derivatives back to ECEF frame
H = [( [dr_dl; da_dl; de_dl] * R_mat' ), zeros(3,3)];

% --- UPDATE STEP ---
S = H * P_pred * H' + R_cov;     % Innovation Covariance
K = (P_pred * H') / S;           % Kalman Gain
x = x_pred + K * y;              % Updated State
P = (eye(6) - K * H) * P_pred;   % Updated Covariance

Detailed Resource Utilization

The data below are representative of the AMD 7 series architecture. The percentages are relative to the budget friendly XC7A100TCSG324-1:

  • Used CLB LUTs: 9,562 (15.08%)
    • LUT as logic: 9,505
    • LUT as Shift Registers: 130
  • CLB Registers: 10,751 (8.48%)
  • CARRY4: 1,531
  • F7 Muxes: 11
  • F8 Muxes: 1
  • CLB Tiles (in the verification project): 3,017 (19.03%)
  • Used DSP: 9 (3.75%)
  • Used BRAM36K: 4 (2.97%)
  • Used BRAM18K: 1 (0.37%)
  • DNA PORT: 1

Timing and Throughput

The core runs on two different clocks:

  • CLK_FAST with a maximum frequency of 200 MHz
  • CLK_SLOW that shall run at 50 MHz (phase aligned with CLK_FAST)

CLK_SLOW is used for the ACE90011 initialization, while CLK_FAST is used for all the runtime operations.

In the verification project, the timing was closed with 0.086 ns timing margin and with 0 timing violations.

Interfaces and Operation Flow

The Multi-Sensor Extended Kalman Filter core is packaged as an AMD IP core. Figure 1 illustrates the verification configuration.

ACE90011 Verification Configuration Block Diagram
Figure 1 — ACE90011 Verification Configuration

The core is fully controlled through read/write operations on a BRAM (optionally accessible via an AXI BRAM_CONTROLLER). The instantiated BRAMs are 2 True Dual Port memories with port A available to the user and port B managed by the internal Math Engine.

The BRAMs have a width of 32 bits and a depth of 1024 locations. The core uses the first 96 locations (0–95), with the remaining ones completely available for the user via port(s) A (port(s) B are assigned to the internal Math Engine). Port(s) A operates in the user clock domain; Port(s) B operates in the internal engine clock domain.

Table 1 — Dual-Port BRAM Memory Map

IP ADDR VARIABLE DIR FORMAT Note
BRAM_00START_CMDIN-OUTBINARYUser needs to set it to 0x1 to start the cycle. The Engine will toggle the LSB at the end of the computation
BRAM_01T_currINFLOAT32 [s]Time of the measurement
BRAM_02px_old/px_newIN-OUTFLOAT32 [m]User writes the last estimated position (ECEF X). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_03pz_old/pz_newIN-OUTFLOAT32 [m]User writes the last estimated position (ECEF Z). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_04vy_old/vy_newIN-OUTFLOAT32 [m/s]User writes the last estimated velocity (ECEF Y). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_05P00_OLD/P00_NEWIN-OUTFLOAT32P matrix element
BRAM_06P02_OLD/P02_NEWIN-OUTFLOAT32P matrix element
BRAM_07P04_OLD/P04_NEWIN-OUTFLOAT32P matrix element
BRAM_08P11_OLD/P11_NEWIN-OUTFLOAT32P matrix element
BRAM_09P13_OLD/P13_NEWIN-OUTFLOAT32P matrix element
BRAM_010P15_OLD/P15_NEWIN-OUTFLOAT32P matrix element
BRAM_011P23_OLD/P23_NEWIN-OUTFLOAT32P matrix element
BRAM_012P25_OLD/P25_NEWIN-OUTFLOAT32P matrix element
BRAM_013P34_OLD/P34_NEWIN-OUTFLOAT32P matrix element
BRAM_014P44_OLD/P44_NEWIN-OUTFLOAT32P matrix element
BRAM_015P55_OLD/P55_NEWIN-OUTFLOAT32P matrix element
BRAM_016Q00INFLOAT32Q matrix element
BRAM_017Q02INFLOAT32Q matrix element
BRAM_018Q04INFLOAT32Q matrix element
BRAM_019Q11INFLOAT32Q matrix element
BRAM_020Q13INFLOAT32Q matrix element
BRAM_021Q15INFLOAT32Q matrix element
BRAM_022Q23INFLOAT32Q matrix element
BRAM_023Q25INFLOAT32Q matrix element
BRAM_024Q34INFLOAT32Q matrix element
BRAM_025Q44INFLOAT32Q matrix element
BRAM_026Q55INFLOAT32Q matrix element
BRAM_027lat_sens_fxINFIXED POINT [scaled radians] Q2.30 (π=01.0000..., -π=11.0000...)Latitude of the measuring sensor at time T_curr
BRAM_028alt_sensINFLOAT32 [m]Altitude of the measuring sensor at time T_curr
BRAM_029obs_az_fxINFIXED POINT [scaled radians] Q2.30 (π=01.0000..., -π=11.0000...)Measured azimuth (true bearing)
BRAM_030R_RANGEINFLOAT32 [m²]Range measurement variance
BRAM_031R_ELINFLOAT32 [scaled_radians²]Elevation measurement variance
BRAM_032–91DON'T TOUCHN/ARESERVEDInternal engine scratchpad registers (do not overwrite during execution)
BRAM_092DNA1OUTBINARYFPGA DNA (MSB)
BRAM_093DNA2OUTBINARYFPGA DNA (LSB)
BRAM_094USER_KEY1INBINARYLICENSE_KEY (MSB)
BRAM_095USER_KEY2INBINARYLICENSE_KEY (LSB)
BRAM_10T_lastINFLOAT32 [s]Previous measurement time
BRAM_11py_old/py_newIN-OUTFLOAT32 [m]User writes the last estimated position (ECEF Y). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_12vx_old/vx_newIN-OUTFLOAT32 [m/s]User writes the last estimated velocity (ECEF X). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_13vz_old/vz_newIN-OUTFLOAT32 [m/s]User writes the last estimated velocity (ECEF Z). The Math Engine overwrites the value at the end of the computation. For consecutive operations on the same target, the new value is stored until the subsequent cycle, avoiding the need to rewrite
BRAM_14P01_OLD/P01_NEWIN-OUTFLOAT32P matrix element
BRAM_15P03_OLD/P03_NEWIN-OUTFLOAT32P matrix element
BRAM_16P05_OLD/P05_NEWIN-OUTFLOAT32P matrix element
BRAM_17P12_OLD/P12_NEWIN-OUTFLOAT32P matrix element
BRAM_18P14_OLD/P14_NEWIN-OUTFLOAT32P matrix element
BRAM_19P22_OLD/P22_NEWIN-OUTFLOAT32P matrix element
BRAM_110P24_OLD/P24_NEWIN-OUTFLOAT32P matrix element
BRAM_111P33_OLD/P33_NEWIN-OUTFLOAT32P matrix element
BRAM_112P35_OLD/P35_NEWIN-OUTFLOAT32P matrix element
BRAM_113P45_OLD/P45_NEWIN-OUTFLOAT32P matrix element
BRAM_114Q01INFLOAT32Q matrix element
BRAM_115Q03INFLOAT32Q matrix element
BRAM_116Q05INFLOAT32Q matrix element
BRAM_117Q12INFLOAT32Q matrix element
BRAM_118Q14INFLOAT32Q matrix element
BRAM_119Q22INFLOAT32Q matrix element
BRAM_120Q24INFLOAT32Q matrix element
BRAM_121Q33INFLOAT32Q matrix element
BRAM_122Q35INFLOAT32Q matrix element
BRAM_123Q45INFLOAT32Q matrix element
BRAM_124lon_sens_fxINFIXED POINT [scaled radians] Q2.30 (π=01.0000..., -π=11.0000...)Longitude of the measuring sensor at time T_curr
BRAM_125obs_rangeINFLOAT32 [m]Measured Range
BRAM_126obs_el_fxINFIXED POINT [scaled radians] Q2.30 (π=01.0000..., -π=11.0000...)Measured True Elevation
BRAM_127R_AZINFLOAT32 [scaled_radians²]Bearing measurement variance
BRAM_128–95DON'T TOUCHN/ARESERVEDInternal engine scratchpad registers (do not overwrite during execution)

In addition to the BRAM interface, the core exposes:

  • Two clock slave interfaces:
    • CLK_SLOW is used for the initialization and for the access to the DNA reader primitive (50 MHz)
    • CLK_FAST is used to drive the internal computation engine (Max Frequency: 200 MHz)
  • A BUSY pin that, when set to high, signals when the core is executing the initialization or its main function.

The core, at power-up, performs an initialization sequence that lasts (with CLK_SLOW @ 50 MHz) less than 5,000 ns.

When the initialization is complete, the BRAM is populated with the DNA of the FPGA (see Memory Map).

Once the initialization is complete, the user may load the BRAM in accordance with the input reported in the Memory Map and, finally, set the START_CMD to 0x1.

The results are written in BRAM, in accordance with the memory map, after exactly 1,536 clock cycles. The end of execution is communicated by the core by setting the START_CMD to 0x0 and via the BUSY pin (BUSY=0 indicates the core is in the IDLE state, ready for the new execution).

When the START_CMD is asserted, the core performs the entire computation. Execution cannot be stopped. Writing on the BRAM first 96 addresses during the execution will produce undefined results and it is not supported. The execution will always complete in the specified 1,536 clock cycle window.

Note: if the USER_KEY is not correct, the core terminates in the specified timeframe, but produces unpredictable results.

Results

The ACE90011 hardware core undergoes rigorous validation via a "Math-to-Silicon" functional pipeline. Performance results are verified using an explicit dual-filter co-simulation testbench framework running alongside a single-precision software Golden Model. Both tracking profiles process identical noisy, asynchronous multi-sensor spherical inputs (Range, Azimuth, Elevation) generated by a target trajectory. For verification consistency, both filter instances are deliberately initialized with an identical state displacement offset in local coordinates ($[1000, -2000, -200]$ meters in the NED frame) to test convergence capabilities and baseline recovery.

Functional and Bit-Level Execution Verification

Hardware-in-the-loop and post-placement testbench validation tracks exact register outputs inside the dual BRAM memory structure across active filtering epochs. The validation script continuously audits base-10 single-precision IEEE-754 hardware conversions directly against the modeling equations. Crucial internal parameters—such as the Innovation Covariance matrix determinant ($\det(S)$), inverted elements ($S^{-1}_{xx}$), state error covariances ($P_{yz}$), and corrected state vectors—confirm exact architectural alignment with zero numerical divergence.

An extract of the simulated data is reported in Table 2.

Table 2 — Bit-Level Hardware Execution Verification Extract

Filter Epoch Parameter Description BRAM Target Address Hexadecimal Token Value Decoded Physical Metric
STAGE 1 ($t = 1.5\text{ s}$)Estimated ECEF X Position (px_new)BRAM0 / Addr 020x4A7941DC4,083,830.00 m
Innovation Covariance Determinant (DetS)BRAM0 / Addr 760x3718A5A4$9.09847 \times 10^{-6}$
Cross Error Covariance Element (P01)BRAM1 / Addr 040x43458178197.506
Inverted Innovation Matrix Scalar (si00)BRAM1 / Addr 710x3800A8CB$3.06748 \times 10^{-5}$
STAGE 10 ($t = 15.0\text{ s}$)Estimated ECEF Z Position (pz_new)BRAM0 / Addr 030x4A949A964,869,450.00 m
Estimated ECEF X Velocity (vx_new)BRAM1 / Addr 020xC1128553-9.15755 m/s
STAGE 30 ($t = 45.0\text{ s}$)Innovation Covariance Determinant (DetS)BRAM0 / Addr 760x2DED44DF$2.69744 \times 10^{-11}$
Estimated ECEF Y Velocity (vy_new)BRAM0 / Addr 040x409C6AA44.88802 m/s
STAGE 60 ($t = 90.0\text{ s}$)Estimated ECEF Y Position (py_new)BRAM1 / Addr 010x48B38BD2367,711.00 m
Cross Error Covariance Element (P01)BRAM1 / Addr 040x42536D7B52.8569

Tracking Performance & Coordinate Transformations

To provide an informative, system-level interpretation of filter accuracy, absolute ECEF state estimation vectors are transformed into the local North-East-Down (NED) frame relative to the moving sensor platform position. This transformation uses Bowring's closed-form geodetic equations mapped into a localized Direction Cosine Matrix.

Tracking performance analysis isolates individual spatial and velocity components against real ground truth target data. The architectural choices result in unique tracking behaviors:

  • High-Fidelity Initialization Tracking: The ACE90011 hardware core matches the single-precision software Reference Model right from the first filtering epoch (Stages 1 through 15). Because the core's internal pipelines are numerically optimized, the hardware completely eliminates transient quantization penalties or dampening, matching the software reference model's convergence path even under high initial tracking uncertainty.
  • Steady-State Co-Simulation Alignment: As the state error covariance envelope contracts and settles into steady-state tracking bounds (Stages 20 to 60), the hardware core and the software reference model remain securely locked in lockstep. The error traces mirror each other asymptotically throughout the flight path, demonstrating complete mathematical stability and bit-validated functional alignment between the silicon execution and the simulation baseline.
ACE90011 Tracking Performance and Co-Simulation Alignment
Figure 2 — Tracking Performance & Co-Simulation Alignment

Innovation Matrix Stability Analysis

The structural integrity of the analytic matrix inversion engine (implemented inside the DSP arithmetic pipelines via Cramer's Rule) is heavily bound to the Innovation Matrix determinant ($\det(S)$).

During initial track acquisition at Stage 1, the high estimation variance results in a well-conditioned determinant value ($\det(S) = 9.09847 \times 10^{-6}$).

As the state updates lock onto the steady-state target flight path, the covariance fields decay uniformly. By Stage 60, the hardware matrix loops handle extremely tight innovation metrics down to $\det(S) \approx 2.69744 \times 10^{-11}$ without underflow clipping, showing robust numerical stability under high-dynamic scenarios.

Licensing & Ordering Information

ACE90011 is delivered as a pre‑packaged Vivado IP core, ready for integration through the AMD/Xilinx IP Catalog.

Each licensed core includes:

  • Pre‑packaged Vivado IP (compatible with IP Catalog) including simulation model
  • Memory map documentation (available in this datasheet)
  • USER_KEY file for license activation
  • Example project for rapid integration

ACE provides a USER_KEY value (64 bits) for FPGA Serial Number (DNA for AMD/Xilinx). The keys are delivered in a simple CSV file (a template is reported below):

DNA_HEX,AUTHORIZATION_KEY
0011223344556677,C303E222F7D44C5B
ABCDE1234567890F,A2A3A3114194ED74
5566778899AABBCC,94C023F594AA6F63
DEADBEEF12345678,F40237F85DFB6F2A
00123456789ABCDE,E8ACBBDBFCF3ACB7
...............,.................

The user may store the file with all the SN/licenses and select the key to load after reading the SN of the FPGA from the BRAM_PORTA interface of the ACE90011 core.

The envisioned process is the following:

  1. The file with the keys is embedded in the customer software.
  2. The customer software, waiting at least 5,000 ns from power on, reads the FPGA SN from the BRAM_PORTA interface exposed by the ACE90011 core.
  3. The customer software retrieves the USER_KEY corresponding to the FPGA SN in the ACE provided USER_KEY file.
  4. The customer software loads the USER_KEY via the BRAM_PORTA interface exposed by the ACE90011 core.

The keys are generated on customer order. In simulation, a demo DNA is used and the corresponding USER_KEY is provided in the file for a seamless experience.

Pricing is provided directly by ACE based on:

  • Deployment volume
  • License type
  • Optional customization requirements
  • Target FPGA family

Customers may request a quotation by providing their expected deployment profile and FPGA device list.

Data Privacy note: By contacting us via email, you agree that we will use your provided contact details and mathematical specifications solely to evaluate project feasibility during our early-access phase. We do not sell or share your personal information with third parties. We may use standard web analytics tools to monitor basic, aggregated website traffic to improve our site performance.