The ACE910N01 is an ultra-fast, deterministic hardware co-processor engineered by Accelerated Computing Engineering (ACE) for real-time motion control, precision servo actuation, and dynamic non-linear friction compensation. Operating as a production-ready "Math-to-Silicon" architecture, the IP core offloads complex kinematics, multi-variable non-linear disturbance compensation, and field-oriented control (FOC) vector loops directly into high-speed, cycle-accurate FPGA hardware.
Non-linear mechanical friction—specifically velocity-reversal stiction, the Stribeck effect, viscous dissipation, and acceleration-dependent thermal hysteresis—represents the single largest impediment to tracking precision and tactile transparency in high-performance drive systems.
While classical PID and static feedforward look-up tables struggle to adapt across dynamic velocity reversals and shifting thermal operating points, the ACE910N01 integrates the proprietary Neural ACE artificial neural network engine. Running in parallel with IEEE-754 single-precision floating-point arithmetic and high-bandwidth CORDIC vector engines, Neural ACE synthesizes an optimal feedforward counter-torque in lockstep with the current-loop update.
ACE910N01 is controlled via dual RAM based interfaces (port 1 for the controlling logic and port 2 for the core itself), making it easy to integrate and avoid complex cross-clock domains.
Targeted for Advanced Robotics, Semiconductor Lithography, Medical Teleoperation, and High-Precision Machine Tools, the ACE910N01 delivers deterministic microsecond-grade execution with an ultra-lean silicon footprint.
More information about customization and product development can be found at www.accelerated-computing.be.
xc7a100tcsg324-1 FPGA, leaving $\sim 89\%$ of the device available for multi-axis drive logic and communications.The ACE910N01 executes an end-to-end motion control pipeline consisting of three stages: Kinematics & Signal Conditioning (Phase A), Neural ACE Feedforward Synthesis, and FOC Current Control & Space-Vector Duty Generation (Phase B).
To ensure bit-exact parity with the FPGA silicon implementation, the executable Python software twin mirrors the complete ACE910N01 hardware execution pipeline for verification, latency profiling, and system-level integration:
"""
===============================================================================
Neural ACE Motion Control Pipeline (ACE910N01)
Real-Time Execution Model: Kinematics, Neural Feedforward, and Vector FOC
===============================================================================
Target Control Loop Rate : 20 kHz (Ts = 50 us)
Core Hardware Latency : 12.250 us (2,450 cycles @ 200 MHz)
Parity Guarantee : Bit-exact alignment with FPGA BRAM registers
-------------------------------------------------------------------------------
"""
import math
from typing import NamedTuple, Tuple
# Vector Math Constants
ONE_BY_SQRT3: float = 1.0 / math.sqrt(3.0)
TWO_BY_SQRT3: float = 2.0 / math.sqrt(3.0)
SCALE_2Q30: float = float(1 << 30) # 1,073,741,824.0 (2Q30 Fixed-Point Base)
class AceInputs(NamedTuple):
"""Dynamic real-time inputs provided to the core at each sampling step."""
theta_curr_fx: int # Rotor angle in 2Q30 [-1.0, +1.0) = [-pi, +pi) rad
I_a_raw_fx: int # Phase A ADC count (15-bit left-shifted)
I_b_raw_fx: int # Phase B ADC count (15-bit left-shifted)
temp_raw_fx: int # RTD temperature ADC count (15-bit left-shifted)
target_vel: float # Commanded mechanical velocity (rad/s)
class AceOutputs(NamedTuple):
"""Hardware synthesized control variables generated by the core."""
T_ff: float # Neural ACE dynamic friction compensation (Nm)
T_total: float # Combined torque setpoint (Nm)
I_q_target: float # Target quadrature current setpoint (A)
duty_alpha_fx: int # Space-Vector PWM Alpha duty register (2Q30 counts)
duty_beta_fx: int # Space-Vector PWM Beta duty register (2Q30 counts)
class AceState:
"""Persistent internal state variables updated after every execution cycle."""
def __init__(self, theta_init: int = 0):
self.theta_prev_fx: int = theta_init
self.v_prev: float = 0.0
self.a_prev: float = 0.0
self.integral_v: float = 0.0 # Velocity PI loop accumulator
self.integral_Id: float = 0.0 # Id current PI loop accumulator
self.integral_Iq: float = 0.0 # Iq current PI loop accumulator
def float_to_hw_int8_bit30_slice(val_norm: float) -> int:
"""Clamps normalized input [-1.0, 1.0] and extracts Bits [30:23] to mirror FPGA BRAM quantization."""
clamped = max(-1.0, min(1.0, val_norm))
val_2q30 = int(round(clamped * SCALE_2Q30)) & 0xFFFFFFFF
val_int8 = (val_2q30 >> 23) & 0xFF
return val_int8 - 256 if val_int8 >= 128 else val_int8
def run_full_pipeline_step(
inputs: AceInputs,
state: AceState,
params: dict,
neural_eval_fn,
) -> Tuple[AceOutputs, AceState]:
"""Executes a single, complete step of the ACE910N01 control & compensation pipeline."""
# -------------------------------------------------------------------------
# PHASE A: Sensor Calibration & State Kinematics
# -------------------------------------------------------------------------
# 1. Calibrated Physical Measurements
I_alpha = float(inputs.I_a_raw_fx - params['I_a_zero_fx']) * params['SCALE_I']
I_b = float(inputs.I_b_raw_fx - params['I_b_zero_fx']) * params['SCALE_I']
temp_c = float(inputs.temp_raw_fx - params['temp_zero_fx']) * params['SCALE_TEMP']
# 2. Angular Velocity Estimation (2Q30 Scaled Radians: 1.0 = pi)
delta_theta_fx = (inputs.theta_curr_fx - state.theta_prev_fx) & 0xFFFFFFFF
if delta_theta_fx >= 0x80000000:
delta_theta_fx -= 0x100000000
delta_theta = float(delta_theta_fx) / SCALE_2Q30
v_est = (delta_theta * math.pi) / params['Ts']
# 3. Filtered Acceleration (Single-Pole Low-Pass Filter)
raw_a = (v_est - state.v_prev) / params['Ts']
a_est = (params['alpha_filter'] * raw_a) + ((1.0 - params['alpha_filter']) * state.a_prev)
# 4. Linear Feedback Velocity Control (PI Loop)
err_v = inputs.target_vel - v_est
state.integral_v += err_v * params['Ts']
T_linear = (params['Kp'] * err_v) + (params['Ki'] * state.integral_v)
# -------------------------------------------------------------------------
# NEURAL ACE: Non-Linear Dynamic Friction Feedforward Synthesis
# -------------------------------------------------------------------------
# 1. Boundary Normalization [-1.0, +1.0]
v_norm = v_est / params['V_max']
a_norm = a_est / params['A_max']
temp_norm = (temp_c - params['temp_mid']) / params['temp_span']
# 2. Bit 30-Sliced Fixed-Point Input Quantization (Matching FPGA Logic)
in0_int8 = float_to_hw_int8_bit30_slice(v_norm)
in1_int8 = float_to_hw_int8_bit30_slice(a_norm)
in2_int8 = float_to_hw_int8_bit30_slice(temp_norm)
# 3. Parallel 8-Layer Quantized Neural Engine Evaluation
norm_feedforward = neural_eval_fn(
in0_int8 / 128.0, in1_int8 / 128.0, in2_int8 / 128.0
)
# 4. Feedforward Counter-Torque Scaling (Nm)
T_ff = norm_feedforward * params['MAX_TORQUE']
# -------------------------------------------------------------------------
# PHASE B: Field-Oriented Control (FOC) & Space-Vector Modulation
# -------------------------------------------------------------------------
# 1. Torque Command Fusion & Quadrature Setpoint
T_total = T_linear + T_ff
I_q_target = T_total / params['Kt']
# 2. Clarke Transform (3-Phase -> Alpha-Beta Stationary Frame)
I_beta = (I_alpha * ONE_BY_SQRT3) + (I_b * TWO_BY_SQRT3)
# 3. CORDIC Trigonometry & Park Transform (Alpha-Beta -> Synchronous d-q Frame)
theta_rad = (float(inputs.theta_curr_fx) / SCALE_2Q30) * math.pi
sin_theta = math.sin(theta_rad)
cos_theta = math.cos(theta_rad)
I_d = (I_alpha * cos_theta) + (I_beta * sin_theta)
I_q = (-I_alpha * sin_theta) + (I_beta * cos_theta)
# 4. Synchronous PI Current Regulators (Decoupled Id / Iq Control)
err_Id = 0.0 - I_d # Field-weakening / alignment reference Id_ref = 0
state.integral_Id += err_Id * params['Ts']
V_d_target = (params['Kp_d'] * err_Id) + (params['Ki_d'] * state.integral_Id)
err_Iq = I_q_target - I_q
state.integral_Iq += err_Iq * params['Ts']
V_q_target = (params['Kp_q'] * err_Iq) + (params['Ki_q'] * state.integral_Iq)
# 5. Inverse Park Transform (Synchronous d-q -> Stationary Alpha-Beta)
V_alpha = (V_d_target * cos_theta) - (V_q_target * sin_theta)
V_beta = (V_d_target * sin_theta) + (V_q_target * cos_theta)
# 6. Normalized Space-Vector Modulation (SVPWM 2Q30 Output Generation)
duty_alpha_scaled = ((V_alpha / params['Vdc']) + 1.0) * 0.5
duty_beta_scaled = ((V_beta / params['Vdc']) + 1.0) * 0.5
duty_alpha_fx = int(round(max(0.0, min(1.0, duty_alpha_scaled)) * SCALE_2Q30)) & 0xFFFFFFFF
duty_beta_fx = int(round(max(0.0, min(1.0, duty_beta_scaled)) * SCALE_2Q30)) & 0xFFFFFFFF
# -------------------------------------------------------------------------
# STATE HISTORY UPDATE (Prepare for Step [k+1])
# -------------------------------------------------------------------------
state.theta_prev_fx = inputs.theta_curr_fx
state.v_prev = v_est
state.a_prev = a_est
outputs = AceOutputs(
T_ff=T_ff,
T_total=T_total,
I_q_target=I_q_target,
duty_alpha_fx=duty_alpha_fx,
duty_beta_fx=duty_beta_fx,
)
return outputs, state
To provide seamless integration with standard motor control ADCs and encoders, the ACE910N01 accepts inputs in industry-standard formats. All input bit-widths, scaling gains, and zero-offset alignments can be fully customized upon request:
theta_curr_fx): 32-bit signed 2Q30 scaled radians ($[-1.0, +1.0)$ corresponding to $[-\pi, +\pi)$). Compatible with optical encoders, magnetic resolvers, and BiSS-C/EnDat digital interfaces.I_a_raw, I_b_raw, temp_raw): 16-bit signed integer ADC counts shifted to Bit-30 MSB alignment (15-bit left shift). Configurable to direct 12-bit, 16-bit, or 18-bit delta-sigma conversions.target_vel): IEEE-754 single-precision float ($\text{rad/s}$).duty_alpha, duty_beta): 32-bit unsigned 2Q30 normalized duty ratios ($0$ to $2^{30}$), easily converted to 16-bit PWM timer registers via a 15-bit right shift.The pre-compiled reference design implements an 8-layer deep Quantized Artificial Neural Network (QANN) with the following structure:
v_norm), Filtered Acceleration (a_norm), Ambient Temperature (temp_norm).T_ff).Critical Silicon Decoupling: NeuralACE hardware is a runtime programmable engine. The physical FPGA resource utilization (LUTs, registers, DSPs) remains strictly constant regardless of network depth or layer dimensions. Expanding or reducing the neural network modifies only the execution cycle latency and instruction count, leaving the FPGA silicon footprint completely unaffected.
The ACE910N01 features dedicated instruction memory blocks accessible via standard AXI/LMB memory-mapped buses during normal operation:
INSTRUCTION RAM 01: 32-bit Lower Instruction Word.INSTRUCTION RAM 02: 32-bit Upper Instruction Word.This allows host systems to flash new neural topologies, updated motor calibrations, or wear-compensated model weights online without interrupting base FPGA bitstream operation. The memory comfortably accommodates standard motor models (the 8-layer, 7,816-parameter reference design compiles into 1,457 instruction words).
Every ACE910N01 license includes a comprehensive software suite for rapid deployment:
.pt) and outputs microcode binaries (.coe / .bin) tailored for direct flashing into the ACE910N01 instruction RAM.
The resource utilization for the standalone ACE910N01 core (comprising the Math Engine, Neural ACE Co-processor, CORDIC trig unit, and floating-point primitives) placed on an AMD Artix-7 xc7a100tcsg324-1 is detailed below. Note: Reported utilization includes a MicroBlaze soft core and debug infrastructure used only for validation. The delivered ACE910N01 IP core (without MicroBlaze) consumes fewer resources than the figures shown.
| Resource Type | Used | Available | Utilization (%) |
|---|---|---|---|
| Slice LUTs | 6,984 | 63,400 | 11.02% |
| Slice Registers (Flip-Flops) | 8,356 | 126,800 | 6.59% |
| Block RAM (Tiles) | 11 | 135 | 8.15% |
| DSP48E1 Slice Primitives | 12 | 240 | 5.00% |
| Metric | Value | Notes |
|---|---|---|
Engine Clock (CLK_FAST) |
200.0 MHz | $5.0\text{ ns}$ period driving high-speed math logic |
| Execution Latency | 2,450 Cycles (12.250 μs) | Deterministic cycle count across all dynamic operating points |
| Execution Jitter | 0.000 ns | Zero-jitter pipeline execution |
| Max Continuous Throughput | 81.63 kHz | Allows execution within ultra-high-speed current loops |
The core is controlled through a dual-port memory-mapped interface. Only registers required for user configuration, command injection, and output duty retrieval are exposed below; internal scratchpads and intermediate registers are reserved.
| Word | Byte Offset | Register Name | Type | Description |
|---|---|---|---|---|
0 | 0x0000 | TRIGGER | uint32 | Core trigger: Write 0x01 to start execution; auto-cleared upon completion |
1 | 0x0004 | theta_curr_fx | int32 | Current electrical rotor position (2Q30 scaled radians: $1.0 = \pi$) |
3 | 0x000C | I_a_raw_fx | int32 | Phase A current raw ADC count (<< 15 shifted) |
4 | 0x0010 | I_b_raw_fx | int32 | Phase B current raw ADC count (<< 15 shifted) |
5 | 0x0014 | temp_raw_fx | int32 | Temperature sensor raw ADC count (<< 15 shifted) |
6 | 0x0018 | target_vel | float32 | Target mechanical velocity command ($\text{rad/s}$) |
12 | 0x0030 | T_ff | float32 | Synthesized Neural ACE Feedforward Friction Torque ($\text{Nm}$) |
13 | 0x0034 | T_total | float32 | Total commanded torque ($T_{\text{linear}} + T_{\text{ff}}$) in $\text{Nm}$ |
14 | 0x0038 | I_q_target | float32 | Target quadrature current command ($\text{A}$) |
26 | 0x0068 | duty_alpha_fx | int32 | Synthesized Space-Vector PWM Duty Alpha (2Q30 counts) |
27 | 0x006C | duty_beta_fx | int32 | Synthesized Space-Vector PWM Duty Beta (2Q30 counts) |
30 .. 44 | 0x0078 - 0x00B0 | System Parameters | float32 | Physical motor and loop gains (Ts, V_max, A_max, Kt, Vdc, Kp, Ki, Kp_d, Ki_d...) |
45 .. 49 | 0x00B4 - 0x00C4 | Calibration Offsets | i32 / flt | ADC zero offsets and scale conversion gains |
Others | Various | RESERVED | — | Internal pipeline registers, integrators, and scratchpads |
Note: While test and verification suites utilize an auxiliary soft-core processor (MicroBlaze) for telemetry, vector injection, and cycle-accurate latency profiling, this processor is strictly a test fixture and is not part of the final delivered silicon IP core. The standalone ACE910N01 core operates autonomously with native dual-port RAM interfaces. The interfaces may be controlled via Hard/Soft Processors (e.g. LMB or AXI) or pure RTL for “close to wire” designs.
Physical hardware validation was conducted on the Artix-7 device across an automated 100-test matrix spanning velocity sweeps ($-9.00\text{ rad/s}$ to $+9.00\text{ rad/s}$), temperatures ($20.0^\circ\text{C}$ to $80.0^\circ\text{C}$), and electrical angles ($0.0^\circ$ to $178.2^\circ$).
| Operating Domain | Uncompensated Baseline | ACE910N01 Output | Net Accuracy Gain | Benchmark Status |
|---|---|---|---|---|
| Breakaway / Stiction ($|v| \le 1.5\text{ rad/s}$) | $0.2532\text{ Nm}$ | $0.0168\text{ Nm}$ | $+0.2364\text{ Nm}$ | 100% PASS |
| Nominal Domain ($|v| > 1.5\text{ rad/s}$) | $0.2386\text{ Nm}$ | $0.0064\text{ Nm}$ | $+0.2322\text{ Nm}$ | 100% PASS |
| Global 100-Test Average | $0.2409\text{ Nm}$ | $0.0081\text{ Nm}$ | $+0.2329\text{ Nm}$ ($+9.31\%$ FSR) | 100 / 100 PASS |
Delivered as an encrypted or RTL-level AMD Vivado IP core, the ACE910N01 package includes:
USER_KEY authorization file for IP licensing protection.For evaluation kits, benchmark test vectors, or custom motor training engagements, contact Accelerated Computing Engineering (ACE).
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.