NAI Documentation

DL Module Guide

22 min read

LVDT/RVDT Simulation (D/L) Family Guide

Overview

The DL family is NAI’s line of Digital-to-LVDT/RVDT (D/L(R)VDT) simulation smart function modules. It is the exact mirror image of the LD family: where an LD module reads an LVDT/RVDT and tells you the position of the moving core, a DL module does the reverse — you hand it a digital position in software and it generates the AC output signals a real LVDT or RVDT at that displacement would produce, at a reference frequency and voltage you choose. There is no core and no sensor; the module is the simulated LVDT/RVDT, in solid-state form.

This page is the starting point for any DL module. Use it to understand the family, pick the member that matches the LVDT/RVDT your equipment expects, wire an output channel, and confirm the module is driving the correct signals. It’s aimed at engineers who need to feed position-feedback signals to equipment that consumes LVDT/RVDT data — without a physical sensor in the loop.

DL completes a four-way family. NAI builds both a measure side and a generate side for both rotary angle (synchro/resolver) and linear/limited-rotary displacement (LVDT/RVDT):

Measure (read the sensor)Generate / simulate (be the sensor)
Synchro / resolver — full-circle angleSD DR
LVDT / RVDT — linear / limited-rotary travelLDDL (this guide)

An LVDT (Linear Variable Differential Transformer) is a position sensor built as a transformer with a sliding magnetic core: an AC reference (excitation) drives the primary winding, and the core’s position sets how much signal couples into the secondary windings — the output amplitude says how far the core has moved and its phase says which way. An RVDT is the same device on a shaft, measuring limited-range rotary displacement. A DL module synthesizes exactly that secondary signal set electronically — ratiometrically locked to a reference, with no transformer and no moving core — so a commanded position of, say, 75% looks to the receiving equipment like a real LVDT core sitting at 75% of full travel.

In a real system, a DL module is most often a signal source for test and simulation. Concretely, it is used to:

  • Bench-test or repair the equipment that reads position — flight-control computers and actuator control electronics, FADEC/engine controllers, cockpit and test-stand instrumentation. Instead of building a rig with a real actuator and LVDT to move to each position, you command the position in software: SetPosition(75.0).
  • Drive hardware-in-the-loop (HIL) simulation — a flight-sim or test computer streams modeled positions in real time, and the DL converts each into live LVDT/RVDT signals so the real unit-under-test behaves as if its actuators are moving.
  • Stand in for a sensor that isn’t present yet during integration, so the consuming system can be developed and verified in parallel with the airframe or actuator.
  • Drive a real LVDT/RVDT input — the higher-power models can source enough drive to feed an actual position-measurement front-end (including an LD channel, for loopback).

(The mirror-image sibling is the LD family, which measures displacement from a real sensor — DL produces the signal, LD reads it; a DL output can drive an LD input for loopback. The rotary-angle cousin is the DS/DR family, which generates synchro/resolver signals instead of LVDT/RVDT. DL and DS generate; SD and LD measure.)

DL modules at a glance

Every DL module does the same job — turn a digital position into LVDT/RVDT output signals — and the output format (2-wire / 3-wire / 4-wire) and LVDT-vs-RVDT behavior are selectable per channel in software, not fixed by the model. A single DL designation covers both LVDT and RVDT: there is no separate DR part number (unlike the synchro/resolver DR generator) — one channel simulates either.

What the models actually differ by is output power vs. channel density (more channels means lower power per channel), then within that by excitation frequency band and signal voltage. The family splits into three tiers — the same structure as the DS generator:

Single-channel — high power (3 VA/channel): for driving heavier loads.

ModuleChannelsOutput (RMS, L–L)Output driveFrequencyManual
DL11*2–28 V3 VA @ 28 V47 Hz – 1 kHzDL1-DLN Manual
DL21*2–28 V3 VA @ 28 V1 – 5 kHzDL1-DLN Manual
DL31*2–28 V3 VA @ 28 V5 – 10 kHzDL1-DLN Manual
DL41*2–28 V3 VA @ 28 V10 – 20 kHzDL1-DLN Manual
DL51*28–90 V3 VA @ 90 V47 Hz – 1 kHzDL1-DLN Manual

2-channel — standard power (1.5 VA @ 28 V / 2.2 VA @ 90 V per channel):

ModuleChannelsOutput (RMS, L–L)Output driveFrequencyManual
DLA22–28 V1.5 VA @ 28 V47 Hz – 1 kHzDL1-DLN Manual
DLB22–28 V1.5 VA @ 28 V1 – 5 kHzDL1-DLN Manual
DLC22–28 V1.5 VA @ 28 V5 – 10 kHzDL1-DLN Manual
DLD22–28 V1.5 VA @ 28 V10 – 20 kHzDL1-DLN Manual
DLE228–90 V2.2 VA @ 90 V47 Hz – 1 kHzDL1-DLN Manual

3-channel — high density, low power (0.5 VA/channel): ideal for driving solid-state instruments and gauges (most LVDT/RVDT measurement inputs are high-impedance and draw little current — just like a real sensor).

ModuleChannelsOutput (RMS, L–L)Output driveFrequencyManual
DLJ32–28 V0.5 VA @ 28 V47 Hz – 1 kHzDL1-DLN Manual
DLK32–28 V0.5 VA @ 28 V1 – 5 kHzDL1-DLN Manual
DLL32–28 V0.5 VA @ 28 V5 – 10 kHzDL1-DLN Manual
DLM32–28 V0.5 VA @ 28 V10 – 20 kHzDL1-DLN Manual
DLN328–90 V0.5 VA @ 90 V47 Hz – 1 kHzDL1-DLN Manual

Note

* Single-channel availability is a contact-factory option. Always confirm the exact model, channel count, and ranges on the DLx data sheet and the DL1-DLN Manual.

Choosing a member:

  • Match the excitation first. The reference frequency and signal voltage you need to simulate must fall in the model’s bands — standard 400 Hz aircraft LVDTs/RVDTs at low level → a 47 Hz–1 kHz, 2–28 V model; 115 V-class sensors → a 28–90 V model (DL5/DLE/DLN); higher-frequency sensors → the 1–5 k / 5–10 k / 10–20 k models.
  • Then match power to the load. Driving a heavier load needs the high-power single-channel (3 VA) parts; feeding solid-state measurement inputs, gauges, or instruments is what the 3-channel (0.5 VA) parts are built for; general bench/HIL use fits the 2-channel parts.
  • LVDT or RVDT is not a model choice — every channel simulates either; there is no separate model or part-number split for RVDT.
  • Wire format is per channel, in software — a channel can simulate a 4-wire, 3-wire, or 2-wire LVDT (see Physical setup); 2-wire mode splits the channel into two independent positions (A and B).

Physical setup

A DL channel is an output: it drives LVDT/RVDT signals into the equipment (or measurement front-end) you’re feeding. Each channel needs three things wired — the reference (excitation) input pair, the A/B signal-output lines, and the voltage-sense lines — plus attention to the model’s drive rating (VA), since unlike a measurement input a DL channel actually sources power into a load. The exact pins are per-module, so always get them from the module’s manual or overlay card; the pattern is the same for every DL module:

  1. Identify the module’s slot number on your NAI motherboard or system.
  2. Bring the channel’s lines out through the breakout board, where the slot’s pins appear as generic IO# numbers.
  3. Map IO# pins to the channel’s reference (excitation) input, its ‘A’ and ‘B’ high/low signal-output pairs, and its sense (Hi/Lo) lines, per the pinout in the manual.
  4. Connect those output lines to the equipment’s LVDT/RVDT input (or to an LD channel for loopback), and connect the sense lines at the load.

A few things hold for every DL module:

  • Enable the channel and its power before you get output. A channel is silent until you enable it (naibrd_DL_SetChanStatusEnable) and turn on its output power (naibrd_DL_SetPowerSupplyState). “No output” is almost always one of these two.
  • Set the wire mode to match how the receiving side is wired. 4-wire mode (which also covers the 3-wire wiring variant, where the A and B low lines are tied together at the load) presents one commanded position across the channel’s A/B output pair — this is the normal “simulate one LVDT/RVDT” case. 2-wire mode splits the channel into two independent positions, A and B. Set it with naibrd_DL_SetWireMode (NAIBRD_DL_4WIRE_MODE / NAIBRD_DL_2WIRE_MODE).
  • You supply the reference; the module rides on it. In the usual configuration an external AC reference (excitation) is applied to each A/B output pair, and the output is generated relative to it. (Some DL models also offer an optional on-board reference oscillator — naibrd_DL_SetOnBoardOSC in SSK 1.x — when no external reference is available; confirm availability for your model.) Tell the module the reference and signal levels with the REF_VOLT and VLL_VOLT configurations, then choose how the output relates to the reference with naibrd_DL_SetOutputMode: in ratio mode (NAIBRD_DL_VLL_MODE_RATIO) the output amplitude tracks the applied reference via the transformation ratio (TR = max output ÷ reference), so it rides along with whatever excitation the equipment supplies — exactly like a real LVDT, and it cancels reference-voltage variation; in fixed mode (NAIBRD_DL_VLL_MODE_FIXED) the output is an absolute programmed voltage regardless of the reference.
  • Respect the drive rating. The output sources real power into the load (0.5 / 1.5–2.2 / 3 VA depending on the model). Driving a load heavier than the part supports trips the over-current status — use a higher-power tier for heavier loads.
  • Use the voltage-sense lines. Each A/B pair has two feedback sense lines that provide automatic output-drive compensation for voltage drops in the wiring. Connect Sense (Hi) → Output (Hi) and Sense (Lo) → Output (Lo) at the load for best accuracy (remote sensing). If running the extra wiring isn’t practical, the sense lines may be terminated at the connector instead — accuracy will not be as good.

Worked examples (use your module’s pinout for the actual pins):

  • Feed a unit-under-test’s LVDT input. Wire the channel’s A/B signal outputs to the equipment’s LVDT/RVDT input, apply the same reference the equipment uses to the channel’s reference input (ratio mode), set 4-wire mode, enable the channel and power, then SetPosition() — the equipment now sees a sensor at that displacement.
  • Loopback to an LD channel. Wire the DL channel’s signal outputs to an LD channel’s signal inputs and share the reference between them. Command a position on the DL and read it back on the LD — it should match. (This is the cross-family version of the self-test below.)

Software

There’s nothing DL-specific about which software you run. The NAI SSK (naibrd library) is identical across every OS and architecture — PetaLinux, VxWorks, DEOS, Windows. What OS you’re on is determined by your motherboard/SBC, not by the DL module. The only family-specific part is which API functions you call: DL modules use the naibrd_DL_* calls (the API simulates both LVDT and RVDT — there is no separate naibrd_DR_* namespace).

DL calls are stateless — every function takes (cardIndex, module, channel) and acts immediately; there is no Open/Init/Free lifecycle to manage. Where to find what you need:

  • Which functions/registers to call — the DL1-DLN Manual documents every naibrd_DL_* register (position, output/wire mode, reference and signal voltages, phase offset, thresholds, BIT, status, and the measured-output reads).
  • Building and deploying on your platform — Connecting to Boards covers the toolchain, deployment, and terminal access for PetaLinux/ARM Linux, VxWorks, DEOS, and Windows.
  • Launching the app on the board itself — Running Applications from the Target walks through loading and launching your executable on the target.

Example — a 68ARM2 SBC with a DL1 module: pull the naibrd_DL_* calls from the DL1-DLN Manual, set up the ARM Linux toolchain per Connecting to Boards, then load and launch a DL sample on the target per Running Applications from the Target.

Confirm communication

A DL module generates signals, so the quickest proof that the board, SSK, and module all work needs no external wiring at all — the module can test its own output path internally with a wrap-around self-test. Then, when you want to prove the signals are physically correct, drive a real LVDT/RVDT input or an LD channel.

Built-in test (no wiring). The module supports a power-on self-test (D0), a continuous background test (D2 / CBIT, transparent, 0.2 % FS), and an offline initiated self-test (D3 / IBIT) that drives an internal stimulus across the full positional range to 0.1 % FS and reports pass/fail — completing within ~30 seconds. Enable a channel, command a position, run the initiated test, and read the latched BIT result:

/* Bring the channel up and command a position */
naibrd_DL_SetChanStatusEnable(cardIndex, module, channel, NAI_TRUE);              /* enable the channel */
naibrd_DL_SetPowerSupplyState(cardIndex, module, channel, NAIBRD_DL_ON);          /* turn on output power */
naibrd_DL_SetPosition(cardIndex, module, channel, NAIBRD_DL_SUBCHANNEL_A, 50.0);  /* 50% of full-scale */
 
/* Run the offline initiated self-test (D3 / IBIT): internal stimulus, full-scale range */
bool_t running = NAI_TRUE;
naibrd_DL_SetTestEnable(cardIndex, module, NAIBRD_DL_D3_TEST, NAI_TRUE);
do { naibrd_DL_GetTestEnable(cardIndex, module,
        NAIBRD_DL_D3_TEST, &running); } while (running);                          /* IBIT clears when done (<30s) */
 
/* Read the latched BIT result for the channel (GOOD = pass) */
naibrd_dl_module_status_t bitStatus;
naibrd_DL_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_DL_CHAN_MAPPED_STATUS_BIT_LATCHED, &bitStatus);

For continuous monitoring while running, leave the online test (D2 / CBIT) enabled and poll the real-time status instead:

naibrd_DL_SetTestEnable(cardIndex, module, NAIBRD_DL_D2_TEST, NAI_TRUE);
naibrd_DL_GetChanMappedStatus(cardIndex, module, channel,
   NAIBRD_DL_CHAN_MAPPED_STATUS_BIT_REALTIME, &bitStatus);                        /* GOOD = normal */

If the initiated test completes and BIT status is clean, your board connection, the SSK, and the module’s full output-generation path are confirmed.

Known-position output check (proves the signals are real). Wire the channel’s outputs to an LVDT/RVDT display, a scope/DMM, or an LD channel (sharing the reference), command a known position, and confirm it appears. The module’s own wrap-around measurement reads its output back without anything else connected:

naibrd_DL_SetWireMode(cardIndex, module, channel, NAIBRD_DL_4WIRE_MODE);          /* match the receiver */
naibrd_DL_SetPosition(cardIndex, module, channel, NAIBRD_DL_SUBCHANNEL_A, 75.0);
 
float64_t wrapPosition;
naibrd_DL_GetMeasuredValue(cardIndex, module, channel,
   NAIBRD_DL_MEASURED_WRAP_POSITION_SUBCHANNEL_A, &wrapPosition);                 /* should read ~75% */
/* On a looped-back LD channel: naibrd_LVDT_GetPosition(...) should read ~75% */

A receiver (or looped-back LD channel) that reflects the commanded position confirms the full path end-to-end, including the analog output signals. The DL BasicOps sample drives exactly this flow — position, voltages, mode, BIT, and status across channels.

Features

Each DL operation works per channel (a few are per module) through the naibrd_DL_* API. The blocks below group the calls by what you’re doing — with the SSK 1.x and 2.x signatures side by side. The function names are largely the same in both versions; the 1.x → 2.x differences are narrow: enum types renamed nai_dl_* → naibrd_dl_*, out-parameters gained the p_out prefix, and the status calls GetStatus / GetStatusRealtime / ClearStatus (with latched vs. real-time as separate calls) became per-channel GetChanMappedStatus / ClearChanMappedStatus (with latched vs. real-time folded into the status-type enum, e.g. ..._BIT_LATCHED / ..._BIT_REALTIME).

Set the output position

What it does: the core operation — present a commanded position on the channel’s output, given as a percentage of full-scale travel (−100 % … +99.999 %). In 4-wire mode the A subchannel sets the single position for the channel; in 2-wire mode the A and B subchannels are commanded independently.

Applies to: all DL modules. The B subchannel applies in 2-wire mode.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DL_SetPosition(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_subchannel_t subchannel, float64_t position);
nai_status_t naibrd_DL_GetPosition(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_subchannel_t subchannel, float64_t* outPosition);
/* SSK 2.x */
nai_status_t naibrd_DL_SetPosition(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_subchannel_t subchannel, float64_t position);
nai_status_t naibrd_DL_GetPosition(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_subchannel_t subchannel, float64_t* p_outposition);

Exercise it: DL BasicOps · DL BasicOps (1.x).

Configure the channel

What it does: set up how the channel drives its output before (or while) you command a position — the wire mode (4-wire single position / 2-wire dual position), ratio vs. fixed output mode, the reference and signal (VLL) voltages, phase offset, fault thresholds (VLL, reference, current per subchannel), the response filter, the channel enable and output power, and per-channel floating-point position offset/scale.

Applies to: all DL modules. Per-subchannel thresholds and the floating-point attributes take an A / B selector.

Also here: naibrd_DL_SetWireMode uses NAIBRD_DL_4WIRE_MODE / NAIBRD_DL_2WIRE_MODE; naibrd_DL_SetOutputMode uses NAIBRD_DL_VLL_MODE_RATIO / NAIBRD_DL_VLL_MODE_FIXED; the configuration type selects NAIBRD_DL_CONFIGURATION_{REF_VOLT, VLL_VOLT, PHASE_OFFSET, WIRE_MODE, THRESHOLD_*, RESPONSE_FILTER, OUTPUT_MODE}; floating-point attributes are NAIBRD_DL_FLOATING_POINT_POSITION_{A,B}_{OFFSET,SCALE}.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DL_SetConfigurationValue(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_configuration_type_t opMode, float64_t opValue);
nai_status_t naibrd_DL_SetWireMode(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_wire_mode_type_t mode);
nai_status_t naibrd_DL_SetOutputMode(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_vll_mode_type_t mode);
nai_status_t naibrd_DL_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_DL_SetPowerSupplyState(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_on_off_t setting);
nai_status_t naibrd_DL_SetFloatingPointAttributes(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_floating_point_attributes_type_t attrType, float64_t attrValue);
/* SSK 2.x */
nai_status_t naibrd_DL_SetConfigurationValue(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_configuration_type_t opMode, float64_t opValue);
nai_status_t naibrd_DL_SetWireMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_wire_mode_type_t mode);
nai_status_t naibrd_DL_SetOutputMode(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_vll_mode_type_t mode);
nai_status_t naibrd_DL_SetChanStatusEnable(int32_t cardIndex, int32_t module, int32_t channel, bool_t enable);
nai_status_t naibrd_DL_SetPowerSupplyState(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_on_off_t setting);
nai_status_t naibrd_DL_SetFloatingPointAttributes(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_floating_point_attributes_type_t attrType, float64_t attrValue);

Exercise it: DL BasicOps · DL BasicOps (1.x).

Measure & monitor the output

What it does: the module continuously measures its own output (a wrap-around read) so you can verify it’s driving correctly — measured wrap position (A/B), reference voltage, signal (VLL) voltage (A/B), reference frequency, signal current (A/B), and velocity (A/B). (This is the module watching its own output, not reading an external sensor.)

Applies to: all DL modules; the B-subchannel values apply in 2-wire mode.

Also here: select what to read with the type argument — NAIBRD_DL_MEASURED_{WRAP_POSITION_SUBCHANNEL_A/B, REF_VOLTAGE, VLL_VOLTAGE, VLL_VOLTAGE_SUBCHANNEL_B, REF_FREQUENCY, SIGNAL_CURRENT, SIGNAL_CURRENT_SUBCHANNEL_B, VELOCITY_SUBCHANNEL_A/B}.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DL_GetMeasuredValue(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_measured_value_type_t opMode, float64_t* opValue);
/* SSK 2.x */
nai_status_t naibrd_DL_GetMeasuredValue(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_measured_value_type_t opMode, float64_t* p_outopValue);

Exercise it: DL BasicOps (status row) · DL BasicOps (1.x).

Health, BIT & status

What it does: run the built-in tests and read the channel’s fault flags. D0 is the power-on self-test; D2 / CBIT is the transparent online background test (with a verify value); D3 / IBIT is the offline initiated full-range test. The channel-mapped status reports BIT, signal loss, reference loss, PLL, and over-current (plus B-subchannel BIT and signal-loss), each in real-time and latched form.

Applies to: all DL modules. Test enable/verify are per module; status is per channel.

Also here: test types are NAIBRD_DL_D0_TEST / _D2_TEST / _D3_TEST; status types are NAIBRD_DL_CHAN_MAPPED_STATUS_{BIT, SIGNAL_LOSS, REF_LOSS, PLL, OVERCURRENT, BIT_B, SIGNAL_LOSS_B} each in _LATCHED / _REALTIME form. In SSK 1.x these are the plain NAI_DL_STATUS_* types read with separate GetStatus (latched) and GetStatusRealtime calls.

Relevant APIs:

/* SSK 1.x */
nai_status_t naibrd_DL_SetTestEnable(int32_t cardIndex, int32_t module, nai_dl_test_type_t type, bool_t inTestEnable);
nai_status_t naibrd_DL_GetTestEnable(int32_t cardIndex, int32_t module, nai_dl_test_type_t type, bool_t* outTestEnable);
nai_status_t naibrd_DL_SetD2TestVerifyValue(int32_t cardIndex, int32_t module, uint32_t inValue);
nai_status_t naibrd_DL_GetStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_status_type_t statusType, nai_dl_module_status_t* outStatus);
nai_status_t naibrd_DL_GetStatusRealtime(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_status_type_t statusType, nai_dl_module_status_t* outStatus);
nai_status_t naibrd_DL_ClearStatus(int32_t cardIndex, int32_t module, int32_t channel, nai_dl_status_type_t statusType);
/* SSK 2.x */
nai_status_t naibrd_DL_SetTestEnable(int32_t cardIndex, int32_t module, naibrd_dl_test_type_t type, bool_t inTestEnable);
nai_status_t naibrd_DL_GetTestEnable(int32_t cardIndex, int32_t module, naibrd_dl_test_type_t type, bool_t* p_outtestEnable);
nai_status_t naibrd_DL_SetD2TestVerifyValue(int32_t cardIndex, int32_t module, uint32_t inValue);
nai_status_t naibrd_DL_GetChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_chan_mapped_status_type_t statusType, naibrd_dl_module_status_t* p_outstatus);
nai_status_t naibrd_DL_ClearChanMappedStatus(int32_t cardIndex, int32_t module, int32_t channel, naibrd_dl_chan_mapped_status_type_t statusType);

Exercise it: DL BasicOps (BIT/status) · DL BasicOps (1.x).

Try it

The snippets below show the order of naibrd_DL_* calls for each task — drop them into the body of an NAI sample app (after the standard board-connection flow: naiapp_RunBoardMenu() → naiapp_query_CardIndex() / naiapp_query_ModuleNumber() → cardIndex/module, see Opening a Software Handle to Your Board) and you have a working output. Each is the conceptual sequence, not a fully-buildable program; the DL BasicOps sample is the full reference. DL calls are stateless — there is no Open/Init/Free.

Try it — Drive a static position

Configure the output mode and the reference/signal voltages, set the wire mode, enable the channel and its power, then command a position. Read the module’s own wrap-around measurement of the output back to confirm.

/* SSK 1.x — drive a static position */
naibrd_DL_SetOutputMode(cardIndex, module, channel, NAI_DL_VLL_MODE_RATIO);                       /* or NAI_DL_VLL_MODE_FIXED */
naibrd_DL_SetConfigurationValue(cardIndex, module, channel, NAI_DL_CONFIGURATION_REF_VOLT, 26.0); /* applied reference, VRMS */
naibrd_DL_SetConfigurationValue(cardIndex, module, channel, NAI_DL_CONFIGURATION_VLL_VOLT, 11.8); /* full-scale output, VLL */
naibrd_DL_SetWireMode(cardIndex, module, channel, NAI_DL_4WIRE_MODE);
naibrd_DL_SetChanStatusEnable(cardIndex, module, channel, TRUE);                                  /* enable channel */
naibrd_DL_SetPowerSupplyState(cardIndex, module, channel, DL_ON);                                 /* output on */
naibrd_DL_SetPosition(cardIndex, module, channel, DL_SUBCHANNEL_A, 75.0);                         /* 75% of full-scale */
 
float64_t wrapPosition;
naibrd_DL_GetMeasuredValue(cardIndex, module, channel, NAI_DL_MEASURED_WRAP_POSITION_SUBCHANNEL_A, &wrapPosition);
/* SSK 2.x — drive a static position */
naibrd_DL_SetOutputMode(cardIndex, module, channel, NAIBRD_DL_VLL_MODE_RATIO);                       /* or NAIBRD_DL_VLL_MODE_FIXED */
naibrd_DL_SetConfigurationValue(cardIndex, module, channel, NAIBRD_DL_CONFIGURATION_REF_VOLT, 26.0); /* applied reference, VRMS */
naibrd_DL_SetConfigurationValue(cardIndex, module, channel, NAIBRD_DL_CONFIGURATION_VLL_VOLT, 11.8); /* full-scale output, VLL */
naibrd_DL_SetWireMode(cardIndex, module, channel, NAIBRD_DL_4WIRE_MODE);
naibrd_DL_SetChanStatusEnable(cardIndex, module, channel, NAI_TRUE);                                 /* enable channel */
naibrd_DL_SetPowerSupplyState(cardIndex, module, channel, NAIBRD_DL_ON);                             /* output on */
naibrd_DL_SetPosition(cardIndex, module, channel, NAIBRD_DL_SUBCHANNEL_A, 75.0);                     /* 75% of full-scale */
 
float64_t wrapPosition;
naibrd_DL_GetMeasuredValue(cardIndex, module, channel, NAIBRD_DL_MEASURED_WRAP_POSITION_SUBCHANNEL_A, &wrapPosition);

Try it — Two independent positions (2-wire)

Put the channel in 2-wire mode and command the A and B subchannels independently.

/* SSK 1.x — two independent positions on one channel */
naibrd_DL_SetWireMode(cardIndex, module, channel, NAI_DL_2WIRE_MODE);
naibrd_DL_SetPosition(cardIndex, module, channel, DL_SUBCHANNEL_A, 25.0);
naibrd_DL_SetPosition(cardIndex, module, channel, DL_SUBCHANNEL_B, -40.0);
/* SSK 2.x — two independent positions on one channel */
naibrd_DL_SetWireMode(cardIndex, module, channel, NAIBRD_DL_2WIRE_MODE);
naibrd_DL_SetPosition(cardIndex, module, channel, NAIBRD_DL_SUBCHANNEL_A, 25.0);
naibrd_DL_SetPosition(cardIndex, module, channel, NAIBRD_DL_SUBCHANNEL_B, -40.0);

Try it — Self-test with the initiated BIT (D3)

Enable the channel and power, run the offline initiated self-test, and read the latched BIT result — no external wiring needed.

/* SSK 1.x — run the initiated self-test (D3 / IBIT), read latched BIT */
naibrd_DL_SetChanStatusEnable(cardIndex, module, channel, TRUE);
naibrd_DL_SetPowerSupplyState(cardIndex, module, channel, DL_ON);
 
bool_t running = TRUE;
naibrd_DL_SetTestEnable(cardIndex, module, NAI_DL_D3_TEST, TRUE);
do { naibrd_DL_GetTestEnable(cardIndex, module, NAI_DL_D3_TEST, &running); } while (running);
 
nai_dl_module_status_t bit;
naibrd_DL_GetStatus(cardIndex, module, channel, NAI_DL_STATUS_BIT, &bit);          /* latched BIT (GOOD = pass) */
/* SSK 2.x — run the initiated self-test (D3 / IBIT), read latched BIT */
naibrd_DL_SetChanStatusEnable(cardIndex, module, channel, NAI_TRUE);
naibrd_DL_SetPowerSupplyState(cardIndex, module, channel, NAIBRD_DL_ON);
 
bool_t running = NAI_TRUE;
naibrd_DL_SetTestEnable(cardIndex, module, NAIBRD_DL_D3_TEST, NAI_TRUE);
do { naibrd_DL_GetTestEnable(cardIndex, module, NAIBRD_DL_D3_TEST, &running); } while (running);
 
naibrd_dl_module_status_t bit;
naibrd_DL_GetChanMappedStatus(cardIndex, module, channel, NAIBRD_DL_CHAN_MAPPED_STATUS_BIT_LATCHED, &bit);

Building and running the SSK samples. The snippets above are condensed for orientation. For full, buildable programs see the “Exercise it:” links under each block in Features — DL BasicOps (2.x) and DL BasicOps (1.x) — and Using NAI SSK 2.x Sample Applications · Using NAI SSK 1.x Sample Applications for build/run instructions across platforms.

Hardware capabilities and status monitoring

This section covers what the hardware provides and what you can monitor — for how to drive each function (position, configuration, BIT), see Features and Try it above.

What the hardware provides:

  • Solid-state LVDT/RVDT synthesis — generates the 2-wire, 3-wire, or 4-wire output signal set with no transformer or moving core; format is selectable per channel in software.
  • Per-channel programmable output — each channel drives its own line-to-line (VLL) voltage in ratio mode (output rides the applied reference; TR = max output ÷ reference, cancelling reference-voltage variation) or fixed (absolute) mode.
  • External reference, with an optional on-board oscillator — an AC reference is applied to each A/B output pair; some models add an optional on-board reference oscillator (naibrd_DL_SetOnBoardOSC, SSK 1.x) for when no external reference is available.
  • Independent A/B outputs — 4-wire mode presents one commanded position across the A/B pair; 2-wire mode splits the channel into two independent positions.
  • Voltage-feedback sense lines — automatic output-drive compensation for voltage drops in the wiring; connect the sense lines at the load for best (remote-sense) accuracy.
  • Three power tiers — high-power single-channel (3 VA), 2-channel (1.5–2.2 VA), and high-density 3-channel (0.5 VA) for instruments and gauges.
  • Phase offset, response filter, and floating-point scaling — per-channel phase-offset adjustment, a configurable response filter, and per-channel floating-point position offset/scale.
  • Wrap-around self-test — the module measures its own output position, current, and carrier frequency.
  • Built-in test — power-on self-test (D0), continuous background CBIT (D2) to 0.2 % FS, and offline initiated IBIT (D3) across the full positional range to 0.1 % FS.

Statuses you can monitor programmatically (per channel, each in real-time and latched form via naibrd_DL_GetChanMappedStatus):

StatusWhat it tells you
BITA built-in-test fault on the channel (CBIT/IBIT result)
Signal lossThe output (line-to-line) signal fell below its threshold
Reference lossThe reference/excitation fell below its threshold
PLLLoss of phase lock between the output and the reference
Over-currentThe channel’s output drive exceeded its current limit (load too heavy)

In 2-wire mode, the B subchannel reports its own BIT and signal-loss status. Measured values — wrap position, signal/reference voltage, reference frequency, output current, and velocity — are read with naibrd_DL_GetMeasuredValue (see Measure & monitor the output).

Common pitfalls

  • No output at all. The channel is silent until you both enable it (naibrd_DL_SetChanStatusEnable) and turn on output power (naibrd_DL_SetPowerSupplyState). This is the most common “nothing happens.”
  • Wrong wire mode. 4-wire presents one position across the A/B pair; 2-wire drives two independent positions. Reading the receiving side in a different format than the channel is driving misinterprets the signals — match naibrd_DL_SetWireMode to the wiring.
  • Ratio mode with no/wrong reference. In ratio mode the output amplitude tracks the applied reference — if the reference is missing or wrong, the output scales unexpectedly. Use fixed mode (or the optional on-board oscillator) when nothing external supplies a reference.
  • Over-driving the load. Each model has a VA limit (0.5 / 1.5–2.2 / 3 VA). Driving a load heavier than the part supports trips over-current status — use a higher-power tier for heavier loads.
  • Output doesn’t map to physical units. Set the reference and signal (VLL) voltages (and any floating-point offset/scale) so the commanded percentage maps to your sensor’s full-scale travel — otherwise the simulated position is uncalibrated.
  • Sense lines not connected at the load. Leaving the voltage-sense lines at the connector instead of the load degrades accuracy, especially at higher current or lower voltage. Connect Sense (Hi) → Output (Hi) and Sense (Lo) → Output (Lo) at the load.
  • Expecting GetMeasuredValue to read an external sensor. It reports the module’s own wrap-around output, not a core on a wire — DL produces position, it doesn’t read one. (That’s the LD family.)
NAI Docs Assistant
Was this document helpful?

Backlinks