Neural ACE Motion Control & Dynamic Friction Compensation Accelerator — ACE910N01

Accelerated Computing Engineering — IP Core Technical Datasheet

Fixed Latency
12.250 μs (2,450 cyc)
Engine Clock
200.0 MHz
Max Throughput
81.63 kHz
Friction Reduction
96.6% Eliminated

Overview

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.

Key Features

  • Deterministic 2,450-Cycle Real-Time Latency: Fixed $12.250\ \mu\text{s}$ execution at $200\text{ MHz}$ with zero execution jitter, regardless of dynamic trajectories or temperature shifts.
  • High Loop Bandwidth: Up to $81.63\text{ kHz}$ continuous pipeline throughput capacity, providing a $75.5\%$ timing margin inside standard $20\text{ kHz}$ ($50\ \mu\text{s}$) field-oriented control periods.
  • 96.6% Dynamic Friction Error Elimination: Reduces global physical torque error from $0.2409\text{ Nm}$ to $0.0081\text{ Nm}$ on a $2.50\text{ Nm}$ full-scale system (residual error of only $0.32\%$ FSR).
  • Zero-Velocity Stiction Cancellation: Reduces breakaway zone error ($|v| \le 1.5\text{ rad/s}$) from $0.2532\text{ Nm}$ down to $0.0168\text{ Nm}$ ($+0.2364\text{ Nm}$ net torque improvement).
  • Configurable Neural ACE On-Chip Memory: Includes an independent AXI/LMB accessible microcode memory allowing runtime flashing and reconfiguration of custom neural network topologies and weights.
  • Decoupled Silicon Footprint vs. Network Depth: Network topology and parameter count scale execution latency, not FPGA logic or DSP resources.
  • Turnkey Model-to-Silicon Toolchain: Scope of delivery includes an automated GUI executable and a Python library for Quantization-Aware Training (QAT), coupled with ACE Cloud Compilation Services for one-click microcode binary generation.
  • Minimal Silicon Footprint: Requires only $\sim 11\%$ Slice LUTs (6,984) and $5\%$ DSP48E1 slices (12) on an entry-level AMD Artix-7 xc7a100tcsg324-1 FPGA, leaving $\sim 89\%$ of the device available for multi-axis drive logic and communications.
  • Hardware-Tethered Security: Cryptographically locked and validated via FPGA Silicon DNA binding.

Functional Description & Control Formulation

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).

Bit-Exact Software Twin Reference Model

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

Input Quantization & Format Specifications

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:

  • Rotor Position (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.
  • Phase Currents & Temperature (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 Velocity (target_vel): IEEE-754 single-precision float ($\text{rad/s}$).
  • Space-Vector PWM Outputs (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.

Neural ACE: Architecture, Training & Cloud Toolchain

Neural Architecture & Parameter Scaling

The pre-compiled reference design implements an 8-layer deep Quantized Artificial Neural Network (QANN) with the following structure:

  • Network Inputs (3): Normalized Velocity (v_norm), Filtered Acceleration (a_norm), Ambient Temperature (temp_norm).
  • Network Output (1): Feedforward Counter-Torque (T_ff).
  • Topology: $3 \rightarrow 36 \rightarrow 36 \rightarrow 72 \rightarrow 36 \rightarrow 21 \rightarrow 18 \rightarrow 15 \rightarrow 1$.
  • Total Parameter Count: 7,816 parameters (7,617 weights + 199 biases), quantized to INT8 precision.

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.

Runtime Reconfigurable Instruction Memory

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).

Scope of Delivery: Complete Model-to-Silicon Toolchain

Every ACE910N01 license includes a comprehensive software suite for rapid deployment:

  1. Standalone QAT Training GUI Executable: A turnkey desktop tool allowing engineers to import experimental motor drive trajectories, define layer sizes, and execute automated Quantization-Aware Training (QAT).
  2. Python / PyTorch Neural ACE Library: A full SDK for advanced machine learning teams to embed custom non-linear friction models, loss functions, and thermal models directly into existing training workflows.
  3. ACE Cloud Conversion Portal: Secure compilation service that ingests trained PyTorch models (.pt) and outputs microcode binaries (.coe / .bin) tailored for direct flashing into the ACE910N01 instruction RAM.

Hardware Resource Utilization

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%

Timing & Latency Specifications

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

User Interface & Memory Map

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
00x0000TRIGGERuint32Core trigger: Write 0x01 to start execution; auto-cleared upon completion
10x0004theta_curr_fxint32Current electrical rotor position (2Q30 scaled radians: $1.0 = \pi$)
30x000CI_a_raw_fxint32Phase A current raw ADC count (<< 15 shifted)
40x0010I_b_raw_fxint32Phase B current raw ADC count (<< 15 shifted)
50x0014temp_raw_fxint32Temperature sensor raw ADC count (<< 15 shifted)
60x0018target_velfloat32Target mechanical velocity command ($\text{rad/s}$)
120x0030T_fffloat32Synthesized Neural ACE Feedforward Friction Torque ($\text{Nm}$)
130x0034T_totalfloat32Total commanded torque ($T_{\text{linear}} + T_{\text{ff}}$) in $\text{Nm}$
140x0038I_q_targetfloat32Target quadrature current command ($\text{A}$)
260x0068duty_alpha_fxint32Synthesized Space-Vector PWM Duty Alpha (2Q30 counts)
270x006Cduty_beta_fxint32Synthesized Space-Vector PWM Duty Beta (2Q30 counts)
30 .. 440x0078 - 0x00B0System Parametersfloat32Physical motor and loop gains (Ts, V_max, A_max, Kt, Vdc, Kp, Ki, Kp_d, Ki_d...)
45 .. 490x00B4 - 0x00C4Calibration Offsetsi32 / fltADC zero offsets and scale conversion gains
OthersVariousRESERVED—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.

Silicon Validation & Benchmark Performance

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

Licensing & Deliverables

Delivered as an encrypted or RTL-level AMD Vivado IP core, the ACE910N01 package includes:

  • ACE910N01 Hardware IP Core (VHDL netlist) with timing closure constraints.
  • Standalone Model-to-Silicon QAT Training GUI Executable.
  • Advanced Python / PyTorch QAT Training & Validation SDK.
  • Access credentials to the ACE Cloud Microcode Compilation Portal.
  • Bit-exact Python software twin reference test suite.
  • Silicon DNA 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.